osdu-python-client 0.4.1__py3-none-any.whl

osdu_python_client/generated/crs_conversion/models/geo_json_base.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 ..models.geo_json_base_geo_json_variant_internal import (
+    GeoJsonBaseGeoJsonVariantInternal,
+)
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="GeoJsonBase")
+
+
+@_attrs_define
+class GeoJsonBase:
+    """
+    Attributes:
+        type_ (str):
+        geo_json_variant_internal (GeoJsonBaseGeoJsonVariantInternal | Unset):
+        bbox (list[float] | Unset):
+    """
+
+    type_: str
+    geo_json_variant_internal: GeoJsonBaseGeoJsonVariantInternal | Unset = UNSET
+    bbox: list[float] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_
+
+        geo_json_variant_internal: str | Unset = UNSET
+        if not isinstance(self.geo_json_variant_internal, Unset):
+            geo_json_variant_internal = self.geo_json_variant_internal.value
+
+        bbox: list[float] | Unset = UNSET
+        if not isinstance(self.bbox, Unset):
+            bbox = self.bbox
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "type": type_,
+            }
+        )
+        if geo_json_variant_internal is not UNSET:
+            field_dict["geoJsonVariantInternal"] = geo_json_variant_internal
+        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_ = d.pop("type")
+
+        _geo_json_variant_internal = d.pop("geoJsonVariantInternal", UNSET)
+        geo_json_variant_internal: GeoJsonBaseGeoJsonVariantInternal | Unset
+        if isinstance(_geo_json_variant_internal, Unset):
+            geo_json_variant_internal = UNSET
+        else:
+            geo_json_variant_internal = GeoJsonBaseGeoJsonVariantInternal(
+                _geo_json_variant_internal
+            )
+
+        bbox = cast(list[float], d.pop("bbox", UNSET))
+
+        geo_json_base = cls(
+            type_=type_,
+            geo_json_variant_internal=geo_json_variant_internal,
+            bbox=bbox,
+        )
+
+        geo_json_base.additional_properties = d
+        return geo_json_base
+
+    @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

osdu_python_client/generated/crs_conversion/models/geo_json_base_geo_json_variant_internal.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class GeoJsonBaseGeoJsonVariantInternal(str, Enum):
+    ANY_CRS_GEO_JSON = "ANY_CRS_GEO_JSON"
+    GEO_JSON = "GEO_JSON"
+
+    def __str__(self) -> str:
+        return str(self.value)

osdu_python_client/generated/crs_conversion/models/geo_json_feature.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.geo_json_feature_geo_json_variant_internal import (
+    GeoJsonFeatureGeoJsonVariantInternal,
+)
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.geo_json_base import GeoJsonBase
+    from ..models.geo_json_feature_properties import GeoJsonFeatureProperties
+
+
+T = TypeVar("T", bound="GeoJsonFeature")
+
+
+@_attrs_define
+class GeoJsonFeature:
+    """
+    Attributes:
+        type_ (str):
+        geometry (GeoJsonBase):
+        geo_json_variant_internal (GeoJsonFeatureGeoJsonVariantInternal | Unset):
+        bbox (list[float] | Unset):
+        properties (GeoJsonFeatureProperties | Unset):
+    """
+
+    type_: str
+    geometry: GeoJsonBase
+    geo_json_variant_internal: GeoJsonFeatureGeoJsonVariantInternal | Unset = UNSET
+    bbox: list[float] | Unset = UNSET
+    properties: GeoJsonFeatureProperties | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_
+
+        geometry = self.geometry.to_dict()
+
+        geo_json_variant_internal: str | Unset = UNSET
+        if not isinstance(self.geo_json_variant_internal, Unset):
+            geo_json_variant_internal = self.geo_json_variant_internal.value
+
+        bbox: list[float] | Unset = UNSET
+        if not isinstance(self.bbox, Unset):
+            bbox = self.bbox
+
+        properties: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.properties, Unset):
+            properties = self.properties.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "type": type_,
+                "geometry": geometry,
+            }
+        )
+        if geo_json_variant_internal is not UNSET:
+            field_dict["geoJsonVariantInternal"] = geo_json_variant_internal
+        if bbox is not UNSET:
+            field_dict["bbox"] = bbox
+        if properties is not UNSET:
+            field_dict["properties"] = properties
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.geo_json_base import GeoJsonBase
+        from ..models.geo_json_feature_properties import GeoJsonFeatureProperties
+
+        d = dict(src_dict)
+        type_ = d.pop("type")
+
+        geometry = GeoJsonBase.from_dict(d.pop("geometry"))
+
+        _geo_json_variant_internal = d.pop("geoJsonVariantInternal", UNSET)
+        geo_json_variant_internal: GeoJsonFeatureGeoJsonVariantInternal | Unset
+        if isinstance(_geo_json_variant_internal, Unset):
+            geo_json_variant_internal = UNSET
+        else:
+            geo_json_variant_internal = GeoJsonFeatureGeoJsonVariantInternal(
+                _geo_json_variant_internal
+            )
+
+        bbox = cast(list[float], d.pop("bbox", UNSET))
+
+        _properties = d.pop("properties", UNSET)
+        properties: GeoJsonFeatureProperties | Unset
+        if isinstance(_properties, Unset):
+            properties = UNSET
+        else:
+            properties = GeoJsonFeatureProperties.from_dict(_properties)
+
+        geo_json_feature = cls(
+            type_=type_,
+            geometry=geometry,
+            geo_json_variant_internal=geo_json_variant_internal,
+            bbox=bbox,
+            properties=properties,
+        )
+
+        geo_json_feature.additional_properties = d
+        return geo_json_feature
+
+    @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

osdu_python_client/generated/crs_conversion/models/geo_json_feature_collection.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.geo_json_feature_collection_geo_json_variant_internal import (
+    GeoJsonFeatureCollectionGeoJsonVariantInternal,
+)
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.geo_json_feature import GeoJsonFeature
+    from ..models.geo_json_feature_collection_properties import (
+        GeoJsonFeatureCollectionProperties,
+    )
+
+
+T = TypeVar("T", bound="GeoJsonFeatureCollection")
+
+
+@_attrs_define
+class GeoJsonFeatureCollection:
+    """The converted GeoJSON FeatureCollection or AnyCrsFeatureCollection with 'toCRS' context; length and order of the
+    structure is the same as in the request. Points, which failed to convert, are returned as NaN.
+
+        Attributes:
+            type_ (str):
+            features (list[GeoJsonFeature]):
+            geo_json_variant_internal (GeoJsonFeatureCollectionGeoJsonVariantInternal | Unset):
+            bbox (list[float] | Unset):
+            properties (GeoJsonFeatureCollectionProperties | Unset):
+            persistable_reference_crs (str | Unset):
+            coordinate_reference_system_id (str | Unset):
+            vertical_unit_id (str | Unset):
+            persistable_reference_unit_z (str | Unset):
+    """
+
+    type_: str
+    features: list[GeoJsonFeature]
+    geo_json_variant_internal: (
+        GeoJsonFeatureCollectionGeoJsonVariantInternal | Unset
+    ) = UNSET
+    bbox: list[float] | Unset = UNSET
+    properties: GeoJsonFeatureCollectionProperties | Unset = UNSET
+    persistable_reference_crs: str | Unset = UNSET
+    coordinate_reference_system_id: str | Unset = UNSET
+    vertical_unit_id: str | Unset = UNSET
+    persistable_reference_unit_z: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_
+
+        features = []
+        for features_item_data in self.features:
+            features_item = features_item_data.to_dict()
+            features.append(features_item)
+
+        geo_json_variant_internal: str | Unset = UNSET
+        if not isinstance(self.geo_json_variant_internal, Unset):
+            geo_json_variant_internal = self.geo_json_variant_internal.value
+
+        bbox: list[float] | Unset = UNSET
+        if not isinstance(self.bbox, Unset):
+            bbox = self.bbox
+
+        properties: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.properties, Unset):
+            properties = self.properties.to_dict()
+
+        persistable_reference_crs = self.persistable_reference_crs
+
+        coordinate_reference_system_id = self.coordinate_reference_system_id
+
+        vertical_unit_id = self.vertical_unit_id
+
+        persistable_reference_unit_z = self.persistable_reference_unit_z
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "type": type_,
+                "features": features,
+            }
+        )
+        if geo_json_variant_internal is not UNSET:
+            field_dict["geoJsonVariantInternal"] = geo_json_variant_internal
+        if bbox is not UNSET:
+            field_dict["bbox"] = bbox
+        if properties is not UNSET:
+            field_dict["properties"] = properties
+        if persistable_reference_crs is not UNSET:
+            field_dict["persistableReferenceCrs"] = persistable_reference_crs
+        if coordinate_reference_system_id is not UNSET:
+            field_dict["CoordinateReferenceSystemID"] = coordinate_reference_system_id
+        if vertical_unit_id is not UNSET:
+            field_dict["VerticalUnitID"] = vertical_unit_id
+        if persistable_reference_unit_z is not UNSET:
+            field_dict["persistableReferenceUnitZ"] = persistable_reference_unit_z
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.geo_json_feature import GeoJsonFeature
+        from ..models.geo_json_feature_collection_properties import (
+            GeoJsonFeatureCollectionProperties,
+        )
+
+        d = dict(src_dict)
+        type_ = d.pop("type")
+
+        features = []
+        _features = d.pop("features")
+        for features_item_data in _features:
+            features_item = GeoJsonFeature.from_dict(features_item_data)
+
+            features.append(features_item)
+
+        _geo_json_variant_internal = d.pop("geoJsonVariantInternal", UNSET)
+        geo_json_variant_internal: (
+            GeoJsonFeatureCollectionGeoJsonVariantInternal | Unset
+        )
+        if isinstance(_geo_json_variant_internal, Unset):
+            geo_json_variant_internal = UNSET
+        else:
+            geo_json_variant_internal = GeoJsonFeatureCollectionGeoJsonVariantInternal(
+                _geo_json_variant_internal
+            )
+
+        bbox = cast(list[float], d.pop("bbox", UNSET))
+
+        _properties = d.pop("properties", UNSET)
+        properties: GeoJsonFeatureCollectionProperties | Unset
+        if isinstance(_properties, Unset):
+            properties = UNSET
+        else:
+            properties = GeoJsonFeatureCollectionProperties.from_dict(_properties)
+
+        persistable_reference_crs = d.pop("persistableReferenceCrs", UNSET)
+
+        coordinate_reference_system_id = d.pop("CoordinateReferenceSystemID", UNSET)
+
+        vertical_unit_id = d.pop("VerticalUnitID", UNSET)
+
+        persistable_reference_unit_z = d.pop("persistableReferenceUnitZ", UNSET)
+
+        geo_json_feature_collection = cls(
+            type_=type_,
+            features=features,
+            geo_json_variant_internal=geo_json_variant_internal,
+            bbox=bbox,
+            properties=properties,
+            persistable_reference_crs=persistable_reference_crs,
+            coordinate_reference_system_id=coordinate_reference_system_id,
+            vertical_unit_id=vertical_unit_id,
+            persistable_reference_unit_z=persistable_reference_unit_z,
+        )
+
+        geo_json_feature_collection.additional_properties = d
+        return geo_json_feature_collection
+
+    @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

osdu_python_client/generated/crs_conversion/models/geo_json_feature_collection_geo_json_variant_internal.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class GeoJsonFeatureCollectionGeoJsonVariantInternal(str, Enum):
+    ANY_CRS_GEO_JSON = "ANY_CRS_GEO_JSON"
+    GEO_JSON = "GEO_JSON"
+
+    def __str__(self) -> str:
+        return str(self.value)

osdu_python_client/generated/crs_conversion/models/geo_json_feature_collection_properties.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="GeoJsonFeatureCollectionProperties")
+
+
+@_attrs_define
+class GeoJsonFeatureCollectionProperties:
+    """ """
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        geo_json_feature_collection_properties = cls()
+
+        geo_json_feature_collection_properties.additional_properties = d
+        return geo_json_feature_collection_properties
+
+    @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

osdu_python_client/generated/crs_conversion/models/geo_json_feature_geo_json_variant_internal.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class GeoJsonFeatureGeoJsonVariantInternal(str, Enum):
+    ANY_CRS_GEO_JSON = "ANY_CRS_GEO_JSON"
+    GEO_JSON = "GEO_JSON"
+
+    def __str__(self) -> str:
+        return str(self.value)

osdu_python_client/generated/crs_conversion/models/geo_json_feature_properties.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="GeoJsonFeatureProperties")
+
+
+@_attrs_define
+class GeoJsonFeatureProperties:
+    """ """
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        geo_json_feature_properties = cls()
+
+        geo_json_feature_properties.additional_properties = d
+        return geo_json_feature_properties
+
+    @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

osdu_python_client/generated/crs_conversion/models/geometry.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="Geometry")
+
+
+@_attrs_define
+class Geometry:
+    """
+    Attributes:
+        type_ (str):
+        coordinates (list[float]):
+    """
+
+    type_: str
+    coordinates: list[float]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_
+
+        coordinates = self.coordinates
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "type": type_,
+                "coordinates": coordinates,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        type_ = d.pop("type")
+
+        coordinates = cast(list[float], d.pop("coordinates"))
+
+        geometry = cls(
+            type_=type_,
+            coordinates=coordinates,
+        )
+
+        geometry.additional_properties = d
+        return geometry
+
+    @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

osdu_python_client/generated/crs_conversion/models/max_mis_location.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="MaxMisLocation")
+
+
+@_attrs_define
+class MaxMisLocation:
+    """
+    Attributes:
+        d_i (float | Unset):
+        d_j (float | Unset):
+    """
+
+    d_i: float | Unset = UNSET
+    d_j: float | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        d_i = self.d_i
+
+        d_j = self.d_j
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if d_i is not UNSET:
+            field_dict["dI"] = d_i
+        if d_j is not UNSET:
+            field_dict["dJ"] = d_j
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        d_i = d.pop("dI", UNSET)
+
+        d_j = d.pop("dJ", UNSET)
+
+        max_mis_location = cls(
+            d_i=d_i,
+            d_j=d_j,
+        )
+
+        max_mis_location.additional_properties = d
+        return max_mis_location
+
+    @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