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

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

@@ -0,0 +1,132 @@
+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
+import json
+
+from ..types import UNSET, Unset
+
+from ..types import File, FileJsonType
+from ..types import UNSET, Unset
+from io import BytesIO
+from typing import cast, Union
+from typing import Union
+
+
+
+
+
+
+T = TypeVar("T", bound="BodyUploadLocationsToProjectProjectsProjectIdLocationsUploadPost")
+
+
+@_attrs_define
+class BodyUploadLocationsToProjectProjectsProjectIdLocationsUploadPost:
+    """ 
+        Attributes:
+            file (File):
+            comment (Union[None, Unset, str]):  Default: ''.
+     """
+
+    file: File
+    comment: Union[None, Unset, str] = ''
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> Dict[str, Any]:
+        file = self.file.to_tuple()
+
+
+        comment: Union[None, Unset, str]
+        if isinstance(self.comment, Unset):
+            comment = UNSET
+        else:
+            comment = self.comment
+
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "file": file,
+        })
+        if comment is not UNSET:
+            field_dict["comment"] = comment
+
+        return field_dict
+
+
+    def to_multipart(self) -> Dict[str, Any]:
+        file = self.file.to_tuple()
+
+
+        comment: Union[Tuple[None, bytes, str], Unset]
+
+        if isinstance(self.comment, Unset):
+            comment = UNSET
+        elif isinstance(self.comment, str):
+            comment =  (None, str(self.comment).encode(), "text/plain")
+        else:
+            comment =  (None, str(self.comment).encode(), "text/plain")
+
+
+
+        field_dict: Dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] =  (None, str(prop).encode(), "text/plain")
+
+        field_dict.update({
+            "file": file,
+        })
+        if comment is not UNSET:
+            field_dict["comment"] = comment
+
+        return field_dict
+
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        file = File(
+             payload = BytesIO(d.pop("file"))
+        )
+
+
+
+
+        def _parse_comment(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)
+
+        comment = _parse_comment(d.pop("comment", UNSET))
+
+
+        body_upload_locations_to_project_projects_project_id_locations_upload_post = cls(
+            file=file,
+            comment=comment,
+        )
+
+
+        body_upload_locations_to_project_projects_project_id_locations_upload_post.additional_properties = d
+        return body_upload_locations_to_project_projects_project_id_locations_upload_post
+
+    @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/color_mode.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class ColorMode(str, Enum):
+    COLOR = "color"
+    GRAYSCALE = "grayscale"
+
+    def __str__(self) -> str:
+        return str(self.value)

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

@@ -0,0 +1,233 @@
+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 dateutil.parser import isoparse
+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
+import datetime
+
+if TYPE_CHECKING:
+  from ..models.like import Like
+
+
+
+
+
+T = TypeVar("T", bound="Comment")
+
+
+@_attrs_define
+class Comment:
+    """ 
+        Attributes:
+            text (str):
+            created_by (UUID):
+            user_name (str):
+            created_at (datetime.datetime):
+            updated_at (datetime.datetime):
+            is_updated (bool):
+            is_deleted (bool):
+            comment_id (UUID):
+            location_id (Union[None, UUID]):
+            method_id (Union[None, UUID]):
+            likes (Union[Unset, List['Like']]):
+     """
+
+    text: str
+    created_by: UUID
+    user_name: str
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+    is_updated: bool
+    is_deleted: bool
+    comment_id: UUID
+    location_id: Union[None, UUID]
+    method_id: Union[None, UUID]
+    likes: Union[Unset, List['Like']] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> Dict[str, Any]:
+        from ..models.like import Like
+        text = self.text
+
+        created_by = str(self.created_by)
+
+        user_name = self.user_name
+
+        created_at = self.created_at.isoformat()
+
+        updated_at = self.updated_at.isoformat()
+
+        is_updated = self.is_updated
+
+        is_deleted = self.is_deleted
+
+        comment_id = str(self.comment_id)
+
+        location_id: Union[None, str]
+        if isinstance(self.location_id, UUID):
+            location_id = str(self.location_id)
+        else:
+            location_id = self.location_id
+
+        method_id: Union[None, str]
+        if isinstance(self.method_id, UUID):
+            method_id = str(self.method_id)
+        else:
+            method_id = self.method_id
+
+        likes: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.likes, Unset):
+            likes = []
+            for likes_item_data in self.likes:
+                likes_item = likes_item_data.to_dict()
+                likes.append(likes_item)
+
+
+
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "text": text,
+            "created_by": created_by,
+            "user_name": user_name,
+            "created_at": created_at,
+            "updated_at": updated_at,
+            "is_updated": is_updated,
+            "is_deleted": is_deleted,
+            "comment_id": comment_id,
+            "location_id": location_id,
+            "method_id": method_id,
+        })
+        if likes is not UNSET:
+            field_dict["likes"] = likes
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.like import Like
+        d = src_dict.copy()
+        text = d.pop("text")
+
+        created_by = UUID(d.pop("created_by"))
+
+
+
+
+        user_name = d.pop("user_name")
+
+        created_at = isoparse(d.pop("created_at"))
+
+
+
+
+        updated_at = isoparse(d.pop("updated_at"))
+
+
+
+
+        is_updated = d.pop("is_updated")
+
+        is_deleted = d.pop("is_deleted")
+
+        comment_id = UUID(d.pop("comment_id"))
+
+
+
+
+        def _parse_location_id(data: object) -> Union[None, UUID]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                location_id_type_0 = UUID(data)
+
+
+
+                return location_id_type_0
+            except: # noqa: E722
+                pass
+            return cast(Union[None, UUID], data)
+
+        location_id = _parse_location_id(d.pop("location_id"))
+
+
+        def _parse_method_id(data: object) -> Union[None, UUID]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                method_id_type_0 = UUID(data)
+
+
+
+                return method_id_type_0
+            except: # noqa: E722
+                pass
+            return cast(Union[None, UUID], data)
+
+        method_id = _parse_method_id(d.pop("method_id"))
+
+
+        likes = []
+        _likes = d.pop("likes", UNSET)
+        for likes_item_data in (_likes or []):
+            likes_item = Like.from_dict(likes_item_data)
+
+
+
+            likes.append(likes_item)
+
+
+        comment = cls(
+            text=text,
+            created_by=created_by,
+            user_name=user_name,
+            created_at=created_at,
+            updated_at=updated_at,
+            is_updated=is_updated,
+            is_deleted=is_deleted,
+            comment_id=comment_id,
+            location_id=location_id,
+            method_id=method_id,
+            likes=likes,
+        )
+
+
+        comment.additional_properties = d
+        return comment
+
+    @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/comment_create.py

@@ -0,0 +1,72 @@
+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="CommentCreate")
+
+
+@_attrs_define
+class CommentCreate:
+    """ 
+        Attributes:
+            text (str):
+     """
+
+    text: str
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> Dict[str, Any]:
+        text = self.text
+
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "text": text,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        text = d.pop("text")
+
+        comment_create = cls(
+            text=text,
+        )
+
+
+        comment_create.additional_properties = d
+        return comment_create
+
+    @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/comment_update.py

@@ -0,0 +1,72 @@
+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="CommentUpdate")
+
+
+@_attrs_define
+class CommentUpdate:
+    """ 
+        Attributes:
+            text (str):
+     """
+
+    text: str
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> Dict[str, Any]:
+        text = self.text
+
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "text": text,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        text = d.pop("text")
+
+        comment_update = cls(
+            text=text,
+        )
+
+
+        comment_update.additional_properties = d
+        return comment_update
+
+    @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/cpt_options.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
+
+from ..models.scaling_mode import ScalingMode
+from ..types import UNSET, Unset
+from typing import Union
+
+
+
+
+
+
+T = TypeVar("T", bound="CPTOptions")
+
+
+@_attrs_define
+class CPTOptions:
+    """ 
+        Attributes:
+            scaling_mode (Union[Unset, ScalingMode]):
+            percentile (Union[Unset, float]):  Default: 0.975.
+     """
+
+    scaling_mode: Union[Unset, ScalingMode] = UNSET
+    percentile: Union[Unset, float] = 0.975
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> Dict[str, Any]:
+        scaling_mode: Union[Unset, str] = UNSET
+        if not isinstance(self.scaling_mode, Unset):
+            scaling_mode = self.scaling_mode.value
+
+
+        percentile = self.percentile
+
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if scaling_mode is not UNSET:
+            field_dict["scaling_mode"] = scaling_mode
+        if percentile is not UNSET:
+            field_dict["percentile"] = percentile
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        _scaling_mode = d.pop("scaling_mode", UNSET)
+        scaling_mode: Union[Unset, ScalingMode]
+        if isinstance(_scaling_mode,  Unset):
+            scaling_mode = UNSET
+        else:
+            scaling_mode = ScalingMode(_scaling_mode)
+
+
+
+
+        percentile = d.pop("percentile", UNSET)
+
+        cpt_options = cls(
+            scaling_mode=scaling_mode,
+            percentile=percentile,
+        )
+
+
+        cpt_options.additional_properties = d
+        return cpt_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/date_format.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class DateFormat(str, Enum):
+    ISO = "ISO"
+    NOR = "NOR"
+
+    def __str__(self) -> str:
+        return str(self.value)

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

@@ -0,0 +1,11 @@
+from enum import Enum
+
+class DPType(str, Enum):
+    DPH = "DPH"
+    DPL = "DPL"
+    DPM = "DPM"
+    DPSH_A = "DPSH-A"
+    DPSH_B = "DPSH-B"
+
+    def __str__(self) -> str:
+        return str(self.value)