├── src └── anduril │ ├── py.typed │ ├── types │ ├── timestamp.py │ ├── media_item_type.py │ ├── acm_details_acm_type.py │ ├── override_type.py │ ├── alert_level.py │ ├── power_source_power_type.py │ ├── correlation_metadata_type.py │ ├── health_connection_status.py │ ├── orbit_mean_elements_metadata_ref_frame.py │ ├── schedule_schedule_type.py │ ├── orbit_mean_elements_metadata_mean_element_theory.py │ ├── task_error_code.py │ ├── correlation_metadata_replication_mode.py │ ├── field_of_view_mode.py │ ├── mil_view_environment.py │ ├── ontology_template.py │ ├── mode5mode5interrogation_response.py │ ├── health_health_status.py │ ├── component_health_health.py │ ├── entity_event_event_type.py │ ├── component_message_status.py │ ├── power_source_power_status.py │ ├── control_area_details_type.py │ ├── override_status.py │ ├── transponder_codes_mode4interrogation_response.py │ ├── mil_view_disposition.py │ ├── payload_configuration_effective_environment_item.py │ ├── geo_details_type.py │ ├── sensor_operational_state.py │ ├── sensor_sensor_type.py │ ├── classification_information_level.py │ ├── lla_altitude_reference.py │ ├── primary_membership.py │ ├── non_primary_membership.py │ ├── echelon_army_echelon.py │ ├── payload_configuration_payload_operational_state.py │ ├── entity_stream_heartbeat.py │ ├── mil_std2525c.py │ ├── entity_stream_event.py │ ├── enu.py │ ├── fixed.py │ ├── task_status_status.py │ ├── list_response.py │ ├── media.py │ ├── sensors.py │ ├── heartbeat_object.py │ ├── schedules.py │ ├── payload.py │ ├── active_target.py │ ├── alternate_id.py │ ├── decorrelated_all.py │ ├── geo_point.py │ ├── merged_from.py │ ├── supplies.py │ ├── geo_line.py │ ├── group_details.py │ ├── linear_ring.py │ ├── path_metadata.py │ ├── relationships.py │ ├── quaternion.py │ ├── t_mat2.py │ ├── bandwidth.py │ ├── dimensions.py │ ├── u_int32range.py │ ├── control_area_details.py │ ├── overrides.py │ ├── symbology.py │ ├── group_child.py │ ├── group_parent.py │ ├── payloads.py │ ├── primary_correlation.py │ ├── task_catalog.py │ ├── user.py │ ├── agent.py │ ├── entity_ids_selector.py │ ├── entity_manager_t_mat3.py │ ├── scan_characteristics_scan_type.py │ ├── owner.py │ ├── measurement.py │ ├── execute_request.py │ ├── threat.py │ ├── pulse_repetition_interval.py │ ├── complete_request.py │ ├── google_protobuf_any.py │ ├── orbit.py │ ├── team.py │ ├── allocation.py │ ├── mode_s.py │ ├── replication.py │ ├── frequency.py │ ├── mil_view.py │ ├── content_identifier.py │ ├── media_item.py │ ├── task_definition.py │ ├── component_message.py │ ├── visual_details.py │ ├── emitter_notation.py │ ├── alternate_id_type.py │ ├── aliases.py │ ├── bandwidth_range.py │ ├── echelon.py │ ├── geo_shape.py │ ├── decorrelated_single.py │ ├── scan_characteristics.py │ ├── secondary_correlation.py │ ├── geo_details.py │ ├── acm_details.py │ ├── power_state.py │ ├── route_details.py │ ├── lla.py │ ├── entity_event.py │ ├── entity_event_response.py │ ├── target_priority.py │ ├── indicators.py │ ├── status.py │ ├── frequency_range.py │ ├── geo_polygon_position.py │ ├── orbit_mean_elements.py │ ├── classification_information.py │ ├── classification.py │ ├── high_value_target_match.py │ ├── relations.py │ ├── rf_configuration.py │ ├── cancel_request.py │ ├── task_entity.py │ ├── schedule.py │ ├── principal.py │ ├── ontology.py │ ├── field_classification_information.py │ ├── mode5.py │ ├── alert_condition.py │ ├── cron_window.py │ ├── line_of_bearing.py │ ├── relationship_type.py │ ├── relationship.py │ ├── tracked_by.py │ ├── task_error.py │ ├── entity_manager_pose.py │ ├── geo_ellipsoid.py │ ├── geo_polygon.py │ ├── decorrelation.py │ ├── angle_of_arrival.py │ ├── system.py │ ├── range_rings.py │ ├── correlation_membership.py │ ├── color.py │ ├── component_health.py │ ├── projected_frustum.py │ ├── task_query_results.py │ ├── error_ellipse.py │ ├── location_uncertainty.py │ ├── location.py │ ├── task_version.py │ ├── correlation_metadata.py │ └── agent_request.py │ ├── version.py │ ├── core │ ├── http_sse │ │ ├── _exceptions.py │ │ ├── _models.py │ │ ├── __init__.py │ │ └── _decoders.py │ ├── remove_none_from_dict.py │ ├── force_multipart.py │ ├── api_error.py │ ├── datetime_utils.py │ ├── http_response.py │ └── request_options.py │ ├── environment.py │ ├── objects │ ├── types │ │ ├── get_object_request_accept_encoding.py │ │ └── __init__.py │ └── __init__.py │ ├── errors │ ├── not_found_error.py │ ├── bad_request_error.py │ ├── unauthorized_error.py │ ├── content_too_large_error.py │ ├── internal_server_error.py │ ├── request_timeout_error.py │ ├── too_many_requests_error.py │ └── insufficient_storage_error.py │ ├── task │ ├── types │ │ ├── error.py │ │ └── __init__.py │ └── __init__.py │ ├── object │ ├── types │ │ ├── error.py │ │ └── __init__.py │ └── __init__.py │ ├── tasks │ ├── types │ │ ├── task_query_status_filter_status.py │ │ ├── task_query_status_filter.py │ │ ├── task_query_update_time_range.py │ │ └── __init__.py │ └── __init__.py │ ├── entity │ ├── types │ │ ├── error.py │ │ └── __init__.py │ └── __init__.py │ └── entities │ ├── __init__.py │ └── types │ └── __init__.py ├── .github └── CODEOWNERS ├── .fernignore ├── .gitignore ├── tests ├── utils │ ├── __init__.py │ ├── assets │ │ └── models │ │ │ ├── color.py │ │ │ ├── undiscriminated_shape.py │ │ │ ├── circle.py │ │ │ ├── square.py │ │ │ ├── object_with_defaults.py │ │ │ ├── __init__.py │ │ │ ├── shape.py │ │ │ └── object_with_optional_field.py │ └── test_query_encoding.py └── custom │ └── test_client.py ├── requirements.txt ├── .fern └── metadata.json └── SECURITY.md /src/anduril/py.typed: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /.github/CODEOWNERS: -------------------------------------------------------------------------------- 1 | * @anduril/lattice-sdk-maintainers 2 | -------------------------------------------------------------------------------- /.fernignore: -------------------------------------------------------------------------------- 1 | SECURITY.md 2 | .github/CODEOWNERS 3 | third-party-licenses.txt 4 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .mypy_cache/ 2 | .ruff_cache/ 3 | __pycache__/ 4 | dist/ 5 | poetry.toml 6 | -------------------------------------------------------------------------------- /tests/utils/__init__.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | httpx>=0.21.2 2 | pydantic>= 1.9.2 3 | pydantic-core>=2.18.2 4 | typing_extensions>= 4.0.0 5 | -------------------------------------------------------------------------------- /src/anduril/types/timestamp.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | Timestamp = str 4 | -------------------------------------------------------------------------------- /src/anduril/version.py: -------------------------------------------------------------------------------- 1 | from importlib import metadata 2 | 3 | __version__ = metadata.version("anduril-lattice-sdk") 4 | -------------------------------------------------------------------------------- /src/anduril/core/http_sse/_exceptions.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import httpx 4 | 5 | 6 | class SSEError(httpx.TransportError): 7 | pass 8 | -------------------------------------------------------------------------------- /src/anduril/environment.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import enum 4 | 5 | 6 | class LatticeEnvironment(enum.Enum): 7 | DEFAULT = "https://example.developer.anduril.com" 8 | -------------------------------------------------------------------------------- /tests/custom/test_client.py: -------------------------------------------------------------------------------- 1 | import pytest 2 | 3 | 4 | # Get started with writing tests with pytest at https://docs.pytest.org 5 | @pytest.mark.skip(reason="Unimplemented") 6 | def test_client() -> None: 7 | assert True 8 | -------------------------------------------------------------------------------- /.fern/metadata.json: -------------------------------------------------------------------------------- 1 | { 2 | "cliVersion": "3.5.0", 3 | "generatorName": "fernapi/fern-python-sdk", 4 | "generatorVersion": "4.38.4", 5 | "generatorConfig": { 6 | "client_class_name": "Lattice", 7 | "package_name": "anduril" 8 | } 9 | } -------------------------------------------------------------------------------- /src/anduril/objects/types/get_object_request_accept_encoding.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | GetObjectRequestAcceptEncoding = typing.Union[typing.Literal["identity", "zstd"], typing.Any] 6 | -------------------------------------------------------------------------------- /src/anduril/types/media_item_type.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | MediaItemType = typing.Union[typing.Literal["MEDIA_TYPE_INVALID", "MEDIA_TYPE_IMAGE", "MEDIA_TYPE_VIDEO"], typing.Any] 6 | -------------------------------------------------------------------------------- /src/anduril/types/acm_details_acm_type.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | AcmDetailsAcmType = typing.Union[typing.Literal["ACM_DETAIL_TYPE_INVALID", "ACM_DETAIL_TYPE_LANDING_ZONE"], typing.Any] 6 | -------------------------------------------------------------------------------- /tests/utils/assets/models/color.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | # This file was auto-generated by Fern from our API Definition. 4 | 5 | import typing 6 | 7 | Color = typing.Union[typing.Literal["red", "blue"], typing.Any] 8 | -------------------------------------------------------------------------------- /src/anduril/types/override_type.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | OverrideType = typing.Union[ 6 | typing.Literal["OVERRIDE_TYPE_INVALID", "OVERRIDE_TYPE_LIVE", "OVERRIDE_TYPE_POST_EXPIRY"], typing.Any 7 | ] 8 | -------------------------------------------------------------------------------- /src/anduril/types/alert_level.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | AlertLevel = typing.Union[ 6 | typing.Literal["ALERT_LEVEL_INVALID", "ALERT_LEVEL_ADVISORY", "ALERT_LEVEL_CAUTION", "ALERT_LEVEL_WARNING"], 7 | typing.Any, 8 | ] 9 | -------------------------------------------------------------------------------- /src/anduril/types/power_source_power_type.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | PowerSourcePowerType = typing.Union[ 6 | typing.Literal["POWER_TYPE_INVALID", "POWER_TYPE_UNKNOWN", "POWER_TYPE_GAS", "POWER_TYPE_BATTERY"], typing.Any 7 | ] 8 | -------------------------------------------------------------------------------- /src/anduril/types/correlation_metadata_type.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | CorrelationMetadataType = typing.Union[ 6 | typing.Literal["CORRELATION_TYPE_INVALID", "CORRELATION_TYPE_MANUAL", "CORRELATION_TYPE_AUTOMATED"], typing.Any 7 | ] 8 | -------------------------------------------------------------------------------- /src/anduril/types/health_connection_status.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | HealthConnectionStatus = typing.Union[ 6 | typing.Literal["CONNECTION_STATUS_INVALID", "CONNECTION_STATUS_ONLINE", "CONNECTION_STATUS_OFFLINE"], typing.Any 7 | ] 8 | -------------------------------------------------------------------------------- /src/anduril/types/orbit_mean_elements_metadata_ref_frame.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | OrbitMeanElementsMetadataRefFrame = typing.Union[ 6 | typing.Literal["ECI_REFERENCE_FRAME_INVALID", "ECI_REFERENCE_FRAME_TEME"], typing.Any 7 | ] 8 | -------------------------------------------------------------------------------- /src/anduril/types/schedule_schedule_type.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | ScheduleScheduleType = typing.Union[ 6 | typing.Literal["SCHEDULE_TYPE_INVALID", "SCHEDULE_TYPE_ZONE_ENABLED", "SCHEDULE_TYPE_ZONE_TEMP_ENABLED"], typing.Any 7 | ] 8 | -------------------------------------------------------------------------------- /src/anduril/types/orbit_mean_elements_metadata_mean_element_theory.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | OrbitMeanElementsMetadataMeanElementTheory = typing.Union[ 6 | typing.Literal["MEAN_ELEMENT_THEORY_INVALID", "MEAN_ELEMENT_THEORY_SGP4"], typing.Any 7 | ] 8 | -------------------------------------------------------------------------------- /SECURITY.md: -------------------------------------------------------------------------------- 1 | # Security Policy 2 | 3 | ## Reporting a Vulnerability 4 | 5 | Please report any security issues to the Anduril Information Security team using the email disclosures@anduril.com. Additional information including our pgp key can be found in the [security.txt page](https://www.anduril.com/.well-known/security.txt) of our website. 6 | -------------------------------------------------------------------------------- /src/anduril/types/task_error_code.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | TaskErrorCode = typing.Union[ 6 | typing.Literal[ 7 | "ERROR_CODE_INVALID", "ERROR_CODE_CANCELLED", "ERROR_CODE_REJECTED", "ERROR_CODE_TIMEOUT", "ERROR_CODE_FAILED" 8 | ], 9 | typing.Any, 10 | ] 11 | -------------------------------------------------------------------------------- /tests/utils/assets/models/undiscriminated_shape.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | # This file was auto-generated by Fern from our API Definition. 4 | 5 | import typing 6 | 7 | from .circle import CircleParams 8 | from .square import SquareParams 9 | 10 | UndiscriminatedShapeParams = typing.Union[CircleParams, SquareParams] 11 | -------------------------------------------------------------------------------- /src/anduril/errors/not_found_error.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | from ..core.api_error import ApiError 6 | 7 | 8 | class NotFoundError(ApiError): 9 | def __init__(self, body: typing.Any, headers: typing.Optional[typing.Dict[str, str]] = None): 10 | super().__init__(status_code=404, headers=headers, body=body) 11 | -------------------------------------------------------------------------------- /src/anduril/errors/bad_request_error.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | from ..core.api_error import ApiError 6 | 7 | 8 | class BadRequestError(ApiError): 9 | def __init__(self, body: typing.Any, headers: typing.Optional[typing.Dict[str, str]] = None): 10 | super().__init__(status_code=400, headers=headers, body=body) 11 | -------------------------------------------------------------------------------- /src/anduril/errors/unauthorized_error.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | from ..core.api_error import ApiError 6 | 7 | 8 | class UnauthorizedError(ApiError): 9 | def __init__(self, body: typing.Any, headers: typing.Optional[typing.Dict[str, str]] = None): 10 | super().__init__(status_code=401, headers=headers, body=body) 11 | -------------------------------------------------------------------------------- /src/anduril/errors/content_too_large_error.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | from ..core.api_error import ApiError 6 | 7 | 8 | class ContentTooLargeError(ApiError): 9 | def __init__(self, body: typing.Any, headers: typing.Optional[typing.Dict[str, str]] = None): 10 | super().__init__(status_code=413, headers=headers, body=body) 11 | -------------------------------------------------------------------------------- /src/anduril/errors/internal_server_error.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | from ..core.api_error import ApiError 6 | 7 | 8 | class InternalServerError(ApiError): 9 | def __init__(self, body: typing.Any, headers: typing.Optional[typing.Dict[str, str]] = None): 10 | super().__init__(status_code=500, headers=headers, body=body) 11 | -------------------------------------------------------------------------------- /src/anduril/errors/request_timeout_error.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | from ..core.api_error import ApiError 6 | 7 | 8 | class RequestTimeoutError(ApiError): 9 | def __init__(self, body: typing.Any, headers: typing.Optional[typing.Dict[str, str]] = None): 10 | super().__init__(status_code=408, headers=headers, body=body) 11 | -------------------------------------------------------------------------------- /src/anduril/errors/too_many_requests_error.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | from ..core.api_error import ApiError 6 | 7 | 8 | class TooManyRequestsError(ApiError): 9 | def __init__(self, body: typing.Any, headers: typing.Optional[typing.Dict[str, str]] = None): 10 | super().__init__(status_code=429, headers=headers, body=body) 11 | -------------------------------------------------------------------------------- /src/anduril/errors/insufficient_storage_error.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | from ..core.api_error import ApiError 6 | 7 | 8 | class InsufficientStorageError(ApiError): 9 | def __init__(self, body: typing.Any, headers: typing.Optional[typing.Dict[str, str]] = None): 10 | super().__init__(status_code=507, headers=headers, body=body) 11 | -------------------------------------------------------------------------------- /src/anduril/types/correlation_metadata_replication_mode.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | CorrelationMetadataReplicationMode = typing.Union[ 6 | typing.Literal[ 7 | "CORRELATION_REPLICATION_MODE_INVALID", 8 | "CORRELATION_REPLICATION_MODE_LOCAL", 9 | "CORRELATION_REPLICATION_MODE_GLOBAL", 10 | ], 11 | typing.Any, 12 | ] 13 | -------------------------------------------------------------------------------- /src/anduril/core/remove_none_from_dict.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | from typing import Any, Dict, Mapping, Optional 4 | 5 | 6 | def remove_none_from_dict(original: Mapping[str, Optional[Any]]) -> Dict[str, Any]: 7 | new: Dict[str, Any] = {} 8 | for key, value in original.items(): 9 | if value is not None: 10 | new[key] = value 11 | return new 12 | -------------------------------------------------------------------------------- /tests/utils/assets/models/circle.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | # This file was auto-generated by Fern from our API Definition. 4 | 5 | import typing_extensions 6 | 7 | from anduril.core.serialization import FieldMetadata 8 | 9 | 10 | class CircleParams(typing_extensions.TypedDict): 11 | radius_measurement: typing_extensions.Annotated[float, FieldMetadata(alias="radiusMeasurement")] 12 | -------------------------------------------------------------------------------- /tests/utils/assets/models/square.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | # This file was auto-generated by Fern from our API Definition. 4 | 5 | import typing_extensions 6 | 7 | from anduril.core.serialization import FieldMetadata 8 | 9 | 10 | class SquareParams(typing_extensions.TypedDict): 11 | length_measurement: typing_extensions.Annotated[float, FieldMetadata(alias="lengthMeasurement")] 12 | -------------------------------------------------------------------------------- /src/anduril/types/field_of_view_mode.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | FieldOfViewMode = typing.Union[ 6 | typing.Literal[ 7 | "SENSOR_MODE_INVALID", 8 | "SENSOR_MODE_SEARCH", 9 | "SENSOR_MODE_TRACK", 10 | "SENSOR_MODE_WEAPON_SUPPORT", 11 | "SENSOR_MODE_AUTO", 12 | "SENSOR_MODE_MUTE", 13 | ], 14 | typing.Any, 15 | ] 16 | -------------------------------------------------------------------------------- /src/anduril/types/mil_view_environment.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | MilViewEnvironment = typing.Union[ 6 | typing.Literal[ 7 | "ENVIRONMENT_UNKNOWN", 8 | "ENVIRONMENT_AIR", 9 | "ENVIRONMENT_SURFACE", 10 | "ENVIRONMENT_SUB_SURFACE", 11 | "ENVIRONMENT_LAND", 12 | "ENVIRONMENT_SPACE", 13 | ], 14 | typing.Any, 15 | ] 16 | -------------------------------------------------------------------------------- /src/anduril/types/ontology_template.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | OntologyTemplate = typing.Union[ 6 | typing.Literal[ 7 | "TEMPLATE_INVALID", 8 | "TEMPLATE_TRACK", 9 | "TEMPLATE_SENSOR_POINT_OF_INTEREST", 10 | "TEMPLATE_ASSET", 11 | "TEMPLATE_GEO", 12 | "TEMPLATE_SIGNAL_OF_INTEREST", 13 | ], 14 | typing.Any, 15 | ] 16 | -------------------------------------------------------------------------------- /src/anduril/types/mode5mode5interrogation_response.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | Mode5Mode5InterrogationResponse = typing.Union[ 6 | typing.Literal[ 7 | "INTERROGATION_RESPONSE_INVALID", 8 | "INTERROGATION_RESPONSE_CORRECT", 9 | "INTERROGATION_RESPONSE_INCORRECT", 10 | "INTERROGATION_RESPONSE_NO_RESPONSE", 11 | ], 12 | typing.Any, 13 | ] 14 | -------------------------------------------------------------------------------- /src/anduril/types/health_health_status.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | HealthHealthStatus = typing.Union[ 6 | typing.Literal[ 7 | "HEALTH_STATUS_INVALID", 8 | "HEALTH_STATUS_HEALTHY", 9 | "HEALTH_STATUS_WARN", 10 | "HEALTH_STATUS_FAIL", 11 | "HEALTH_STATUS_OFFLINE", 12 | "HEALTH_STATUS_NOT_READY", 13 | ], 14 | typing.Any, 15 | ] 16 | -------------------------------------------------------------------------------- /src/anduril/types/component_health_health.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | ComponentHealthHealth = typing.Union[ 6 | typing.Literal[ 7 | "HEALTH_STATUS_INVALID", 8 | "HEALTH_STATUS_HEALTHY", 9 | "HEALTH_STATUS_WARN", 10 | "HEALTH_STATUS_FAIL", 11 | "HEALTH_STATUS_OFFLINE", 12 | "HEALTH_STATUS_NOT_READY", 13 | ], 14 | typing.Any, 15 | ] 16 | -------------------------------------------------------------------------------- /src/anduril/types/entity_event_event_type.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | EntityEventEventType = typing.Union[ 6 | typing.Literal[ 7 | "EVENT_TYPE_INVALID", 8 | "EVENT_TYPE_CREATED", 9 | "EVENT_TYPE_UPDATE", 10 | "EVENT_TYPE_DELETED", 11 | "EVENT_TYPE_PREEXISTING", 12 | "EVENT_TYPE_POST_EXPIRY_OVERRIDE", 13 | ], 14 | typing.Any, 15 | ] 16 | -------------------------------------------------------------------------------- /src/anduril/types/component_message_status.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | ComponentMessageStatus = typing.Union[ 6 | typing.Literal[ 7 | "HEALTH_STATUS_INVALID", 8 | "HEALTH_STATUS_HEALTHY", 9 | "HEALTH_STATUS_WARN", 10 | "HEALTH_STATUS_FAIL", 11 | "HEALTH_STATUS_OFFLINE", 12 | "HEALTH_STATUS_NOT_READY", 13 | ], 14 | typing.Any, 15 | ] 16 | -------------------------------------------------------------------------------- /src/anduril/types/power_source_power_status.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | PowerSourcePowerStatus = typing.Union[ 6 | typing.Literal[ 7 | "POWER_STATUS_INVALID", 8 | "POWER_STATUS_UNKNOWN", 9 | "POWER_STATUS_NOT_PRESENT", 10 | "POWER_STATUS_OPERATING", 11 | "POWER_STATUS_DISABLED", 12 | "POWER_STATUS_ERROR", 13 | ], 14 | typing.Any, 15 | ] 16 | -------------------------------------------------------------------------------- /src/anduril/types/control_area_details_type.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | ControlAreaDetailsType = typing.Union[ 6 | typing.Literal[ 7 | "CONTROL_AREA_TYPE_INVALID", 8 | "CONTROL_AREA_TYPE_KEEP_IN_ZONE", 9 | "CONTROL_AREA_TYPE_KEEP_OUT_ZONE", 10 | "CONTROL_AREA_TYPE_DITCH_ZONE", 11 | "CONTROL_AREA_TYPE_LOITER_ZONE", 12 | ], 13 | typing.Any, 14 | ] 15 | -------------------------------------------------------------------------------- /src/anduril/types/override_status.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | OverrideStatus = typing.Union[ 6 | typing.Literal[ 7 | "OVERRIDE_STATUS_INVALID", 8 | "OVERRIDE_STATUS_APPLIED", 9 | "OVERRIDE_STATUS_PENDING", 10 | "OVERRIDE_STATUS_TIMEOUT", 11 | "OVERRIDE_STATUS_REJECTED", 12 | "OVERRIDE_STATUS_DELETION_PENDING", 13 | ], 14 | typing.Any, 15 | ] 16 | -------------------------------------------------------------------------------- /src/anduril/types/transponder_codes_mode4interrogation_response.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | TransponderCodesMode4InterrogationResponse = typing.Union[ 6 | typing.Literal[ 7 | "INTERROGATION_RESPONSE_INVALID", 8 | "INTERROGATION_RESPONSE_CORRECT", 9 | "INTERROGATION_RESPONSE_INCORRECT", 10 | "INTERROGATION_RESPONSE_NO_RESPONSE", 11 | ], 12 | typing.Any, 13 | ] 14 | -------------------------------------------------------------------------------- /src/anduril/types/mil_view_disposition.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | MilViewDisposition = typing.Union[ 6 | typing.Literal[ 7 | "DISPOSITION_UNKNOWN", 8 | "DISPOSITION_FRIENDLY", 9 | "DISPOSITION_HOSTILE", 10 | "DISPOSITION_SUSPICIOUS", 11 | "DISPOSITION_ASSUMED_FRIENDLY", 12 | "DISPOSITION_NEUTRAL", 13 | "DISPOSITION_PENDING", 14 | ], 15 | typing.Any, 16 | ] 17 | -------------------------------------------------------------------------------- /src/anduril/types/payload_configuration_effective_environment_item.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | PayloadConfigurationEffectiveEnvironmentItem = typing.Union[ 6 | typing.Literal[ 7 | "ENVIRONMENT_UNKNOWN", 8 | "ENVIRONMENT_AIR", 9 | "ENVIRONMENT_SURFACE", 10 | "ENVIRONMENT_SUB_SURFACE", 11 | "ENVIRONMENT_LAND", 12 | "ENVIRONMENT_SPACE", 13 | ], 14 | typing.Any, 15 | ] 16 | -------------------------------------------------------------------------------- /src/anduril/types/geo_details_type.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | GeoDetailsType = typing.Union[ 6 | typing.Literal[ 7 | "GEO_TYPE_INVALID", 8 | "GEO_TYPE_GENERAL", 9 | "GEO_TYPE_HAZARD", 10 | "GEO_TYPE_EMERGENCY", 11 | "GEO_TYPE_ENGAGEMENT_ZONE", 12 | "GEO_TYPE_CONTROL_AREA", 13 | "GEO_TYPE_BULLSEYE", 14 | "GEO_TYPE_ACM", 15 | ], 16 | typing.Any, 17 | ] 18 | -------------------------------------------------------------------------------- /src/anduril/types/sensor_operational_state.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | SensorOperationalState = typing.Union[ 6 | typing.Literal[ 7 | "OPERATIONAL_STATE_INVALID", 8 | "OPERATIONAL_STATE_OFF", 9 | "OPERATIONAL_STATE_NON_OPERATIONAL", 10 | "OPERATIONAL_STATE_DEGRADED", 11 | "OPERATIONAL_STATE_OPERATIONAL", 12 | "OPERATIONAL_STATE_DENIED", 13 | ], 14 | typing.Any, 15 | ] 16 | -------------------------------------------------------------------------------- /src/anduril/core/http_sse/_models.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import json 4 | from dataclasses import dataclass 5 | from typing import Any, Optional 6 | 7 | 8 | @dataclass(frozen=True) 9 | class ServerSentEvent: 10 | event: str = "message" 11 | data: str = "" 12 | id: str = "" 13 | retry: Optional[int] = None 14 | 15 | def json(self) -> Any: 16 | """Parse the data field as JSON.""" 17 | return json.loads(self.data) 18 | -------------------------------------------------------------------------------- /tests/utils/assets/models/object_with_defaults.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | # This file was auto-generated by Fern from our API Definition. 4 | 5 | import typing_extensions 6 | 7 | 8 | class ObjectWithDefaultsParams(typing_extensions.TypedDict): 9 | """ 10 | Defines properties with default values and validation rules. 11 | """ 12 | 13 | decimal: typing_extensions.NotRequired[float] 14 | string: typing_extensions.NotRequired[str] 15 | required_string: str 16 | -------------------------------------------------------------------------------- /src/anduril/types/sensor_sensor_type.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | SensorSensorType = typing.Union[ 6 | typing.Literal[ 7 | "SENSOR_TYPE_INVALID", 8 | "SENSOR_TYPE_RADAR", 9 | "SENSOR_TYPE_CAMERA", 10 | "SENSOR_TYPE_TRANSPONDER", 11 | "SENSOR_TYPE_RF", 12 | "SENSOR_TYPE_GPS", 13 | "SENSOR_TYPE_PTU_POS", 14 | "SENSOR_TYPE_PERIMETER", 15 | "SENSOR_TYPE_SONAR", 16 | ], 17 | typing.Any, 18 | ] 19 | -------------------------------------------------------------------------------- /src/anduril/types/classification_information_level.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | ClassificationInformationLevel = typing.Union[ 6 | typing.Literal[ 7 | "CLASSIFICATION_LEVELS_INVALID", 8 | "CLASSIFICATION_LEVELS_UNCLASSIFIED", 9 | "CLASSIFICATION_LEVELS_CONTROLLED_UNCLASSIFIED", 10 | "CLASSIFICATION_LEVELS_CONFIDENTIAL", 11 | "CLASSIFICATION_LEVELS_SECRET", 12 | "CLASSIFICATION_LEVELS_TOP_SECRET", 13 | ], 14 | typing.Any, 15 | ] 16 | -------------------------------------------------------------------------------- /src/anduril/types/lla_altitude_reference.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | LlaAltitudeReference = typing.Union[ 6 | typing.Literal[ 7 | "ALTITUDE_REFERENCE_INVALID", 8 | "ALTITUDE_REFERENCE_HEIGHT_ABOVE_WGS84", 9 | "ALTITUDE_REFERENCE_HEIGHT_ABOVE_EGM96", 10 | "ALTITUDE_REFERENCE_UNKNOWN", 11 | "ALTITUDE_REFERENCE_BAROMETRIC", 12 | "ALTITUDE_REFERENCE_ABOVE_SEA_FLOOR", 13 | "ALTITUDE_REFERENCE_BELOW_SEA_SURFACE", 14 | ], 15 | typing.Any, 16 | ] 17 | -------------------------------------------------------------------------------- /src/anduril/core/force_multipart.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | from typing import Any, Dict 4 | 5 | 6 | class ForceMultipartDict(Dict[str, Any]): 7 | """ 8 | A dictionary subclass that always evaluates to True in boolean contexts. 9 | 10 | This is used to force multipart/form-data encoding in HTTP requests even when 11 | the dictionary is empty, which would normally evaluate to False. 12 | """ 13 | 14 | def __bool__(self) -> bool: 15 | return True 16 | 17 | 18 | FORCE_MULTIPART = ForceMultipartDict() 19 | -------------------------------------------------------------------------------- /src/anduril/types/primary_membership.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | 8 | 9 | class PrimaryMembership(UniversalBaseModel): 10 | if IS_PYDANTIC_V2: 11 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 12 | else: 13 | 14 | class Config: 15 | frozen = True 16 | smart_union = True 17 | extra = pydantic.Extra.allow 18 | -------------------------------------------------------------------------------- /src/anduril/types/non_primary_membership.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | 8 | 9 | class NonPrimaryMembership(UniversalBaseModel): 10 | if IS_PYDANTIC_V2: 11 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 12 | else: 13 | 14 | class Config: 15 | frozen = True 16 | smart_union = True 17 | extra = pydantic.Extra.allow 18 | -------------------------------------------------------------------------------- /src/anduril/types/echelon_army_echelon.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | EchelonArmyEchelon = typing.Union[ 6 | typing.Literal[ 7 | "ARMY_ECHELON_INVALID", 8 | "ARMY_ECHELON_FIRE_TEAM", 9 | "ARMY_ECHELON_SQUAD", 10 | "ARMY_ECHELON_PLATOON", 11 | "ARMY_ECHELON_COMPANY", 12 | "ARMY_ECHELON_BATTALION", 13 | "ARMY_ECHELON_REGIMENT", 14 | "ARMY_ECHELON_BRIGADE", 15 | "ARMY_ECHELON_DIVISION", 16 | "ARMY_ECHELON_CORPS", 17 | "ARMY_ECHELON_ARMY", 18 | ], 19 | typing.Any, 20 | ] 21 | -------------------------------------------------------------------------------- /src/anduril/task/types/error.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ...core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | 8 | 9 | class Error(UniversalBaseModel): 10 | code: str 11 | message: str 12 | 13 | if IS_PYDANTIC_V2: 14 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 15 | else: 16 | 17 | class Config: 18 | frozen = True 19 | smart_union = True 20 | extra = pydantic.Extra.allow 21 | -------------------------------------------------------------------------------- /src/anduril/object/types/error.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ...core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | 8 | 9 | class Error(UniversalBaseModel): 10 | code: str 11 | message: str 12 | 13 | if IS_PYDANTIC_V2: 14 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 15 | else: 16 | 17 | class Config: 18 | frozen = True 19 | smart_union = True 20 | extra = pydantic.Extra.allow 21 | -------------------------------------------------------------------------------- /src/anduril/types/payload_configuration_payload_operational_state.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | PayloadConfigurationPayloadOperationalState = typing.Union[ 6 | typing.Literal[ 7 | "PAYLOAD_OPERATIONAL_STATE_INVALID", 8 | "PAYLOAD_OPERATIONAL_STATE_OFF", 9 | "PAYLOAD_OPERATIONAL_STATE_NON_OPERATIONAL", 10 | "PAYLOAD_OPERATIONAL_STATE_DEGRADED", 11 | "PAYLOAD_OPERATIONAL_STATE_OPERATIONAL", 12 | "PAYLOAD_OPERATIONAL_STATE_OUT_OF_SERVICE", 13 | "PAYLOAD_OPERATIONAL_STATE_UNKNOWN", 14 | ], 15 | typing.Any, 16 | ] 17 | -------------------------------------------------------------------------------- /src/anduril/types/entity_stream_heartbeat.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2 7 | from .heartbeat_object import HeartbeatObject 8 | 9 | 10 | class EntityStreamHeartbeat(HeartbeatObject): 11 | if IS_PYDANTIC_V2: 12 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 13 | else: 14 | 15 | class Config: 16 | frozen = True 17 | smart_union = True 18 | extra = pydantic.Extra.allow 19 | -------------------------------------------------------------------------------- /src/anduril/types/mil_std2525c.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | 8 | 9 | class MilStd2525C(UniversalBaseModel): 10 | sidc: typing.Optional[str] = None 11 | 12 | if IS_PYDANTIC_V2: 13 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 14 | else: 15 | 16 | class Config: 17 | frozen = True 18 | smart_union = True 19 | extra = pydantic.Extra.allow 20 | -------------------------------------------------------------------------------- /src/anduril/types/entity_stream_event.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | from __future__ import annotations 4 | 5 | import typing 6 | 7 | import pydantic 8 | from ..core.pydantic_utilities import IS_PYDANTIC_V2 9 | from .entity_event import EntityEvent 10 | 11 | 12 | class EntityStreamEvent(EntityEvent): 13 | if IS_PYDANTIC_V2: 14 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 15 | else: 16 | 17 | class Config: 18 | frozen = True 19 | smart_union = True 20 | extra = pydantic.Extra.allow 21 | -------------------------------------------------------------------------------- /src/anduril/types/enu.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | 8 | 9 | class Enu(UniversalBaseModel): 10 | e: typing.Optional[float] = None 11 | n: typing.Optional[float] = None 12 | u: typing.Optional[float] = None 13 | 14 | if IS_PYDANTIC_V2: 15 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 16 | else: 17 | 18 | class Config: 19 | frozen = True 20 | smart_union = True 21 | extra = pydantic.Extra.allow 22 | -------------------------------------------------------------------------------- /src/anduril/core/api_error.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | from typing import Any, Dict, Optional 4 | 5 | 6 | class ApiError(Exception): 7 | headers: Optional[Dict[str, str]] 8 | status_code: Optional[int] 9 | body: Any 10 | 11 | def __init__( 12 | self, 13 | *, 14 | headers: Optional[Dict[str, str]] = None, 15 | status_code: Optional[int] = None, 16 | body: Any = None, 17 | ) -> None: 18 | self.headers = headers 19 | self.status_code = status_code 20 | self.body = body 21 | 22 | def __str__(self) -> str: 23 | return f"headers: {self.headers}, status_code: {self.status_code}, body: {self.body}" 24 | -------------------------------------------------------------------------------- /src/anduril/types/fixed.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | 8 | 9 | class Fixed(UniversalBaseModel): 10 | """ 11 | A fix of a signal. No extra fields but it is expected that location should be populated when using this report. 12 | """ 13 | 14 | if IS_PYDANTIC_V2: 15 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 16 | else: 17 | 18 | class Config: 19 | frozen = True 20 | smart_union = True 21 | extra = pydantic.Extra.allow 22 | -------------------------------------------------------------------------------- /src/anduril/types/task_status_status.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | TaskStatusStatus = typing.Union[ 6 | typing.Literal[ 7 | "STATUS_INVALID", 8 | "STATUS_CREATED", 9 | "STATUS_SCHEDULED_IN_MANAGER", 10 | "STATUS_SENT", 11 | "STATUS_MACHINE_RECEIPT", 12 | "STATUS_ACK", 13 | "STATUS_WILCO", 14 | "STATUS_EXECUTING", 15 | "STATUS_WAITING_FOR_UPDATE", 16 | "STATUS_DONE_OK", 17 | "STATUS_DONE_NOT_OK", 18 | "STATUS_REPLACED", 19 | "STATUS_CANCEL_REQUESTED", 20 | "STATUS_COMPLETE_REQUESTED", 21 | "STATUS_VERSION_REJECTED", 22 | ], 23 | typing.Any, 24 | ] 25 | -------------------------------------------------------------------------------- /src/anduril/types/list_response.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | from .path_metadata import PathMetadata 8 | 9 | 10 | class ListResponse(UniversalBaseModel): 11 | path_metadatas: typing.List[PathMetadata] 12 | next_page_token: typing.Optional[str] = None 13 | 14 | if IS_PYDANTIC_V2: 15 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 16 | else: 17 | 18 | class Config: 19 | frozen = True 20 | smart_union = True 21 | extra = pydantic.Extra.allow 22 | -------------------------------------------------------------------------------- /src/anduril/types/media.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | from .media_item import MediaItem 8 | 9 | 10 | class Media(UniversalBaseModel): 11 | """ 12 | Media associated with an entity. 13 | """ 14 | 15 | media: typing.Optional[typing.List[MediaItem]] = None 16 | 17 | if IS_PYDANTIC_V2: 18 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 19 | else: 20 | 21 | class Config: 22 | frozen = True 23 | smart_union = True 24 | extra = pydantic.Extra.allow 25 | -------------------------------------------------------------------------------- /src/anduril/tasks/types/task_query_status_filter_status.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | TaskQueryStatusFilterStatus = typing.Union[ 6 | typing.Literal[ 7 | "STATUS_INVALID", 8 | "STATUS_CREATED", 9 | "STATUS_SCHEDULED_IN_MANAGER", 10 | "STATUS_SENT", 11 | "STATUS_MACHINE_RECEIPT", 12 | "STATUS_ACK", 13 | "STATUS_WILCO", 14 | "STATUS_EXECUTING", 15 | "STATUS_WAITING_FOR_UPDATE", 16 | "STATUS_DONE_OK", 17 | "STATUS_DONE_NOT_OK", 18 | "STATUS_REPLACED", 19 | "STATUS_CANCEL_REQUESTED", 20 | "STATUS_COMPLETE_REQUESTED", 21 | "STATUS_VERSION_REJECTED", 22 | ], 23 | typing.Any, 24 | ] 25 | -------------------------------------------------------------------------------- /src/anduril/types/sensors.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | from .sensor import Sensor 8 | 9 | 10 | class Sensors(UniversalBaseModel): 11 | """ 12 | List of sensors available for an entity. 13 | """ 14 | 15 | sensors: typing.Optional[typing.List[Sensor]] = None 16 | 17 | if IS_PYDANTIC_V2: 18 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 19 | else: 20 | 21 | class Config: 22 | frozen = True 23 | smart_union = True 24 | extra = pydantic.Extra.allow 25 | -------------------------------------------------------------------------------- /src/anduril/types/heartbeat_object.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import datetime as dt 4 | import typing 5 | 6 | import pydantic 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | 9 | 10 | class HeartbeatObject(UniversalBaseModel): 11 | timestamp: typing.Optional[dt.datetime] = pydantic.Field(default=None) 12 | """ 13 | timestamp of the heartbeat 14 | """ 15 | 16 | if IS_PYDANTIC_V2: 17 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 18 | else: 19 | 20 | class Config: 21 | frozen = True 22 | smart_union = True 23 | extra = pydantic.Extra.allow 24 | -------------------------------------------------------------------------------- /src/anduril/types/schedules.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | from .schedule import Schedule 8 | 9 | 10 | class Schedules(UniversalBaseModel): 11 | """ 12 | Schedules associated with this entity 13 | """ 14 | 15 | schedules: typing.Optional[typing.List[Schedule]] = None 16 | 17 | if IS_PYDANTIC_V2: 18 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 19 | else: 20 | 21 | class Config: 22 | frozen = True 23 | smart_union = True 24 | extra = pydantic.Extra.allow 25 | -------------------------------------------------------------------------------- /src/anduril/entity/types/error.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ...core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ...core.serialization import FieldMetadata 9 | 10 | 11 | class Error(UniversalBaseModel): 12 | error_code: typing_extensions.Annotated[str, FieldMetadata(alias="errorCode")] 13 | message: str 14 | 15 | if IS_PYDANTIC_V2: 16 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 17 | else: 18 | 19 | class Config: 20 | frozen = True 21 | smart_union = True 22 | extra = pydantic.Extra.allow 23 | -------------------------------------------------------------------------------- /src/anduril/types/payload.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | from .payload_configuration import PayloadConfiguration 8 | 9 | 10 | class Payload(UniversalBaseModel): 11 | """ 12 | Individual payload configuration. 13 | """ 14 | 15 | config: typing.Optional[PayloadConfiguration] = None 16 | 17 | if IS_PYDANTIC_V2: 18 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 19 | else: 20 | 21 | class Config: 22 | frozen = True 23 | smart_union = True 24 | extra = pydantic.Extra.allow 25 | -------------------------------------------------------------------------------- /src/anduril/types/active_target.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | 8 | 9 | class ActiveTarget(UniversalBaseModel): 10 | """ 11 | A target relationship is the inverse of TrackedBy; a one-way relation 12 | from sensor to target, indicating track(s) currently prioritized by a robot. 13 | """ 14 | 15 | if IS_PYDANTIC_V2: 16 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 17 | else: 18 | 19 | class Config: 20 | frozen = True 21 | smart_union = True 22 | extra = pydantic.Extra.allow 23 | -------------------------------------------------------------------------------- /tests/utils/assets/models/__init__.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | # This file was auto-generated by Fern from our API Definition. 4 | 5 | from .circle import CircleParams 6 | from .object_with_defaults import ObjectWithDefaultsParams 7 | from .object_with_optional_field import ObjectWithOptionalFieldParams 8 | from .shape import Shape_CircleParams, Shape_SquareParams, ShapeParams 9 | from .square import SquareParams 10 | from .undiscriminated_shape import UndiscriminatedShapeParams 11 | 12 | __all__ = [ 13 | "CircleParams", 14 | "ObjectWithDefaultsParams", 15 | "ObjectWithOptionalFieldParams", 16 | "ShapeParams", 17 | "Shape_CircleParams", 18 | "Shape_SquareParams", 19 | "SquareParams", 20 | "UndiscriminatedShapeParams", 21 | ] 22 | -------------------------------------------------------------------------------- /src/anduril/types/alternate_id.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | from .alternate_id_type import AlternateIdType 8 | 9 | 10 | class AlternateId(UniversalBaseModel): 11 | """ 12 | An alternate id for an Entity. 13 | """ 14 | 15 | id: typing.Optional[str] = None 16 | type: typing.Optional[AlternateIdType] = None 17 | 18 | if IS_PYDANTIC_V2: 19 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 20 | else: 21 | 22 | class Config: 23 | frozen = True 24 | smart_union = True 25 | extra = pydantic.Extra.allow 26 | -------------------------------------------------------------------------------- /src/anduril/types/decorrelated_all.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | from .correlation_metadata import CorrelationMetadata 8 | 9 | 10 | class DecorrelatedAll(UniversalBaseModel): 11 | metadata: typing.Optional[CorrelationMetadata] = pydantic.Field(default=None) 12 | """ 13 | Metadata about the decorrelation. 14 | """ 15 | 16 | if IS_PYDANTIC_V2: 17 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 18 | else: 19 | 20 | class Config: 21 | frozen = True 22 | smart_union = True 23 | extra = pydantic.Extra.allow 24 | -------------------------------------------------------------------------------- /src/anduril/types/geo_point.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | from .position import Position 8 | 9 | 10 | class GeoPoint(UniversalBaseModel): 11 | """ 12 | A point shaped geo-entity. 13 | See https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.2 14 | """ 15 | 16 | position: typing.Optional[Position] = None 17 | 18 | if IS_PYDANTIC_V2: 19 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 20 | else: 21 | 22 | class Config: 23 | frozen = True 24 | smart_union = True 25 | extra = pydantic.Extra.allow 26 | -------------------------------------------------------------------------------- /src/anduril/types/merged_from.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | 8 | 9 | class MergedFrom(UniversalBaseModel): 10 | """ 11 | A MergedFrom relationship is a uni-directional relationship indicating that this entity is a merged entity whose 12 | data has at least partially been merged from the related entity. 13 | """ 14 | 15 | if IS_PYDANTIC_V2: 16 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 17 | else: 18 | 19 | class Config: 20 | frozen = True 21 | smart_union = True 22 | extra = pydantic.Extra.allow 23 | -------------------------------------------------------------------------------- /src/anduril/types/supplies.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | from .fuel import Fuel 8 | 9 | 10 | class Supplies(UniversalBaseModel): 11 | """ 12 | Represents the state of supplies associated with an entity (available but not in condition to use immediately) 13 | """ 14 | 15 | fuel: typing.Optional[typing.List[Fuel]] = None 16 | 17 | if IS_PYDANTIC_V2: 18 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 19 | else: 20 | 21 | class Config: 22 | frozen = True 23 | smart_union = True 24 | extra = pydantic.Extra.allow 25 | -------------------------------------------------------------------------------- /src/anduril/types/geo_line.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | from .position import Position 8 | 9 | 10 | class GeoLine(UniversalBaseModel): 11 | """ 12 | A line shaped geo-entity. 13 | See https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.4 14 | """ 15 | 16 | positions: typing.Optional[typing.List[Position]] = None 17 | 18 | if IS_PYDANTIC_V2: 19 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 20 | else: 21 | 22 | class Config: 23 | frozen = True 24 | smart_union = True 25 | extra = pydantic.Extra.allow 26 | -------------------------------------------------------------------------------- /src/anduril/types/group_details.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | from .echelon import Echelon 8 | from .team import Team 9 | 10 | 11 | class GroupDetails(UniversalBaseModel): 12 | """ 13 | Details related to grouping for this entity 14 | """ 15 | 16 | team: typing.Optional[Team] = None 17 | echelon: typing.Optional[Echelon] = None 18 | 19 | if IS_PYDANTIC_V2: 20 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 21 | else: 22 | 23 | class Config: 24 | frozen = True 25 | smart_union = True 26 | extra = pydantic.Extra.allow 27 | -------------------------------------------------------------------------------- /src/anduril/types/linear_ring.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | from .geo_polygon_position import GeoPolygonPosition 8 | 9 | 10 | class LinearRing(UniversalBaseModel): 11 | """ 12 | A closed ring of points. The first and last point must be the same. 13 | """ 14 | 15 | positions: typing.Optional[typing.List[GeoPolygonPosition]] = None 16 | 17 | if IS_PYDANTIC_V2: 18 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 19 | else: 20 | 21 | class Config: 22 | frozen = True 23 | smart_union = True 24 | extra = pydantic.Extra.allow 25 | -------------------------------------------------------------------------------- /src/anduril/types/path_metadata.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import datetime as dt 4 | import typing 5 | 6 | import pydantic 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from .content_identifier import ContentIdentifier 9 | 10 | 11 | class PathMetadata(UniversalBaseModel): 12 | content_identifier: ContentIdentifier 13 | size_bytes: int 14 | last_updated_at: dt.datetime 15 | expiry_time: typing.Optional[dt.datetime] = None 16 | 17 | if IS_PYDANTIC_V2: 18 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 19 | else: 20 | 21 | class Config: 22 | frozen = True 23 | smart_union = True 24 | extra = pydantic.Extra.allow 25 | -------------------------------------------------------------------------------- /src/anduril/types/relationships.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | from .relationship import Relationship 8 | 9 | 10 | class Relationships(UniversalBaseModel): 11 | """ 12 | The relationships between this entity and other entities in the common operational picture. 13 | """ 14 | 15 | relationships: typing.Optional[typing.List[Relationship]] = None 16 | 17 | if IS_PYDANTIC_V2: 18 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 19 | else: 20 | 21 | class Config: 22 | frozen = True 23 | smart_union = True 24 | extra = pydantic.Extra.allow 25 | -------------------------------------------------------------------------------- /src/anduril/types/quaternion.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | 8 | 9 | class Quaternion(UniversalBaseModel): 10 | x: typing.Optional[float] = pydantic.Field(default=None) 11 | """ 12 | x, y, z are vector portion, w is scalar 13 | """ 14 | 15 | y: typing.Optional[float] = None 16 | z: typing.Optional[float] = None 17 | w: typing.Optional[float] = None 18 | 19 | if IS_PYDANTIC_V2: 20 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 21 | else: 22 | 23 | class Config: 24 | frozen = True 25 | smart_union = True 26 | extra = pydantic.Extra.allow 27 | -------------------------------------------------------------------------------- /src/anduril/types/t_mat2.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | 8 | 9 | class TMat2(UniversalBaseModel): 10 | """ 11 | symmetric 2d matrix only representing the upper right triangle, useful for 12 | covariance matrices 13 | """ 14 | 15 | mxx: typing.Optional[float] = None 16 | mxy: typing.Optional[float] = None 17 | myy: typing.Optional[float] = None 18 | 19 | if IS_PYDANTIC_V2: 20 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 21 | else: 22 | 23 | class Config: 24 | frozen = True 25 | smart_union = True 26 | extra = pydantic.Extra.allow 27 | -------------------------------------------------------------------------------- /src/anduril/types/bandwidth.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | 10 | 11 | class Bandwidth(UniversalBaseModel): 12 | """ 13 | Describes the bandwidth of a signal 14 | """ 15 | 16 | bandwidth_hz: typing_extensions.Annotated[typing.Optional[float], FieldMetadata(alias="bandwidthHz")] = None 17 | 18 | if IS_PYDANTIC_V2: 19 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 20 | else: 21 | 22 | class Config: 23 | frozen = True 24 | smart_union = True 25 | extra = pydantic.Extra.allow 26 | -------------------------------------------------------------------------------- /src/anduril/tasks/types/task_query_status_filter.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ...core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | from .task_query_status_filter_status import TaskQueryStatusFilterStatus 8 | 9 | 10 | class TaskQueryStatusFilter(UniversalBaseModel): 11 | status: typing.Optional[TaskQueryStatusFilterStatus] = pydantic.Field(default=None) 12 | """ 13 | Status of the Task to filter by, inclusive. 14 | """ 15 | 16 | if IS_PYDANTIC_V2: 17 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 18 | else: 19 | 20 | class Config: 21 | frozen = True 22 | smart_union = True 23 | extra = pydantic.Extra.allow 24 | -------------------------------------------------------------------------------- /src/anduril/types/dimensions.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | 10 | 11 | class Dimensions(UniversalBaseModel): 12 | length_m: typing_extensions.Annotated[typing.Optional[float], FieldMetadata(alias="lengthM")] = pydantic.Field( 13 | default=None 14 | ) 15 | """ 16 | Length of the entity in meters 17 | """ 18 | 19 | if IS_PYDANTIC_V2: 20 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 21 | else: 22 | 23 | class Config: 24 | frozen = True 25 | smart_union = True 26 | extra = pydantic.Extra.allow 27 | -------------------------------------------------------------------------------- /src/anduril/types/u_int32range.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | 10 | 11 | class UInt32Range(UniversalBaseModel): 12 | lower_bound: typing_extensions.Annotated[typing.Optional[int], FieldMetadata(alias="lowerBound")] = None 13 | upper_bound: typing_extensions.Annotated[typing.Optional[int], FieldMetadata(alias="upperBound")] = None 14 | 15 | if IS_PYDANTIC_V2: 16 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 17 | else: 18 | 19 | class Config: 20 | frozen = True 21 | smart_union = True 22 | extra = pydantic.Extra.allow 23 | -------------------------------------------------------------------------------- /src/anduril/types/control_area_details.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | from .control_area_details_type import ControlAreaDetailsType 8 | 9 | 10 | class ControlAreaDetails(UniversalBaseModel): 11 | """ 12 | Determines the type of control area being represented by the geo-entity, 13 | in which an asset can, or cannot, operate. 14 | """ 15 | 16 | type: typing.Optional[ControlAreaDetailsType] = None 17 | 18 | if IS_PYDANTIC_V2: 19 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 20 | else: 21 | 22 | class Config: 23 | frozen = True 24 | smart_union = True 25 | extra = pydantic.Extra.allow 26 | -------------------------------------------------------------------------------- /src/anduril/types/overrides.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | from __future__ import annotations 4 | 5 | import typing 6 | 7 | import pydantic 8 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel, update_forward_refs 9 | 10 | 11 | class Overrides(UniversalBaseModel): 12 | """ 13 | Metadata about entity overrides present. 14 | """ 15 | 16 | override: typing.Optional[typing.List["Override"]] = None 17 | 18 | if IS_PYDANTIC_V2: 19 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 20 | else: 21 | 22 | class Config: 23 | frozen = True 24 | smart_union = True 25 | extra = pydantic.Extra.allow 26 | 27 | 28 | from .override import Override # noqa: E402, I001 29 | 30 | update_forward_refs(Overrides) 31 | -------------------------------------------------------------------------------- /src/anduril/types/symbology.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .mil_std2525c import MilStd2525C 10 | 11 | 12 | class Symbology(UniversalBaseModel): 13 | """ 14 | Symbology associated with an entity. 15 | """ 16 | 17 | mil_std2525c: typing_extensions.Annotated[typing.Optional[MilStd2525C], FieldMetadata(alias="milStd2525C")] = None 18 | 19 | if IS_PYDANTIC_V2: 20 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 21 | else: 22 | 23 | class Config: 24 | frozen = True 25 | smart_union = True 26 | extra = pydantic.Extra.allow 27 | -------------------------------------------------------------------------------- /src/anduril/types/group_child.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | 8 | 9 | class GroupChild(UniversalBaseModel): 10 | """ 11 | A GroupChild relationship is a uni-directional relationship indicating that (1) this entity 12 | represents an Entity Group and (2) the related entity is a child member of this group. The presence of this 13 | relationship alone determines that the type of group is an Entity Group. 14 | """ 15 | 16 | if IS_PYDANTIC_V2: 17 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 18 | else: 19 | 20 | class Config: 21 | frozen = True 22 | smart_union = True 23 | extra = pydantic.Extra.allow 24 | -------------------------------------------------------------------------------- /src/anduril/types/group_parent.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | 8 | 9 | class GroupParent(UniversalBaseModel): 10 | """ 11 | A GroupParent relationship is a uni-directional relationship indicating that this entity is a member of 12 | the Entity Group represented by the related entity. The presence of this relationship alone determines that 13 | the type of group that this entity is a member of is an Entity Group. 14 | """ 15 | 16 | if IS_PYDANTIC_V2: 17 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 18 | else: 19 | 20 | class Config: 21 | frozen = True 22 | smart_union = True 23 | extra = pydantic.Extra.allow 24 | -------------------------------------------------------------------------------- /src/anduril/types/payloads.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .payload import Payload 10 | 11 | 12 | class Payloads(UniversalBaseModel): 13 | """ 14 | List of payloads available for an entity. 15 | """ 16 | 17 | payload_configurations: typing_extensions.Annotated[ 18 | typing.Optional[typing.List[Payload]], FieldMetadata(alias="payloadConfigurations") 19 | ] = None 20 | 21 | if IS_PYDANTIC_V2: 22 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 23 | else: 24 | 25 | class Config: 26 | frozen = True 27 | smart_union = True 28 | extra = pydantic.Extra.allow 29 | -------------------------------------------------------------------------------- /src/anduril/types/primary_correlation.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | 10 | 11 | class PrimaryCorrelation(UniversalBaseModel): 12 | secondary_entity_ids: typing_extensions.Annotated[ 13 | typing.Optional[typing.List[str]], FieldMetadata(alias="secondaryEntityIds") 14 | ] = pydantic.Field(default=None) 15 | """ 16 | The secondary entity IDs part of this correlation. 17 | """ 18 | 19 | if IS_PYDANTIC_V2: 20 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 21 | else: 22 | 23 | class Config: 24 | frozen = True 25 | smart_union = True 26 | extra = pydantic.Extra.allow 27 | -------------------------------------------------------------------------------- /src/anduril/types/task_catalog.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .task_definition import TaskDefinition 10 | 11 | 12 | class TaskCatalog(UniversalBaseModel): 13 | """ 14 | Catalog of supported tasks. 15 | """ 16 | 17 | task_definitions: typing_extensions.Annotated[ 18 | typing.Optional[typing.List[TaskDefinition]], FieldMetadata(alias="taskDefinitions") 19 | ] = None 20 | 21 | if IS_PYDANTIC_V2: 22 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 23 | else: 24 | 25 | class Config: 26 | frozen = True 27 | smart_union = True 28 | extra = pydantic.Extra.allow 29 | -------------------------------------------------------------------------------- /src/anduril/types/user.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | 10 | 11 | class User(UniversalBaseModel): 12 | """ 13 | A User Principal representing a human. 14 | """ 15 | 16 | user_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="userId")] = pydantic.Field( 17 | default=None 18 | ) 19 | """ 20 | The User ID associated with this User. 21 | """ 22 | 23 | if IS_PYDANTIC_V2: 24 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 25 | else: 26 | 27 | class Config: 28 | frozen = True 29 | smart_union = True 30 | extra = pydantic.Extra.allow 31 | -------------------------------------------------------------------------------- /src/anduril/types/agent.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | 10 | 11 | class Agent(UniversalBaseModel): 12 | """ 13 | Represents an agent capable of processing tasks. 14 | """ 15 | 16 | entity_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="entityId")] = pydantic.Field( 17 | default=None 18 | ) 19 | """ 20 | Entity ID of the agent. 21 | """ 22 | 23 | if IS_PYDANTIC_V2: 24 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 25 | else: 26 | 27 | class Config: 28 | frozen = True 29 | smart_union = True 30 | extra = pydantic.Extra.allow 31 | -------------------------------------------------------------------------------- /src/anduril/types/entity_ids_selector.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | 10 | 11 | class EntityIdsSelector(UniversalBaseModel): 12 | entity_ids: typing_extensions.Annotated[typing.Optional[typing.List[str]], FieldMetadata(alias="entityIds")] = ( 13 | pydantic.Field(default=None) 14 | ) 15 | """ 16 | Receive tasks as an assignee for one or more of the supplied entity ids. 17 | """ 18 | 19 | if IS_PYDANTIC_V2: 20 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 21 | else: 22 | 23 | class Config: 24 | frozen = True 25 | smart_union = True 26 | extra = pydantic.Extra.allow 27 | -------------------------------------------------------------------------------- /src/anduril/types/entity_manager_t_mat3.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | 8 | 9 | class EntityManagerTMat3(UniversalBaseModel): 10 | """ 11 | Symmetric 3d matrix only representing the upper right triangle. 12 | """ 13 | 14 | mxx: typing.Optional[float] = None 15 | mxy: typing.Optional[float] = None 16 | mxz: typing.Optional[float] = None 17 | myy: typing.Optional[float] = None 18 | myz: typing.Optional[float] = None 19 | mzz: typing.Optional[float] = None 20 | 21 | if IS_PYDANTIC_V2: 22 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 23 | else: 24 | 25 | class Config: 26 | frozen = True 27 | smart_union = True 28 | extra = pydantic.Extra.allow 29 | -------------------------------------------------------------------------------- /src/anduril/types/scan_characteristics_scan_type.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | ScanCharacteristicsScanType = typing.Union[ 6 | typing.Literal[ 7 | "SCAN_TYPE_INVALID", 8 | "SCAN_TYPE_CIRCULAR", 9 | "SCAN_TYPE_BIDIRECTIONAL_HORIZONTAL_SECTOR", 10 | "SCAN_TYPE_BIDIRECTIONAL_VERTICAL_SECTOR", 11 | "SCAN_TYPE_NON_SCANNING", 12 | "SCAN_TYPE_IRREGULAR", 13 | "SCAN_TYPE_CONICAL", 14 | "SCAN_TYPE_LOBE_SWITCHING", 15 | "SCAN_TYPE_RASTER", 16 | "SCAN_TYPE_CIRCULAR_VERTICAL_SECTOR", 17 | "SCAN_TYPE_CIRCULAR_CONICAL", 18 | "SCAN_TYPE_SECTOR_CONICAL", 19 | "SCAN_TYPE_AGILE_BEAM", 20 | "SCAN_TYPE_UNIDIRECTIONAL_VERTICAL_SECTOR", 21 | "SCAN_TYPE_UNIDIRECTIONAL_HORIZONTAL_SECTOR", 22 | "SCAN_TYPE_UNIDIRECTIONAL_SECTOR", 23 | "SCAN_TYPE_BIDIRECTIONAL_SECTOR", 24 | ], 25 | typing.Any, 26 | ] 27 | -------------------------------------------------------------------------------- /src/anduril/types/owner.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | 10 | 11 | class Owner(UniversalBaseModel): 12 | """ 13 | Owner designates the entity responsible for writes of task data. 14 | """ 15 | 16 | entity_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="entityId")] = pydantic.Field( 17 | default=None 18 | ) 19 | """ 20 | Entity ID of the owner. 21 | """ 22 | 23 | if IS_PYDANTIC_V2: 24 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 25 | else: 26 | 27 | class Config: 28 | frozen = True 29 | smart_union = True 30 | extra = pydantic.Extra.allow 31 | -------------------------------------------------------------------------------- /src/anduril/types/measurement.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | 8 | 9 | class Measurement(UniversalBaseModel): 10 | """ 11 | A component that describes some measured value with error. 12 | """ 13 | 14 | value: typing.Optional[float] = pydantic.Field(default=None) 15 | """ 16 | The value of the measurement. 17 | """ 18 | 19 | sigma: typing.Optional[float] = pydantic.Field(default=None) 20 | """ 21 | Estimated one standard deviation in same unit as the value. 22 | """ 23 | 24 | if IS_PYDANTIC_V2: 25 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 26 | else: 27 | 28 | class Config: 29 | frozen = True 30 | smart_union = True 31 | extra = pydantic.Extra.allow 32 | -------------------------------------------------------------------------------- /src/anduril/types/execute_request.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | from __future__ import annotations 4 | 5 | import typing 6 | 7 | import pydantic 8 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel, update_forward_refs 9 | from .task import Task 10 | 11 | 12 | class ExecuteRequest(UniversalBaseModel): 13 | """ 14 | The request to execute a task. 15 | Contains the unique ID of the task to execute. 16 | """ 17 | 18 | task: typing.Optional[Task] = pydantic.Field(default=None) 19 | """ 20 | The task to execute. 21 | """ 22 | 23 | if IS_PYDANTIC_V2: 24 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 25 | else: 26 | 27 | class Config: 28 | frozen = True 29 | smart_union = True 30 | extra = pydantic.Extra.allow 31 | 32 | 33 | update_forward_refs(ExecuteRequest) 34 | -------------------------------------------------------------------------------- /tests/utils/assets/models/shape.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | # This file was auto-generated by Fern from our API Definition. 4 | 5 | from __future__ import annotations 6 | 7 | import typing 8 | 9 | import typing_extensions 10 | 11 | from anduril.core.serialization import FieldMetadata 12 | 13 | 14 | class Base(typing_extensions.TypedDict): 15 | id: str 16 | 17 | 18 | class Shape_CircleParams(Base): 19 | shape_type: typing_extensions.Annotated[typing.Literal["circle"], FieldMetadata(alias="shapeType")] 20 | radius_measurement: typing_extensions.Annotated[float, FieldMetadata(alias="radiusMeasurement")] 21 | 22 | 23 | class Shape_SquareParams(Base): 24 | shape_type: typing_extensions.Annotated[typing.Literal["square"], FieldMetadata(alias="shapeType")] 25 | length_measurement: typing_extensions.Annotated[float, FieldMetadata(alias="lengthMeasurement")] 26 | 27 | 28 | ShapeParams = typing.Union[Shape_CircleParams, Shape_SquareParams] 29 | -------------------------------------------------------------------------------- /src/anduril/types/threat.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | 10 | 11 | class Threat(UniversalBaseModel): 12 | """ 13 | Describes whether an entity is a threat or not. 14 | """ 15 | 16 | is_threat: typing_extensions.Annotated[typing.Optional[bool], FieldMetadata(alias="isThreat")] = pydantic.Field( 17 | default=None 18 | ) 19 | """ 20 | Indicates that the entity has been determined to be a threat. 21 | """ 22 | 23 | if IS_PYDANTIC_V2: 24 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 25 | else: 26 | 27 | class Config: 28 | frozen = True 29 | smart_union = True 30 | extra = pydantic.Extra.allow 31 | -------------------------------------------------------------------------------- /src/anduril/types/pulse_repetition_interval.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .measurement import Measurement 10 | 11 | 12 | class PulseRepetitionInterval(UniversalBaseModel): 13 | """ 14 | A component that describe the length in time between two pulses 15 | """ 16 | 17 | pulse_repetition_interval_s: typing_extensions.Annotated[ 18 | typing.Optional[Measurement], FieldMetadata(alias="pulseRepetitionIntervalS") 19 | ] = None 20 | 21 | if IS_PYDANTIC_V2: 22 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 23 | else: 24 | 25 | class Config: 26 | frozen = True 27 | smart_union = True 28 | extra = pydantic.Extra.allow 29 | -------------------------------------------------------------------------------- /src/anduril/types/complete_request.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | 10 | 11 | class CompleteRequest(UniversalBaseModel): 12 | """ 13 | The request to complete a task. 14 | Contains the unique ID of the task to complete. 15 | """ 16 | 17 | task_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="taskId")] = pydantic.Field( 18 | default=None 19 | ) 20 | """ 21 | ID of the task to complete. 22 | """ 23 | 24 | if IS_PYDANTIC_V2: 25 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 26 | else: 27 | 28 | class Config: 29 | frozen = True 30 | smart_union = True 31 | extra = pydantic.Extra.allow 32 | -------------------------------------------------------------------------------- /src/anduril/types/google_protobuf_any.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | 10 | 11 | class GoogleProtobufAny(UniversalBaseModel): 12 | """ 13 | Contains an arbitrary serialized message along with a @type that describes the type of the serialized message. 14 | """ 15 | 16 | type: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="@type")] = pydantic.Field(default=None) 17 | """ 18 | The type of the serialized message. 19 | """ 20 | 21 | if IS_PYDANTIC_V2: 22 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 23 | else: 24 | 25 | class Config: 26 | frozen = True 27 | smart_union = True 28 | extra = pydantic.Extra.allow 29 | -------------------------------------------------------------------------------- /src/anduril/types/orbit.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .orbit_mean_elements import OrbitMeanElements 10 | 11 | 12 | class Orbit(UniversalBaseModel): 13 | orbit_mean_elements: typing_extensions.Annotated[ 14 | typing.Optional[OrbitMeanElements], FieldMetadata(alias="orbitMeanElements") 15 | ] = pydantic.Field(default=None) 16 | """ 17 | Orbit Mean Elements data, analogous to the Orbit Mean Elements Message in CCSDS 502.0-B-3 18 | """ 19 | 20 | if IS_PYDANTIC_V2: 21 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 22 | else: 23 | 24 | class Config: 25 | frozen = True 26 | smart_union = True 27 | extra = pydantic.Extra.allow 28 | -------------------------------------------------------------------------------- /src/anduril/types/team.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .agent import Agent 10 | 11 | 12 | class Team(UniversalBaseModel): 13 | """ 14 | Represents a team of agents 15 | """ 16 | 17 | entity_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="entityId")] = pydantic.Field( 18 | default=None 19 | ) 20 | """ 21 | Entity ID of the team 22 | """ 23 | 24 | members: typing.Optional[typing.List[Agent]] = None 25 | 26 | if IS_PYDANTIC_V2: 27 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 28 | else: 29 | 30 | class Config: 31 | frozen = True 32 | smart_union = True 33 | extra = pydantic.Extra.allow 34 | -------------------------------------------------------------------------------- /src/anduril/types/allocation.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .agent import Agent 10 | 11 | 12 | class Allocation(UniversalBaseModel): 13 | """ 14 | Allocation contains a list of agents allocated to a task. 15 | """ 16 | 17 | active_agents: typing_extensions.Annotated[ 18 | typing.Optional[typing.List[Agent]], FieldMetadata(alias="activeAgents") 19 | ] = pydantic.Field(default=None) 20 | """ 21 | Agents actively being utilized in a task. 22 | """ 23 | 24 | if IS_PYDANTIC_V2: 25 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 26 | else: 27 | 28 | class Config: 29 | frozen = True 30 | smart_union = True 31 | extra = pydantic.Extra.allow 32 | -------------------------------------------------------------------------------- /src/anduril/types/mode_s.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | 8 | 9 | class ModeS(UniversalBaseModel): 10 | """ 11 | Describes the Mode S codes. 12 | """ 13 | 14 | id: typing.Optional[str] = pydantic.Field(default=None) 15 | """ 16 | Mode S identifier which comprises of 8 alphanumeric characters. 17 | """ 18 | 19 | address: typing.Optional[int] = pydantic.Field(default=None) 20 | """ 21 | The Mode S ICAO aircraft address. Expected values are between 1 and 16777214 decimal. The Mode S address is 22 | considered unique. 23 | """ 24 | 25 | if IS_PYDANTIC_V2: 26 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 27 | else: 28 | 29 | class Config: 30 | frozen = True 31 | smart_union = True 32 | extra = pydantic.Extra.allow 33 | -------------------------------------------------------------------------------- /src/anduril/types/replication.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import datetime as dt 4 | import typing 5 | 6 | import pydantic 7 | import typing_extensions 8 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 9 | from ..core.serialization import FieldMetadata 10 | 11 | 12 | class Replication(UniversalBaseModel): 13 | """ 14 | Any metadata associated with the replication of a task. 15 | """ 16 | 17 | stale_time: typing_extensions.Annotated[typing.Optional[dt.datetime], FieldMetadata(alias="staleTime")] = ( 18 | pydantic.Field(default=None) 19 | ) 20 | """ 21 | The time by which this task should be assumed to be stale. 22 | """ 23 | 24 | if IS_PYDANTIC_V2: 25 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 26 | else: 27 | 28 | class Config: 29 | frozen = True 30 | smart_union = True 31 | extra = pydantic.Extra.allow 32 | -------------------------------------------------------------------------------- /src/anduril/types/frequency.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .measurement import Measurement 10 | 11 | 12 | class Frequency(UniversalBaseModel): 13 | """ 14 | A component for describing frequency. 15 | """ 16 | 17 | frequency_hz: typing_extensions.Annotated[typing.Optional[Measurement], FieldMetadata(alias="frequencyHz")] = ( 18 | pydantic.Field(default=None) 19 | ) 20 | """ 21 | Indicates a frequency of a signal (Hz) with its standard deviation. 22 | """ 23 | 24 | if IS_PYDANTIC_V2: 25 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 26 | else: 27 | 28 | class Config: 29 | frozen = True 30 | smart_union = True 31 | extra = pydantic.Extra.allow 32 | -------------------------------------------------------------------------------- /src/anduril/types/mil_view.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | from .mil_view_disposition import MilViewDisposition 8 | from .mil_view_environment import MilViewEnvironment 9 | from .mil_view_nationality import MilViewNationality 10 | 11 | 12 | class MilView(UniversalBaseModel): 13 | """ 14 | Provides the disposition, environment, and nationality of an Entity. 15 | """ 16 | 17 | disposition: typing.Optional[MilViewDisposition] = None 18 | environment: typing.Optional[MilViewEnvironment] = None 19 | nationality: typing.Optional[MilViewNationality] = None 20 | 21 | if IS_PYDANTIC_V2: 22 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 23 | else: 24 | 25 | class Config: 26 | frozen = True 27 | smart_union = True 28 | extra = pydantic.Extra.allow 29 | -------------------------------------------------------------------------------- /src/anduril/types/content_identifier.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | 8 | 9 | class ContentIdentifier(UniversalBaseModel): 10 | path: str = pydantic.Field() 11 | """ 12 | A valid path must not contain the following: 13 | - Spaces or Tabs 14 | - Special characters other than underscore (_), dash (-), period (.) and slash (/) 15 | - Non-ASCII characters such as accents or symbols 16 | Paths must not start with a leading space. 17 | """ 18 | 19 | checksum: str = pydantic.Field() 20 | """ 21 | The SHA-256 checksum of this object. 22 | """ 23 | 24 | if IS_PYDANTIC_V2: 25 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 26 | else: 27 | 28 | class Config: 29 | frozen = True 30 | smart_union = True 31 | extra = pydantic.Extra.allow 32 | -------------------------------------------------------------------------------- /src/anduril/types/media_item.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .media_item_type import MediaItemType 10 | 11 | 12 | class MediaItem(UniversalBaseModel): 13 | type: typing.Optional[MediaItemType] = None 14 | relative_path: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="relativePath")] = ( 15 | pydantic.Field(default=None) 16 | ) 17 | """ 18 | The path, relative to the environment base URL, where media related to an entity can be accessed 19 | """ 20 | 21 | if IS_PYDANTIC_V2: 22 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 23 | else: 24 | 25 | class Config: 26 | frozen = True 27 | smart_union = True 28 | extra = pydantic.Extra.allow 29 | -------------------------------------------------------------------------------- /src/anduril/types/task_definition.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | 10 | 11 | class TaskDefinition(UniversalBaseModel): 12 | """ 13 | Defines a supported task by the task specification URL of its "Any" type. 14 | """ 15 | 16 | task_specification_url: typing_extensions.Annotated[ 17 | typing.Optional[str], FieldMetadata(alias="taskSpecificationUrl") 18 | ] = pydantic.Field(default=None) 19 | """ 20 | Url path must be prefixed with `type.googleapis.com/`. 21 | """ 22 | 23 | if IS_PYDANTIC_V2: 24 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 25 | else: 26 | 27 | class Config: 28 | frozen = True 29 | smart_union = True 30 | extra = pydantic.Extra.allow 31 | -------------------------------------------------------------------------------- /src/anduril/types/component_message.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | from .component_message_status import ComponentMessageStatus 8 | 9 | 10 | class ComponentMessage(UniversalBaseModel): 11 | """ 12 | A message describing the component's health status. 13 | """ 14 | 15 | status: typing.Optional[ComponentMessageStatus] = pydantic.Field(default=None) 16 | """ 17 | The status associated with this message. 18 | """ 19 | 20 | message: typing.Optional[str] = pydantic.Field(default=None) 21 | """ 22 | The human-readable content of the message. 23 | """ 24 | 25 | if IS_PYDANTIC_V2: 26 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 27 | else: 28 | 29 | class Config: 30 | frozen = True 31 | smart_union = True 32 | extra = pydantic.Extra.allow 33 | -------------------------------------------------------------------------------- /src/anduril/types/visual_details.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .range_rings import RangeRings 10 | 11 | 12 | class VisualDetails(UniversalBaseModel): 13 | """ 14 | Visual details associated with the display of an entity in the client. 15 | """ 16 | 17 | range_rings: typing_extensions.Annotated[typing.Optional[RangeRings], FieldMetadata(alias="rangeRings")] = ( 18 | pydantic.Field(default=None) 19 | ) 20 | """ 21 | The range rings to display around an entity. 22 | """ 23 | 24 | if IS_PYDANTIC_V2: 25 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 26 | else: 27 | 28 | class Config: 29 | frozen = True 30 | smart_union = True 31 | extra = pydantic.Extra.allow 32 | -------------------------------------------------------------------------------- /src/anduril/types/emitter_notation.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | 10 | 11 | class EmitterNotation(UniversalBaseModel): 12 | """ 13 | A representation of a single emitter notation. 14 | """ 15 | 16 | emitter_notation: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="emitterNotation")] = None 17 | confidence: typing.Optional[float] = pydantic.Field(default=None) 18 | """ 19 | confidence as a percentage that the emitter notation in this component is accurate 20 | """ 21 | 22 | if IS_PYDANTIC_V2: 23 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 24 | else: 25 | 26 | class Config: 27 | frozen = True 28 | smart_union = True 29 | extra = pydantic.Extra.allow 30 | -------------------------------------------------------------------------------- /src/anduril/types/alternate_id_type.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | AlternateIdType = typing.Union[ 6 | typing.Literal[ 7 | "ALT_ID_TYPE_INVALID", 8 | "ALT_ID_TYPE_TRACK_ID_2", 9 | "ALT_ID_TYPE_TRACK_ID_1", 10 | "ALT_ID_TYPE_SPI_ID", 11 | "ALT_ID_TYPE_NITF_FILE_TITLE", 12 | "ALT_ID_TYPE_TRACK_REPO_ALERT_ID", 13 | "ALT_ID_TYPE_ASSET_ID", 14 | "ALT_ID_TYPE_LINK16_TRACK_NUMBER", 15 | "ALT_ID_TYPE_LINK16_JU", 16 | "ALT_ID_TYPE_NCCT_MESSAGE_ID", 17 | "ALT_ID_TYPE_CALLSIGN", 18 | "ALT_ID_TYPE_MMSI_ID", 19 | "ALT_ID_TYPE_VMF_URN", 20 | "ALT_ID_TYPE_IMO_ID", 21 | "ALT_ID_TYPE_VMF_TARGET_NUMBER", 22 | "ALT_ID_TYPE_SERIAL_NUMBER", 23 | "ALT_ID_TYPE_REGISTRATION_ID", 24 | "ALT_ID_TYPE_IBS_GID", 25 | "ALT_ID_TYPE_DODAAC", 26 | "ALT_ID_TYPE_UIC", 27 | "ALT_ID_TYPE_NORAD_CAT_ID", 28 | "ALT_ID_TYPE_UNOOSA_NAME", 29 | "ALT_ID_TYPE_UNOOSA_ID", 30 | ], 31 | typing.Any, 32 | ] 33 | -------------------------------------------------------------------------------- /src/anduril/types/aliases.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .alternate_id import AlternateId 10 | 11 | 12 | class Aliases(UniversalBaseModel): 13 | """ 14 | Available for any Entities with alternate ids in other systems. 15 | """ 16 | 17 | alternate_ids: typing_extensions.Annotated[ 18 | typing.Optional[typing.List[AlternateId]], FieldMetadata(alias="alternateIds") 19 | ] = None 20 | name: typing.Optional[str] = pydantic.Field(default=None) 21 | """ 22 | The best available version of the entity's display name. 23 | """ 24 | 25 | if IS_PYDANTIC_V2: 26 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 27 | else: 28 | 29 | class Config: 30 | frozen = True 31 | smart_union = True 32 | extra = pydantic.Extra.allow 33 | -------------------------------------------------------------------------------- /src/anduril/types/bandwidth_range.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .bandwidth import Bandwidth 10 | 11 | 12 | class BandwidthRange(UniversalBaseModel): 13 | """ 14 | A component that describes the min and max bandwidths of a sensor 15 | """ 16 | 17 | minimum_bandwidth: typing_extensions.Annotated[ 18 | typing.Optional[Bandwidth], FieldMetadata(alias="minimumBandwidth") 19 | ] = None 20 | maximum_bandwidth: typing_extensions.Annotated[ 21 | typing.Optional[Bandwidth], FieldMetadata(alias="maximumBandwidth") 22 | ] = None 23 | 24 | if IS_PYDANTIC_V2: 25 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 26 | else: 27 | 28 | class Config: 29 | frozen = True 30 | smart_union = True 31 | extra = pydantic.Extra.allow 32 | -------------------------------------------------------------------------------- /src/anduril/types/echelon.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .echelon_army_echelon import EchelonArmyEchelon 10 | 11 | 12 | class Echelon(UniversalBaseModel): 13 | """ 14 | Describes a Echelon group type. Comprised of entities which are members of the 15 | same unit or echelon. Ex: A group of tanks within a armored company or that same company 16 | as a member of a battalion. 17 | """ 18 | 19 | army_echelon: typing_extensions.Annotated[ 20 | typing.Optional[EchelonArmyEchelon], FieldMetadata(alias="armyEchelon") 21 | ] = None 22 | 23 | if IS_PYDANTIC_V2: 24 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 25 | else: 26 | 27 | class Config: 28 | frozen = True 29 | smart_union = True 30 | extra = pydantic.Extra.allow 31 | -------------------------------------------------------------------------------- /src/anduril/types/geo_shape.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | from .geo_ellipse import GeoEllipse 8 | from .geo_ellipsoid import GeoEllipsoid 9 | from .geo_line import GeoLine 10 | from .geo_point import GeoPoint 11 | from .geo_polygon import GeoPolygon 12 | 13 | 14 | class GeoShape(UniversalBaseModel): 15 | """ 16 | A component that describes the shape of a geo-entity. 17 | """ 18 | 19 | point: typing.Optional[GeoPoint] = None 20 | line: typing.Optional[GeoLine] = None 21 | polygon: typing.Optional[GeoPolygon] = None 22 | ellipse: typing.Optional[GeoEllipse] = None 23 | ellipsoid: typing.Optional[GeoEllipsoid] = None 24 | 25 | if IS_PYDANTIC_V2: 26 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 27 | else: 28 | 29 | class Config: 30 | frozen = True 31 | smart_union = True 32 | extra = pydantic.Extra.allow 33 | -------------------------------------------------------------------------------- /src/anduril/types/decorrelated_single.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .correlation_metadata import CorrelationMetadata 10 | 11 | 12 | class DecorrelatedSingle(UniversalBaseModel): 13 | entity_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="entityId")] = pydantic.Field( 14 | default=None 15 | ) 16 | """ 17 | The entity that was decorrelated against. 18 | """ 19 | 20 | metadata: typing.Optional[CorrelationMetadata] = pydantic.Field(default=None) 21 | """ 22 | Metadata about the decorrelation. 23 | """ 24 | 25 | if IS_PYDANTIC_V2: 26 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 27 | else: 28 | 29 | class Config: 30 | frozen = True 31 | smart_union = True 32 | extra = pydantic.Extra.allow 33 | -------------------------------------------------------------------------------- /src/anduril/types/scan_characteristics.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .scan_characteristics_scan_type import ScanCharacteristicsScanType 10 | 11 | 12 | class ScanCharacteristics(UniversalBaseModel): 13 | """ 14 | A component that describes the scanning characteristics of a signal 15 | """ 16 | 17 | scan_type: typing_extensions.Annotated[ 18 | typing.Optional[ScanCharacteristicsScanType], FieldMetadata(alias="scanType") 19 | ] = None 20 | scan_period_s: typing_extensions.Annotated[typing.Optional[float], FieldMetadata(alias="scanPeriodS")] = None 21 | 22 | if IS_PYDANTIC_V2: 23 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 24 | else: 25 | 26 | class Config: 27 | frozen = True 28 | smart_union = True 29 | extra = pydantic.Extra.allow 30 | -------------------------------------------------------------------------------- /src/anduril/types/secondary_correlation.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .correlation_metadata import CorrelationMetadata 10 | 11 | 12 | class SecondaryCorrelation(UniversalBaseModel): 13 | primary_entity_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="primaryEntityId")] = ( 14 | pydantic.Field(default=None) 15 | ) 16 | """ 17 | The primary of this correlation. 18 | """ 19 | 20 | metadata: typing.Optional[CorrelationMetadata] = pydantic.Field(default=None) 21 | """ 22 | Metadata about the correlation. 23 | """ 24 | 25 | if IS_PYDANTIC_V2: 26 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 27 | else: 28 | 29 | class Config: 30 | frozen = True 31 | smart_union = True 32 | extra = pydantic.Extra.allow 33 | -------------------------------------------------------------------------------- /src/anduril/types/geo_details.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .acm_details import AcmDetails 10 | from .control_area_details import ControlAreaDetails 11 | from .geo_details_type import GeoDetailsType 12 | 13 | 14 | class GeoDetails(UniversalBaseModel): 15 | """ 16 | A component that describes a geo-entity. 17 | """ 18 | 19 | type: typing.Optional[GeoDetailsType] = None 20 | control_area: typing_extensions.Annotated[ 21 | typing.Optional[ControlAreaDetails], FieldMetadata(alias="controlArea") 22 | ] = None 23 | acm: typing.Optional[AcmDetails] = None 24 | 25 | if IS_PYDANTIC_V2: 26 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 27 | else: 28 | 29 | class Config: 30 | frozen = True 31 | smart_union = True 32 | extra = pydantic.Extra.allow 33 | -------------------------------------------------------------------------------- /src/anduril/types/acm_details.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .acm_details_acm_type import AcmDetailsAcmType 10 | 11 | 12 | class AcmDetails(UniversalBaseModel): 13 | acm_type: typing_extensions.Annotated[typing.Optional[AcmDetailsAcmType], FieldMetadata(alias="acmType")] = None 14 | acm_description: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="acmDescription")] = ( 15 | pydantic.Field(default=None) 16 | ) 17 | """ 18 | Used for loosely typed associations, such as assignment to a specific fires unit. 19 | Limit to 150 characters. 20 | """ 21 | 22 | if IS_PYDANTIC_V2: 23 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 24 | else: 25 | 26 | class Config: 27 | frozen = True 28 | smart_union = True 29 | extra = pydantic.Extra.allow 30 | -------------------------------------------------------------------------------- /src/anduril/core/datetime_utils.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import datetime as dt 4 | 5 | 6 | def serialize_datetime(v: dt.datetime) -> str: 7 | """ 8 | Serialize a datetime including timezone info. 9 | 10 | Uses the timezone info provided if present, otherwise uses the current runtime's timezone info. 11 | 12 | UTC datetimes end in "Z" while all other timezones are represented as offset from UTC, e.g. +05:00. 13 | """ 14 | 15 | def _serialize_zoned_datetime(v: dt.datetime) -> str: 16 | if v.tzinfo is not None and v.tzinfo.tzname(None) == dt.timezone.utc.tzname(None): 17 | # UTC is a special case where we use "Z" at the end instead of "+00:00" 18 | return v.isoformat().replace("+00:00", "Z") 19 | else: 20 | # Delegate to the typical +/- offset format 21 | return v.isoformat() 22 | 23 | if v.tzinfo is not None: 24 | return _serialize_zoned_datetime(v) 25 | else: 26 | local_tz = dt.datetime.now().astimezone().tzinfo 27 | localized_dt = v.replace(tzinfo=local_tz) 28 | return _serialize_zoned_datetime(localized_dt) 29 | -------------------------------------------------------------------------------- /src/anduril/types/power_state.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .power_source import PowerSource 10 | 11 | 12 | class PowerState(UniversalBaseModel): 13 | """ 14 | Represents the state of power sources connected to this entity. 15 | """ 16 | 17 | source_id_to_state: typing_extensions.Annotated[ 18 | typing.Optional[typing.Dict[str, PowerSource]], FieldMetadata(alias="sourceIdToState") 19 | ] = pydantic.Field(default=None) 20 | """ 21 | This is a map where the key is a unique id of the power source and the value is additional information about the 22 | power source. 23 | """ 24 | 25 | if IS_PYDANTIC_V2: 26 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 27 | else: 28 | 29 | class Config: 30 | frozen = True 31 | smart_union = True 32 | extra = pydantic.Extra.allow 33 | -------------------------------------------------------------------------------- /src/anduril/entity/__init__.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | # isort: skip_file 4 | 5 | import typing 6 | from importlib import import_module 7 | 8 | if typing.TYPE_CHECKING: 9 | from .types import Error 10 | _dynamic_imports: typing.Dict[str, str] = {"Error": ".types"} 11 | 12 | 13 | def __getattr__(attr_name: str) -> typing.Any: 14 | module_name = _dynamic_imports.get(attr_name) 15 | if module_name is None: 16 | raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}") 17 | try: 18 | module = import_module(module_name, __package__) 19 | if module_name == f".{attr_name}": 20 | return module 21 | else: 22 | return getattr(module, attr_name) 23 | except ImportError as e: 24 | raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e 25 | except AttributeError as e: 26 | raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e 27 | 28 | 29 | def __dir__(): 30 | lazy_attrs = list(_dynamic_imports.keys()) 31 | return sorted(lazy_attrs) 32 | 33 | 34 | __all__ = ["Error"] 35 | -------------------------------------------------------------------------------- /src/anduril/object/__init__.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | # isort: skip_file 4 | 5 | import typing 6 | from importlib import import_module 7 | 8 | if typing.TYPE_CHECKING: 9 | from .types import Error 10 | _dynamic_imports: typing.Dict[str, str] = {"Error": ".types"} 11 | 12 | 13 | def __getattr__(attr_name: str) -> typing.Any: 14 | module_name = _dynamic_imports.get(attr_name) 15 | if module_name is None: 16 | raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}") 17 | try: 18 | module = import_module(module_name, __package__) 19 | if module_name == f".{attr_name}": 20 | return module 21 | else: 22 | return getattr(module, attr_name) 23 | except ImportError as e: 24 | raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e 25 | except AttributeError as e: 26 | raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e 27 | 28 | 29 | def __dir__(): 30 | lazy_attrs = list(_dynamic_imports.keys()) 31 | return sorted(lazy_attrs) 32 | 33 | 34 | __all__ = ["Error"] 35 | -------------------------------------------------------------------------------- /src/anduril/task/__init__.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | # isort: skip_file 4 | 5 | import typing 6 | from importlib import import_module 7 | 8 | if typing.TYPE_CHECKING: 9 | from .types import Error 10 | _dynamic_imports: typing.Dict[str, str] = {"Error": ".types"} 11 | 12 | 13 | def __getattr__(attr_name: str) -> typing.Any: 14 | module_name = _dynamic_imports.get(attr_name) 15 | if module_name is None: 16 | raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}") 17 | try: 18 | module = import_module(module_name, __package__) 19 | if module_name == f".{attr_name}": 20 | return module 21 | else: 22 | return getattr(module, attr_name) 23 | except ImportError as e: 24 | raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e 25 | except AttributeError as e: 26 | raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e 27 | 28 | 29 | def __dir__(): 30 | lazy_attrs = list(_dynamic_imports.keys()) 31 | return sorted(lazy_attrs) 32 | 33 | 34 | __all__ = ["Error"] 35 | -------------------------------------------------------------------------------- /src/anduril/entity/types/__init__.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | # isort: skip_file 4 | 5 | import typing 6 | from importlib import import_module 7 | 8 | if typing.TYPE_CHECKING: 9 | from .error import Error 10 | _dynamic_imports: typing.Dict[str, str] = {"Error": ".error"} 11 | 12 | 13 | def __getattr__(attr_name: str) -> typing.Any: 14 | module_name = _dynamic_imports.get(attr_name) 15 | if module_name is None: 16 | raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}") 17 | try: 18 | module = import_module(module_name, __package__) 19 | if module_name == f".{attr_name}": 20 | return module 21 | else: 22 | return getattr(module, attr_name) 23 | except ImportError as e: 24 | raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e 25 | except AttributeError as e: 26 | raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e 27 | 28 | 29 | def __dir__(): 30 | lazy_attrs = list(_dynamic_imports.keys()) 31 | return sorted(lazy_attrs) 32 | 33 | 34 | __all__ = ["Error"] 35 | -------------------------------------------------------------------------------- /src/anduril/object/types/__init__.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | # isort: skip_file 4 | 5 | import typing 6 | from importlib import import_module 7 | 8 | if typing.TYPE_CHECKING: 9 | from .error import Error 10 | _dynamic_imports: typing.Dict[str, str] = {"Error": ".error"} 11 | 12 | 13 | def __getattr__(attr_name: str) -> typing.Any: 14 | module_name = _dynamic_imports.get(attr_name) 15 | if module_name is None: 16 | raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}") 17 | try: 18 | module = import_module(module_name, __package__) 19 | if module_name == f".{attr_name}": 20 | return module 21 | else: 22 | return getattr(module, attr_name) 23 | except ImportError as e: 24 | raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e 25 | except AttributeError as e: 26 | raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e 27 | 28 | 29 | def __dir__(): 30 | lazy_attrs = list(_dynamic_imports.keys()) 31 | return sorted(lazy_attrs) 32 | 33 | 34 | __all__ = ["Error"] 35 | -------------------------------------------------------------------------------- /src/anduril/task/types/__init__.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | # isort: skip_file 4 | 5 | import typing 6 | from importlib import import_module 7 | 8 | if typing.TYPE_CHECKING: 9 | from .error import Error 10 | _dynamic_imports: typing.Dict[str, str] = {"Error": ".error"} 11 | 12 | 13 | def __getattr__(attr_name: str) -> typing.Any: 14 | module_name = _dynamic_imports.get(attr_name) 15 | if module_name is None: 16 | raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}") 17 | try: 18 | module = import_module(module_name, __package__) 19 | if module_name == f".{attr_name}": 20 | return module 21 | else: 22 | return getattr(module, attr_name) 23 | except ImportError as e: 24 | raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e 25 | except AttributeError as e: 26 | raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e 27 | 28 | 29 | def __dir__(): 30 | lazy_attrs = list(_dynamic_imports.keys()) 31 | return sorted(lazy_attrs) 32 | 33 | 34 | __all__ = ["Error"] 35 | -------------------------------------------------------------------------------- /src/anduril/types/route_details.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import datetime as dt 4 | import typing 5 | 6 | import pydantic 7 | import typing_extensions 8 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 9 | from ..core.serialization import FieldMetadata 10 | 11 | 12 | class RouteDetails(UniversalBaseModel): 13 | destination_name: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="destinationName")] = ( 14 | pydantic.Field(default=None) 15 | ) 16 | """ 17 | Free form text giving the name of the entity's destination 18 | """ 19 | 20 | estimated_arrival_time: typing_extensions.Annotated[ 21 | typing.Optional[dt.datetime], FieldMetadata(alias="estimatedArrivalTime") 22 | ] = pydantic.Field(default=None) 23 | """ 24 | Estimated time of arrival at destination 25 | """ 26 | 27 | if IS_PYDANTIC_V2: 28 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 29 | else: 30 | 31 | class Config: 32 | frozen = True 33 | smart_union = True 34 | extra = pydantic.Extra.allow 35 | -------------------------------------------------------------------------------- /src/anduril/types/lla.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .lla_altitude_reference import LlaAltitudeReference 10 | 11 | 12 | class Lla(UniversalBaseModel): 13 | lon: typing.Optional[float] = None 14 | lat: typing.Optional[float] = None 15 | alt: typing.Optional[float] = None 16 | is2d: typing.Optional[bool] = None 17 | altitude_reference: typing_extensions.Annotated[ 18 | typing.Optional[LlaAltitudeReference], FieldMetadata(alias="altitudeReference") 19 | ] = pydantic.Field(default=None) 20 | """ 21 | Meaning of alt. 22 | altitude in meters above either WGS84 or EGM96, use altitude_reference to 23 | determine what zero means. 24 | """ 25 | 26 | if IS_PYDANTIC_V2: 27 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 28 | else: 29 | 30 | class Config: 31 | frozen = True 32 | smart_union = True 33 | extra = pydantic.Extra.allow 34 | -------------------------------------------------------------------------------- /src/anduril/objects/__init__.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | # isort: skip_file 4 | 5 | import typing 6 | from importlib import import_module 7 | 8 | if typing.TYPE_CHECKING: 9 | from .types import GetObjectRequestAcceptEncoding 10 | _dynamic_imports: typing.Dict[str, str] = {"GetObjectRequestAcceptEncoding": ".types"} 11 | 12 | 13 | def __getattr__(attr_name: str) -> typing.Any: 14 | module_name = _dynamic_imports.get(attr_name) 15 | if module_name is None: 16 | raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}") 17 | try: 18 | module = import_module(module_name, __package__) 19 | if module_name == f".{attr_name}": 20 | return module 21 | else: 22 | return getattr(module, attr_name) 23 | except ImportError as e: 24 | raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e 25 | except AttributeError as e: 26 | raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e 27 | 28 | 29 | def __dir__(): 30 | lazy_attrs = list(_dynamic_imports.keys()) 31 | return sorted(lazy_attrs) 32 | 33 | 34 | __all__ = ["GetObjectRequestAcceptEncoding"] 35 | -------------------------------------------------------------------------------- /src/anduril/types/entity_event.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | from __future__ import annotations 4 | 5 | import datetime as dt 6 | import typing 7 | 8 | import pydantic 9 | import typing_extensions 10 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel, update_forward_refs 11 | from ..core.serialization import FieldMetadata 12 | from .entity_event_event_type import EntityEventEventType 13 | 14 | 15 | class EntityEvent(UniversalBaseModel): 16 | """ 17 | Event representing some type of entity change. 18 | """ 19 | 20 | event_type: typing_extensions.Annotated[typing.Optional[EntityEventEventType], FieldMetadata(alias="eventType")] = ( 21 | None 22 | ) 23 | time: typing.Optional[dt.datetime] = None 24 | entity: typing.Optional["Entity"] = None 25 | 26 | if IS_PYDANTIC_V2: 27 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 28 | else: 29 | 30 | class Config: 31 | frozen = True 32 | smart_union = True 33 | extra = pydantic.Extra.allow 34 | 35 | 36 | from .entity import Entity # noqa: E402, I001 37 | 38 | update_forward_refs(EntityEvent) 39 | -------------------------------------------------------------------------------- /src/anduril/types/entity_event_response.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | from __future__ import annotations 4 | 5 | import typing 6 | 7 | import pydantic 8 | import typing_extensions 9 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel, update_forward_refs 10 | from ..core.serialization import FieldMetadata 11 | from .entity_event import EntityEvent 12 | 13 | 14 | class EntityEventResponse(UniversalBaseModel): 15 | session_token: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="sessionToken")] = ( 16 | pydantic.Field(default=None) 17 | ) 18 | """ 19 | Long-poll session identifier. Use this token to resume polling on subsequent requests. 20 | """ 21 | 22 | entity_events: typing_extensions.Annotated[ 23 | typing.Optional[typing.List[EntityEvent]], FieldMetadata(alias="entityEvents") 24 | ] = None 25 | 26 | if IS_PYDANTIC_V2: 27 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 28 | else: 29 | 30 | class Config: 31 | frozen = True 32 | smart_union = True 33 | extra = pydantic.Extra.allow 34 | 35 | 36 | update_forward_refs(EntityEventResponse) 37 | -------------------------------------------------------------------------------- /src/anduril/types/target_priority.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .high_value_target import HighValueTarget 10 | from .threat import Threat 11 | 12 | 13 | class TargetPriority(UniversalBaseModel): 14 | """ 15 | The target prioritization associated with an entity. 16 | """ 17 | 18 | high_value_target: typing_extensions.Annotated[ 19 | typing.Optional[HighValueTarget], FieldMetadata(alias="highValueTarget") 20 | ] = pydantic.Field(default=None) 21 | """ 22 | Describes the target priority in relation to high value target lists. 23 | """ 24 | 25 | threat: typing.Optional[Threat] = pydantic.Field(default=None) 26 | """ 27 | Describes whether the entity should be treated as a threat 28 | """ 29 | 30 | if IS_PYDANTIC_V2: 31 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 32 | else: 33 | 34 | class Config: 35 | frozen = True 36 | smart_union = True 37 | extra = pydantic.Extra.allow 38 | -------------------------------------------------------------------------------- /src/anduril/tasks/types/task_query_update_time_range.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ...core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ...core.serialization import FieldMetadata 9 | 10 | 11 | class TaskQueryUpdateTimeRange(UniversalBaseModel): 12 | """ 13 | If provided, only provides Tasks updated within the time range. 14 | """ 15 | 16 | start_time: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="startTime")] = pydantic.Field( 17 | default=None 18 | ) 19 | """ 20 | If provided, returns Tasks only updated after this time. 21 | """ 22 | 23 | end_time: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="endTime")] = pydantic.Field( 24 | default=None 25 | ) 26 | """ 27 | If provided, returns Tasks only updated before this time. 28 | """ 29 | 30 | if IS_PYDANTIC_V2: 31 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 32 | else: 33 | 34 | class Config: 35 | frozen = True 36 | smart_union = True 37 | extra = pydantic.Extra.allow 38 | -------------------------------------------------------------------------------- /src/anduril/types/indicators.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | 8 | 9 | class Indicators(UniversalBaseModel): 10 | """ 11 | Indicators to describe entity to consumers. 12 | """ 13 | 14 | simulated: typing.Optional[bool] = None 15 | exercise: typing.Optional[bool] = None 16 | emergency: typing.Optional[bool] = None 17 | c2: typing.Optional[bool] = None 18 | egressable: typing.Optional[bool] = pydantic.Field(default=None) 19 | """ 20 | Indicates the Entity should be egressed to external sources. 21 | Integrations choose how the egressing happens (e.g. if an Entity needs fuzzing). 22 | """ 23 | 24 | starred: typing.Optional[bool] = pydantic.Field(default=None) 25 | """ 26 | A signal of arbitrary importance such that the entity should be globally marked for all users 27 | """ 28 | 29 | if IS_PYDANTIC_V2: 30 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 31 | else: 32 | 33 | class Config: 34 | frozen = True 35 | smart_union = True 36 | extra = pydantic.Extra.allow 37 | -------------------------------------------------------------------------------- /src/anduril/objects/types/__init__.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | # isort: skip_file 4 | 5 | import typing 6 | from importlib import import_module 7 | 8 | if typing.TYPE_CHECKING: 9 | from .get_object_request_accept_encoding import GetObjectRequestAcceptEncoding 10 | _dynamic_imports: typing.Dict[str, str] = {"GetObjectRequestAcceptEncoding": ".get_object_request_accept_encoding"} 11 | 12 | 13 | def __getattr__(attr_name: str) -> typing.Any: 14 | module_name = _dynamic_imports.get(attr_name) 15 | if module_name is None: 16 | raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}") 17 | try: 18 | module = import_module(module_name, __package__) 19 | if module_name == f".{attr_name}": 20 | return module 21 | else: 22 | return getattr(module, attr_name) 23 | except ImportError as e: 24 | raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e 25 | except AttributeError as e: 26 | raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e 27 | 28 | 29 | def __dir__(): 30 | lazy_attrs = list(_dynamic_imports.keys()) 31 | return sorted(lazy_attrs) 32 | 33 | 34 | __all__ = ["GetObjectRequestAcceptEncoding"] 35 | -------------------------------------------------------------------------------- /src/anduril/types/status.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | 10 | 11 | class Status(UniversalBaseModel): 12 | """ 13 | Contains status of entities. 14 | """ 15 | 16 | platform_activity: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="platformActivity")] = ( 17 | pydantic.Field(default=None) 18 | ) 19 | """ 20 | A string that describes the activity that the entity is performing. 21 | Examples include "RECONNAISSANCE", "INTERDICTION", "RETURN TO BASE (RTB)", "PREPARING FOR LAUNCH". 22 | """ 23 | 24 | role: typing.Optional[str] = pydantic.Field(default=None) 25 | """ 26 | A human-readable string that describes the role the entity is currently performing. E.g. "Team Member", "Commander". 27 | """ 28 | 29 | if IS_PYDANTIC_V2: 30 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 31 | else: 32 | 33 | class Config: 34 | frozen = True 35 | smart_union = True 36 | extra = pydantic.Extra.allow 37 | -------------------------------------------------------------------------------- /src/anduril/types/frequency_range.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .frequency import Frequency 10 | 11 | 12 | class FrequencyRange(UniversalBaseModel): 13 | """ 14 | A component to represent a frequency range. 15 | """ 16 | 17 | minimum_frequency_hz: typing_extensions.Annotated[ 18 | typing.Optional[Frequency], FieldMetadata(alias="minimumFrequencyHz") 19 | ] = pydantic.Field(default=None) 20 | """ 21 | Indicates the lowest measured frequency of a signal (Hz). 22 | """ 23 | 24 | maximum_frequency_hz: typing_extensions.Annotated[ 25 | typing.Optional[Frequency], FieldMetadata(alias="maximumFrequencyHz") 26 | ] = pydantic.Field(default=None) 27 | """ 28 | Indicates the maximum measured frequency of a signal (Hz). 29 | """ 30 | 31 | if IS_PYDANTIC_V2: 32 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 33 | else: 34 | 35 | class Config: 36 | frozen = True 37 | smart_union = True 38 | extra = pydantic.Extra.allow 39 | -------------------------------------------------------------------------------- /src/anduril/types/geo_polygon_position.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .position import Position 10 | 11 | 12 | class GeoPolygonPosition(UniversalBaseModel): 13 | """ 14 | A position in a GeoPolygon with an optional extruded height. 15 | """ 16 | 17 | position: typing.Optional[Position] = pydantic.Field(default=None) 18 | """ 19 | base position. if no altitude set, its on the ground. 20 | """ 21 | 22 | height_m: typing_extensions.Annotated[typing.Optional[float], FieldMetadata(alias="heightM")] = pydantic.Field( 23 | default=None 24 | ) 25 | """ 26 | optional height above base position to extrude in meters. 27 | for a given polygon, all points should have a height or none of them. 28 | strictly GeoJSON compatible polygons will not have this set. 29 | """ 30 | 31 | if IS_PYDANTIC_V2: 32 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 33 | else: 34 | 35 | class Config: 36 | frozen = True 37 | smart_union = True 38 | extra = pydantic.Extra.allow 39 | -------------------------------------------------------------------------------- /src/anduril/types/orbit_mean_elements.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .mean_keplerian_elements import MeanKeplerianElements 10 | from .orbit_mean_elements_metadata import OrbitMeanElementsMetadata 11 | from .tle_parameters import TleParameters 12 | 13 | 14 | class OrbitMeanElements(UniversalBaseModel): 15 | """ 16 | Orbit Mean Elements data, analogous to the Orbit Mean Elements Message in CCSDS 502.0-B-3 17 | """ 18 | 19 | metadata: typing.Optional[OrbitMeanElementsMetadata] = None 20 | mean_keplerian_elements: typing_extensions.Annotated[ 21 | typing.Optional[MeanKeplerianElements], FieldMetadata(alias="meanKeplerianElements") 22 | ] = None 23 | tle_parameters: typing_extensions.Annotated[ 24 | typing.Optional[TleParameters], FieldMetadata(alias="tleParameters") 25 | ] = None 26 | 27 | if IS_PYDANTIC_V2: 28 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 29 | else: 30 | 31 | class Config: 32 | frozen = True 33 | smart_union = True 34 | extra = pydantic.Extra.allow 35 | -------------------------------------------------------------------------------- /src/anduril/types/classification_information.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | from .classification_information_level import ClassificationInformationLevel 8 | 9 | 10 | class ClassificationInformation(UniversalBaseModel): 11 | """ 12 | Represents all of the necessary information required to generate a summarized 13 | classification marking. 14 | 15 | > example: A summarized classification marking of "TOPSECRET//NOFORN//FISA" 16 | would be defined as: { "level": 5, "caveats": [ "NOFORN, "FISA" ] } 17 | """ 18 | 19 | level: typing.Optional[ClassificationInformationLevel] = pydantic.Field(default=None) 20 | """ 21 | Classification level to be applied to the information in question. 22 | """ 23 | 24 | caveats: typing.Optional[typing.List[str]] = pydantic.Field(default=None) 25 | """ 26 | Caveats that may further restrict how the information can be disseminated. 27 | """ 28 | 29 | if IS_PYDANTIC_V2: 30 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 31 | else: 32 | 33 | class Config: 34 | frozen = True 35 | smart_union = True 36 | extra = pydantic.Extra.allow 37 | -------------------------------------------------------------------------------- /src/anduril/types/classification.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | from .classification_information import ClassificationInformation 8 | from .field_classification_information import FieldClassificationInformation 9 | 10 | 11 | class Classification(UniversalBaseModel): 12 | """ 13 | A component that describes an entity's security classification levels. 14 | """ 15 | 16 | default: typing.Optional[ClassificationInformation] = pydantic.Field(default=None) 17 | """ 18 | The default classification information which should be assumed to apply to everything in 19 | the entity unless a specific field level classification is present. 20 | """ 21 | 22 | fields: typing.Optional[typing.List[FieldClassificationInformation]] = pydantic.Field(default=None) 23 | """ 24 | The set of individual field classification information which should always precedence 25 | over the default classification information. 26 | """ 27 | 28 | if IS_PYDANTIC_V2: 29 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 30 | else: 31 | 32 | class Config: 33 | frozen = True 34 | smart_union = True 35 | extra = pydantic.Extra.allow 36 | -------------------------------------------------------------------------------- /src/anduril/types/high_value_target_match.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | 10 | 11 | class HighValueTargetMatch(UniversalBaseModel): 12 | high_value_target_list_id: typing_extensions.Annotated[ 13 | typing.Optional[str], FieldMetadata(alias="highValueTargetListId") 14 | ] = pydantic.Field(default=None) 15 | """ 16 | The ID of the high value target list that matches the target description. 17 | """ 18 | 19 | high_value_target_description_id: typing_extensions.Annotated[ 20 | typing.Optional[str], FieldMetadata(alias="highValueTargetDescriptionId") 21 | ] = pydantic.Field(default=None) 22 | """ 23 | The ID of the specific high value target description within a high value target list that was matched against. 24 | The ID is considered to be a globally unique identifier across all high value target IDs. 25 | """ 26 | 27 | if IS_PYDANTIC_V2: 28 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 29 | else: 30 | 31 | class Config: 32 | frozen = True 33 | smart_union = True 34 | extra = pydantic.Extra.allow 35 | -------------------------------------------------------------------------------- /src/anduril/types/relations.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | from __future__ import annotations 4 | 5 | import typing 6 | 7 | import pydantic 8 | import typing_extensions 9 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel, update_forward_refs 10 | from ..core.serialization import FieldMetadata 11 | 12 | 13 | class Relations(UniversalBaseModel): 14 | """ 15 | Describes the relationships associated with this task: the system assigned to 16 | execute the task, and the parent task, if one exists. 17 | """ 18 | 19 | assignee: typing.Optional["Principal"] = pydantic.Field(default=None) 20 | """ 21 | The system, user, or team assigned to the task. 22 | """ 23 | 24 | parent_task_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="parentTaskId")] = ( 25 | pydantic.Field(default=None) 26 | ) 27 | """ 28 | Identifies the parent task if the task is a sub-task. 29 | """ 30 | 31 | if IS_PYDANTIC_V2: 32 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 33 | else: 34 | 35 | class Config: 36 | frozen = True 37 | smart_union = True 38 | extra = pydantic.Extra.allow 39 | 40 | 41 | from .principal import Principal # noqa: E402, I001 42 | 43 | update_forward_refs(Relations) 44 | -------------------------------------------------------------------------------- /src/anduril/types/rf_configuration.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .bandwidth_range import BandwidthRange 10 | from .frequency_range import FrequencyRange 11 | 12 | 13 | class RfConfiguration(UniversalBaseModel): 14 | """ 15 | Represents RF configurations supported on this sensor. 16 | """ 17 | 18 | frequency_range_hz: typing_extensions.Annotated[ 19 | typing.Optional[typing.List[FrequencyRange]], FieldMetadata(alias="frequencyRangeHz") 20 | ] = pydantic.Field(default=None) 21 | """ 22 | Frequency ranges that are available for this sensor. 23 | """ 24 | 25 | bandwidth_range_hz: typing_extensions.Annotated[ 26 | typing.Optional[typing.List[BandwidthRange]], FieldMetadata(alias="bandwidthRangeHz") 27 | ] = pydantic.Field(default=None) 28 | """ 29 | Bandwidth ranges that are available for this sensor. 30 | """ 31 | 32 | if IS_PYDANTIC_V2: 33 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 34 | else: 35 | 36 | class Config: 37 | frozen = True 38 | smart_union = True 39 | extra = pydantic.Extra.allow 40 | -------------------------------------------------------------------------------- /src/anduril/tasks/__init__.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | # isort: skip_file 4 | 5 | import typing 6 | from importlib import import_module 7 | 8 | if typing.TYPE_CHECKING: 9 | from .types import TaskQueryStatusFilter, TaskQueryStatusFilterStatus, TaskQueryUpdateTimeRange 10 | _dynamic_imports: typing.Dict[str, str] = { 11 | "TaskQueryStatusFilter": ".types", 12 | "TaskQueryStatusFilterStatus": ".types", 13 | "TaskQueryUpdateTimeRange": ".types", 14 | } 15 | 16 | 17 | def __getattr__(attr_name: str) -> typing.Any: 18 | module_name = _dynamic_imports.get(attr_name) 19 | if module_name is None: 20 | raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}") 21 | try: 22 | module = import_module(module_name, __package__) 23 | if module_name == f".{attr_name}": 24 | return module 25 | else: 26 | return getattr(module, attr_name) 27 | except ImportError as e: 28 | raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e 29 | except AttributeError as e: 30 | raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e 31 | 32 | 33 | def __dir__(): 34 | lazy_attrs = list(_dynamic_imports.keys()) 35 | return sorted(lazy_attrs) 36 | 37 | 38 | __all__ = ["TaskQueryStatusFilter", "TaskQueryStatusFilterStatus", "TaskQueryUpdateTimeRange"] 39 | -------------------------------------------------------------------------------- /src/anduril/types/cancel_request.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | from __future__ import annotations 4 | 5 | import typing 6 | 7 | import pydantic 8 | import typing_extensions 9 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel, update_forward_refs 10 | from ..core.serialization import FieldMetadata 11 | 12 | 13 | class CancelRequest(UniversalBaseModel): 14 | """ 15 | The request to cancel a task. 16 | Contains the task, and the assignee of the request to cancel the task. 17 | """ 18 | 19 | task_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="taskId")] = pydantic.Field( 20 | default=None 21 | ) 22 | """ 23 | The unique task ID of the task to cancel. 24 | """ 25 | 26 | assignee: typing.Optional["Principal"] = pydantic.Field(default=None) 27 | """ 28 | The assignee of the Task. Useful for agent routing where an endpoint owns multiple agents, 29 | especially onBehalfOf assignees. 30 | """ 31 | 32 | if IS_PYDANTIC_V2: 33 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 34 | else: 35 | 36 | class Config: 37 | frozen = True 38 | smart_union = True 39 | extra = pydantic.Extra.allow 40 | 41 | 42 | from .principal import Principal # noqa: E402, I001 43 | 44 | update_forward_refs(CancelRequest) 45 | -------------------------------------------------------------------------------- /src/anduril/types/task_entity.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | from __future__ import annotations 4 | 5 | import typing 6 | 7 | import pydantic 8 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel, update_forward_refs 9 | 10 | 11 | class TaskEntity(UniversalBaseModel): 12 | """ 13 | An entity wrapper used in task definitions, with additional metadata. 14 | 15 | TaskEntity wraps an entity reference with additional contextual information for task execution. 16 | This structure allows entities to be passed to tasks with supplementary metadata that aids 17 | in proper task execution, while also serving as an extension point for future capabilities. 18 | """ 19 | 20 | entity: typing.Optional["Entity"] = pydantic.Field(default=None) 21 | """ 22 | The wrapped entity. 23 | """ 24 | 25 | snapshot: typing.Optional[bool] = pydantic.Field(default=None) 26 | """ 27 | Indicates that this entity was generated from a snapshot of a live entity. 28 | """ 29 | 30 | if IS_PYDANTIC_V2: 31 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 32 | else: 33 | 34 | class Config: 35 | frozen = True 36 | smart_union = True 37 | extra = pydantic.Extra.allow 38 | 39 | 40 | from .entity import Entity # noqa: E402, I001 41 | 42 | update_forward_refs(TaskEntity) 43 | -------------------------------------------------------------------------------- /src/anduril/entities/__init__.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | # isort: skip_file 4 | 5 | import typing 6 | from importlib import import_module 7 | 8 | if typing.TYPE_CHECKING: 9 | from .types import StreamEntitiesResponse, StreamEntitiesResponse_Entity, StreamEntitiesResponse_Heartbeat 10 | _dynamic_imports: typing.Dict[str, str] = { 11 | "StreamEntitiesResponse": ".types", 12 | "StreamEntitiesResponse_Entity": ".types", 13 | "StreamEntitiesResponse_Heartbeat": ".types", 14 | } 15 | 16 | 17 | def __getattr__(attr_name: str) -> typing.Any: 18 | module_name = _dynamic_imports.get(attr_name) 19 | if module_name is None: 20 | raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}") 21 | try: 22 | module = import_module(module_name, __package__) 23 | if module_name == f".{attr_name}": 24 | return module 25 | else: 26 | return getattr(module, attr_name) 27 | except ImportError as e: 28 | raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e 29 | except AttributeError as e: 30 | raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e 31 | 32 | 33 | def __dir__(): 34 | lazy_attrs = list(_dynamic_imports.keys()) 35 | return sorted(lazy_attrs) 36 | 37 | 38 | __all__ = ["StreamEntitiesResponse", "StreamEntitiesResponse_Entity", "StreamEntitiesResponse_Heartbeat"] 39 | -------------------------------------------------------------------------------- /src/anduril/types/schedule.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .cron_window import CronWindow 10 | from .schedule_schedule_type import ScheduleScheduleType 11 | 12 | 13 | class Schedule(UniversalBaseModel): 14 | """ 15 | A Schedule associated with this entity 16 | """ 17 | 18 | windows: typing.Optional[typing.List[CronWindow]] = pydantic.Field(default=None) 19 | """ 20 | expression that represents this schedule's "ON" state 21 | """ 22 | 23 | schedule_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="scheduleId")] = pydantic.Field( 24 | default=None 25 | ) 26 | """ 27 | A unique identifier for this schedule. 28 | """ 29 | 30 | schedule_type: typing_extensions.Annotated[ 31 | typing.Optional[ScheduleScheduleType], FieldMetadata(alias="scheduleType") 32 | ] = pydantic.Field(default=None) 33 | """ 34 | The schedule type 35 | """ 36 | 37 | if IS_PYDANTIC_V2: 38 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 39 | else: 40 | 41 | class Config: 42 | frozen = True 43 | smart_union = True 44 | extra = pydantic.Extra.allow 45 | -------------------------------------------------------------------------------- /tests/utils/test_query_encoding.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | from anduril.core.query_encoder import encode_query 4 | 5 | 6 | def test_query_encoding_deep_objects() -> None: 7 | assert encode_query({"hello world": "hello world"}) == [("hello world", "hello world")] 8 | assert encode_query({"hello_world": {"hello": "world"}}) == [("hello_world[hello]", "world")] 9 | assert encode_query({"hello_world": {"hello": {"world": "today"}, "test": "this"}, "hi": "there"}) == [ 10 | ("hello_world[hello][world]", "today"), 11 | ("hello_world[test]", "this"), 12 | ("hi", "there"), 13 | ] 14 | 15 | 16 | def test_query_encoding_deep_object_arrays() -> None: 17 | assert encode_query({"objects": [{"key": "hello", "value": "world"}, {"key": "foo", "value": "bar"}]}) == [ 18 | ("objects[key]", "hello"), 19 | ("objects[value]", "world"), 20 | ("objects[key]", "foo"), 21 | ("objects[value]", "bar"), 22 | ] 23 | assert encode_query( 24 | {"users": [{"name": "string", "tags": ["string"]}, {"name": "string2", "tags": ["string2", "string3"]}]} 25 | ) == [ 26 | ("users[name]", "string"), 27 | ("users[tags]", "string"), 28 | ("users[name]", "string2"), 29 | ("users[tags]", "string2"), 30 | ("users[tags]", "string3"), 31 | ] 32 | 33 | 34 | def test_encode_query_with_none() -> None: 35 | encoded = encode_query(None) 36 | assert encoded is None 37 | -------------------------------------------------------------------------------- /src/anduril/types/principal.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | from __future__ import annotations 4 | 5 | import typing 6 | 7 | import pydantic 8 | import typing_extensions 9 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel, update_forward_refs 10 | from ..core.serialization import FieldMetadata 11 | from .system import System 12 | from .team import Team 13 | from .user import User 14 | 15 | 16 | class Principal(UniversalBaseModel): 17 | """ 18 | A Principal is an entity that has authority over this task. 19 | """ 20 | 21 | system: typing.Optional[System] = None 22 | user: typing.Optional[User] = None 23 | team: typing.Optional[Team] = None 24 | on_behalf_of: typing_extensions.Annotated[typing.Optional["Principal"], FieldMetadata(alias="onBehalfOf")] = ( 25 | pydantic.Field(default=None) 26 | ) 27 | """ 28 | The Principal _this_ Principal is acting on behalf of. 29 | 30 | Likely only populated once in the nesting (i.e. the "on_behalf_of" Principal would not have another "on_behalf_of" in most cases). 31 | """ 32 | 33 | if IS_PYDANTIC_V2: 34 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 35 | else: 36 | 37 | class Config: 38 | frozen = True 39 | smart_union = True 40 | extra = pydantic.Extra.allow 41 | 42 | 43 | update_forward_refs(Principal) 44 | -------------------------------------------------------------------------------- /src/anduril/types/ontology.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .ontology_template import OntologyTemplate 10 | 11 | 12 | class Ontology(UniversalBaseModel): 13 | """ 14 | Ontology of the entity. 15 | """ 16 | 17 | platform_type: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="platformType")] = ( 18 | pydantic.Field(default=None) 19 | ) 20 | """ 21 | A string that describes the entity's high-level type with natural language. 22 | """ 23 | 24 | specific_type: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="specificType")] = ( 25 | pydantic.Field(default=None) 26 | ) 27 | """ 28 | A string that describes the entity's exact model or type. 29 | """ 30 | 31 | template: typing.Optional[OntologyTemplate] = pydantic.Field(default=None) 32 | """ 33 | The template used when creating this entity. Specifies minimum required components. 34 | """ 35 | 36 | if IS_PYDANTIC_V2: 37 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 38 | else: 39 | 40 | class Config: 41 | frozen = True 42 | smart_union = True 43 | extra = pydantic.Extra.allow 44 | -------------------------------------------------------------------------------- /src/anduril/types/field_classification_information.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .classification_information import ClassificationInformation 10 | 11 | 12 | class FieldClassificationInformation(UniversalBaseModel): 13 | """ 14 | A field specific classification information definition. 15 | """ 16 | 17 | field_path: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="fieldPath")] = pydantic.Field( 18 | default=None 19 | ) 20 | """ 21 | Proto field path which is the string representation of a field. 22 | > example: signal.bandwidth_hz would be bandwidth_hz in the signal component 23 | """ 24 | 25 | classification_information: typing_extensions.Annotated[ 26 | typing.Optional[ClassificationInformation], FieldMetadata(alias="classificationInformation") 27 | ] = pydantic.Field(default=None) 28 | """ 29 | The information which makes up the field level classification marking. 30 | """ 31 | 32 | if IS_PYDANTIC_V2: 33 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 34 | else: 35 | 36 | class Config: 37 | frozen = True 38 | smart_union = True 39 | extra = pydantic.Extra.allow 40 | -------------------------------------------------------------------------------- /src/anduril/core/http_sse/__init__.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | # isort: skip_file 4 | 5 | import typing 6 | from importlib import import_module 7 | 8 | if typing.TYPE_CHECKING: 9 | from ._api import EventSource, aconnect_sse, connect_sse 10 | from ._exceptions import SSEError 11 | from ._models import ServerSentEvent 12 | _dynamic_imports: typing.Dict[str, str] = { 13 | "EventSource": "._api", 14 | "SSEError": "._exceptions", 15 | "ServerSentEvent": "._models", 16 | "aconnect_sse": "._api", 17 | "connect_sse": "._api", 18 | } 19 | 20 | 21 | def __getattr__(attr_name: str) -> typing.Any: 22 | module_name = _dynamic_imports.get(attr_name) 23 | if module_name is None: 24 | raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}") 25 | try: 26 | module = import_module(module_name, __package__) 27 | if module_name == f".{attr_name}": 28 | return module 29 | else: 30 | return getattr(module, attr_name) 31 | except ImportError as e: 32 | raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e 33 | except AttributeError as e: 34 | raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e 35 | 36 | 37 | def __dir__(): 38 | lazy_attrs = list(_dynamic_imports.keys()) 39 | return sorted(lazy_attrs) 40 | 41 | 42 | __all__ = ["EventSource", "SSEError", "ServerSentEvent", "aconnect_sse", "connect_sse"] 43 | -------------------------------------------------------------------------------- /src/anduril/types/mode5.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .mode5mode5interrogation_response import Mode5Mode5InterrogationResponse 10 | 11 | 12 | class Mode5(UniversalBaseModel): 13 | """ 14 | Describes the Mode 5 transponder interrogation status and codes. 15 | """ 16 | 17 | mode5interrogation_response: typing_extensions.Annotated[ 18 | typing.Optional[Mode5Mode5InterrogationResponse], FieldMetadata(alias="mode5InterrogationResponse") 19 | ] = pydantic.Field(default=None) 20 | """ 21 | The validity of the response from the Mode 5 interrogation. 22 | """ 23 | 24 | mode5: typing.Optional[int] = pydantic.Field(default=None) 25 | """ 26 | The Mode 5 code assigned to military assets. 27 | """ 28 | 29 | mode5platform_id: typing_extensions.Annotated[typing.Optional[int], FieldMetadata(alias="mode5PlatformId")] = ( 30 | pydantic.Field(default=None) 31 | ) 32 | """ 33 | The Mode 5 platform identification code. 34 | """ 35 | 36 | if IS_PYDANTIC_V2: 37 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 38 | else: 39 | 40 | class Config: 41 | frozen = True 42 | smart_union = True 43 | extra = pydantic.Extra.allow 44 | -------------------------------------------------------------------------------- /src/anduril/types/alert_condition.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | 10 | 11 | class AlertCondition(UniversalBaseModel): 12 | """ 13 | A condition which may trigger an alert. 14 | """ 15 | 16 | condition_code: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="conditionCode")] = ( 17 | pydantic.Field(default=None) 18 | ) 19 | """ 20 | Short, machine-readable code that describes this condition. This code is intended to provide systems off-asset 21 | with a lookup key to retrieve more detailed information about the condition. 22 | """ 23 | 24 | description: typing.Optional[str] = pydantic.Field(default=None) 25 | """ 26 | Human-readable description of this condition. The description is intended for display in the UI for human 27 | understanding and should not be used for machine processing. If the description is fixed and the vehicle controller 28 | provides no dynamic substitutions, then prefer lookup based on condition_code. 29 | """ 30 | 31 | if IS_PYDANTIC_V2: 32 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 33 | else: 34 | 35 | class Config: 36 | frozen = True 37 | smart_union = True 38 | extra = pydantic.Extra.allow 39 | -------------------------------------------------------------------------------- /src/anduril/core/http_response.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | from typing import Dict, Generic, TypeVar 4 | 5 | import httpx 6 | 7 | # Generic to represent the underlying type of the data wrapped by the HTTP response. 8 | T = TypeVar("T") 9 | 10 | 11 | class BaseHttpResponse: 12 | """Minimalist HTTP response wrapper that exposes response headers.""" 13 | 14 | _response: httpx.Response 15 | 16 | def __init__(self, response: httpx.Response): 17 | self._response = response 18 | 19 | @property 20 | def headers(self) -> Dict[str, str]: 21 | return dict(self._response.headers) 22 | 23 | 24 | class HttpResponse(Generic[T], BaseHttpResponse): 25 | """HTTP response wrapper that exposes response headers and data.""" 26 | 27 | _data: T 28 | 29 | def __init__(self, response: httpx.Response, data: T): 30 | super().__init__(response) 31 | self._data = data 32 | 33 | @property 34 | def data(self) -> T: 35 | return self._data 36 | 37 | def close(self) -> None: 38 | self._response.close() 39 | 40 | 41 | class AsyncHttpResponse(Generic[T], BaseHttpResponse): 42 | """HTTP response wrapper that exposes response headers and data.""" 43 | 44 | _data: T 45 | 46 | def __init__(self, response: httpx.Response, data: T): 47 | super().__init__(response) 48 | self._data = data 49 | 50 | @property 51 | def data(self) -> T: 52 | return self._data 53 | 54 | async def close(self) -> None: 55 | await self._response.aclose() 56 | -------------------------------------------------------------------------------- /src/anduril/types/cron_window.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | 10 | 11 | class CronWindow(UniversalBaseModel): 12 | cron_expression: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="cronExpression")] = ( 13 | pydantic.Field(default=None) 14 | ) 15 | """ 16 | in UTC, describes when and at what cadence this window starts, in the quartz flavor of cron 17 | 18 | examples: 19 | This schedule is begins at 7:00:00am UTC everyday between Monday and Friday 20 | 0 0 7 ? * MON-FRI * 21 | This schedule begins every 5 minutes starting at 12:00:00pm UTC until 8:00:00pm UTC everyday 22 | 0 0/5 12-20 * * ? * 23 | This schedule begins at 12:00:00pm UTC on March 2nd 2023 24 | 0 0 12 2 3 ? 2023 25 | """ 26 | 27 | duration_millis: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="durationMillis")] = ( 28 | pydantic.Field(default=None) 29 | ) 30 | """ 31 | describes the duration 32 | """ 33 | 34 | if IS_PYDANTIC_V2: 35 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 36 | else: 37 | 38 | class Config: 39 | frozen = True 40 | smart_union = True 41 | extra = pydantic.Extra.allow 42 | -------------------------------------------------------------------------------- /src/anduril/types/line_of_bearing.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .angle_of_arrival import AngleOfArrival 10 | from .measurement import Measurement 11 | 12 | 13 | class LineOfBearing(UniversalBaseModel): 14 | """ 15 | A line of bearing of a signal. 16 | """ 17 | 18 | angle_of_arrival: typing_extensions.Annotated[ 19 | typing.Optional[AngleOfArrival], FieldMetadata(alias="angleOfArrival") 20 | ] = pydantic.Field(default=None) 21 | """ 22 | The direction pointing from this entity to the detection 23 | """ 24 | 25 | range_estimate_m: typing_extensions.Annotated[ 26 | typing.Optional[Measurement], FieldMetadata(alias="rangeEstimateM") 27 | ] = pydantic.Field(default=None) 28 | """ 29 | The estimated distance of the detection 30 | """ 31 | 32 | max_range_m: typing_extensions.Annotated[typing.Optional[Measurement], FieldMetadata(alias="maxRangeM")] = ( 33 | pydantic.Field(default=None) 34 | ) 35 | """ 36 | The maximum distance of the detection 37 | """ 38 | 39 | if IS_PYDANTIC_V2: 40 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 41 | else: 42 | 43 | class Config: 44 | frozen = True 45 | smart_union = True 46 | extra = pydantic.Extra.allow 47 | -------------------------------------------------------------------------------- /src/anduril/types/relationship_type.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .active_target import ActiveTarget 10 | from .group_child import GroupChild 11 | from .group_parent import GroupParent 12 | from .merged_from import MergedFrom 13 | from .tracked_by import TrackedBy 14 | 15 | 16 | class RelationshipType(UniversalBaseModel): 17 | """ 18 | Determines the type of relationship between this entity and another. 19 | """ 20 | 21 | tracked_by: typing_extensions.Annotated[typing.Optional[TrackedBy], FieldMetadata(alias="trackedBy")] = None 22 | group_child: typing_extensions.Annotated[typing.Optional[GroupChild], FieldMetadata(alias="groupChild")] = None 23 | group_parent: typing_extensions.Annotated[typing.Optional[GroupParent], FieldMetadata(alias="groupParent")] = None 24 | merged_from: typing_extensions.Annotated[typing.Optional[MergedFrom], FieldMetadata(alias="mergedFrom")] = None 25 | active_target: typing_extensions.Annotated[typing.Optional[ActiveTarget], FieldMetadata(alias="activeTarget")] = ( 26 | None 27 | ) 28 | 29 | if IS_PYDANTIC_V2: 30 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 31 | else: 32 | 33 | class Config: 34 | frozen = True 35 | smart_union = True 36 | extra = pydantic.Extra.allow 37 | -------------------------------------------------------------------------------- /src/anduril/entities/types/__init__.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | # isort: skip_file 4 | 5 | import typing 6 | from importlib import import_module 7 | 8 | if typing.TYPE_CHECKING: 9 | from .stream_entities_response import ( 10 | StreamEntitiesResponse, 11 | StreamEntitiesResponse_Entity, 12 | StreamEntitiesResponse_Heartbeat, 13 | ) 14 | _dynamic_imports: typing.Dict[str, str] = { 15 | "StreamEntitiesResponse": ".stream_entities_response", 16 | "StreamEntitiesResponse_Entity": ".stream_entities_response", 17 | "StreamEntitiesResponse_Heartbeat": ".stream_entities_response", 18 | } 19 | 20 | 21 | def __getattr__(attr_name: str) -> typing.Any: 22 | module_name = _dynamic_imports.get(attr_name) 23 | if module_name is None: 24 | raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}") 25 | try: 26 | module = import_module(module_name, __package__) 27 | if module_name == f".{attr_name}": 28 | return module 29 | else: 30 | return getattr(module, attr_name) 31 | except ImportError as e: 32 | raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e 33 | except AttributeError as e: 34 | raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e 35 | 36 | 37 | def __dir__(): 38 | lazy_attrs = list(_dynamic_imports.keys()) 39 | return sorted(lazy_attrs) 40 | 41 | 42 | __all__ = ["StreamEntitiesResponse", "StreamEntitiesResponse_Entity", "StreamEntitiesResponse_Heartbeat"] 43 | -------------------------------------------------------------------------------- /src/anduril/types/relationship.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .relationship_type import RelationshipType 10 | 11 | 12 | class Relationship(UniversalBaseModel): 13 | """ 14 | The relationship component indicates a relationship to another entity. 15 | """ 16 | 17 | related_entity_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="relatedEntityId")] = ( 18 | pydantic.Field(default=None) 19 | ) 20 | """ 21 | The entity ID to which this entity is related. 22 | """ 23 | 24 | relationship_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="relationshipId")] = ( 25 | pydantic.Field(default=None) 26 | ) 27 | """ 28 | A unique identifier for this relationship. Allows removing or updating relationships. 29 | """ 30 | 31 | relationship_type: typing_extensions.Annotated[ 32 | typing.Optional[RelationshipType], FieldMetadata(alias="relationshipType") 33 | ] = pydantic.Field(default=None) 34 | """ 35 | The relationship type 36 | """ 37 | 38 | if IS_PYDANTIC_V2: 39 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 40 | else: 41 | 42 | class Config: 43 | frozen = True 44 | smart_union = True 45 | extra = pydantic.Extra.allow 46 | -------------------------------------------------------------------------------- /src/anduril/types/tracked_by.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import datetime as dt 4 | import typing 5 | 6 | import pydantic 7 | import typing_extensions 8 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 9 | from ..core.serialization import FieldMetadata 10 | from .sensors import Sensors 11 | 12 | 13 | class TrackedBy(UniversalBaseModel): 14 | """ 15 | Describes the relationship between the entity being tracked ("tracked entity") and the entity that is 16 | performing the tracking ("tracking entity"). 17 | """ 18 | 19 | actively_tracking_sensors: typing_extensions.Annotated[ 20 | typing.Optional[Sensors], FieldMetadata(alias="activelyTrackingSensors") 21 | ] = pydantic.Field(default=None) 22 | """ 23 | Sensor details of the tracking entity's sensors that were active and tracking the tracked entity. This may be 24 | a subset of the total sensors available on the tracking entity. 25 | """ 26 | 27 | last_measurement_timestamp: typing_extensions.Annotated[ 28 | typing.Optional[dt.datetime], FieldMetadata(alias="lastMeasurementTimestamp") 29 | ] = pydantic.Field(default=None) 30 | """ 31 | Latest time that any sensor in actively_tracking_sensors detected the tracked entity. 32 | """ 33 | 34 | if IS_PYDANTIC_V2: 35 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 36 | else: 37 | 38 | class Config: 39 | frozen = True 40 | smart_union = True 41 | extra = pydantic.Extra.allow 42 | -------------------------------------------------------------------------------- /src/anduril/tasks/types/__init__.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | # isort: skip_file 4 | 5 | import typing 6 | from importlib import import_module 7 | 8 | if typing.TYPE_CHECKING: 9 | from .task_query_status_filter import TaskQueryStatusFilter 10 | from .task_query_status_filter_status import TaskQueryStatusFilterStatus 11 | from .task_query_update_time_range import TaskQueryUpdateTimeRange 12 | _dynamic_imports: typing.Dict[str, str] = { 13 | "TaskQueryStatusFilter": ".task_query_status_filter", 14 | "TaskQueryStatusFilterStatus": ".task_query_status_filter_status", 15 | "TaskQueryUpdateTimeRange": ".task_query_update_time_range", 16 | } 17 | 18 | 19 | def __getattr__(attr_name: str) -> typing.Any: 20 | module_name = _dynamic_imports.get(attr_name) 21 | if module_name is None: 22 | raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}") 23 | try: 24 | module = import_module(module_name, __package__) 25 | if module_name == f".{attr_name}": 26 | return module 27 | else: 28 | return getattr(module, attr_name) 29 | except ImportError as e: 30 | raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e 31 | except AttributeError as e: 32 | raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e 33 | 34 | 35 | def __dir__(): 36 | lazy_attrs = list(_dynamic_imports.keys()) 37 | return sorted(lazy_attrs) 38 | 39 | 40 | __all__ = ["TaskQueryStatusFilter", "TaskQueryStatusFilterStatus", "TaskQueryUpdateTimeRange"] 41 | -------------------------------------------------------------------------------- /src/anduril/types/task_error.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .google_protobuf_any import GoogleProtobufAny 10 | from .task_error_code import TaskErrorCode 11 | 12 | 13 | class TaskError(UniversalBaseModel): 14 | """ 15 | Error information associated with a task. 16 | 17 | TaskError contains structured error details, including an error code, a human-readable 18 | message, and optional extended error information. This structure is used when a task 19 | encounters problems during its lifecycle. 20 | """ 21 | 22 | code: typing.Optional[TaskErrorCode] = pydantic.Field(default=None) 23 | """ 24 | Error code for task error. 25 | """ 26 | 27 | message: typing.Optional[str] = pydantic.Field(default=None) 28 | """ 29 | Descriptive human-readable string regarding this error. 30 | """ 31 | 32 | error_details: typing_extensions.Annotated[ 33 | typing.Optional[GoogleProtobufAny], FieldMetadata(alias="errorDetails") 34 | ] = pydantic.Field(default=None) 35 | """ 36 | Any additional details regarding this error. 37 | """ 38 | 39 | if IS_PYDANTIC_V2: 40 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 41 | else: 42 | 43 | class Config: 44 | frozen = True 45 | smart_union = True 46 | extra = pydantic.Extra.allow 47 | -------------------------------------------------------------------------------- /src/anduril/types/entity_manager_pose.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | from .position import Position 8 | from .quaternion import Quaternion 9 | 10 | 11 | class EntityManagerPose(UniversalBaseModel): 12 | pos: typing.Optional[Position] = pydantic.Field(default=None) 13 | """ 14 | Geospatial location defined by this Pose. 15 | """ 16 | 17 | orientation: typing.Optional[Quaternion] = pydantic.Field(default=None) 18 | """ 19 | The quaternion to transform a point in the Pose frame to the ENU frame. The Pose frame could be Body, Turret, 20 | etc and is determined by the context in which this Pose is used. 21 | The normal convention for defining orientation is to list the frames of transformation, for example 22 | att_gimbal_to_enu is the quaternion which transforms a point in the gimbal frame to the body frame, but 23 | in this case we truncate to att_enu because the Pose frame isn't defined. A potentially better name for this 24 | field would have been att_pose_to_enu. 25 | 26 | Implementations of this quaternion should left multiply this quaternion to transform a point from the Pose frame 27 | to the enu frame. 28 | """ 29 | 30 | if IS_PYDANTIC_V2: 31 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 32 | else: 33 | 34 | class Config: 35 | frozen = True 36 | smart_union = True 37 | extra = pydantic.Extra.allow 38 | -------------------------------------------------------------------------------- /src/anduril/types/geo_ellipsoid.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | 10 | 11 | class GeoEllipsoid(UniversalBaseModel): 12 | """ 13 | An ellipsoid shaped geo-entity. 14 | Principal axis lengths are defined in entity body space 15 | This shape is NOT Geo-JSON compatible. 16 | """ 17 | 18 | forward_axis_m: typing_extensions.Annotated[typing.Optional[float], FieldMetadata(alias="forwardAxisM")] = ( 19 | pydantic.Field(default=None) 20 | ) 21 | """ 22 | Defines the distance from the center point to the surface along the forward axis 23 | """ 24 | 25 | side_axis_m: typing_extensions.Annotated[typing.Optional[float], FieldMetadata(alias="sideAxisM")] = pydantic.Field( 26 | default=None 27 | ) 28 | """ 29 | Defines the distance from the center point to the surface along the side axis 30 | """ 31 | 32 | up_axis_m: typing_extensions.Annotated[typing.Optional[float], FieldMetadata(alias="upAxisM")] = pydantic.Field( 33 | default=None 34 | ) 35 | """ 36 | Defines the distance from the center point to the surface along the up axis 37 | """ 38 | 39 | if IS_PYDANTIC_V2: 40 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 41 | else: 42 | 43 | class Config: 44 | frozen = True 45 | smart_union = True 46 | extra = pydantic.Extra.allow 47 | -------------------------------------------------------------------------------- /src/anduril/types/geo_polygon.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .linear_ring import LinearRing 10 | 11 | 12 | class GeoPolygon(UniversalBaseModel): 13 | """ 14 | A polygon shaped geo-entity. 15 | See https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.6, only canonical representations accepted 16 | """ 17 | 18 | rings: typing.Optional[typing.List[LinearRing]] = pydantic.Field(default=None) 19 | """ 20 | An array of LinearRings where the first item is the exterior ring and subsequent items are interior rings. 21 | """ 22 | 23 | is_rectangle: typing_extensions.Annotated[typing.Optional[bool], FieldMetadata(alias="isRectangle")] = ( 24 | pydantic.Field(default=None) 25 | ) 26 | """ 27 | An extension hint that this polygon is a rectangle. When true this implies several things: 28 | * exactly 1 linear ring with 5 points (starting corner, 3 other corners and start again) 29 | * each point has the same altitude corresponding with the plane of the rectangle 30 | * each point has the same height (either all present and equal, or all not present) 31 | """ 32 | 33 | if IS_PYDANTIC_V2: 34 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 35 | else: 36 | 37 | class Config: 38 | frozen = True 39 | smart_union = True 40 | extra = pydantic.Extra.allow 41 | -------------------------------------------------------------------------------- /src/anduril/types/decorrelation.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .decorrelated_all import DecorrelatedAll 10 | from .decorrelated_single import DecorrelatedSingle 11 | 12 | 13 | class Decorrelation(UniversalBaseModel): 14 | all_: typing_extensions.Annotated[typing.Optional[DecorrelatedAll], FieldMetadata(alias="all")] = pydantic.Field( 15 | default=None 16 | ) 17 | """ 18 | This will be specified if this entity was decorrelated against all other entities. 19 | """ 20 | 21 | decorrelated_entities: typing_extensions.Annotated[ 22 | typing.Optional[typing.List[DecorrelatedSingle]], FieldMetadata(alias="decorrelatedEntities") 23 | ] = pydantic.Field(default=None) 24 | """ 25 | A list of decorrelated entities that have been explicitly decorrelated against this entity 26 | which prevents lower precedence correlations from overriding it in the future. 27 | For example, if an operator in the UI decorrelated tracks A and B, any automated 28 | correlators would be unable to correlate them since manual decorrelations have 29 | higher precedence than automatic ones. Precedence is determined by both correlation 30 | type and replication mode. 31 | """ 32 | 33 | if IS_PYDANTIC_V2: 34 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 35 | else: 36 | 37 | class Config: 38 | frozen = True 39 | smart_union = True 40 | extra = pydantic.Extra.allow 41 | -------------------------------------------------------------------------------- /src/anduril/types/angle_of_arrival.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .pose import Pose 10 | from .t_mat2 import TMat2 11 | 12 | 13 | class AngleOfArrival(UniversalBaseModel): 14 | """ 15 | The direction from which the signal is received 16 | """ 17 | 18 | relative_pose: typing_extensions.Annotated[typing.Optional[Pose], FieldMetadata(alias="relativePose")] = ( 19 | pydantic.Field(default=None) 20 | ) 21 | """ 22 | Origin (LLA) and attitude (relative to ENU) of a ray pointing towards the detection. The attitude represents a 23 | forward-left-up (FLU) frame where the x-axis (1, 0, 0) is pointing towards the target. 24 | """ 25 | 26 | bearing_elevation_covariance_rad2: typing_extensions.Annotated[ 27 | typing.Optional[TMat2], FieldMetadata(alias="bearingElevationCovarianceRad2") 28 | ] = pydantic.Field(default=None) 29 | """ 30 | Bearing/elevation covariance matrix where bearing is defined in radians CCW+ about the z-axis from the x-axis of FLU frame 31 | and elevation is positive down from the FL/XY plane. 32 | mxx = bearing variance in rad^2 33 | mxy = bearing/elevation covariance in rad^2 34 | myy = elevation variance in rad^2 35 | """ 36 | 37 | if IS_PYDANTIC_V2: 38 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 39 | else: 40 | 41 | class Config: 42 | frozen = True 43 | smart_union = True 44 | extra = pydantic.Extra.allow 45 | -------------------------------------------------------------------------------- /src/anduril/types/system.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | 10 | 11 | class System(UniversalBaseModel): 12 | """ 13 | System Principal representing some autonomous system. 14 | """ 15 | 16 | service_name: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="serviceName")] = ( 17 | pydantic.Field(default=None) 18 | ) 19 | """ 20 | Name of the service associated with this System. 21 | """ 22 | 23 | entity_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="entityId")] = pydantic.Field( 24 | default=None 25 | ) 26 | """ 27 | The Entity ID of the System. 28 | """ 29 | 30 | manages_own_scheduling: typing_extensions.Annotated[ 31 | typing.Optional[bool], FieldMetadata(alias="managesOwnScheduling") 32 | ] = pydantic.Field(default=None) 33 | """ 34 | Whether the System Principal (for example, an Asset) can own scheduling. 35 | This means we bypass manager-owned scheduling and defer to the system 36 | Principal to handle scheduling and give us status updates for the task. 37 | Regardless of the value defined by the client, the Task Manager will 38 | determine and set this value appropriately. 39 | """ 40 | 41 | if IS_PYDANTIC_V2: 42 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 43 | else: 44 | 45 | class Config: 46 | frozen = True 47 | smart_union = True 48 | extra = pydantic.Extra.allow 49 | -------------------------------------------------------------------------------- /src/anduril/types/range_rings.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .color import Color 10 | 11 | 12 | class RangeRings(UniversalBaseModel): 13 | """ 14 | Range rings allow visual assessment of map distance at varying zoom levels. 15 | """ 16 | 17 | min_distance_m: typing_extensions.Annotated[typing.Optional[float], FieldMetadata(alias="minDistanceM")] = ( 18 | pydantic.Field(default=None) 19 | ) 20 | """ 21 | The minimum range ring distance, specified in meters. 22 | """ 23 | 24 | max_distance_m: typing_extensions.Annotated[typing.Optional[float], FieldMetadata(alias="maxDistanceM")] = ( 25 | pydantic.Field(default=None) 26 | ) 27 | """ 28 | The maximum range ring distance, specified in meters. 29 | """ 30 | 31 | ring_count: typing_extensions.Annotated[typing.Optional[int], FieldMetadata(alias="ringCount")] = pydantic.Field( 32 | default=None 33 | ) 34 | """ 35 | The count of range rings. 36 | """ 37 | 38 | ring_line_color: typing_extensions.Annotated[typing.Optional[Color], FieldMetadata(alias="ringLineColor")] = ( 39 | pydantic.Field(default=None) 40 | ) 41 | """ 42 | The color of range rings, specified in hex string. 43 | """ 44 | 45 | if IS_PYDANTIC_V2: 46 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 47 | else: 48 | 49 | class Config: 50 | frozen = True 51 | smart_union = True 52 | extra = pydantic.Extra.allow 53 | -------------------------------------------------------------------------------- /src/anduril/core/request_options.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | try: 6 | from typing import NotRequired # type: ignore 7 | except ImportError: 8 | from typing_extensions import NotRequired 9 | 10 | 11 | class RequestOptions(typing.TypedDict, total=False): 12 | """ 13 | Additional options for request-specific configuration when calling APIs via the SDK. 14 | This is used primarily as an optional final parameter for service functions. 15 | 16 | Attributes: 17 | - timeout_in_seconds: int. The number of seconds to await an API call before timing out. 18 | 19 | - max_retries: int. The max number of retries to attempt if the API call fails. 20 | 21 | - additional_headers: typing.Dict[str, typing.Any]. A dictionary containing additional parameters to spread into the request's header dict 22 | 23 | - additional_query_parameters: typing.Dict[str, typing.Any]. A dictionary containing additional parameters to spread into the request's query parameters dict 24 | 25 | - additional_body_parameters: typing.Dict[str, typing.Any]. A dictionary containing additional parameters to spread into the request's body parameters dict 26 | 27 | - chunk_size: int. The size, in bytes, to process each chunk of data being streamed back within the response. This equates to leveraging `chunk_size` within `requests` or `httpx`, and is only leveraged for file downloads. 28 | """ 29 | 30 | timeout_in_seconds: NotRequired[int] 31 | max_retries: NotRequired[int] 32 | additional_headers: NotRequired[typing.Dict[str, typing.Any]] 33 | additional_query_parameters: NotRequired[typing.Dict[str, typing.Any]] 34 | additional_body_parameters: NotRequired[typing.Dict[str, typing.Any]] 35 | chunk_size: NotRequired[int] 36 | -------------------------------------------------------------------------------- /src/anduril/types/correlation_membership.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .correlation_metadata import CorrelationMetadata 10 | from .non_primary_membership import NonPrimaryMembership 11 | from .primary_membership import PrimaryMembership 12 | 13 | 14 | class CorrelationMembership(UniversalBaseModel): 15 | correlation_set_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="correlationSetId")] = ( 16 | pydantic.Field(default=None) 17 | ) 18 | """ 19 | The ID of the correlation set this entity belongs to. 20 | """ 21 | 22 | primary: typing.Optional[PrimaryMembership] = pydantic.Field(default=None) 23 | """ 24 | This entity is the primary of a correlation set meaning that it serves as the representative 25 | entity of the correlation set. 26 | """ 27 | 28 | non_primary: typing_extensions.Annotated[ 29 | typing.Optional[NonPrimaryMembership], FieldMetadata(alias="nonPrimary") 30 | ] = pydantic.Field(default=None) 31 | """ 32 | This entity is not the primary of the correlation set. Note that there may not 33 | be a primary at all. 34 | """ 35 | 36 | metadata: typing.Optional[CorrelationMetadata] = pydantic.Field(default=None) 37 | """ 38 | Additional metadata on this correlation. 39 | """ 40 | 41 | if IS_PYDANTIC_V2: 42 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 43 | else: 44 | 45 | class Config: 46 | frozen = True 47 | smart_union = True 48 | extra = pydantic.Extra.allow 49 | -------------------------------------------------------------------------------- /src/anduril/types/color.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 7 | 8 | 9 | class Color(UniversalBaseModel): 10 | red: typing.Optional[float] = pydantic.Field(default=None) 11 | """ 12 | The amount of red in the color as a value in the interval [0, 1]. 13 | """ 14 | 15 | green: typing.Optional[float] = pydantic.Field(default=None) 16 | """ 17 | The amount of green in the color as a value in the interval [0, 1]. 18 | """ 19 | 20 | blue: typing.Optional[float] = pydantic.Field(default=None) 21 | """ 22 | The amount of blue in the color as a value in the interval [0, 1]. 23 | """ 24 | 25 | alpha: typing.Optional[float] = pydantic.Field(default=None) 26 | """ 27 | The fraction of this color that should be applied to the pixel. That is, 28 | the final pixel color is defined by the equation: 29 | 30 | `pixel color = alpha * (this color) + (1.0 - alpha) * (background color)` 31 | 32 | This means that a value of 1.0 corresponds to a solid color, whereas 33 | a value of 0.0 corresponds to a completely transparent color. This 34 | uses a wrapper message rather than a simple float scalar so that it is 35 | possible to distinguish between a default value and the value being unset. 36 | If omitted, this color object is rendered as a solid color 37 | (as if the alpha value had been explicitly given a value of 1.0). 38 | """ 39 | 40 | if IS_PYDANTIC_V2: 41 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 42 | else: 43 | 44 | class Config: 45 | frozen = True 46 | smart_union = True 47 | extra = pydantic.Extra.allow 48 | -------------------------------------------------------------------------------- /src/anduril/types/component_health.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import datetime as dt 4 | import typing 5 | 6 | import pydantic 7 | import typing_extensions 8 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 9 | from ..core.serialization import FieldMetadata 10 | from .component_health_health import ComponentHealthHealth 11 | from .component_message import ComponentMessage 12 | 13 | 14 | class ComponentHealth(UniversalBaseModel): 15 | """ 16 | Health of an individual component. 17 | """ 18 | 19 | id: typing.Optional[str] = pydantic.Field(default=None) 20 | """ 21 | Consistent internal ID for this component. 22 | """ 23 | 24 | name: typing.Optional[str] = pydantic.Field(default=None) 25 | """ 26 | Display name for this component. 27 | """ 28 | 29 | health: typing.Optional[ComponentHealthHealth] = pydantic.Field(default=None) 30 | """ 31 | Health for this component. 32 | """ 33 | 34 | messages: typing.Optional[typing.List[ComponentMessage]] = pydantic.Field(default=None) 35 | """ 36 | Human-readable describing the component state. These messages should be understandable by end users. 37 | """ 38 | 39 | update_time: typing_extensions.Annotated[typing.Optional[dt.datetime], FieldMetadata(alias="updateTime")] = ( 40 | pydantic.Field(default=None) 41 | ) 42 | """ 43 | The last update time for this specific component. 44 | If this timestamp is unset, the data is assumed to be most recent 45 | """ 46 | 47 | if IS_PYDANTIC_V2: 48 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 49 | else: 50 | 51 | class Config: 52 | frozen = True 53 | smart_union = True 54 | extra = pydantic.Extra.allow 55 | -------------------------------------------------------------------------------- /src/anduril/types/projected_frustum.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .position import Position 10 | 11 | 12 | class ProjectedFrustum(UniversalBaseModel): 13 | """ 14 | Represents a frustum in which which all four corner points project onto the ground. All points in this message 15 | are optional, if the projection to the ground fails then they will not be populated. 16 | """ 17 | 18 | upper_left: typing_extensions.Annotated[typing.Optional[Position], FieldMetadata(alias="upperLeft")] = ( 19 | pydantic.Field(default=None) 20 | ) 21 | """ 22 | Upper left point of the frustum. 23 | """ 24 | 25 | upper_right: typing_extensions.Annotated[typing.Optional[Position], FieldMetadata(alias="upperRight")] = ( 26 | pydantic.Field(default=None) 27 | ) 28 | """ 29 | Upper right point of the frustum. 30 | """ 31 | 32 | bottom_right: typing_extensions.Annotated[typing.Optional[Position], FieldMetadata(alias="bottomRight")] = ( 33 | pydantic.Field(default=None) 34 | ) 35 | """ 36 | Bottom right point of the frustum. 37 | """ 38 | 39 | bottom_left: typing_extensions.Annotated[typing.Optional[Position], FieldMetadata(alias="bottomLeft")] = ( 40 | pydantic.Field(default=None) 41 | ) 42 | """ 43 | Bottom left point of the frustum. 44 | """ 45 | 46 | if IS_PYDANTIC_V2: 47 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 48 | else: 49 | 50 | class Config: 51 | frozen = True 52 | smart_union = True 53 | extra = pydantic.Extra.allow 54 | -------------------------------------------------------------------------------- /src/anduril/types/task_query_results.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | from __future__ import annotations 4 | 5 | import typing 6 | 7 | import pydantic 8 | import typing_extensions 9 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel, update_forward_refs 10 | from ..core.serialization import FieldMetadata 11 | from .task import Task 12 | 13 | 14 | class TaskQueryResults(UniversalBaseModel): 15 | """ 16 | Response containing tasks that match the query criteria. 17 | 18 | This message returns a list of Task objects that satisfy the filter conditions 19 | specified in the request. When there are more matching tasks than can be returned 20 | in a single response, a page_token is provided to retrieve the next batch in 21 | a subsequent request. An empty tasks list with no page_token indicates that 22 | there are no more matching tasks. 23 | """ 24 | 25 | tasks: typing.Optional[typing.List[Task]] = None 26 | next_page_token: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="nextPageToken")] = ( 27 | pydantic.Field(default=None) 28 | ) 29 | """ 30 | Incomplete results can be detected by a non-empty nextPageToken field in the query results. In order to retrieve 31 | the next page, perform the exact same request as previously and append a pageToken field with the value of 32 | nextPageToken from the previous page. A new nextPageToken is provided on the following pages until all the 33 | results are retrieved. 34 | """ 35 | 36 | if IS_PYDANTIC_V2: 37 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 38 | else: 39 | 40 | class Config: 41 | frozen = True 42 | smart_union = True 43 | extra = pydantic.Extra.allow 44 | 45 | 46 | update_forward_refs(TaskQueryResults) 47 | -------------------------------------------------------------------------------- /tests/utils/assets/models/object_with_optional_field.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | # This file was auto-generated by Fern from our API Definition. 4 | 5 | import datetime as dt 6 | import typing 7 | import uuid 8 | 9 | import typing_extensions 10 | from .color import Color 11 | from .shape import ShapeParams 12 | from .undiscriminated_shape import UndiscriminatedShapeParams 13 | 14 | from anduril.core.serialization import FieldMetadata 15 | 16 | 17 | class ObjectWithOptionalFieldParams(typing_extensions.TypedDict): 18 | literal: typing.Literal["lit_one"] 19 | string: typing_extensions.NotRequired[str] 20 | integer: typing_extensions.NotRequired[int] 21 | long_: typing_extensions.NotRequired[typing_extensions.Annotated[int, FieldMetadata(alias="long")]] 22 | double: typing_extensions.NotRequired[float] 23 | bool_: typing_extensions.NotRequired[typing_extensions.Annotated[bool, FieldMetadata(alias="bool")]] 24 | datetime: typing_extensions.NotRequired[dt.datetime] 25 | date: typing_extensions.NotRequired[dt.date] 26 | uuid_: typing_extensions.NotRequired[typing_extensions.Annotated[uuid.UUID, FieldMetadata(alias="uuid")]] 27 | base_64: typing_extensions.NotRequired[typing_extensions.Annotated[str, FieldMetadata(alias="base64")]] 28 | list_: typing_extensions.NotRequired[typing_extensions.Annotated[typing.Sequence[str], FieldMetadata(alias="list")]] 29 | set_: typing_extensions.NotRequired[typing_extensions.Annotated[typing.Set[str], FieldMetadata(alias="set")]] 30 | map_: typing_extensions.NotRequired[typing_extensions.Annotated[typing.Dict[int, str], FieldMetadata(alias="map")]] 31 | enum: typing_extensions.NotRequired[Color] 32 | union: typing_extensions.NotRequired[ShapeParams] 33 | second_union: typing_extensions.NotRequired[ShapeParams] 34 | undiscriminated_union: typing_extensions.NotRequired[UndiscriminatedShapeParams] 35 | any: typing.Optional[typing.Any] 36 | -------------------------------------------------------------------------------- /src/anduril/types/error_ellipse.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | 10 | 11 | class ErrorEllipse(UniversalBaseModel): 12 | """ 13 | Indicates ellipse characteristics and probability that an entity lies within the defined ellipse. 14 | """ 15 | 16 | probability: typing.Optional[float] = pydantic.Field(default=None) 17 | """ 18 | Defines the probability in percentage that an entity lies within the given ellipse: 0-1. 19 | """ 20 | 21 | semi_major_axis_m: typing_extensions.Annotated[typing.Optional[float], FieldMetadata(alias="semiMajorAxisM")] = ( 22 | pydantic.Field(default=None) 23 | ) 24 | """ 25 | Defines the distance from the center point of the ellipse to the furthest distance on the perimeter in meters. 26 | """ 27 | 28 | semi_minor_axis_m: typing_extensions.Annotated[typing.Optional[float], FieldMetadata(alias="semiMinorAxisM")] = ( 29 | pydantic.Field(default=None) 30 | ) 31 | """ 32 | Defines the distance from the center point of the ellipse to the shortest distance on the perimeter in meters. 33 | """ 34 | 35 | orientation_d: typing_extensions.Annotated[typing.Optional[float], FieldMetadata(alias="orientationD")] = ( 36 | pydantic.Field(default=None) 37 | ) 38 | """ 39 | The orientation of the semi-major relative to true north in degrees from clockwise: 0-180 due to symmetry across the semi-minor axis. 40 | """ 41 | 42 | if IS_PYDANTIC_V2: 43 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 44 | else: 45 | 46 | class Config: 47 | frozen = True 48 | smart_union = True 49 | extra = pydantic.Extra.allow 50 | -------------------------------------------------------------------------------- /src/anduril/core/http_sse/_decoders.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | from typing import List, Optional 4 | 5 | from ._models import ServerSentEvent 6 | 7 | 8 | class SSEDecoder: 9 | def __init__(self) -> None: 10 | self._event = "" 11 | self._data: List[str] = [] 12 | self._last_event_id = "" 13 | self._retry: Optional[int] = None 14 | 15 | def decode(self, line: str) -> Optional[ServerSentEvent]: 16 | # See: https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation # noqa: E501 17 | 18 | if not line: 19 | if not self._event and not self._data and not self._last_event_id and self._retry is None: 20 | return None 21 | 22 | sse = ServerSentEvent( 23 | event=self._event, 24 | data="\n".join(self._data), 25 | id=self._last_event_id, 26 | retry=self._retry, 27 | ) 28 | 29 | # NOTE: as per the SSE spec, do not reset last_event_id. 30 | self._event = "" 31 | self._data = [] 32 | self._retry = None 33 | 34 | return sse 35 | 36 | if line.startswith(":"): 37 | return None 38 | 39 | fieldname, _, value = line.partition(":") 40 | 41 | if value.startswith(" "): 42 | value = value[1:] 43 | 44 | if fieldname == "event": 45 | self._event = value 46 | elif fieldname == "data": 47 | self._data.append(value) 48 | elif fieldname == "id": 49 | if "\0" in value: 50 | pass 51 | else: 52 | self._last_event_id = value 53 | elif fieldname == "retry": 54 | try: 55 | self._retry = int(value) 56 | except (TypeError, ValueError): 57 | pass 58 | else: 59 | pass # Field is ignored. 60 | 61 | return None 62 | -------------------------------------------------------------------------------- /src/anduril/types/location_uncertainty.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .entity_manager_t_mat3 import EntityManagerTMat3 10 | from .error_ellipse import ErrorEllipse 11 | 12 | 13 | class LocationUncertainty(UniversalBaseModel): 14 | """ 15 | Uncertainty of entity position and velocity, if available. 16 | """ 17 | 18 | position_enu_cov: typing_extensions.Annotated[ 19 | typing.Optional[EntityManagerTMat3], FieldMetadata(alias="positionEnuCov") 20 | ] = pydantic.Field(default=None) 21 | """ 22 | Positional covariance represented by the upper triangle of the covariance matrix. It is valid to populate 23 | only the diagonal of the matrix if the full covariance matrix is unknown. 24 | """ 25 | 26 | velocity_enu_cov: typing_extensions.Annotated[ 27 | typing.Optional[EntityManagerTMat3], FieldMetadata(alias="velocityEnuCov") 28 | ] = pydantic.Field(default=None) 29 | """ 30 | Velocity covariance represented by the upper triangle of the covariance matrix. It is valid to populate 31 | only the diagonal of the matrix if the full covariance matrix is unknown. 32 | """ 33 | 34 | position_error_ellipse: typing_extensions.Annotated[ 35 | typing.Optional[ErrorEllipse], FieldMetadata(alias="positionErrorEllipse") 36 | ] = pydantic.Field(default=None) 37 | """ 38 | An ellipse that describes the certainty probability and error boundary for a given geolocation. 39 | """ 40 | 41 | if IS_PYDANTIC_V2: 42 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 43 | else: 44 | 45 | class Config: 46 | frozen = True 47 | smart_union = True 48 | extra = pydantic.Extra.allow 49 | -------------------------------------------------------------------------------- /src/anduril/types/location.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .enu import Enu 10 | from .position import Position 11 | from .quaternion import Quaternion 12 | 13 | 14 | class Location(UniversalBaseModel): 15 | """ 16 | Available for Entities that have a single or primary Location. 17 | """ 18 | 19 | position: typing.Optional[Position] = pydantic.Field(default=None) 20 | """ 21 | see Position definition for details. 22 | """ 23 | 24 | velocity_enu: typing_extensions.Annotated[typing.Optional[Enu], FieldMetadata(alias="velocityEnu")] = ( 25 | pydantic.Field(default=None) 26 | ) 27 | """ 28 | Velocity in an ENU reference frame centered on the corresponding position. All units are meters per second. 29 | """ 30 | 31 | speed_mps: typing_extensions.Annotated[typing.Optional[float], FieldMetadata(alias="speedMps")] = pydantic.Field( 32 | default=None 33 | ) 34 | """ 35 | Speed is the magnitude of velocity_enu vector [sqrt(e^2 + n^2 + u^2)] when present, measured in m/s. 36 | """ 37 | 38 | acceleration: typing.Optional[Enu] = pydantic.Field(default=None) 39 | """ 40 | The entity's acceleration in meters/s^2. 41 | """ 42 | 43 | attitude_enu: typing_extensions.Annotated[typing.Optional[Quaternion], FieldMetadata(alias="attitudeEnu")] = ( 44 | pydantic.Field(default=None) 45 | ) 46 | """ 47 | quaternion to translate from entity body frame to it's ENU frame 48 | """ 49 | 50 | if IS_PYDANTIC_V2: 51 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 52 | else: 53 | 54 | class Config: 55 | frozen = True 56 | smart_union = True 57 | extra = pydantic.Extra.allow 58 | -------------------------------------------------------------------------------- /src/anduril/types/task_version.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | 10 | 11 | class TaskVersion(UniversalBaseModel): 12 | """ 13 | Versioning information for a task. 14 | 15 | TaskVersion provides a unique identifier for each task, along with separate version counters 16 | for tracking changes to the task's definition and its status. This versioning system enables 17 | optimistic concurrency control, ensuring that updates from multiple sources don't conflict. 18 | """ 19 | 20 | task_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="taskId")] = pydantic.Field( 21 | default=None 22 | ) 23 | """ 24 | The unique identifier for this task, used to distinguish it from all other tasks in the system. 25 | """ 26 | 27 | definition_version: typing_extensions.Annotated[typing.Optional[int], FieldMetadata(alias="definitionVersion")] = ( 28 | pydantic.Field(default=None) 29 | ) 30 | """ 31 | Counter that increments on changes to the task definition. 32 | Unset (0) initially, starts at 1 on creation, and increments with each update to task fields. 33 | """ 34 | 35 | status_version: typing_extensions.Annotated[typing.Optional[int], FieldMetadata(alias="statusVersion")] = ( 36 | pydantic.Field(default=None) 37 | ) 38 | """ 39 | Counter that increments on changes to TaskStatus. 40 | Unset (0) initially, starts at 1 on creation, and increments with each status update. 41 | """ 42 | 43 | if IS_PYDANTIC_V2: 44 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 45 | else: 46 | 47 | class Config: 48 | frozen = True 49 | smart_union = True 50 | extra = pydantic.Extra.allow 51 | -------------------------------------------------------------------------------- /src/anduril/types/correlation_metadata.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | import typing 4 | 5 | import pydantic 6 | import typing_extensions 7 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel 8 | from ..core.serialization import FieldMetadata 9 | from .correlation_metadata_replication_mode import CorrelationMetadataReplicationMode 10 | from .correlation_metadata_type import CorrelationMetadataType 11 | from .provenance import Provenance 12 | 13 | 14 | class CorrelationMetadata(UniversalBaseModel): 15 | provenance: typing.Optional[Provenance] = pydantic.Field(default=None) 16 | """ 17 | Who or what added this entity to the (de)correlation. 18 | """ 19 | 20 | replication_mode: typing_extensions.Annotated[ 21 | typing.Optional[CorrelationMetadataReplicationMode], FieldMetadata(alias="replicationMode") 22 | ] = pydantic.Field(default=None) 23 | """ 24 | Indicates how the correlation will be distributed. Because a correlation is composed of 25 | multiple secondaries, each of which may have been correlated with different replication 26 | modes, the distribution of the correlation is composed of distributions of the individual 27 | entities within the correlation set. 28 | For example, if there are two secondary entities A and B correlated against a primary C, 29 | with A having been correlated globally and B having been correlated locally, then the 30 | correlation set that is distributed globally than what is known locally in the node. 31 | """ 32 | 33 | type: typing.Optional[CorrelationMetadataType] = pydantic.Field(default=None) 34 | """ 35 | What type of (de)correlation was this entity added with. 36 | """ 37 | 38 | if IS_PYDANTIC_V2: 39 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 40 | else: 41 | 42 | class Config: 43 | frozen = True 44 | smart_union = True 45 | extra = pydantic.Extra.allow 46 | -------------------------------------------------------------------------------- /src/anduril/types/agent_request.py: -------------------------------------------------------------------------------- 1 | # This file was auto-generated by Fern from our API Definition. 2 | 3 | from __future__ import annotations 4 | 5 | import typing 6 | 7 | import pydantic 8 | import typing_extensions 9 | from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel, update_forward_refs 10 | from ..core.serialization import FieldMetadata 11 | from .cancel_request import CancelRequest 12 | from .complete_request import CompleteRequest 13 | from .execute_request import ExecuteRequest 14 | 15 | 16 | class AgentRequest(UniversalBaseModel): 17 | """ 18 | Response streamed to an agent containing task actions to perform. 19 | 20 | This message is streamed from Tasks API to agents and contains one of three 21 | possible requests: execute a task, cancel a task, or complete a task. The agent 22 | should process these requests according to its capabilities and report status 23 | updates back to Tasks API using the UpdateStatus endpoint. 24 | 25 | Multiple responses may be sent for different tasks, and the agent should maintain 26 | the connection to receive ongoing task requests. The connection may also be used 27 | for heartbeat messages to ensure the agent is still responsive. 28 | """ 29 | 30 | execute_request: typing_extensions.Annotated[ 31 | typing.Optional[ExecuteRequest], FieldMetadata(alias="executeRequest") 32 | ] = None 33 | cancel_request: typing_extensions.Annotated[ 34 | typing.Optional[CancelRequest], FieldMetadata(alias="cancelRequest") 35 | ] = None 36 | complete_request: typing_extensions.Annotated[ 37 | typing.Optional[CompleteRequest], FieldMetadata(alias="completeRequest") 38 | ] = None 39 | 40 | if IS_PYDANTIC_V2: 41 | model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True) # type: ignore # Pydantic v2 42 | else: 43 | 44 | class Config: 45 | frozen = True 46 | smart_union = True 47 | extra = pydantic.Extra.allow 48 | 49 | 50 | update_forward_refs(AgentRequest) 51 | --------------------------------------------------------------------------------