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

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

@@ -0,0 +1,96 @@
+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
+
+
+
+
+
+
+
+T = TypeVar("T", bound="SamplerType")
+
+
+@_attrs_define
+class SamplerType:
+    """ 
+        Attributes:
+            sampler_type_id (int):
+            name (str):
+            description (str):
+            sort_order (int):
+     """
+
+    sampler_type_id: int
+    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]:
+        sampler_type_id = self.sampler_type_id
+
+        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({
+            "sampler_type_id": sampler_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()
+        sampler_type_id = d.pop("sampler_type_id")
+
+        name = d.pop("name")
+
+        description = d.pop("description")
+
+        sort_order = d.pop("sort_order")
+
+        sampler_type = cls(
+            sampler_type_id=sampler_type_id,
+            name=name,
+            description=description,
+            sort_order=sort_order,
+        )
+
+
+        sampler_type.additional_properties = d
+        return sampler_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/sampling_technique.py

@@ -0,0 +1,96 @@
+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
+
+
+
+
+
+
+
+T = TypeVar("T", bound="SamplingTechnique")
+
+
+@_attrs_define
+class SamplingTechnique:
+    """ 
+        Attributes:
+            sampling_technique_id (int):
+            name (str):
+            description (str):
+            sort_order (int):
+     """
+
+    sampling_technique_id: int
+    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]:
+        sampling_technique_id = self.sampling_technique_id
+
+        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({
+            "sampling_technique_id": sampling_technique_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()
+        sampling_technique_id = d.pop("sampling_technique_id")
+
+        name = d.pop("name")
+
+        description = d.pop("description")
+
+        sort_order = d.pop("sort_order")
+
+        sampling_technique = cls(
+            sampling_technique_id=sampling_technique_id,
+            name=name,
+            description=description,
+            sort_order=sort_order,
+        )
+
+
+        sampling_technique.additional_properties = d
+        return sampling_technique
+
+    @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/scales.py

@@ -0,0 +1,26 @@
+from enum import Enum
+
+class Scales(str, Enum):
+    AUTO_SCALING = "Auto scaling"
+    FIT_SCALING = "Fit scaling"
+    VALUE_10 = "1/250"
+    VALUE_11 = "1/300"
+    VALUE_12 = "1/350"
+    VALUE_13 = "1/400"
+    VALUE_14 = "1/450"
+    VALUE_15 = "1/500"
+    VALUE_16 = "1/600"
+    VALUE_17 = "1/750"
+    VALUE_18 = "1/800"
+    VALUE_19 = "1/1000"
+    VALUE_2 = "1/25"
+    VALUE_3 = "1/50"
+    VALUE_4 = "1/75"
+    VALUE_5 = "1/100"
+    VALUE_6 = "1/125"
+    VALUE_7 = "1/150"
+    VALUE_8 = "1/175"
+    VALUE_9 = "1/200"
+
+    def __str__(self) -> str:
+        return str(self.value)

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

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class ScalingMode(str, Enum):
+    AUTO = "auto"
+    MANUAL = "manual"
+    PERCENTILE = "percentile"
+
+    def __str__(self) -> str:
+        return str(self.value)

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

@@ -0,0 +1,10 @@
+from enum import Enum
+
+class SoundingClass(str, Enum):
+    JB_1 = "Jb-1"
+    JB_2 = "Jb-2"
+    JB_3 = "Jb-3"
+    JB_TOT = "Jb-tot"
+
+    def __str__(self) -> str:
+        return str(self.value)

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

@@ -0,0 +1,133 @@
+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.standard_type import StandardType
+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.method_type import MethodType
+
+
+
+
+
+T = TypeVar("T", bound="Standard")
+
+
+@_attrs_define
+class Standard:
+    """ 
+        Attributes:
+            standard_id (StandardType):
+            name (str):
+            description (str):
+            sort_order (int):
+            method_types (Union[Unset, List['MethodType']]):
+     """
+
+    standard_id: StandardType
+    name: str
+    description: str
+    sort_order: int
+    method_types: Union[Unset, List['MethodType']] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> Dict[str, Any]:
+        from ..models.method_type import MethodType
+        standard_id = self.standard_id.value
+
+        name = self.name
+
+        description = self.description
+
+        sort_order = self.sort_order
+
+        method_types: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.method_types, Unset):
+            method_types = []
+            for method_types_item_data in self.method_types:
+                method_types_item = method_types_item_data.to_dict()
+                method_types.append(method_types_item)
+
+
+
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "standard_id": standard_id,
+            "name": name,
+            "description": description,
+            "sort_order": sort_order,
+        })
+        if method_types is not UNSET:
+            field_dict["method_types"] = method_types
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.method_type import MethodType
+        d = src_dict.copy()
+        standard_id = StandardType(d.pop("standard_id"))
+
+
+
+
+        name = d.pop("name")
+
+        description = d.pop("description")
+
+        sort_order = d.pop("sort_order")
+
+        method_types = []
+        _method_types = d.pop("method_types", UNSET)
+        for method_types_item_data in (_method_types or []):
+            method_types_item = MethodType.from_dict(method_types_item_data)
+
+
+
+            method_types.append(method_types_item)
+
+
+        standard = cls(
+            standard_id=standard_id,
+            name=name,
+            description=description,
+            sort_order=sort_order,
+            method_types=method_types,
+        )
+
+
+        standard.additional_properties = d
+        return standard
+
+    @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/standard_type.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+class StandardType(str, Enum):
+    IOGP = "IOGP"
+    NGF = "NGF"
+    OW = "OW"
+    SGF = "SGF"
+
+    def __str__(self) -> str:
+        return str(self.value)

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

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class TransformationType(str, Enum):
+    ABSOLUTE = "ABSOLUTE"
+    NONE = "NONE"
+    POLYNOMIAL = "POLYNOMIAL"
+
+    def __str__(self) -> str:
+        return str(self.value)

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

@@ -0,0 +1,195 @@
+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 cast, Union
+from typing import Dict
+from typing import Union
+from uuid import UUID
+
+if TYPE_CHECKING:
+  from ..models.role import Role
+
+
+
+
+
+T = TypeVar("T", bound="User")
+
+
+@_attrs_define
+class User:
+    """ 
+        Attributes:
+            user_id (Union[None, UUID, Unset]):
+            name (Union[None, Unset, str]):
+            email (Union[None, Unset, str]):
+            roles (Union[Unset, List['Role']]):
+            email_verified (Union[None, Unset, bool]):
+     """
+
+    user_id: Union[None, UUID, Unset] = UNSET
+    name: Union[None, Unset, str] = UNSET
+    email: Union[None, Unset, str] = UNSET
+    roles: Union[Unset, List['Role']] = UNSET
+    email_verified: Union[None, Unset, bool] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> Dict[str, Any]:
+        from ..models.role import Role
+        user_id: Union[None, Unset, str]
+        if isinstance(self.user_id, Unset):
+            user_id = UNSET
+        elif isinstance(self.user_id, UUID):
+            user_id = str(self.user_id)
+        else:
+            user_id = self.user_id
+
+        name: Union[None, Unset, str]
+        if isinstance(self.name, Unset):
+            name = UNSET
+        else:
+            name = self.name
+
+        email: Union[None, Unset, str]
+        if isinstance(self.email, Unset):
+            email = UNSET
+        else:
+            email = self.email
+
+        roles: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.roles, Unset):
+            roles = []
+            for roles_item_data in self.roles:
+                roles_item = roles_item_data.to_dict()
+                roles.append(roles_item)
+
+
+
+        email_verified: Union[None, Unset, bool]
+        if isinstance(self.email_verified, Unset):
+            email_verified = UNSET
+        else:
+            email_verified = self.email_verified
+
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if user_id is not UNSET:
+            field_dict["user_id"] = user_id
+        if name is not UNSET:
+            field_dict["name"] = name
+        if email is not UNSET:
+            field_dict["email"] = email
+        if roles is not UNSET:
+            field_dict["roles"] = roles
+        if email_verified is not UNSET:
+            field_dict["email_verified"] = email_verified
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.role import Role
+        d = src_dict.copy()
+        def _parse_user_id(data: object) -> Union[None, UUID, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                user_id_type_0 = UUID(data)
+
+
+
+                return user_id_type_0
+            except: # noqa: E722
+                pass
+            return cast(Union[None, UUID, Unset], data)
+
+        user_id = _parse_user_id(d.pop("user_id", UNSET))
+
+
+        def _parse_name(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        name = _parse_name(d.pop("name", UNSET))
+
+
+        def _parse_email(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        email = _parse_email(d.pop("email", UNSET))
+
+
+        roles = []
+        _roles = d.pop("roles", UNSET)
+        for roles_item_data in (_roles or []):
+            roles_item = Role.from_dict(roles_item_data)
+
+
+
+            roles.append(roles_item)
+
+
+        def _parse_email_verified(data: object) -> Union[None, Unset, bool]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, bool], data)
+
+        email_verified = _parse_email_verified(d.pop("email_verified", UNSET))
+
+
+        user = cls(
+            user_id=user_id,
+            name=name,
+            email=email,
+            roles=roles,
+            email_verified=email_verified,
+        )
+
+
+        user.additional_properties = d
+        return user
+
+    @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/validation_error.py

@@ -0,0 +1,105 @@
+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 typing import cast, List
+from typing import cast, Union
+
+
+
+
+
+
+T = TypeVar("T", bound="ValidationError")
+
+
+@_attrs_define
+class ValidationError:
+    """ 
+        Attributes:
+            loc (List[Union[int, str]]):
+            msg (str):
+            type (str):
+     """
+
+    loc: List[Union[int, str]]
+    msg: str
+    type: str
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> Dict[str, Any]:
+        loc = []
+        for loc_item_data in self.loc:
+            loc_item: Union[int, str]
+            loc_item = loc_item_data
+            loc.append(loc_item)
+
+
+
+        msg = self.msg
+
+        type = self.type
+
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "loc": loc,
+            "msg": msg,
+            "type": type,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        loc = []
+        _loc = d.pop("loc")
+        for loc_item_data in (_loc):
+            def _parse_loc_item(data: object) -> Union[int, str]:
+                return cast(Union[int, str], data)
+
+            loc_item = _parse_loc_item(loc_item_data)
+
+            loc.append(loc_item)
+
+
+        msg = d.pop("msg")
+
+        type = d.pop("type")
+
+        validation_error = cls(
+            loc=loc,
+            msg=msg,
+            type=type,
+        )
+
+
+        validation_error.additional_properties = d
+        return 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/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561