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

apex_dispatch_api_client/models/provider.py

@@ -0,0 +1,135 @@
+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 ..types import UNSET, Unset
+
+T = TypeVar("T", bound="Provider")
+
+
+@_attrs_define
+class Provider:
+    """https://github.com/radiantearth/stac-spec/blob/v1.0.0/collection-spec/collection-spec.md#provider-object
+
+    Attributes:
+        name (str):
+        description (None | str | Unset):
+        roles (list[str] | None | Unset):
+        url (None | str | Unset):
+    """
+
+    name: str
+    description: None | str | Unset = UNSET
+    roles: list[str] | None | Unset = UNSET
+    url: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        description: None | str | Unset
+        if isinstance(self.description, Unset):
+            description = UNSET
+        else:
+            description = self.description
+
+        roles: list[str] | None | Unset
+        if isinstance(self.roles, Unset):
+            roles = UNSET
+        elif isinstance(self.roles, list):
+            roles = self.roles
+
+        else:
+            roles = self.roles
+
+        url: None | str | Unset
+        if isinstance(self.url, Unset):
+            url = UNSET
+        else:
+            url = self.url
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+        if description is not UNSET:
+            field_dict["description"] = description
+        if roles is not UNSET:
+            field_dict["roles"] = roles
+        if url is not UNSET:
+            field_dict["url"] = url
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        def _parse_description(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        description = _parse_description(d.pop("description", UNSET))
+
+        def _parse_roles(data: object) -> list[str] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                roles_type_0 = cast(list[str], data)
+
+                return roles_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[str] | None | Unset, data)
+
+        roles = _parse_roles(d.pop("roles", UNSET))
+
+        def _parse_url(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        url = _parse_url(d.pop("url", UNSET))
+
+        provider = cls(
+            name=name,
+            description=description,
+            roles=roles,
+            url=url,
+        )
+
+        provider.additional_properties = d
+        return provider
+
+    @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/range_.py

@@ -0,0 +1,79 @@
+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="Range")
+
+
+@_attrs_define
+class Range:
+    """https://github.com/radiantearth/stac-spec/blob/v1.0.0/collection-spec/collection-spec.md#stats-object
+
+    Attributes:
+        minimum (float | int | str):
+        maximum (float | int | str):
+    """
+
+    minimum: float | int | str
+    maximum: float | int | str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        minimum: float | int | str
+        minimum = self.minimum
+
+        maximum: float | int | str
+        maximum = self.maximum
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "minimum": minimum,
+                "maximum": maximum,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+
+        def _parse_minimum(data: object) -> float | int | str:
+            return cast(float | int | str, data)
+
+        minimum = _parse_minimum(d.pop("minimum"))
+
+        def _parse_maximum(data: object) -> float | int | str:
+            return cast(float | int | str, data)
+
+        maximum = _parse_maximum(d.pop("maximum"))
+
+        range_ = cls(
+            minimum=minimum,
+            maximum=maximum,
+        )
+
+        range_.additional_properties = d
+        return range_
+
+    @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/service_details.py

@@ -0,0 +1,95 @@
+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 ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ServiceDetails")
+
+
+@_attrs_define
+class ServiceDetails:
+    """
+    Attributes:
+        endpoint (str): URL to the endpoint where the service is hosted. For openEO, this is the openEO backend. For OGC
+            API Processes, this field should include the base URL of the platform API
+        application (str): Path to the application that needs to be executed. For openEO this is referring to the public
+            URL of the UDP (JSON) to execute. For OGC API Processes, this field should include the URL path pointing to the
+            hosted service.
+        namespace (None | str | Unset): Namespace under the endpoint where the service is hosted.For openEO, this field
+            is not set.For OGC API Processes, this field should include the namespace IDrepresenting the service deployment
+    """
+
+    endpoint: str
+    application: str
+    namespace: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        endpoint = self.endpoint
+
+        application = self.application
+
+        namespace: None | str | Unset
+        if isinstance(self.namespace, Unset):
+            namespace = UNSET
+        else:
+            namespace = self.namespace
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "endpoint": endpoint,
+                "application": application,
+            }
+        )
+        if namespace is not UNSET:
+            field_dict["namespace"] = namespace
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        endpoint = d.pop("endpoint")
+
+        application = d.pop("application")
+
+        def _parse_namespace(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        namespace = _parse_namespace(d.pop("namespace", UNSET))
+
+        service_details = cls(
+            endpoint=endpoint,
+            application=application,
+            namespace=namespace,
+        )
+
+        service_details.additional_properties = d
+        return service_details
+
+    @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/spatial_extent.py

@@ -0,0 +1,96 @@
+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="SpatialExtent")
+
+
+@_attrs_define
+class SpatialExtent:
+    """https://github.com/radiantearth/stac-spec/blob/v1.0.0/collection-spec/collection-spec.md#spatial-extent-object
+
+    Attributes:
+        bbox (list[list[float | int]]):
+    """
+
+    bbox: list[list[float | int]]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        bbox = []
+        for bbox_item_data in self.bbox:
+            bbox_item: list[float | int]
+            if isinstance(bbox_item_data, list):
+                bbox_item = []
+                for bbox_item_type_0_item_data in bbox_item_data:
+                    bbox_item_type_0_item: float | int
+                    bbox_item_type_0_item = bbox_item_type_0_item_data
+                    bbox_item.append(bbox_item_type_0_item)
+
+            bbox.append(bbox_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "bbox": bbox,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        bbox = []
+        _bbox = d.pop("bbox")
+        for bbox_item_data in _bbox:
+
+            def _parse_bbox_item(data: object) -> list[float | int]:
+                if not isinstance(data, list):
+                    raise TypeError()
+                bbox_item_type_0 = []
+                _bbox_item_type_0 = data
+                for bbox_item_type_0_item_data in _bbox_item_type_0:
+
+                    def _parse_bbox_item_type_0_item(data: object) -> float | int:
+                        return cast(float | int, data)
+
+                    bbox_item_type_0_item = _parse_bbox_item_type_0_item(
+                        bbox_item_type_0_item_data
+                    )
+
+                    bbox_item_type_0.append(bbox_item_type_0_item)
+
+                return bbox_item_type_0
+
+            bbox_item = _parse_bbox_item(bbox_item_data)
+
+            bbox.append(bbox_item)
+
+        spatial_extent = cls(
+            bbox=bbox,
+        )
+
+        spatial_extent.additional_properties = d
+        return spatial_extent
+
+    @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/tile_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.grid_type_enum import GridTypeEnum
+
+if TYPE_CHECKING:
+    from ..models.polygon import Polygon
+
+
+T = TypeVar("T", bound="TileRequest")
+
+
+@_attrs_define
+class TileRequest:
+    """
+    Attributes:
+        aoi (Polygon): Polygon Model
+        grid (GridTypeEnum):
+    """
+
+    aoi: Polygon
+    grid: GridTypeEnum
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        aoi = self.aoi.to_dict()
+
+        grid = self.grid.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "aoi": aoi,
+                "grid": grid,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.polygon import Polygon
+
+        d = dict(src_dict)
+        aoi = Polygon.from_dict(d.pop("aoi"))
+
+        grid = GridTypeEnum(d.pop("grid"))
+
+        tile_request = cls(
+            aoi=aoi,
+            grid=grid,
+        )
+
+        tile_request.additional_properties = d
+        return tile_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/time_interval.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import datetime
+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 dateutil.parser import isoparse
+
+T = TypeVar("T", bound="TimeInterval")
+
+
+@_attrs_define
+class TimeInterval:
+    """https://github.com/radiantearth/stac-spec/blob/v1.0.0/collection-spec/collection-spec.md#temporal-extent-object
+
+    Attributes:
+        interval (list[list[datetime.datetime | None]]):
+    """
+
+    interval: list[list[datetime.datetime | None]]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        interval = []
+        for interval_item_data in self.interval:
+            interval_item = []
+            for interval_item_item_data in interval_item_data:
+                interval_item_item: None | str
+                if isinstance(interval_item_item_data, datetime.datetime):
+                    interval_item_item = interval_item_item_data.isoformat()
+                else:
+                    interval_item_item = interval_item_item_data
+                interval_item.append(interval_item_item)
+
+            interval.append(interval_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "interval": interval,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        interval = []
+        _interval = d.pop("interval")
+        for interval_item_data in _interval:
+            interval_item = []
+            _interval_item = interval_item_data
+            for interval_item_item_data in _interval_item:
+
+                def _parse_interval_item_item(data: object) -> datetime.datetime | None:
+                    if data is None:
+                        return data
+                    try:
+                        if not isinstance(data, str):
+                            raise TypeError()
+                        interval_item_item_type_0 = isoparse(data)
+
+                        return interval_item_item_type_0
+                    except (TypeError, ValueError, AttributeError, KeyError):
+                        pass
+                    return cast(datetime.datetime | None, data)
+
+                interval_item_item = _parse_interval_item_item(interval_item_item_data)
+
+                interval_item.append(interval_item_item)
+
+            interval.append(interval_item)
+
+        time_interval = cls(
+            interval=interval,
+        )
+
+        time_interval.additional_properties = d
+        return time_interval
+
+    @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