field-manager-python-client 4.4.82rc1__py3-none-any.whl

field-manager-python-client/models/fm_plot_options.py

@@ -0,0 +1,168 @@
+from typing import Any, Dict, Type, TypeVar, Tuple, Optional, BinaryIO, TextIO, TYPE_CHECKING
+
+from typing import List
+
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..models.scales import Scales
+from ..types import UNSET, Unset
+from typing import cast
+from typing import cast, List
+from typing import cast, Union
+from typing import Dict
+from typing import Union
+
+if TYPE_CHECKING:
+  from ..models.cpt_options import CPTOptions
+
+
+
+
+
+T = TypeVar("T", bound="FMPlotOptions")
+
+
+@_attrs_define
+class FMPlotOptions:
+    """ 
+        Attributes:
+            fill_curve (Union[Unset, bool]):  Default: True.
+            depth_scale (Union[Unset, Scales]):
+            depth_range (Union[List[float], None, Unset]):
+            cpt (Union[Unset, CPTOptions]):
+     """
+
+    fill_curve: Union[Unset, bool] = True
+    depth_scale: Union[Unset, Scales] = UNSET
+    depth_range: Union[List[float], None, Unset] = UNSET
+    cpt: Union[Unset, 'CPTOptions'] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> Dict[str, Any]:
+        from ..models.cpt_options import CPTOptions
+        fill_curve = self.fill_curve
+
+        depth_scale: Union[Unset, str] = UNSET
+        if not isinstance(self.depth_scale, Unset):
+            depth_scale = self.depth_scale.value
+
+
+        depth_range: Union[List[float], None, Unset]
+        if isinstance(self.depth_range, Unset):
+            depth_range = UNSET
+        elif isinstance(self.depth_range, list):
+            depth_range = []
+            for depth_range_type_0_item_data in self.depth_range:
+                depth_range_type_0_item: float
+                depth_range_type_0_item = depth_range_type_0_item_data
+                depth_range.append(depth_range_type_0_item)
+
+
+        else:
+            depth_range = self.depth_range
+
+        cpt: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.cpt, Unset):
+            cpt = self.cpt.to_dict()
+
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if fill_curve is not UNSET:
+            field_dict["fill_curve"] = fill_curve
+        if depth_scale is not UNSET:
+            field_dict["depth_scale"] = depth_scale
+        if depth_range is not UNSET:
+            field_dict["depth_range"] = depth_range
+        if cpt is not UNSET:
+            field_dict["cpt"] = cpt
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.cpt_options import CPTOptions
+        d = src_dict.copy()
+        fill_curve = d.pop("fill_curve", UNSET)
+
+        _depth_scale = d.pop("depth_scale", UNSET)
+        depth_scale: Union[Unset, Scales]
+        if isinstance(_depth_scale,  Unset):
+            depth_scale = UNSET
+        else:
+            depth_scale = Scales(_depth_scale)
+
+
+
+
+        def _parse_depth_range(data: object) -> Union[List[float], None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                depth_range_type_0 = []
+                _depth_range_type_0 = data
+                for depth_range_type_0_item_data in (_depth_range_type_0):
+                    def _parse_depth_range_type_0_item(data: object) -> float:
+                        return cast(float, data)
+
+                    depth_range_type_0_item = _parse_depth_range_type_0_item(depth_range_type_0_item_data)
+
+                    depth_range_type_0.append(depth_range_type_0_item)
+
+                return depth_range_type_0
+            except: # noqa: E722
+                pass
+            return cast(Union[List[float], None, Unset], data)
+
+        depth_range = _parse_depth_range(d.pop("depth_range", UNSET))
+
+
+        _cpt = d.pop("cpt", UNSET)
+        cpt: Union[Unset, CPTOptions]
+        if isinstance(_cpt,  Unset):
+            cpt = UNSET
+        else:
+            cpt = CPTOptions.from_dict(_cpt)
+
+
+
+
+        fm_plot_options = cls(
+            fill_curve=fill_curve,
+            depth_scale=depth_scale,
+            depth_range=depth_range,
+            cpt=cpt,
+        )
+
+
+        fm_plot_options.additional_properties = d
+        return fm_plot_options
+
+    @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

field-manager-python-client/models/height_reference.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+class HeightReference(str, Enum):
+    LAT_DEPTH = "LAT_DEPTH"
+    MSL_HEIGHT = "MSL_HEIGHT"
+    NN1954 = "NN1954"
+    NN2000 = "NN2000"
+    RH2000 = "RH2000"
+    TWVD2001 = "TWVD2001"
+
+    def __str__(self) -> str:
+        return str(self.value)

field-manager-python-client/models/http_validation_error.py

@@ -0,0 +1,97 @@
+from typing import Any, Dict, Type, TypeVar, Tuple, Optional, BinaryIO, TextIO, TYPE_CHECKING
+
+from typing import List
+
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..types import UNSET, Unset
+from typing import cast
+from typing import cast, List
+from typing import Dict
+from typing import Union
+
+if TYPE_CHECKING:
+  from ..models.validation_error import ValidationError
+
+
+
+
+
+T = TypeVar("T", bound="HTTPValidationError")
+
+
+@_attrs_define
+class HTTPValidationError:
+    """ 
+        Attributes:
+            detail (Union[Unset, List['ValidationError']]):
+     """
+
+    detail: Union[Unset, List['ValidationError']] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> Dict[str, Any]:
+        from ..models.validation_error import ValidationError
+        detail: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.detail, Unset):
+            detail = []
+            for detail_item_data in self.detail:
+                detail_item = detail_item_data.to_dict()
+                detail.append(detail_item)
+
+
+
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if detail is not UNSET:
+            field_dict["detail"] = detail
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.validation_error import ValidationError
+        d = src_dict.copy()
+        detail = []
+        _detail = d.pop("detail", UNSET)
+        for detail_item_data in (_detail or []):
+            detail_item = ValidationError.from_dict(detail_item_data)
+
+
+
+            detail.append(detail_item)
+
+
+        http_validation_error = cls(
+            detail=detail,
+        )
+
+
+        http_validation_error.additional_properties = d
+        return http_validation_error
+
+    @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

field-manager-python-client/models/image_size.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+class ImageSize(str, Enum):
+    LARGE = "LARGE"
+    MEDIUM = "MEDIUM"
+    ORIGINAL = "ORIGINAL"
+    SMALL = "SMALL"
+
+    def __str__(self) -> str:
+        return str(self.value)

field-manager-python-client/models/iogp_type.py

@@ -0,0 +1,100 @@
+from typing import Any, Dict, Type, TypeVar, Tuple, Optional, BinaryIO, TextIO, TYPE_CHECKING
+
+from typing import List
+
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..models.iogp_type_enum import IOGPTypeEnum
+
+
+
+
+
+
+T = TypeVar("T", bound="IOGPType")
+
+
+@_attrs_define
+class IOGPType:
+    """ 
+        Attributes:
+            iogp_type_id (IOGPTypeEnum): For offshore locations, an IOGP type is required
+            name (str):
+            description (str):
+            sort_order (int):
+     """
+
+    iogp_type_id: IOGPTypeEnum
+    name: str
+    description: str
+    sort_order: int
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> Dict[str, Any]:
+        iogp_type_id = self.iogp_type_id.value
+
+        name = self.name
+
+        description = self.description
+
+        sort_order = self.sort_order
+
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "iogp_type_id": iogp_type_id,
+            "name": name,
+            "description": description,
+            "sort_order": sort_order,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        iogp_type_id = IOGPTypeEnum(d.pop("iogp_type_id"))
+
+
+
+
+        name = d.pop("name")
+
+        description = d.pop("description")
+
+        sort_order = d.pop("sort_order")
+
+        iogp_type = cls(
+            iogp_type_id=iogp_type_id,
+            name=name,
+            description=description,
+            sort_order=sort_order,
+        )
+
+
+        iogp_type.additional_properties = d
+        return iogp_type
+
+    @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

field-manager-python-client/models/iogp_type_enum.py

@@ -0,0 +1,33 @@
+from enum import Enum
+
+class IOGPTypeEnum(str, Enum):
+    BENTHIC_SAMPLE = "BENTHIC_SAMPLE"
+    BOX_CORE = "BOX_CORE"
+    CAMERA_TRANSECT = "CAMERA_TRANSECT"
+    COMPOSITE = "COMPOSITE"
+    CPT = "CPT"
+    GEOCHEMICAL_SAMPLE = "GEOCHEMICAL_SAMPLE"
+    GEOTECHNICAL_SAMPLE = "GEOTECHNICAL_SAMPLE"
+    GRAB_SAMPLE = "GRAB_SAMPLE"
+    GRAVITY_CORE = "GRAVITY_CORE"
+    HEAT_FLOW_MEASUREMENT = "HEAT_FLOW_MEASUREMENT"
+    HYDRAULIC_FRACTURE = "HYDRAULIC_FRACTURE"
+    JUMBO_CORE = "JUMBO_CORE"
+    MULTI_CORE = "MULTI_CORE"
+    PCPT = "PCPT"
+    PILOT = "PILOT"
+    PISTON_CORE = "PISTON_CORE"
+    SAMPLING = "SAMPLING"
+    SEABED_CPT = "SEABED_CPT"
+    SEABED_PCPT = "SEABED_PCPT"
+    SEISMIC_PCPT = "SEISMIC_PCPT"
+    SOIL_OR_SEDIMENT_SAMPLE = "SOIL_OR_SEDIMENT_SAMPLE"
+    SPI_SEDIMENT_PROFILE_INDEX = "SPI_SEDIMENT_PROFILE_INDEX"
+    TSDIP = "TSDIP"
+    VELO_VELOCIMETER = "VELO_VELOCIMETER"
+    VIBRO_CORE = "VIBRO_CORE"
+    VIDEO_SAMPLE = "VIDEO_SAMPLE"
+    WATER_SAMPLE = "WATER_SAMPLE"
+
+    def __str__(self) -> str:
+        return str(self.value)

field-manager-python-client/models/language.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+class Language(str, Enum):
+    ENG = "eng"
+    FIN = "fin"
+    NOR = "nor"
+    SWE = "swe"
+
+    def __str__(self) -> str:
+        return str(self.value)

field-manager-python-client/models/like.py

@@ -0,0 +1,139 @@
+from typing import Any, Dict, Type, TypeVar, Tuple, Optional, BinaryIO, TextIO, TYPE_CHECKING
+
+from typing import List
+
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from dateutil.parser import isoparse
+from typing import cast
+from uuid import UUID
+import datetime
+
+
+
+
+
+
+T = TypeVar("T", bound="Like")
+
+
+@_attrs_define
+class Like:
+    """ 
+        Attributes:
+            like_id (UUID):
+            user_id (UUID):
+            user_name (str):
+            comment_id (UUID):
+            created_at (datetime.datetime):
+            updated_at (datetime.datetime):
+            is_deleted (bool):
+     """
+
+    like_id: UUID
+    user_id: UUID
+    user_name: str
+    comment_id: UUID
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+    is_deleted: bool
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> Dict[str, Any]:
+        like_id = str(self.like_id)
+
+        user_id = str(self.user_id)
+
+        user_name = self.user_name
+
+        comment_id = str(self.comment_id)
+
+        created_at = self.created_at.isoformat()
+
+        updated_at = self.updated_at.isoformat()
+
+        is_deleted = self.is_deleted
+
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "like_id": like_id,
+            "user_id": user_id,
+            "user_name": user_name,
+            "comment_id": comment_id,
+            "created_at": created_at,
+            "updated_at": updated_at,
+            "is_deleted": is_deleted,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        like_id = UUID(d.pop("like_id"))
+
+
+
+
+        user_id = UUID(d.pop("user_id"))
+
+
+
+
+        user_name = d.pop("user_name")
+
+        comment_id = UUID(d.pop("comment_id"))
+
+
+
+
+        created_at = isoparse(d.pop("created_at"))
+
+
+
+
+        updated_at = isoparse(d.pop("updated_at"))
+
+
+
+
+        is_deleted = d.pop("is_deleted")
+
+        like = cls(
+            like_id=like_id,
+            user_id=user_id,
+            user_name=user_name,
+            comment_id=comment_id,
+            created_at=created_at,
+            updated_at=updated_at,
+            is_deleted=is_deleted,
+        )
+
+
+        like.additional_properties = d
+        return like
+
+    @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