benchling-api-client 2.0.416__py3-none-any.whl → 2.0.418__py3-none-any.whl

benchling_api_client/v2/beta/openapi.yaml

@@ -2839,7 +2839,7 @@ components:
           description: The path of the web URL, omitting the tenant domain
           type: string
         webURL:
-          description: URL of the protein.
+          description: URL of the AA sequence.
           example: https://benchling.com/benchling/f/lib_55UxcIps-registry/prtn_7nMBOMm0-kedchain11/edit"
           format: uri
           readOnly: true
@@ -3414,6 +3414,7 @@ components:
       enum:
       - ENTRY
       - ENTRY_TEMPLATE
+      - APP_HOME
       type: string
     BoxCreationTableNotePart:
       allOf:
@@ -7894,8 +7895,8 @@ tags:
     assigned to access an item.
   name: Collaborations
 - description: 'Benchling supports custom entities for biological entities that are
-    neither sequences or proteins. Custom entities must have an entity schema set
-    and can have both schema fields and custom fields.
+    neither DNA, RNA, nor AA sequences. Custom entities must have an entity schema
+    set and can have both schema fields and custom fields.
 
     '
   name: Custom Entities

benchling_api_client/v2/stable/models/aa_sequence.py

@@ -809,7 +809,7 @@ class AaSequence:
 
     @property
     def web_url(self) -> str:
-        """ URL of the protein. """
+        """ URL of the AA sequence. """
         if isinstance(self._web_url, Unset):
             raise NotPresentError(self, "web_url")
         return self._web_url

benchling_api_client/v2/stable/models/aa_sequence_with_entity_type.py

@@ -851,7 +851,7 @@ class AaSequenceWithEntityType:
 
     @property
     def web_url(self) -> str:
-        """ URL of the protein. """
+        """ URL of the AA sequence. """
         if isinstance(self._web_url, Unset):
             raise NotPresentError(self, "web_url")
         return self._web_url

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."""

benchling_api_client/v2/stable/models/back_translate_gc_content_range.py

@@ -0,0 +1,98 @@
+from typing import Any, cast, Dict, Type, TypeVar, Union
+
+import attr
+
+from ..extensions import NotPresentError
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="BackTranslateGcContentRange")
+
+
+@attr.s(auto_attribs=True, repr=False)
+class 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."""
+
+    _max: Union[Unset, float] = UNSET
+    _min: Union[Unset, float] = UNSET
+
+    def __repr__(self):
+        fields = []
+        fields.append("max={}".format(repr(self._max)))
+        fields.append("min={}".format(repr(self._min)))
+        return "BackTranslateGcContentRange({})".format(", ".join(fields))
+
+    def to_dict(self) -> Dict[str, Any]:
+        max = self._max
+        min = self._min
+
+        field_dict: Dict[str, Any] = {}
+        # Allow the model to serialize even if it was created outside of the constructor, circumventing validation
+        if max is not UNSET:
+            field_dict["max"] = max
+        if min is not UNSET:
+            field_dict["min"] = min
+
+        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_max() -> Union[Unset, float]:
+            max = d.pop("max")
+            return max
+
+        try:
+            max = get_max()
+        except KeyError:
+            if strict:
+                raise
+            max = cast(Union[Unset, float], UNSET)
+
+        def get_min() -> Union[Unset, float]:
+            min = d.pop("min")
+            return min
+
+        try:
+            min = get_min()
+        except KeyError:
+            if strict:
+                raise
+            min = cast(Union[Unset, float], UNSET)
+
+        back_translate_gc_content_range = cls(
+            max=max,
+            min=min,
+        )
+
+        return back_translate_gc_content_range
+
+    @property
+    def max(self) -> float:
+        """ Maximum GC content ratio (e.g., 0.6 for 60%) """
+        if isinstance(self._max, Unset):
+            raise NotPresentError(self, "max")
+        return self._max
+
+    @max.setter
+    def max(self, value: float) -> None:
+        self._max = value
+
+    @max.deleter
+    def max(self) -> None:
+        self._max = UNSET
+
+    @property
+    def min(self) -> float:
+        """ Minimum GC content ratio (e.g., 0.4 for 40%) """
+        if isinstance(self._min, Unset):
+            raise NotPresentError(self, "min")
+        return self._min
+
+    @min.setter
+    def min(self, value: float) -> None:
+        self._min = value
+
+    @min.deleter
+    def min(self) -> None:
+        self._min = UNSET

benchling_api_client/v2/stable/models/back_translate_method.py

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

benchling_api_client/v2/stable/models/optimize_codons.py

@@ -4,7 +4,9 @@ import attr
 
 from ..extensions import NotPresentError
 from ..models.optimize_codons_gc_content import OptimizeCodonsGcContent
+from ..models.optimize_codons_gc_content_range import OptimizeCodonsGcContentRange
 from ..models.optimize_codons_hairpin_parameters import OptimizeCodonsHairpinParameters
+from ..models.optimize_codons_method import OptimizeCodonsMethod
 from ..models.reduced_pattern import ReducedPattern
 from ..types import UNSET, Unset
 
@@ -20,7 +22,9 @@ class OptimizeCodons:
     _avoided_cutsite_enzyme_ids: Union[Unset, List[str]] = UNSET
     _codon_usage_table_id: Union[Unset, str] = UNSET
     _gc_content: Union[Unset, OptimizeCodonsGcContent] = OptimizeCodonsGcContent.ANY
+    _gc_content_range: Union[Unset, OptimizeCodonsGcContentRange] = UNSET
     _hairpin_parameters: Union[Unset, OptimizeCodonsHairpinParameters] = UNSET
+    _method: Union[Unset, OptimizeCodonsMethod] = OptimizeCodonsMethod.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 OptimizeCodons:
         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 OptimizeCodons:
         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 OptimizeCodons:
             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 OptimizeCodons:
                 raise
             gc_content = cast(Union[Unset, OptimizeCodonsGcContent], UNSET)
 
+        def get_gc_content_range() -> Union[Unset, OptimizeCodonsGcContentRange]:
+            gc_content_range: Union[Unset, Union[Unset, OptimizeCodonsGcContentRange]] = UNSET
+            _gc_content_range = d.pop("gcContentRange")
+
+            if not isinstance(_gc_content_range, Unset):
+                gc_content_range = OptimizeCodonsGcContentRange.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, OptimizeCodonsGcContentRange], UNSET)
+
         def get_hairpin_parameters() -> Union[Unset, OptimizeCodonsHairpinParameters]:
             hairpin_parameters: Union[Unset, Union[Unset, OptimizeCodonsHairpinParameters]] = UNSET
             _hairpin_parameters = d.pop("hairpinParameters")
@@ -173,6 +207,24 @@ class OptimizeCodons:
                 raise
             hairpin_parameters = cast(Union[Unset, OptimizeCodonsHairpinParameters], UNSET)
 
+        def get_method() -> Union[Unset, OptimizeCodonsMethod]:
+            method = UNSET
+            _method = d.pop("method")
+            if _method is not None and _method is not UNSET:
+                try:
+                    method = OptimizeCodonsMethod(_method)
+                except ValueError:
+                    method = OptimizeCodonsMethod.of_unknown(_method)
+
+            return method
+
+        try:
+            method = get_method()
+        except KeyError:
+            if strict:
+                raise
+            method = cast(Union[Unset, OptimizeCodonsMethod], UNSET)
+
         def get_reduced_patterns() -> Union[Unset, List[ReducedPattern]]:
             reduced_patterns = []
             _reduced_patterns = d.pop("reducedPatterns")
@@ -218,7 +270,9 @@ class OptimizeCodons:
             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 OptimizeCodons:
 
     @property
     def gc_content(self) -> OptimizeCodonsGcContent:
-        """The amount of GC content in the optimized sequence. If not specified, the optimization 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 OptimizeCodons:
     def gc_content(self) -> None:
         self._gc_content = UNSET
 
+    @property
+    def gc_content_range(self) -> OptimizeCodonsGcContentRange:
+        """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: OptimizeCodonsGcContentRange) -> 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) -> OptimizeCodonsHairpinParameters:
         """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 OptimizeCodons:
     def hairpin_parameters(self) -> None:
         self._hairpin_parameters = UNSET
 
+    @property
+    def method(self) -> OptimizeCodonsMethod:
+        """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: OptimizeCodonsMethod) -> 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 optimized sequence, on the coding strand only."""

benchling_api_client/v2/stable/models/optimize_codons_gc_content_range.py

@@ -0,0 +1,98 @@
+from typing import Any, cast, Dict, Type, TypeVar, Union
+
+import attr
+
+from ..extensions import NotPresentError
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="OptimizeCodonsGcContentRange")
+
+
+@attr.s(auto_attribs=True, repr=False)
+class OptimizeCodonsGcContentRange:
+    """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."""
+
+    _max: Union[Unset, float] = UNSET
+    _min: Union[Unset, float] = UNSET
+
+    def __repr__(self):
+        fields = []
+        fields.append("max={}".format(repr(self._max)))
+        fields.append("min={}".format(repr(self._min)))
+        return "OptimizeCodonsGcContentRange({})".format(", ".join(fields))
+
+    def to_dict(self) -> Dict[str, Any]:
+        max = self._max
+        min = self._min
+
+        field_dict: Dict[str, Any] = {}
+        # Allow the model to serialize even if it was created outside of the constructor, circumventing validation
+        if max is not UNSET:
+            field_dict["max"] = max
+        if min is not UNSET:
+            field_dict["min"] = min
+
+        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_max() -> Union[Unset, float]:
+            max = d.pop("max")
+            return max
+
+        try:
+            max = get_max()
+        except KeyError:
+            if strict:
+                raise
+            max = cast(Union[Unset, float], UNSET)
+
+        def get_min() -> Union[Unset, float]:
+            min = d.pop("min")
+            return min
+
+        try:
+            min = get_min()
+        except KeyError:
+            if strict:
+                raise
+            min = cast(Union[Unset, float], UNSET)
+
+        optimize_codons_gc_content_range = cls(
+            max=max,
+            min=min,
+        )
+
+        return optimize_codons_gc_content_range
+
+    @property
+    def max(self) -> float:
+        """ Maximum GC content ratio (e.g., 0.6 for 60%) """
+        if isinstance(self._max, Unset):
+            raise NotPresentError(self, "max")
+        return self._max
+
+    @max.setter
+    def max(self, value: float) -> None:
+        self._max = value
+
+    @max.deleter
+    def max(self) -> None:
+        self._max = UNSET
+
+    @property
+    def min(self) -> float:
+        """ Minimum GC content ratio (e.g., 0.4 for 40%) """
+        if isinstance(self._min, Unset):
+            raise NotPresentError(self, "min")
+        return self._min
+
+    @min.setter
+    def min(self, value: float) -> None:
+        self._min = value
+
+    @min.deleter
+    def min(self) -> None:
+        self._min = UNSET

benchling_api_client/v2/stable/models/optimize_codons_method.py

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

benchling_api_client/v2/stable/models/reduced_pattern.py

@@ -10,7 +10,9 @@ T = TypeVar("T", bound="ReducedPattern")
 
 @attr.s(auto_attribs=True, repr=False)
 class ReducedPattern:
-    """Patterns must consist of ATGC bases only, and are case-insensitive ("gat" will reduce usage of "GAT"). If avoidReverseComplement is true, then the pattern's reverse complement will also be avoided."""
+    """DNA patterns to avoid during optimization. Supports two formats: 1) DNA base patterns: strings of ATGC bases (case-insensitive, e.g., "ATGC" or "gat") 2) Repeat patterns: format "nxkmer" specifying n repeats of k-sized sequences (e.g., "3x4mer" matches 3 consecutive 4-base repeats). Maximum total length for repeat patterns is 50 bases (n * k ≤ 50).
+    If avoidReverseComplement is true, the pattern's reverse complement will also be avoided. Note: avoidReverseComplement cannot be true for repeat patterns (nxkmer format).
+    """
 
     _avoid_reverse_complement: Union[Unset, bool] = False
     _pattern: Union[Unset, str] = UNSET