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

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

@@ -0,0 +1,353 @@
+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.location_type import LocationType
+from ..models.plot_type import PlotType
+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.pdf_page_info import PDFPageInfo
+  from ..models.location_info import LocationInfo
+  from ..models.location_coordinates import LocationCoordinates
+  from ..models.fm_plot_options import FMPlotOptions
+  from ..models.plot_info_object_stats_type_0 import PlotInfoObjectStatsType0
+  from ..models.method_info import MethodInfo
+
+
+
+
+
+T = TypeVar("T", bound="PlotInfoObject")
+
+
+@_attrs_define
+class PlotInfoObject:
+    """ 
+        Attributes:
+            project_id (UUID):
+            location_type (LocationType):
+            location_ids (List[UUID]):
+            location_names (List[str]):
+            location_coordinates (List['LocationCoordinates']):
+            location_info (List['LocationInfo']):
+            method_info (List['MethodInfo']):
+            method_ids (List[UUID]):
+            method_type (str):
+            is_combined_plot (bool):
+            plot_type (PlotType):
+            plot_options (FMPlotOptions):
+            messages (Union[List[str], None, Unset]):
+            pdf_info (Union[Unset, PDFPageInfo]):
+            stats (Union['PlotInfoObjectStatsType0', None, Unset]):
+     """
+
+    project_id: UUID
+    location_type: LocationType
+    location_ids: List[UUID]
+    location_names: List[str]
+    location_coordinates: List['LocationCoordinates']
+    location_info: List['LocationInfo']
+    method_info: List['MethodInfo']
+    method_ids: List[UUID]
+    method_type: str
+    is_combined_plot: bool
+    plot_type: PlotType
+    plot_options: 'FMPlotOptions'
+    messages: Union[List[str], None, Unset] = UNSET
+    pdf_info: Union[Unset, 'PDFPageInfo'] = UNSET
+    stats: Union['PlotInfoObjectStatsType0', None, Unset] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> Dict[str, Any]:
+        from ..models.pdf_page_info import PDFPageInfo
+        from ..models.location_info import LocationInfo
+        from ..models.location_coordinates import LocationCoordinates
+        from ..models.fm_plot_options import FMPlotOptions
+        from ..models.plot_info_object_stats_type_0 import PlotInfoObjectStatsType0
+        from ..models.method_info import MethodInfo
+        project_id = str(self.project_id)
+
+        location_type = self.location_type.value
+
+        location_ids = []
+        for location_ids_item_data in self.location_ids:
+            location_ids_item = str(location_ids_item_data)
+            location_ids.append(location_ids_item)
+
+
+
+        location_names = self.location_names
+
+
+
+        location_coordinates = []
+        for location_coordinates_item_data in self.location_coordinates:
+            location_coordinates_item = location_coordinates_item_data.to_dict()
+            location_coordinates.append(location_coordinates_item)
+
+
+
+        location_info = []
+        for location_info_item_data in self.location_info:
+            location_info_item = location_info_item_data.to_dict()
+            location_info.append(location_info_item)
+
+
+
+        method_info = []
+        for method_info_item_data in self.method_info:
+            method_info_item = method_info_item_data.to_dict()
+            method_info.append(method_info_item)
+
+
+
+        method_ids = []
+        for method_ids_item_data in self.method_ids:
+            method_ids_item = str(method_ids_item_data)
+            method_ids.append(method_ids_item)
+
+
+
+        method_type = self.method_type
+
+        is_combined_plot = self.is_combined_plot
+
+        plot_type = self.plot_type.value
+
+        plot_options = self.plot_options.to_dict()
+
+        messages: Union[List[str], None, Unset]
+        if isinstance(self.messages, Unset):
+            messages = UNSET
+        elif isinstance(self.messages, list):
+            messages = self.messages
+
+
+        else:
+            messages = self.messages
+
+        pdf_info: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.pdf_info, Unset):
+            pdf_info = self.pdf_info.to_dict()
+
+        stats: Union[Dict[str, Any], None, Unset]
+        if isinstance(self.stats, Unset):
+            stats = UNSET
+        elif isinstance(self.stats, PlotInfoObjectStatsType0):
+            stats = self.stats.to_dict()
+        else:
+            stats = self.stats
+
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "project_id": project_id,
+            "location_type": location_type,
+            "location_ids": location_ids,
+            "location_names": location_names,
+            "location_coordinates": location_coordinates,
+            "location_info": location_info,
+            "method_info": method_info,
+            "method_ids": method_ids,
+            "method_type": method_type,
+            "is_combined_plot": is_combined_plot,
+            "plot_type": plot_type,
+            "plot_options": plot_options,
+        })
+        if messages is not UNSET:
+            field_dict["messages"] = messages
+        if pdf_info is not UNSET:
+            field_dict["pdf_info"] = pdf_info
+        if stats is not UNSET:
+            field_dict["stats"] = stats
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.pdf_page_info import PDFPageInfo
+        from ..models.location_info import LocationInfo
+        from ..models.location_coordinates import LocationCoordinates
+        from ..models.fm_plot_options import FMPlotOptions
+        from ..models.plot_info_object_stats_type_0 import PlotInfoObjectStatsType0
+        from ..models.method_info import MethodInfo
+        d = src_dict.copy()
+        project_id = UUID(d.pop("project_id"))
+
+
+
+
+        location_type = LocationType(d.pop("location_type"))
+
+
+
+
+        location_ids = []
+        _location_ids = d.pop("location_ids")
+        for location_ids_item_data in (_location_ids):
+            location_ids_item = UUID(location_ids_item_data)
+
+
+
+            location_ids.append(location_ids_item)
+
+
+        location_names = cast(List[str], d.pop("location_names"))
+
+
+        location_coordinates = []
+        _location_coordinates = d.pop("location_coordinates")
+        for location_coordinates_item_data in (_location_coordinates):
+            location_coordinates_item = LocationCoordinates.from_dict(location_coordinates_item_data)
+
+
+
+            location_coordinates.append(location_coordinates_item)
+
+
+        location_info = []
+        _location_info = d.pop("location_info")
+        for location_info_item_data in (_location_info):
+            location_info_item = LocationInfo.from_dict(location_info_item_data)
+
+
+
+            location_info.append(location_info_item)
+
+
+        method_info = []
+        _method_info = d.pop("method_info")
+        for method_info_item_data in (_method_info):
+            method_info_item = MethodInfo.from_dict(method_info_item_data)
+
+
+
+            method_info.append(method_info_item)
+
+
+        method_ids = []
+        _method_ids = d.pop("method_ids")
+        for method_ids_item_data in (_method_ids):
+            method_ids_item = UUID(method_ids_item_data)
+
+
+
+            method_ids.append(method_ids_item)
+
+
+        method_type = d.pop("method_type")
+
+        is_combined_plot = d.pop("is_combined_plot")
+
+        plot_type = PlotType(d.pop("plot_type"))
+
+
+
+
+        plot_options = FMPlotOptions.from_dict(d.pop("plot_options"))
+
+
+
+
+        def _parse_messages(data: object) -> Union[List[str], None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                messages_type_0 = cast(List[str], data)
+
+                return messages_type_0
+            except: # noqa: E722
+                pass
+            return cast(Union[List[str], None, Unset], data)
+
+        messages = _parse_messages(d.pop("messages", UNSET))
+
+
+        _pdf_info = d.pop("pdf_info", UNSET)
+        pdf_info: Union[Unset, PDFPageInfo]
+        if isinstance(_pdf_info,  Unset):
+            pdf_info = UNSET
+        else:
+            pdf_info = PDFPageInfo.from_dict(_pdf_info)
+
+
+
+
+        def _parse_stats(data: object) -> Union['PlotInfoObjectStatsType0', None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                stats_type_0 = PlotInfoObjectStatsType0.from_dict(data)
+
+
+
+                return stats_type_0
+            except: # noqa: E722
+                pass
+            return cast(Union['PlotInfoObjectStatsType0', None, Unset], data)
+
+        stats = _parse_stats(d.pop("stats", UNSET))
+
+
+        plot_info_object = cls(
+            project_id=project_id,
+            location_type=location_type,
+            location_ids=location_ids,
+            location_names=location_names,
+            location_coordinates=location_coordinates,
+            location_info=location_info,
+            method_info=method_info,
+            method_ids=method_ids,
+            method_type=method_type,
+            is_combined_plot=is_combined_plot,
+            plot_type=plot_type,
+            plot_options=plot_options,
+            messages=messages,
+            pdf_info=pdf_info,
+            stats=stats,
+        )
+
+
+        plot_info_object.additional_properties = d
+        return plot_info_object
+
+    @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/plot_info_object_stats_type_0.py

@@ -0,0 +1,77 @@
+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
+from typing import Dict
+
+if TYPE_CHECKING:
+  from ..models.plot_data_stats import PlotDataStats
+
+
+
+
+
+T = TypeVar("T", bound="PlotInfoObjectStatsType0")
+
+
+@_attrs_define
+class PlotInfoObjectStatsType0:
+    """ 
+     """
+
+    additional_properties: Dict[str, 'PlotDataStats'] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> Dict[str, Any]:
+        from ..models.plot_data_stats import PlotDataStats
+        
+        field_dict: Dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop.to_dict()
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.plot_data_stats import PlotDataStats
+        d = src_dict.copy()
+        plot_info_object_stats_type_0 = cls(
+        )
+
+
+        from ..models.plot_data_stats_percentiles import PlotDataStatsPercentiles
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = PlotDataStats.from_dict(prop_dict)
+
+
+
+            additional_properties[prop_name] = additional_property
+
+        plot_info_object_stats_type_0.additional_properties = additional_properties
+        return plot_info_object_stats_type_0
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> 'PlotDataStats':
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: 'PlotDataStats') -> 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/plot_sequence.py

@@ -0,0 +1,116 @@
+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.plot_info_object import PlotInfoObject
+  from ..models.plot_sequence_options import PlotSequenceOptions
+
+
+
+
+
+T = TypeVar("T", bound="PlotSequence")
+
+
+@_attrs_define
+class PlotSequence:
+    """ 
+        Attributes:
+            sequence (List['PlotInfoObject']):
+            options (Union[Unset, PlotSequenceOptions]):
+     """
+
+    sequence: List['PlotInfoObject']
+    options: Union[Unset, 'PlotSequenceOptions'] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> Dict[str, Any]:
+        from ..models.plot_info_object import PlotInfoObject
+        from ..models.plot_sequence_options import PlotSequenceOptions
+        sequence = []
+        for sequence_item_data in self.sequence:
+            sequence_item = sequence_item_data.to_dict()
+            sequence.append(sequence_item)
+
+
+
+        options: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.options, Unset):
+            options = self.options.to_dict()
+
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "sequence": sequence,
+        })
+        if options is not UNSET:
+            field_dict["options"] = options
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.plot_info_object import PlotInfoObject
+        from ..models.plot_sequence_options import PlotSequenceOptions
+        d = src_dict.copy()
+        sequence = []
+        _sequence = d.pop("sequence")
+        for sequence_item_data in (_sequence):
+            sequence_item = PlotInfoObject.from_dict(sequence_item_data)
+
+
+
+            sequence.append(sequence_item)
+
+
+        _options = d.pop("options", UNSET)
+        options: Union[Unset, PlotSequenceOptions]
+        if isinstance(_options,  Unset):
+            options = UNSET
+        else:
+            options = PlotSequenceOptions.from_dict(_options)
+
+
+
+
+        plot_sequence = cls(
+            sequence=sequence,
+            options=options,
+        )
+
+
+        plot_sequence.additional_properties = d
+        return plot_sequence
+
+    @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/plot_sequence_options.py

@@ -0,0 +1,109 @@
+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 Dict
+from typing import Union
+
+if TYPE_CHECKING:
+  from ..models.pdf_options import PdfOptions
+
+
+
+
+
+T = TypeVar("T", bound="PlotSequenceOptions")
+
+
+@_attrs_define
+class PlotSequenceOptions:
+    """ 
+        Attributes:
+            auto_set_depth (Union[Unset, bool]):  Default: False.
+            pdf_filename (Union[Unset, str]):  Default: 'factual_report.pdf'.
+            pdf (Union[Unset, PdfOptions]):
+     """
+
+    auto_set_depth: Union[Unset, bool] = False
+    pdf_filename: Union[Unset, str] = 'factual_report.pdf'
+    pdf: Union[Unset, 'PdfOptions'] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+    def to_dict(self) -> Dict[str, Any]:
+        from ..models.pdf_options import PdfOptions
+        auto_set_depth = self.auto_set_depth
+
+        pdf_filename = self.pdf_filename
+
+        pdf: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.pdf, Unset):
+            pdf = self.pdf.to_dict()
+
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if auto_set_depth is not UNSET:
+            field_dict["auto_set_depth"] = auto_set_depth
+        if pdf_filename is not UNSET:
+            field_dict["pdf_filename"] = pdf_filename
+        if pdf is not UNSET:
+            field_dict["pdf"] = pdf
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.pdf_options import PdfOptions
+        d = src_dict.copy()
+        auto_set_depth = d.pop("auto_set_depth", UNSET)
+
+        pdf_filename = d.pop("pdf_filename", UNSET)
+
+        _pdf = d.pop("pdf", UNSET)
+        pdf: Union[Unset, PdfOptions]
+        if isinstance(_pdf,  Unset):
+            pdf = UNSET
+        else:
+            pdf = PdfOptions.from_dict(_pdf)
+
+
+
+
+        plot_sequence_options = cls(
+            auto_set_depth=auto_set_depth,
+            pdf_filename=pdf_filename,
+            pdf=pdf,
+        )
+
+
+        plot_sequence_options.additional_properties = d
+        return plot_sequence_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/plot_type.py

@@ -0,0 +1,17 @@
+from enum import Enum
+
+class PlotType(str, Enum):
+    ALL = "all"
+    CPT = "cpt"
+    DP = "dp"
+    PZ = "pz"
+    RCD = "rcd"
+    RP = "rp"
+    SRS = "srs"
+    SS = "ss"
+    SVT = "svt"
+    TOT = "tot"
+    WST = "wst"
+
+    def __str__(self) -> str:
+        return str(self.value)