benchling-api-client 2.0.417__py3-none-any.whl → 2.0.419__py3-none-any.whl

benchling_api_client/v2/beta/models/entry_beta_review_record.py

@@ -4,6 +4,7 @@ import attr
 
 from ..extensions import NotPresentError
 from ..models.entry_beta_review_record_status import EntryBetaReviewRecordStatus
+from ..models.entry_review_process import EntryReviewProcess
 from ..models.review_change import ReviewChange
 from ..types import UNSET, Unset
 
@@ -16,6 +17,7 @@ class EntryBetaReviewRecord:
 
     _comment: Union[Unset, str] = UNSET
     _review_changes: Union[Unset, List[ReviewChange]] = UNSET
+    _review_processes: Union[Unset, None, List[EntryReviewProcess]] = UNSET
     _status: Union[Unset, EntryBetaReviewRecordStatus] = UNSET
     additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
 
@@ -23,6 +25,7 @@ class EntryBetaReviewRecord:
         fields = []
         fields.append("comment={}".format(repr(self._comment)))
         fields.append("review_changes={}".format(repr(self._review_changes)))
+        fields.append("review_processes={}".format(repr(self._review_processes)))
         fields.append("status={}".format(repr(self._status)))
         fields.append("additional_properties={}".format(repr(self.additional_properties)))
         return "EntryBetaReviewRecord({})".format(", ".join(fields))
@@ -37,6 +40,17 @@ class EntryBetaReviewRecord:
 
                 review_changes.append(review_changes_item)
 
+        review_processes: Union[Unset, None, List[Any]] = UNSET
+        if not isinstance(self._review_processes, Unset):
+            if self._review_processes is None:
+                review_processes = None
+            else:
+                review_processes = []
+                for review_processes_item_data in self._review_processes:
+                    review_processes_item = review_processes_item_data.to_dict()
+
+                    review_processes.append(review_processes_item)
+
         status: Union[Unset, int] = UNSET
         if not isinstance(self._status, Unset):
             status = self._status.value
@@ -48,6 +62,8 @@ class EntryBetaReviewRecord:
             field_dict["comment"] = comment
         if review_changes is not UNSET:
             field_dict["reviewChanges"] = review_changes
+        if review_processes is not UNSET:
+            field_dict["reviewProcesses"] = review_processes
         if status is not UNSET:
             field_dict["status"] = status
 
@@ -85,6 +101,23 @@ class EntryBetaReviewRecord:
                 raise
             review_changes = cast(Union[Unset, List[ReviewChange]], UNSET)
 
+        def get_review_processes() -> Union[Unset, None, List[EntryReviewProcess]]:
+            review_processes = []
+            _review_processes = d.pop("reviewProcesses")
+            for review_processes_item_data in _review_processes or []:
+                review_processes_item = EntryReviewProcess.from_dict(review_processes_item_data, strict=False)
+
+                review_processes.append(review_processes_item)
+
+            return review_processes
+
+        try:
+            review_processes = get_review_processes()
+        except KeyError:
+            if strict:
+                raise
+            review_processes = cast(Union[Unset, None, List[EntryReviewProcess]], UNSET)
+
         def get_status() -> Union[Unset, EntryBetaReviewRecordStatus]:
             status = UNSET
             _status = d.pop("status")
@@ -106,6 +139,7 @@ class EntryBetaReviewRecord:
         entry_beta_review_record = cls(
             comment=comment,
             review_changes=review_changes,
+            review_processes=review_processes,
             status=status,
         )
 
@@ -161,6 +195,21 @@ class EntryBetaReviewRecord:
     def review_changes(self) -> None:
         self._review_changes = UNSET
 
+    @property
+    def review_processes(self) -> Optional[List[EntryReviewProcess]]:
+        """ Review Processes associated with the Entry """
+        if isinstance(self._review_processes, Unset):
+            raise NotPresentError(self, "review_processes")
+        return self._review_processes
+
+    @review_processes.setter
+    def review_processes(self, value: Optional[List[EntryReviewProcess]]) -> None:
+        self._review_processes = value
+
+    @review_processes.deleter
+    def review_processes(self) -> None:
+        self._review_processes = UNSET
+
     @property
     def status(self) -> EntryBetaReviewRecordStatus:
         """ Review Status of the entry """

benchling_api_client/v2/beta/models/entry_review_process.py

@@ -0,0 +1,252 @@
+from typing import Any, cast, Dict, List, Optional, Type, TypeVar, Union
+
+import attr
+
+from ..extensions import NotPresentError
+from ..models.entry_review_process_completion_status import EntryReviewProcessCompletionStatus
+from ..models.entry_review_process_stages_item import EntryReviewProcessStagesItem
+from ..models.entry_review_process_type import EntryReviewProcessType
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="EntryReviewProcess")
+
+
+@attr.s(auto_attribs=True, repr=False)
+class EntryReviewProcess:
+    """  """
+
+    _completion_status: Union[Unset, EntryReviewProcessCompletionStatus] = UNSET
+    _id: Union[Unset, str] = UNSET
+    _name: Union[Unset, str] = UNSET
+    _stages: Union[Unset, List[EntryReviewProcessStagesItem]] = UNSET
+    _type: Union[Unset, EntryReviewProcessType] = UNSET
+    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
+
+    def __repr__(self):
+        fields = []
+        fields.append("completion_status={}".format(repr(self._completion_status)))
+        fields.append("id={}".format(repr(self._id)))
+        fields.append("name={}".format(repr(self._name)))
+        fields.append("stages={}".format(repr(self._stages)))
+        fields.append("type={}".format(repr(self._type)))
+        fields.append("additional_properties={}".format(repr(self.additional_properties)))
+        return "EntryReviewProcess({})".format(", ".join(fields))
+
+    def to_dict(self) -> Dict[str, Any]:
+        completion_status: Union[Unset, int] = UNSET
+        if not isinstance(self._completion_status, Unset):
+            completion_status = self._completion_status.value
+
+        id = self._id
+        name = self._name
+        stages: Union[Unset, List[Any]] = UNSET
+        if not isinstance(self._stages, Unset):
+            stages = []
+            for stages_item_data in self._stages:
+                stages_item = stages_item_data.to_dict()
+
+                stages.append(stages_item)
+
+        type: Union[Unset, int] = UNSET
+        if not isinstance(self._type, Unset):
+            type = self._type.value
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        # Allow the model to serialize even if it was created outside of the constructor, circumventing validation
+        if completion_status is not UNSET:
+            field_dict["completionStatus"] = completion_status
+        if id is not UNSET:
+            field_dict["id"] = id
+        if name is not UNSET:
+            field_dict["name"] = name
+        if stages is not UNSET:
+            field_dict["stages"] = stages
+        if type is not UNSET:
+            field_dict["type"] = type
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any], strict: bool = False) -> T:
+        d = src_dict.copy()
+
+        def get_completion_status() -> Union[Unset, EntryReviewProcessCompletionStatus]:
+            completion_status = UNSET
+            _completion_status = d.pop("completionStatus")
+            if _completion_status is not None and _completion_status is not UNSET:
+                try:
+                    completion_status = EntryReviewProcessCompletionStatus(_completion_status)
+                except ValueError:
+                    completion_status = EntryReviewProcessCompletionStatus.of_unknown(_completion_status)
+
+            return completion_status
+
+        try:
+            completion_status = get_completion_status()
+        except KeyError:
+            if strict:
+                raise
+            completion_status = cast(Union[Unset, EntryReviewProcessCompletionStatus], UNSET)
+
+        def get_id() -> Union[Unset, str]:
+            id = d.pop("id")
+            return id
+
+        try:
+            id = get_id()
+        except KeyError:
+            if strict:
+                raise
+            id = cast(Union[Unset, str], UNSET)
+
+        def get_name() -> Union[Unset, str]:
+            name = d.pop("name")
+            return name
+
+        try:
+            name = get_name()
+        except KeyError:
+            if strict:
+                raise
+            name = cast(Union[Unset, str], UNSET)
+
+        def get_stages() -> Union[Unset, List[EntryReviewProcessStagesItem]]:
+            stages = []
+            _stages = d.pop("stages")
+            for stages_item_data in _stages or []:
+                stages_item = EntryReviewProcessStagesItem.from_dict(stages_item_data, strict=False)
+
+                stages.append(stages_item)
+
+            return stages
+
+        try:
+            stages = get_stages()
+        except KeyError:
+            if strict:
+                raise
+            stages = cast(Union[Unset, List[EntryReviewProcessStagesItem]], UNSET)
+
+        def get_type() -> Union[Unset, EntryReviewProcessType]:
+            type = UNSET
+            _type = d.pop("type")
+            if _type is not None and _type is not UNSET:
+                try:
+                    type = EntryReviewProcessType(_type)
+                except ValueError:
+                    type = EntryReviewProcessType.of_unknown(_type)
+
+            return type
+
+        try:
+            type = get_type()
+        except KeyError:
+            if strict:
+                raise
+            type = cast(Union[Unset, EntryReviewProcessType], UNSET)
+
+        entry_review_process = cls(
+            completion_status=completion_status,
+            id=id,
+            name=name,
+            stages=stages,
+            type=type,
+        )
+
+        entry_review_process.additional_properties = d
+        return entry_review_process
+
+    @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
+
+    def get(self, key, default=None) -> Optional[Any]:
+        return self.additional_properties.get(key, default)
+
+    @property
+    def completion_status(self) -> EntryReviewProcessCompletionStatus:
+        """ State of the Entry at the end of the Review Process """
+        if isinstance(self._completion_status, Unset):
+            raise NotPresentError(self, "completion_status")
+        return self._completion_status
+
+    @completion_status.setter
+    def completion_status(self, value: EntryReviewProcessCompletionStatus) -> None:
+        self._completion_status = value
+
+    @completion_status.deleter
+    def completion_status(self) -> None:
+        self._completion_status = UNSET
+
+    @property
+    def id(self) -> str:
+        """ ID of the Review Process """
+        if isinstance(self._id, Unset):
+            raise NotPresentError(self, "id")
+        return self._id
+
+    @id.setter
+    def id(self, value: str) -> None:
+        self._id = value
+
+    @id.deleter
+    def id(self) -> None:
+        self._id = UNSET
+
+    @property
+    def name(self) -> str:
+        """ Name of the Review Process """
+        if isinstance(self._name, Unset):
+            raise NotPresentError(self, "name")
+        return self._name
+
+    @name.setter
+    def name(self, value: str) -> None:
+        self._name = value
+
+    @name.deleter
+    def name(self) -> None:
+        self._name = UNSET
+
+    @property
+    def stages(self) -> List[EntryReviewProcessStagesItem]:
+        """ Array of Stages for the Review Process """
+        if isinstance(self._stages, Unset):
+            raise NotPresentError(self, "stages")
+        return self._stages
+
+    @stages.setter
+    def stages(self, value: List[EntryReviewProcessStagesItem]) -> None:
+        self._stages = value
+
+    @stages.deleter
+    def stages(self) -> None:
+        self._stages = UNSET
+
+    @property
+    def type(self) -> EntryReviewProcessType:
+        """ Type of the Review Process """
+        if isinstance(self._type, Unset):
+            raise NotPresentError(self, "type")
+        return self._type
+
+    @type.setter
+    def type(self, value: EntryReviewProcessType) -> None:
+        self._type = value
+
+    @type.deleter
+    def type(self) -> None:
+        self._type = UNSET

benchling_api_client/v2/beta/models/entry_review_process_completion_status.py

@@ -0,0 +1,27 @@
+from enum import Enum
+from functools import lru_cache
+from typing import cast
+
+from ..extensions import Enums
+
+
+class EntryReviewProcessCompletionStatus(Enums.KnownString):
+    APPROVED = "APPROVED"
+    COMPLETED = "COMPLETED"
+    ACCEPTED = "ACCEPTED"
+    REVIEWED = "REVIEWED"
+    WITNESSED = "WITNESSED"
+    SELF_REVIEWED = "SELF_REVIEWED"
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    @staticmethod
+    @lru_cache(maxsize=None)
+    def of_unknown(val: str) -> "EntryReviewProcessCompletionStatus":
+        if not isinstance(val, str):
+            raise ValueError(
+                f"Value of EntryReviewProcessCompletionStatus must be a string (encountered: {val})"
+            )
+        newcls = Enum("EntryReviewProcessCompletionStatus", {"_UNKNOWN": val}, type=Enums.UnknownString)  # type: ignore
+        return cast(EntryReviewProcessCompletionStatus, getattr(newcls, "_UNKNOWN"))

benchling_api_client/v2/beta/models/entry_review_process_stages_item.py

@@ -0,0 +1,211 @@
+from typing import Any, cast, Dict, List, Optional, Type, TypeVar, Union
+
+import attr
+
+from ..extensions import NotPresentError
+from ..models.entry_review_process_stages_item_action_label import EntryReviewProcessStagesItemActionLabel
+from ..models.entry_review_process_stages_item_reviewers_item import EntryReviewProcessStagesItemReviewersItem
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="EntryReviewProcessStagesItem")
+
+
+@attr.s(auto_attribs=True, repr=False)
+class EntryReviewProcessStagesItem:
+    """  """
+
+    _action_label: Union[Unset, EntryReviewProcessStagesItemActionLabel] = UNSET
+    _id: Union[Unset, str] = UNSET
+    _name: Union[Unset, str] = UNSET
+    _reviewers: Union[Unset, List[EntryReviewProcessStagesItemReviewersItem]] = UNSET
+    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
+
+    def __repr__(self):
+        fields = []
+        fields.append("action_label={}".format(repr(self._action_label)))
+        fields.append("id={}".format(repr(self._id)))
+        fields.append("name={}".format(repr(self._name)))
+        fields.append("reviewers={}".format(repr(self._reviewers)))
+        fields.append("additional_properties={}".format(repr(self.additional_properties)))
+        return "EntryReviewProcessStagesItem({})".format(", ".join(fields))
+
+    def to_dict(self) -> Dict[str, Any]:
+        action_label: Union[Unset, int] = UNSET
+        if not isinstance(self._action_label, Unset):
+            action_label = self._action_label.value
+
+        id = self._id
+        name = self._name
+        reviewers: Union[Unset, List[Any]] = UNSET
+        if not isinstance(self._reviewers, Unset):
+            reviewers = []
+            for reviewers_item_data in self._reviewers:
+                reviewers_item = reviewers_item_data.to_dict()
+
+                reviewers.append(reviewers_item)
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        # Allow the model to serialize even if it was created outside of the constructor, circumventing validation
+        if action_label is not UNSET:
+            field_dict["actionLabel"] = action_label
+        if id is not UNSET:
+            field_dict["id"] = id
+        if name is not UNSET:
+            field_dict["name"] = name
+        if reviewers is not UNSET:
+            field_dict["reviewers"] = reviewers
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any], strict: bool = False) -> T:
+        d = src_dict.copy()
+
+        def get_action_label() -> Union[Unset, EntryReviewProcessStagesItemActionLabel]:
+            action_label = UNSET
+            _action_label = d.pop("actionLabel")
+            if _action_label is not None and _action_label is not UNSET:
+                try:
+                    action_label = EntryReviewProcessStagesItemActionLabel(_action_label)
+                except ValueError:
+                    action_label = EntryReviewProcessStagesItemActionLabel.of_unknown(_action_label)
+
+            return action_label
+
+        try:
+            action_label = get_action_label()
+        except KeyError:
+            if strict:
+                raise
+            action_label = cast(Union[Unset, EntryReviewProcessStagesItemActionLabel], UNSET)
+
+        def get_id() -> Union[Unset, str]:
+            id = d.pop("id")
+            return id
+
+        try:
+            id = get_id()
+        except KeyError:
+            if strict:
+                raise
+            id = cast(Union[Unset, str], UNSET)
+
+        def get_name() -> Union[Unset, str]:
+            name = d.pop("name")
+            return name
+
+        try:
+            name = get_name()
+        except KeyError:
+            if strict:
+                raise
+            name = cast(Union[Unset, str], UNSET)
+
+        def get_reviewers() -> Union[Unset, List[EntryReviewProcessStagesItemReviewersItem]]:
+            reviewers = []
+            _reviewers = d.pop("reviewers")
+            for reviewers_item_data in _reviewers or []:
+                reviewers_item = EntryReviewProcessStagesItemReviewersItem.from_dict(
+                    reviewers_item_data, strict=False
+                )
+
+                reviewers.append(reviewers_item)
+
+            return reviewers
+
+        try:
+            reviewers = get_reviewers()
+        except KeyError:
+            if strict:
+                raise
+            reviewers = cast(Union[Unset, List[EntryReviewProcessStagesItemReviewersItem]], UNSET)
+
+        entry_review_process_stages_item = cls(
+            action_label=action_label,
+            id=id,
+            name=name,
+            reviewers=reviewers,
+        )
+
+        entry_review_process_stages_item.additional_properties = d
+        return entry_review_process_stages_item
+
+    @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
+
+    def get(self, key, default=None) -> Optional[Any]:
+        return self.additional_properties.get(key, default)
+
+    @property
+    def action_label(self) -> EntryReviewProcessStagesItemActionLabel:
+        """ Action reviewer is doing during the review """
+        if isinstance(self._action_label, Unset):
+            raise NotPresentError(self, "action_label")
+        return self._action_label
+
+    @action_label.setter
+    def action_label(self, value: EntryReviewProcessStagesItemActionLabel) -> None:
+        self._action_label = value
+
+    @action_label.deleter
+    def action_label(self) -> None:
+        self._action_label = UNSET
+
+    @property
+    def id(self) -> str:
+        """ ID of the Review Stage """
+        if isinstance(self._id, Unset):
+            raise NotPresentError(self, "id")
+        return self._id
+
+    @id.setter
+    def id(self, value: str) -> None:
+        self._id = value
+
+    @id.deleter
+    def id(self) -> None:
+        self._id = UNSET
+
+    @property
+    def name(self) -> str:
+        """ Name of the Review Stage """
+        if isinstance(self._name, Unset):
+            raise NotPresentError(self, "name")
+        return self._name
+
+    @name.setter
+    def name(self, value: str) -> None:
+        self._name = value
+
+    @name.deleter
+    def name(self) -> None:
+        self._name = UNSET
+
+    @property
+    def reviewers(self) -> List[EntryReviewProcessStagesItemReviewersItem]:
+        """ Reviewers for the Review Stage """
+        if isinstance(self._reviewers, Unset):
+            raise NotPresentError(self, "reviewers")
+        return self._reviewers
+
+    @reviewers.setter
+    def reviewers(self, value: List[EntryReviewProcessStagesItemReviewersItem]) -> None:
+        self._reviewers = value
+
+    @reviewers.deleter
+    def reviewers(self) -> None:
+        self._reviewers = UNSET

benchling_api_client/v2/beta/models/entry_review_process_stages_item_action_label.py

@@ -0,0 +1,27 @@
+from enum import Enum
+from functools import lru_cache
+from typing import cast
+
+from ..extensions import Enums
+
+
+class EntryReviewProcessStagesItemActionLabel(Enums.KnownString):
+    APPROVE = "APPROVE"
+    COMPLETE = "COMPLETE"
+    ACCEPT = "ACCEPT"
+    REVIEW = "REVIEW"
+    WITNESS = "WITNESS"
+    SELF_REVIEW = "SELF_REVIEW"
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    @staticmethod
+    @lru_cache(maxsize=None)
+    def of_unknown(val: str) -> "EntryReviewProcessStagesItemActionLabel":
+        if not isinstance(val, str):
+            raise ValueError(
+                f"Value of EntryReviewProcessStagesItemActionLabel must be a string (encountered: {val})"
+            )
+        newcls = Enum("EntryReviewProcessStagesItemActionLabel", {"_UNKNOWN": val}, type=Enums.UnknownString)  # type: ignore
+        return cast(EntryReviewProcessStagesItemActionLabel, getattr(newcls, "_UNKNOWN"))