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

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

benchling_api_client/v2/stable/openapi.yaml

@@ -23669,9 +23669,10 @@ components:
           type: string
         gcContent:
           default: ANY
-          description: '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.
+          description: '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.
 
             '
           enum:
@@ -23680,6 +23681,25 @@ components:
           - MEDIUM
           - HIGH
           type: string
+        gcContentRange:
+          additionalProperties: false
+          description: '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.
+
+            '
+          properties:
+            max:
+              description: Maximum GC content ratio (e.g., 0.6 for 60%)
+              maximum: 1
+              minimum: 0
+              type: number
+            min:
+              description: Minimum GC content ratio (e.g., 0.4 for 40%)
+              maximum: 1
+              minimum: 0
+              type: number
+          type: object
         hairpinParameters:
           additionalProperties: false
           description: 'These parameters are applied in the AvoidHairpins specification
@@ -23695,6 +23715,18 @@ components:
               default: 200
               type: integer
           type: object
+        method:
+          default: MATCH_CODON_USAGE
+          description: '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.
+
+            '
+          enum:
+          - MATCH_CODON_USAGE
+          - USE_BEST_CODON
+          type: string
         reducedPatterns:
           description: 'List of patterns to avoid when creating the back-translated
             sequence, on the coding strand only.
@@ -31383,9 +31415,10 @@ components:
           type: string
         gcContent:
           default: ANY
-          description: '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.
+          description: '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.
 
             '
           enum:
@@ -31394,6 +31427,25 @@ components:
           - MEDIUM
           - HIGH
           type: string
+        gcContentRange:
+          additionalProperties: false
+          description: '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.
+
+            '
+          properties:
+            max:
+              description: Maximum GC content ratio (e.g., 0.6 for 60%)
+              maximum: 1
+              minimum: 0
+              type: number
+            min:
+              description: Minimum GC content ratio (e.g., 0.4 for 40%)
+              maximum: 1
+              minimum: 0
+              type: number
+          type: object
         hairpinParameters:
           additionalProperties: false
           description: 'These parameters are applied in the AvoidHairpins specification
@@ -31409,6 +31461,18 @@ components:
               default: 200
               type: integer
           type: object
+        method:
+          default: MATCH_CODON_USAGE
+          description: '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.
+
+            '
+          enum:
+          - MATCH_CODON_USAGE
+          - USE_BEST_CODON
+          type: string
         reducedPatterns:
           description: 'List of patterns to avoid when creating the optimized sequence,
             on the coding strand only.
@@ -31924,11 +31988,14 @@ components:
       type: object
     ReducedPattern:
       additionalProperties: false
-      description: '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.
-
-        '
+      description: "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 \u2264 50).\n\
+        If avoidReverseComplement is true, the pattern's reverse complement will also\
+        \ be avoided. Note: avoidReverseComplement cannot be true for repeat patterns\
+        \ (nxkmer format).\n"
       properties:
         avoidReverseComplement:
           default: false

{benchling_api_client-2.0.417.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.417
+Version: 2.0.419
 Summary: Autogenerated Python client from OpenAPI Python Client generator
 License: Apache-2.0
 Author: Benchling Support