benchling-api-client 2.0.418__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"))

benchling_api_client/v2/beta/models/entry_review_process_stages_item_reviewers_item.py

@@ -0,0 +1,195 @@
+from typing import Any, cast, Dict, List, Optional, Type, TypeVar, Union
+
+import attr
+
+from ..extensions import NotPresentError
+from ..models.entry_review_process_stages_item_reviewers_item_status import (
+    EntryReviewProcessStagesItemReviewersItemStatus,
+)
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="EntryReviewProcessStagesItemReviewersItem")
+
+
+@attr.s(auto_attribs=True, repr=False)
+class EntryReviewProcessStagesItemReviewersItem:
+    """  """
+
+    _status: Union[Unset, EntryReviewProcessStagesItemReviewersItemStatus] = UNSET
+    _handle: Union[Unset, str] = UNSET
+    _id: Union[Unset, str] = UNSET
+    _name: Union[Unset, str] = UNSET
+    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
+
+    def __repr__(self):
+        fields = []
+        fields.append("status={}".format(repr(self._status)))
+        fields.append("handle={}".format(repr(self._handle)))
+        fields.append("id={}".format(repr(self._id)))
+        fields.append("name={}".format(repr(self._name)))
+        fields.append("additional_properties={}".format(repr(self.additional_properties)))
+        return "EntryReviewProcessStagesItemReviewersItem({})".format(", ".join(fields))
+
+    def to_dict(self) -> Dict[str, Any]:
+        status: Union[Unset, int] = UNSET
+        if not isinstance(self._status, Unset):
+            status = self._status.value
+
+        handle = self._handle
+        id = self._id
+        name = self._name
+
+        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 status is not UNSET:
+            field_dict["status"] = status
+        if handle is not UNSET:
+            field_dict["handle"] = handle
+        if id is not UNSET:
+            field_dict["id"] = id
+        if name is not UNSET:
+            field_dict["name"] = name
+
+        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_status() -> Union[Unset, EntryReviewProcessStagesItemReviewersItemStatus]:
+            status = UNSET
+            _status = d.pop("status")
+            if _status is not None and _status is not UNSET:
+                try:
+                    status = EntryReviewProcessStagesItemReviewersItemStatus(_status)
+                except ValueError:
+                    status = EntryReviewProcessStagesItemReviewersItemStatus.of_unknown(_status)
+
+            return status
+
+        try:
+            status = get_status()
+        except KeyError:
+            if strict:
+                raise
+            status = cast(Union[Unset, EntryReviewProcessStagesItemReviewersItemStatus], UNSET)
+
+        def get_handle() -> Union[Unset, str]:
+            handle = d.pop("handle")
+            return handle
+
+        try:
+            handle = get_handle()
+        except KeyError:
+            if strict:
+                raise
+            handle = cast(Union[Unset, str], 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)
+
+        entry_review_process_stages_item_reviewers_item = cls(
+            status=status,
+            handle=handle,
+            id=id,
+            name=name,
+        )
+
+        entry_review_process_stages_item_reviewers_item.additional_properties = d
+        return entry_review_process_stages_item_reviewers_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 status(self) -> EntryReviewProcessStagesItemReviewersItemStatus:
+        """ Status of the Reviewer """
+        if isinstance(self._status, Unset):
+            raise NotPresentError(self, "status")
+        return self._status
+
+    @status.setter
+    def status(self, value: EntryReviewProcessStagesItemReviewersItemStatus) -> None:
+        self._status = value
+
+    @status.deleter
+    def status(self) -> None:
+        self._status = UNSET
+
+    @property
+    def handle(self) -> str:
+        if isinstance(self._handle, Unset):
+            raise NotPresentError(self, "handle")
+        return self._handle
+
+    @handle.setter
+    def handle(self, value: str) -> None:
+        self._handle = value
+
+    @handle.deleter
+    def handle(self) -> None:
+        self._handle = UNSET
+
+    @property
+    def id(self) -> str:
+        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:
+        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

benchling_api_client/v2/beta/models/entry_review_process_stages_item_reviewers_item_status.py

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

benchling_api_client/v2/beta/models/entry_review_process_type.py

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

benchling_api_client/v2/beta/models/worksheet_review_changes_review_record.py

@@ -3,6 +3,7 @@ from typing import Any, cast, Dict, List, Optional, Type, TypeVar, Union
 import attr
 
 from ..extensions import NotPresentError
+from ..models.entry_review_process import EntryReviewProcess
 from ..models.review_change import ReviewChange
 from ..models.worksheet_review_changes_review_record_status import WorksheetReviewChangesReviewRecordStatus
 from ..types import UNSET, Unset
@@ -16,6 +17,7 @@ class WorksheetReviewChangesReviewRecord:
 
     _comment: Union[Unset, str] = UNSET
     _review_changes: Union[Unset, List[ReviewChange]] = UNSET
+    _review_processes: Union[Unset, None, List[EntryReviewProcess]] = UNSET
     _status: Union[Unset, WorksheetReviewChangesReviewRecordStatus] = UNSET
     additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
 
@@ -23,6 +25,7 @@ class WorksheetReviewChangesReviewRecord:
         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 "WorksheetReviewChangesReviewRecord({})".format(", ".join(fields))
@@ -37,6 +40,17 @@ class WorksheetReviewChangesReviewRecord:
 
                 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 WorksheetReviewChangesReviewRecord:
             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 WorksheetReviewChangesReviewRecord:
                 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, WorksheetReviewChangesReviewRecordStatus]:
             status = UNSET
             _status = d.pop("status")
@@ -106,6 +139,7 @@ class WorksheetReviewChangesReviewRecord:
         worksheet_review_changes_review_record = cls(
             comment=comment,
             review_changes=review_changes,
+            review_processes=review_processes,
             status=status,
         )
 
@@ -161,6 +195,21 @@ class WorksheetReviewChangesReviewRecord:
     def review_changes(self) -> None:
         self._review_changes = UNSET
 
+    @property
+    def review_processes(self) -> Optional[List[EntryReviewProcess]]:
+        """ Review Processes associated with the Worksheet """
+        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) -> WorksheetReviewChangesReviewRecordStatus:
         """ Review Status of the worksheet """

benchling_api_client/v2/beta/openapi.yaml

@@ -5046,6 +5046,12 @@ components:
               items:
                 $ref: '#/components/schemas/ReviewChange'
               type: array
+            reviewProcesses:
+              description: Review Processes associated with the Entry
+              items:
+                $ref: '#/components/schemas/EntryReviewProcess'
+              nullable: true
+              type: array
             status:
               description: Review Status of the entry
               enum:
@@ -5185,6 +5191,70 @@ components:
       - $ref: '#/components/schemas/ChartNotePart'
       - $ref: '#/components/schemas/AppCanvasNotePart'
       type: object
+    EntryReviewProcess:
+      properties:
+        completionStatus:
+          description: State of the Entry at the end of the Review Process
+          enum:
+          - APPROVED
+          - COMPLETED
+          - ACCEPTED
+          - REVIEWED
+          - WITNESSED
+          - SELF_REVIEWED
+          type: string
+        id:
+          description: ID of the Review Process
+          type: string
+        name:
+          description: Name of the Review Process
+          type: string
+        stages:
+          description: Array of Stages for the Review Process
+          items:
+            properties:
+              actionLabel:
+                description: Action reviewer is doing during the review
+                enum:
+                - APPROVE
+                - COMPLETE
+                - ACCEPT
+                - REVIEW
+                - WITNESS
+                - SELF_REVIEW
+                type: string
+              id:
+                description: ID of the Review Stage
+                type: string
+              name:
+                description: Name of the Review Stage
+                type: string
+              reviewers:
+                description: Reviewers for the Review Stage
+                items:
+                  allOf:
+                  - $ref: '#/components/schemas/PartySummary'
+                  - properties:
+                      status:
+                        description: Status of the Reviewer
+                        enum:
+                        - BLOCKED
+                        - PENDING
+                        - FINISHED
+                        - REJECTED
+                        type: string
+                  type: object
+                type: array
+            type: object
+          type: array
+        type:
+          description: Type of the Review Process
+          enum:
+          - SELF_REVIEW
+          - SEQUENTIAL
+          - PARALLEL
+          type: string
+      type: object
     EntrySchema:
       description: Entry schema
       properties:
@@ -7811,6 +7881,12 @@ components:
               items:
                 $ref: '#/components/schemas/ReviewChange'
               type: array
+            reviewProcesses:
+              description: Review Processes associated with the Worksheet
+              items:
+                $ref: '#/components/schemas/EntryReviewProcess'
+              nullable: true
+              type: array
             status:
               description: Review Status of the worksheet
               enum:

{benchling_api_client-2.0.418.dist-info → benchling_api_client-2.0.419.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: benchling-api-client
-Version: 2.0.418
+Version: 2.0.419
 Summary: Autogenerated Python client from OpenAPI Python Client generator
 License: Apache-2.0
 Author: Benchling Support

{benchling_api_client-2.0.418.dist-info → benchling_api_client-2.0.419.dist-info}/RECORD

@@ -2343,13 +2343,20 @@ benchling_api_client/v2/beta/models/entity_worklist_items_list.py,sha256=R_3RP7w
 benchling_api_client/v2/beta/models/entity_worklist_items_list_type.py,sha256=Ihceu0Zjic5suYDEeKwKg5ttpXxnMrQEAdyAAgdUAXE,704
 benchling_api_client/v2/beta/models/entry.py,sha256=Z5FS0JWfZPvUT-B3h1F-yWM6tyk9PXoIGSfwXN2pRsI,24857
 benchling_api_client/v2/beta/models/entry_beta.py,sha256=_ua70XEjvNb_c0VDT3xTDOitTrx_8nYbs2-fZnd8CRY,24917
-benchling_api_client/v2/beta/models/entry_beta_review_record.py,sha256=8UdDecwDTEqpYEIAM3sshtf5w0-YqZLHop5Lgc_bdTQ,5995
+benchling_api_client/v2/beta/models/entry_beta_review_record.py,sha256=2XneX28rIZXmqKYBxMkhGbIWYzXmSdPM-rmShRglfxw,8097
 benchling_api_client/v2/beta/models/entry_beta_review_record_status.py,sha256=W0WVVurVsa5OOoTttkrRpL9qqmQXu4uReN80Hwwtkyc,998
 benchling_api_client/v2/beta/models/entry_by_id.py,sha256=04gB63nxjElUWX7BT2rFZyGVwzQ8VrEdnNcGx90P16A,3612
 benchling_api_client/v2/beta/models/entry_day.py,sha256=VHSjOoQw6sDNTvNqg031Ztm-Xq9391hmQWfX8LXbkxw,24013
 benchling_api_client/v2/beta/models/entry_link.py,sha256=teGLDCAPMIUcNEbQj2dbUfQcUFwvMBAJiK63vGrDc4M,5491
 benchling_api_client/v2/beta/models/entry_link_type.py,sha256=vnFWrven1Lzf2Xf2Jd1-65pfPOqcEwwMS_qjne6XHSs,1086
 benchling_api_client/v2/beta/models/entry_note_part.py,sha256=DAqEJWsC1XVzNP7B5Dpu7vXcrrjEClhU4mrQNyGMkMI,1579
+benchling_api_client/v2/beta/models/entry_review_process.py,sha256=3pUFe93TnfhjxNdJce0DJgvPqiNqzpR-jPpP4YcQc2k,8292
+benchling_api_client/v2/beta/models/entry_review_process_completion_status.py,sha256=Af1_ViLOQeAVb0ZAtXFIgU-0GkbhTUokQ6VcIhgjDvI,911
+benchling_api_client/v2/beta/models/entry_review_process_stages_item.py,sha256=HGlpPrVro1EITFfAZXEdUpbbcrKl-hmuIxl7xtfaVAg,7105
+benchling_api_client/v2/beta/models/entry_review_process_stages_item_action_label.py,sha256=dnej89HqHv-r5hkxiS4W7txQaPZ264QCjcLqs0fTyLw,916
+benchling_api_client/v2/beta/models/entry_review_process_stages_item_reviewers_item.py,sha256=Bk-y32F7xZGzI9NyPqj4WNzc6l3uwFFyUlH9ziEqpwE,5942
+benchling_api_client/v2/beta/models/entry_review_process_stages_item_reviewers_item_status.py,sha256=Rc6u-QtB4uU270Lt6DdHX_NTvtlJFWUu1K2J1NgMDQ0,906
+benchling_api_client/v2/beta/models/entry_review_process_type.py,sha256=XazpF_uHQfOD35PgvgZaXj7wdUqk0P8h6ytL75j_7ok,739
 benchling_api_client/v2/beta/models/entry_review_record.py,sha256=xUuJMnJzXCQQXcvJWWooL3HpQdIycslAu3Kli_3Ssu0,4105
 benchling_api_client/v2/beta/models/entry_review_record_status.py,sha256=nUrlSL_NQL8e-9B-0ibCFOjZWcSz3_cqLhVcCkX_Oow,978
 benchling_api_client/v2/beta/models/entry_schema.py,sha256=gAf50BRfEd829cum77RHIk02MZ96vaBWmrKCQDSgfMI,4812
@@ -2540,9 +2547,9 @@ benchling_api_client/v2/beta/models/worklist_update.py,sha256=kR8yNfIgKPOpTTxe2k
 benchling_api_client/v2/beta/models/worklists_paginated_list.py,sha256=80I-eXYAiIRVjbDPsmJqWJl3RU8leXUL5dB5RY12V-A,3358
 benchling_api_client/v2/beta/models/worksheet_review_changes.py,sha256=0MmkysLeA0PiIiL8C-4mbAi7-4C1r1HNF_hYxOBH5fE,11863
 benchling_api_client/v2/beta/models/worksheet_review_changes_by_id.py,sha256=UgTNMq3Q_ZcIumMhd8irgQAZjXCFFQeE33b_WiiYgDU,3344
-benchling_api_client/v2/beta/models/worksheet_review_changes_review_record.py,sha256=vYjl1dskegWel0XUx2d0UEFhM5pQ_FKjGZNwKkYTHbQ,6202
+benchling_api_client/v2/beta/models/worksheet_review_changes_review_record.py,sha256=vNRKUQenUJu4yFa847RxaOn4J1BW8PulnioTFKrMexs,8308
 benchling_api_client/v2/beta/models/worksheet_review_changes_review_record_status.py,sha256=9VKJkUCQCFCdkJnV8-JLRQObhO0cTJf2ZeZnBIEyPFA,1093
-benchling_api_client/v2/beta/openapi.yaml,sha256=GtCoVuqUga3RUZsYE71c44Hphyjo6ClaxBexnouv8kI,249442
+benchling_api_client/v2/beta/openapi.yaml,sha256=BwgFmaHEqXX4Vz68aOg3hhVjoFbFlMh2ri1B0f1Tp08,251857
 benchling_api_client/v2/beta/types.py,sha256=nCpxtn44qMDpuS_jcdbjhJlZFvRrXEUEVEDN471GrH8,244
 benchling_api_client/v2/client.py,sha256=-6Yzio8p22BaTJ_BEInEoUzmh4afxXlwceNFtn1vBLc,2241
 benchling_api_client/v2/extensions.py,sha256=4TSjnmlUquvmBu8up1vPXutEInf-oXDSZ58ciyBW7_E,1996
@@ -4547,7 +4554,7 @@ benchling_api_client/webhooks/v0/stable/models/workflow_task_updated_status_webh
 benchling_api_client/webhooks/v0/stable/openapi.yaml,sha256=Gvlve51cLq7Ws8ll_8Nx-6SGXuYEb8TWCoWzfg_YGnA,39400
 benchling_api_client/webhooks/v0/stable/types.py,sha256=nCpxtn44qMDpuS_jcdbjhJlZFvRrXEUEVEDN471GrH8,244
 benchling_api_client/webhooks/v0/types.py,sha256=SkWwIlK-UbP10AeiC1VeIQ_1HwALN65zpQyXPc0qDFs,1169
-benchling_api_client-2.0.418.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-benchling_api_client-2.0.418.dist-info/METADATA,sha256=bOD2na8xmJHM4Rdi-vUCmroiIoOOxzRrpnK4chyXM40,1253
-benchling_api_client-2.0.418.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-benchling_api_client-2.0.418.dist-info/RECORD,,
+benchling_api_client-2.0.419.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+benchling_api_client-2.0.419.dist-info/METADATA,sha256=ud79u69aaD8kBmvql8GwDNwLOfjrE66PuwGul5WDSSY,1253
+benchling_api_client-2.0.419.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+benchling_api_client-2.0.419.dist-info/RECORD,,