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

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

@@ -3414,6 +3414,7 @@ components:
       enum:
       - ENTRY
       - ENTRY_TEMPLATE
+      - APP_HOME
       type: string
     BoxCreationTableNotePart:
       allOf:
@@ -5045,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:
@@ -5184,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:
@@ -7810,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/v2/stable/models/back_translate.py

@@ -4,7 +4,9 @@ import attr
 
 from ..extensions import NotPresentError
 from ..models.back_translate_gc_content import BackTranslateGcContent
+from ..models.back_translate_gc_content_range import BackTranslateGcContentRange
 from ..models.back_translate_hairpin_parameters import BackTranslateHairpinParameters
+from ..models.back_translate_method import BackTranslateMethod
 from ..models.reduced_pattern import ReducedPattern
 from ..types import UNSET, Unset
 
@@ -20,7 +22,9 @@ class BackTranslate:
     _avoided_cutsite_enzyme_ids: Union[Unset, List[str]] = UNSET
     _codon_usage_table_id: Union[Unset, str] = UNSET
     _gc_content: Union[Unset, BackTranslateGcContent] = BackTranslateGcContent.ANY
+    _gc_content_range: Union[Unset, BackTranslateGcContentRange] = UNSET
     _hairpin_parameters: Union[Unset, BackTranslateHairpinParameters] = UNSET
+    _method: Union[Unset, BackTranslateMethod] = BackTranslateMethod.MATCH_CODON_USAGE
     _reduced_patterns: Union[Unset, List[ReducedPattern]] = UNSET
     _schema_id: Union[Unset, str] = UNSET
     _should_deplete_uridine: Union[Unset, bool] = False
@@ -32,7 +36,9 @@ class BackTranslate:
         fields.append("avoided_cutsite_enzyme_ids={}".format(repr(self._avoided_cutsite_enzyme_ids)))
         fields.append("codon_usage_table_id={}".format(repr(self._codon_usage_table_id)))
         fields.append("gc_content={}".format(repr(self._gc_content)))
+        fields.append("gc_content_range={}".format(repr(self._gc_content_range)))
         fields.append("hairpin_parameters={}".format(repr(self._hairpin_parameters)))
+        fields.append("method={}".format(repr(self._method)))
         fields.append("reduced_patterns={}".format(repr(self._reduced_patterns)))
         fields.append("schema_id={}".format(repr(self._schema_id)))
         fields.append("should_deplete_uridine={}".format(repr(self._should_deplete_uridine)))
@@ -51,10 +57,18 @@ class BackTranslate:
         if not isinstance(self._gc_content, Unset):
             gc_content = self._gc_content.value
 
+        gc_content_range: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self._gc_content_range, Unset):
+            gc_content_range = self._gc_content_range.to_dict()
+
         hairpin_parameters: Union[Unset, Dict[str, Any]] = UNSET
         if not isinstance(self._hairpin_parameters, Unset):
             hairpin_parameters = self._hairpin_parameters.to_dict()
 
+        method: Union[Unset, int] = UNSET
+        if not isinstance(self._method, Unset):
+            method = self._method.value
+
         reduced_patterns: Union[Unset, List[Any]] = UNSET
         if not isinstance(self._reduced_patterns, Unset):
             reduced_patterns = []
@@ -78,8 +92,12 @@ class BackTranslate:
             field_dict["codonUsageTableId"] = codon_usage_table_id
         if gc_content is not UNSET:
             field_dict["gcContent"] = gc_content
+        if gc_content_range is not UNSET:
+            field_dict["gcContentRange"] = gc_content_range
         if hairpin_parameters is not UNSET:
             field_dict["hairpinParameters"] = hairpin_parameters
+        if method is not UNSET:
+            field_dict["method"] = method
         if reduced_patterns is not UNSET:
             field_dict["reducedPatterns"] = reduced_patterns
         if schema_id is not UNSET:
@@ -157,6 +175,22 @@ class BackTranslate:
                 raise
             gc_content = cast(Union[Unset, BackTranslateGcContent], UNSET)
 
+        def get_gc_content_range() -> Union[Unset, BackTranslateGcContentRange]:
+            gc_content_range: Union[Unset, Union[Unset, BackTranslateGcContentRange]] = UNSET
+            _gc_content_range = d.pop("gcContentRange")
+
+            if not isinstance(_gc_content_range, Unset):
+                gc_content_range = BackTranslateGcContentRange.from_dict(_gc_content_range)
+
+            return gc_content_range
+
+        try:
+            gc_content_range = get_gc_content_range()
+        except KeyError:
+            if strict:
+                raise
+            gc_content_range = cast(Union[Unset, BackTranslateGcContentRange], UNSET)
+
         def get_hairpin_parameters() -> Union[Unset, BackTranslateHairpinParameters]:
             hairpin_parameters: Union[Unset, Union[Unset, BackTranslateHairpinParameters]] = UNSET
             _hairpin_parameters = d.pop("hairpinParameters")
@@ -173,6 +207,24 @@ class BackTranslate:
                 raise
             hairpin_parameters = cast(Union[Unset, BackTranslateHairpinParameters], UNSET)
 
+        def get_method() -> Union[Unset, BackTranslateMethod]:
+            method = UNSET
+            _method = d.pop("method")
+            if _method is not None and _method is not UNSET:
+                try:
+                    method = BackTranslateMethod(_method)
+                except ValueError:
+                    method = BackTranslateMethod.of_unknown(_method)
+
+            return method
+
+        try:
+            method = get_method()
+        except KeyError:
+            if strict:
+                raise
+            method = cast(Union[Unset, BackTranslateMethod], UNSET)
+
         def get_reduced_patterns() -> Union[Unset, List[ReducedPattern]]:
             reduced_patterns = []
             _reduced_patterns = d.pop("reducedPatterns")
@@ -218,7 +270,9 @@ class BackTranslate:
             avoided_cutsite_enzyme_ids=avoided_cutsite_enzyme_ids,
             codon_usage_table_id=codon_usage_table_id,
             gc_content=gc_content,
+            gc_content_range=gc_content_range,
             hairpin_parameters=hairpin_parameters,
+            method=method,
             reduced_patterns=reduced_patterns,
             schema_id=schema_id,
             should_deplete_uridine=should_deplete_uridine,
@@ -280,7 +334,7 @@ class BackTranslate:
 
     @property
     def gc_content(self) -> BackTranslateGcContent:
-        """The amount of GC content in the back-translated sequence. If not specified, the back-translation will default to ANY (0-1). LOW is defined as below 0.33, MEDIUM as 0.33-0.66, and HIGH as above 0.66."""
+        """The amount of GC content in the optimized sequence. LOW is defined as below 0.33, MEDIUM as 0.33-0.66, and HIGH as above 0.66. If neither gcContent nor gcContentRange is specified, the optimization will default to ANY (0-1). Cannot be specified together with gcContentRange."""
         if isinstance(self._gc_content, Unset):
             raise NotPresentError(self, "gc_content")
         return self._gc_content
@@ -293,6 +347,21 @@ class BackTranslate:
     def gc_content(self) -> None:
         self._gc_content = UNSET
 
+    @property
+    def gc_content_range(self) -> BackTranslateGcContentRange:
+        """Custom GC content range for the optimized sequence, specified as decimal values between 0 and 1. The maximum must be greater than the minimum. Cannot be specified together with gcContent."""
+        if isinstance(self._gc_content_range, Unset):
+            raise NotPresentError(self, "gc_content_range")
+        return self._gc_content_range
+
+    @gc_content_range.setter
+    def gc_content_range(self, value: BackTranslateGcContentRange) -> None:
+        self._gc_content_range = value
+
+    @gc_content_range.deleter
+    def gc_content_range(self) -> None:
+        self._gc_content_range = UNSET
+
     @property
     def hairpin_parameters(self) -> BackTranslateHairpinParameters:
         """These parameters are applied in the AvoidHairpins specification in DNAChisel. If hairpinParameters is not specified, hairpins will not be avoided."""
@@ -308,6 +377,21 @@ class BackTranslate:
     def hairpin_parameters(self) -> None:
         self._hairpin_parameters = UNSET
 
+    @property
+    def method(self) -> BackTranslateMethod:
+        """The codon optimization algorithm to use. Requires codonUsageTableId to be specified. MATCH_CODON_USAGE selects codons probabilistically based on the organism's codon usage frequencies. USE_BEST_CODON always selects the most frequently used codon for each amino acid."""
+        if isinstance(self._method, Unset):
+            raise NotPresentError(self, "method")
+        return self._method
+
+    @method.setter
+    def method(self, value: BackTranslateMethod) -> None:
+        self._method = value
+
+    @method.deleter
+    def method(self) -> None:
+        self._method = UNSET
+
     @property
     def reduced_patterns(self) -> List[ReducedPattern]:
         """List of patterns to avoid when creating the back-translated sequence, on the coding strand only."""