apex-dispatch-api-client 0.7.2__py3-none-any.whl

apex_dispatch_api_client/models/multi_point.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import (
+    Any,
+    Literal,
+    TypeVar,
+    cast,
+)
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="MultiPoint")
+
+
+@_attrs_define
+class MultiPoint:
+    """MultiPoint Model
+
+    Attributes:
+        type_ (Literal['MultiPoint']):
+        coordinates (list[list[float]]):
+        bbox (list[float] | None | Unset):
+    """
+
+    type_: Literal["MultiPoint"]
+    coordinates: list[list[float]]
+    bbox: list[float] | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_
+
+        coordinates = []
+        for coordinates_item_data in self.coordinates:
+            coordinates_item: list[float]
+            if isinstance(coordinates_item_data, list):
+                coordinates_item = []
+                for componentsschemas_position_2d_item_data in coordinates_item_data:
+                    componentsschemas_position_2d_item: float
+                    componentsschemas_position_2d_item = (
+                        componentsschemas_position_2d_item_data
+                    )
+                    coordinates_item.append(componentsschemas_position_2d_item)
+
+            coordinates.append(coordinates_item)
+
+        bbox: list[float] | None | Unset
+        if isinstance(self.bbox, Unset):
+            bbox = UNSET
+        elif isinstance(self.bbox, list):
+            bbox = []
+            for bbox_type_0_item_data in self.bbox:
+                bbox_type_0_item: float
+                bbox_type_0_item = bbox_type_0_item_data
+                bbox.append(bbox_type_0_item)
+
+        else:
+            bbox = self.bbox
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "type": type_,
+                "coordinates": coordinates,
+            }
+        )
+        if bbox is not UNSET:
+            field_dict["bbox"] = bbox
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        type_ = cast(Literal["MultiPoint"], d.pop("type"))
+        if type_ != "MultiPoint":
+            raise ValueError(f"type must match const 'MultiPoint', got '{type_}'")
+
+        coordinates = []
+        _coordinates = d.pop("coordinates")
+        for coordinates_item_data in _coordinates:
+
+            def _parse_coordinates_item(data: object) -> list[float]:
+                if not isinstance(data, list):
+                    raise TypeError()
+                coordinates_item_type_0 = []
+                _coordinates_item_type_0 = data
+                for componentsschemas_position_2d_item_data in _coordinates_item_type_0:
+
+                    def _parse_componentsschemas_position_2d_item(
+                        data: object,
+                    ) -> float:
+                        return cast(float, data)
+
+                    componentsschemas_position_2d_item = (
+                        _parse_componentsschemas_position_2d_item(
+                            componentsschemas_position_2d_item_data
+                        )
+                    )
+
+                    coordinates_item_type_0.append(componentsschemas_position_2d_item)
+
+                return coordinates_item_type_0
+
+            coordinates_item = _parse_coordinates_item(coordinates_item_data)
+
+            coordinates.append(coordinates_item)
+
+        def _parse_bbox(data: object) -> list[float] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                bbox_type_0 = []
+                _bbox_type_0 = data
+                for bbox_type_0_item_data in _bbox_type_0:
+
+                    def _parse_bbox_type_0_item(data: object) -> float:
+                        return cast(float, data)
+
+                    bbox_type_0_item = _parse_bbox_type_0_item(bbox_type_0_item_data)
+
+                    bbox_type_0.append(bbox_type_0_item)
+
+                return bbox_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[float] | None | Unset, data)
+
+        bbox = _parse_bbox(d.pop("bbox", UNSET))
+
+        multi_point = cls(
+            type_=type_,
+            coordinates=coordinates,
+            bbox=bbox,
+        )
+
+        multi_point.additional_properties = d
+        return multi_point
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

apex_dispatch_api_client/models/multi_polygon.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import (
+    Any,
+    Literal,
+    TypeVar,
+    cast,
+)
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="MultiPolygon")
+
+
+@_attrs_define
+class MultiPolygon:
+    """MultiPolygon Model
+
+    Attributes:
+        type_ (Literal['MultiPolygon']):
+        coordinates (list[list[list[list[float]]]]):
+        bbox (list[float] | None | Unset):
+    """
+
+    type_: Literal["MultiPolygon"]
+    coordinates: list[list[list[list[float]]]]
+    bbox: list[float] | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_
+
+        coordinates = []
+        for coordinates_item_data in self.coordinates:
+            coordinates_item = []
+            for coordinates_item_item_data in coordinates_item_data:
+                coordinates_item_item = []
+                for coordinates_item_item_item_data in coordinates_item_item_data:
+                    coordinates_item_item_item: list[float]
+                    if isinstance(coordinates_item_item_item_data, list):
+                        coordinates_item_item_item = []
+                        for (
+                            componentsschemas_position_2d_item_data
+                        ) in coordinates_item_item_item_data:
+                            componentsschemas_position_2d_item: float
+                            componentsschemas_position_2d_item = (
+                                componentsschemas_position_2d_item_data
+                            )
+                            coordinates_item_item_item.append(
+                                componentsschemas_position_2d_item
+                            )
+
+                    coordinates_item_item.append(coordinates_item_item_item)
+
+                coordinates_item.append(coordinates_item_item)
+
+            coordinates.append(coordinates_item)
+
+        bbox: list[float] | None | Unset
+        if isinstance(self.bbox, Unset):
+            bbox = UNSET
+        elif isinstance(self.bbox, list):
+            bbox = []
+            for bbox_type_0_item_data in self.bbox:
+                bbox_type_0_item: float
+                bbox_type_0_item = bbox_type_0_item_data
+                bbox.append(bbox_type_0_item)
+
+        else:
+            bbox = self.bbox
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "type": type_,
+                "coordinates": coordinates,
+            }
+        )
+        if bbox is not UNSET:
+            field_dict["bbox"] = bbox
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        type_ = cast(Literal["MultiPolygon"], d.pop("type"))
+        if type_ != "MultiPolygon":
+            raise ValueError(f"type must match const 'MultiPolygon', got '{type_}'")
+
+        coordinates = []
+        _coordinates = d.pop("coordinates")
+        for coordinates_item_data in _coordinates:
+            coordinates_item = []
+            _coordinates_item = coordinates_item_data
+            for coordinates_item_item_data in _coordinates_item:
+                coordinates_item_item = []
+                _coordinates_item_item = coordinates_item_item_data
+                for coordinates_item_item_item_data in _coordinates_item_item:
+
+                    def _parse_coordinates_item_item_item(data: object) -> list[float]:
+                        if not isinstance(data, list):
+                            raise TypeError()
+                        coordinates_item_item_item_type_0 = []
+                        _coordinates_item_item_item_type_0 = data
+                        for (
+                            componentsschemas_position_2d_item_data
+                        ) in _coordinates_item_item_item_type_0:
+
+                            def _parse_componentsschemas_position_2d_item(
+                                data: object,
+                            ) -> float:
+                                return cast(float, data)
+
+                            componentsschemas_position_2d_item = (
+                                _parse_componentsschemas_position_2d_item(
+                                    componentsschemas_position_2d_item_data
+                                )
+                            )
+
+                            coordinates_item_item_item_type_0.append(
+                                componentsschemas_position_2d_item
+                            )
+
+                        return coordinates_item_item_item_type_0
+
+                    coordinates_item_item_item = _parse_coordinates_item_item_item(
+                        coordinates_item_item_item_data
+                    )
+
+                    coordinates_item_item.append(coordinates_item_item_item)
+
+                coordinates_item.append(coordinates_item_item)
+
+            coordinates.append(coordinates_item)
+
+        def _parse_bbox(data: object) -> list[float] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                bbox_type_0 = []
+                _bbox_type_0 = data
+                for bbox_type_0_item_data in _bbox_type_0:
+
+                    def _parse_bbox_type_0_item(data: object) -> float:
+                        return cast(float, data)
+
+                    bbox_type_0_item = _parse_bbox_type_0_item(bbox_type_0_item_data)
+
+                    bbox_type_0.append(bbox_type_0_item)
+
+                return bbox_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[float] | None | Unset, data)
+
+        bbox = _parse_bbox(d.pop("bbox", UNSET))
+
+        multi_polygon = cls(
+            type_=type_,
+            coordinates=coordinates,
+            bbox=bbox,
+        )
+
+        multi_polygon.additional_properties = d
+        return multi_polygon
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

apex_dispatch_api_client/models/output_format_enum.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class OutputFormatEnum(str, Enum):
+    GEOJSON = "geojson"
+    GTIFF = "gtiff"
+    JSON = "json"
+    NETCDF = "netcdf"
+
+    def __str__(self) -> str:
+        return str(self.value)

apex_dispatch_api_client/models/param_request.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.process_type_enum import ProcessTypeEnum
+
+if TYPE_CHECKING:
+    from ..models.service_details import ServiceDetails
+
+
+T = TypeVar("T", bound="ParamRequest")
+
+
+@_attrs_define
+class ParamRequest:
+    """
+    Attributes:
+        label (ProcessTypeEnum):
+        service (ServiceDetails):
+    """
+
+    label: ProcessTypeEnum
+    service: ServiceDetails
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        label = self.label.value
+
+        service = self.service.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "label": label,
+                "service": service,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.service_details import ServiceDetails
+
+        d = dict(src_dict)
+        label = ProcessTypeEnum(d.pop("label"))
+
+        service = ServiceDetails.from_dict(d.pop("service"))
+
+        param_request = cls(
+            label=label,
+            service=service,
+        )
+
+        param_request.additional_properties = d
+        return param_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

apex_dispatch_api_client/models/param_type_enum.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+
+class ParamTypeEnum(str, Enum):
+    ARRAY_STRING = "array-string"
+    BOOLEAN = "boolean"
+    BOUNDING_BOX = "bounding-box"
+    DATETIME = "datetime"
+    DATE_INTERVAL = "date-interval"
+    DOUBLE = "double"
+    INTEGER = "integer"
+    POLYGON = "polygon"
+    STRING = "string"
+
+    def __str__(self) -> str:
+        return str(self.value)

apex_dispatch_api_client/models/parameter.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.param_type_enum import ParamTypeEnum
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="Parameter")
+
+
+@_attrs_define
+class Parameter:
+    """
+    Attributes:
+        name (str): Name of the parameter
+        type_ (ParamTypeEnum):
+        optional (bool): Indicates whether the parameter is optional
+        description (str): Description of the parameter
+        default (Any | Unset): Default value of the parameter, if any
+        options (list[Any] | Unset): List of valid options for the parameter, if applicable
+    """
+
+    name: str
+    type_: ParamTypeEnum
+    optional: bool
+    description: str
+    default: Any | Unset = UNSET
+    options: list[Any] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        type_ = self.type_.value
+
+        optional = self.optional
+
+        description = self.description
+
+        default = self.default
+
+        options: list[Any] | Unset = UNSET
+        if not isinstance(self.options, Unset):
+            options = self.options
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+                "type": type_,
+                "optional": optional,
+                "description": description,
+            }
+        )
+        if default is not UNSET:
+            field_dict["default"] = default
+        if options is not UNSET:
+            field_dict["options"] = options
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        type_ = ParamTypeEnum(d.pop("type"))
+
+        optional = d.pop("optional")
+
+        description = d.pop("description")
+
+        default = d.pop("default", UNSET)
+
+        options = cast(list[Any], d.pop("options", UNSET))
+
+        parameter = cls(
+            name=name,
+            type_=type_,
+            optional=optional,
+            description=description,
+            default=default,
+            options=options,
+        )
+
+        parameter.additional_properties = d
+        return parameter
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

apex_dispatch_api_client/models/parameter_dimension.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ParameterDimension")
+
+
+@_attrs_define
+class ParameterDimension:
+    """
+    Attributes:
+        name (str): Name of the parameter for which to loop the multiple values
+        values (list[Any]): List of values for which to create a processing job
+    """
+
+    name: str
+    values: list[Any]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        values = self.values
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+                "values": values,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        values = cast(list[Any], d.pop("values"))
+
+        parameter_dimension = cls(
+            name=name,
+            values=values,
+        )
+
+        parameter_dimension.additional_properties = d
+        return parameter_dimension
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties