benchling-sdk 1.10.0a4__py3-none-any.whl → 1.10.0a6__py3-none-any.whl

benchling_sdk/apps/canvas/framework.py

@@ -8,12 +8,11 @@ from benchling_sdk.apps.canvas.errors import DuplicateBlockIdError, NoMatchingBl
 from benchling_sdk.apps.canvas.types import (
     _UI_BLOCK_MAPPINGS_CREATE,
     _UI_BLOCK_MAPPINGS_UPDATE,
-    _UiBlock,
     _UiBlockCreate,
-    _UiBlockType,
     _UiBlockUpdate,
+    UiBlock,
+    UiBlockType,
 )
-from benchling_sdk.helpers.logging_helpers import log_stability_warning, StabilityLevel
 from benchling_sdk.models import (
     AppCanvas,
     AppCanvasApp,
@@ -30,12 +29,10 @@ from benchling_sdk.models import (
     TextInputUiBlock,
 )
 
-log_stability_warning(StabilityLevel.BETA)
+S = TypeVar("S", bound="FilteredCanvasBuilderBlockStream")
 
-S = TypeVar("S", bound="_FilteredCanvasBuilderBlockStream")
 
-
-def _ui_block_to_create(block: _UiBlock) -> _UiBlockCreate:
+def _ui_block_to_create(block: UiBlock) -> _UiBlockCreate:
     # Rely on the fact that the read/write shapes are compatible, for now
     if isinstance(block, UnknownType):
         return block
@@ -49,7 +46,7 @@ def _ui_block_to_create(block: _UiBlock) -> _UiBlockCreate:
     return block  # type: ignore
 
 
-def _ui_block_to_update(block: _UiBlock) -> _UiBlockUpdate:
+def _ui_block_to_update(block: UiBlock) -> _UiBlockUpdate:
     # Rely on the fact that the read/write shapes are compatible, for now
     # Update is functionally the same as create at the moment but different for type safety
     # and reserved in case the shapes do diverge later
@@ -65,28 +62,27 @@ def _ui_block_to_update(block: _UiBlock) -> _UiBlockUpdate:
     return block  # type: ignore
 
 
-class _CanvasBuilderUiBlock(Generic[_UiBlockType]):
+class CanvasBuilderUiBlock(Generic[UiBlockType]):
     """Internal UI block wrapper for CanvasBuilder."""
 
-    _block: _UiBlockType
+    _block: UiBlockType
     _builder: CanvasBuilder
 
-    def __init__(self, block: _UiBlockType, builder: CanvasBuilder):
+    def __init__(self, block: UiBlockType, builder: CanvasBuilder):
+        """Init CanvasBuilderUiBlock."""
         self._block = block
         self._builder = builder
 
     @classmethod
-    def from_api_model(
-        cls, block: _UiBlockType, builder: CanvasBuilder
-    ) -> _CanvasBuilderUiBlock[_UiBlockType]:
+    def from_api_model(cls, block: UiBlockType, builder: CanvasBuilder) -> CanvasBuilderUiBlock[UiBlockType]:
         """Create a _CanvasBuilderUiBlock from an underlying API model."""
         return cls(block, builder)
 
-    def to_api_model(self) -> _UiBlockType:
+    def to_api_model(self) -> UiBlockType:
         """Convert to the underlying API model."""
         return self._block
 
-    def children(self) -> _CanvasBuilderBlockStream:
+    def children(self) -> CanvasBuilderBlockStream:
         """
         Return children for blocks when applicable, such as for section blocks.
 
@@ -97,16 +93,16 @@ class _CanvasBuilderUiBlock(Generic[_UiBlockType]):
             # MyPy can't recognize the type narrowing when we check .children below
             section_block = cast(SectionUiBlock, model)
             child_blocks = [
-                _CanvasBuilderUiBlock.from_api_model(block, self._builder) for block in section_block.children
+                CanvasBuilderUiBlock.from_api_model(block, self._builder) for block in section_block.children
             ]
             # Pass reference to parent block (self)
-            return _CanvasBuilderBlockStream(self._builder, child_blocks, child_blocks, self)
-        return _CanvasBuilderBlockStream(self._builder, [], [])
+            return CanvasBuilderBlockStream(self._builder, child_blocks, child_blocks, self)
+        return CanvasBuilderBlockStream(self._builder, [], [])
 
-    def replace(self, new_blocks: List[_UiBlock]) -> None:
+    def replace(self, new_blocks: List[UiBlock]) -> None:
         """Replace block with provided new_blocks."""
         parent = self._parent_block()
-        model = cast(_UiBlock, self.to_api_model())
+        model = cast(UiBlock, self.to_api_model())
         if parent:
             self.insert_after(new_blocks)
             # Keeps MyPy happy; SectionUiBlock is not valid for .children of SectionUiBlock
@@ -120,7 +116,7 @@ class _CanvasBuilderUiBlock(Generic[_UiBlockType]):
     def remove(self) -> None:
         """Remove block."""
         parent = self._parent_block()
-        model = cast(_UiBlock, self.to_api_model())
+        model = cast(UiBlock, self.to_api_model())
         if parent:
             # Keeps MyPy happy; SectionUiBlock is not valid for .children of SectionUiBlock
             assert not (isinstance(model, SectionUiBlock) or isinstance(model, TableUiBlock))
@@ -129,15 +125,15 @@ class _CanvasBuilderUiBlock(Generic[_UiBlockType]):
             # noinspection PyProtectedMember
             self._builder._source_canvas.blocks.remove(model)
 
-    def insert_after(self, new_blocks: List[_UiBlock]) -> None:
+    def insert_after(self, new_blocks: List[UiBlock]) -> None:
         """Insert new_blocks after block."""
         self._nested_insert(new_blocks, 1)
 
-    def insert_before(self, new_blocks: List[_UiBlock]) -> None:
+    def insert_before(self, new_blocks: List[UiBlock]) -> None:
         """Insert new_blocks before block."""
         self._nested_insert(new_blocks, 0)
 
-    def _nested_insert(self, new_blocks: List[_UiBlock], offset: int) -> None:
+    def _nested_insert(self, new_blocks: List[UiBlock], offset: int) -> None:
         """
         Nested insert.
 
@@ -152,7 +148,7 @@ class _CanvasBuilderUiBlock(Generic[_UiBlockType]):
             # Using list() to solve "List" is invariant creates a copy which means this stops working
             self._insert(new_blocks, offset, child_blocks, self.to_api_model())  # type: ignore
             parent_block.children = child_blocks
-            parent_builder_block = _CanvasBuilderUiBlock.from_api_model(parent_block, self._builder)
+            parent_builder_block = CanvasBuilderUiBlock.from_api_model(parent_block, self._builder)
             parent_builder_block.insert_after([parent_block])
             # noinspection PyProtectedMember
             self._builder._source_canvas.blocks.remove(parent_builder_block.to_api_model())
@@ -161,9 +157,7 @@ class _CanvasBuilderUiBlock(Generic[_UiBlockType]):
             self._insert(new_blocks, offset, self._builder._source_canvas.blocks, self.to_api_model())
 
     @staticmethod
-    def _insert(
-        new_blocks: List[_UiBlock], offset: int, blocks: List[_UiBlock], target_block: _UiBlock
-    ) -> None:
+    def _insert(new_blocks: List[UiBlock], offset: int, blocks: List[UiBlock], target_block: UiBlock) -> None:
         """Insert new_blocks before block as a side effect."""
         index = blocks.index(target_block)
         for count, new_block in enumerate(new_blocks):
@@ -178,26 +172,29 @@ class _CanvasBuilderUiBlock(Generic[_UiBlockType]):
         return None
 
 
-class _CanvasBuilderFilter(Protocol):
-    def __call__(self, block: _UiBlockType) -> bool:
+class CanvasBuilderFilter(Protocol):
+    """Callable protocol for specifying a predicate for filtering UiBlocks."""
+
+    def __call__(self, block: UiBlockType) -> bool:
         """Return True if the UiBlock matches specified conditions."""
         pass
 
 
-class _FilteredCanvasBuilderBlockStream:
-    """Internal Filtered UI block list wrapper for CanvasBuilder."""
+class FilteredCanvasBuilderBlockStream:
+    """Filtered UI block list wrapper for CanvasBuilder."""
 
     _builder: CanvasBuilder
-    _blocks: List[_CanvasBuilderUiBlock]
-    _selected_blocks: List[_CanvasBuilderUiBlock]
+    _blocks: List[CanvasBuilderUiBlock]
+    _selected_blocks: List[CanvasBuilderUiBlock]
     _cursor: int
 
     def __init__(
         self,
         builder: CanvasBuilder,
-        blocks: List[_CanvasBuilderUiBlock],
-        selected_blocks: List[_CanvasBuilderUiBlock],
+        blocks: List[CanvasBuilderUiBlock],
+        selected_blocks: List[CanvasBuilderUiBlock],
     ):
+        """Init FilteredCanvasBuilderBlockStream."""
         self._builder = builder
         self._blocks = blocks
         self._selected_blocks = selected_blocks
@@ -222,26 +219,26 @@ class _FilteredCanvasBuilderBlockStream:
         """
         # noinspection PyProtectedMember
         blocks = [
-            _CanvasBuilderUiBlock.from_api_model(block, builder)
+            CanvasBuilderUiBlock.from_api_model(block, builder)
             for block in builder._source_canvas.blocks
             if not isinstance(block, UnknownType)
         ]
         return cls(builder, blocks, blocks)
 
-    def filter(self, filter_function: _CanvasBuilderFilter) -> _FilteredCanvasBuilderBlockStream:
+    def filter(self, filter_function: CanvasBuilderFilter) -> FilteredCanvasBuilderBlockStream:
         """
         Filter.
 
         Accept a predicate that evaluates if a UiBlock should be included in the result or not.
         Returns a new stream of blocks filtered to the predicate, which is further operable.
         """
-        return _CanvasBuilderBlockStream(
+        return CanvasBuilderBlockStream(
             self._builder,
             self._blocks,
             [block for block in self._selected_blocks if filter_function(block.to_api_model())],
         )
 
-    def get_by_id(self, block_id: str) -> _CanvasBuilderUiBlock:
+    def get_by_id(self, block_id: str) -> CanvasBuilderUiBlock:
         """
         Get a block by its id.
 
@@ -253,8 +250,8 @@ class _FilteredCanvasBuilderBlockStream:
         return matched_block
 
     def _block_by_id(
-        self, block_id: str, blocks: List[_CanvasBuilderUiBlock]
-    ) -> Optional[_CanvasBuilderUiBlock]:
+        self, block_id: str, blocks: List[CanvasBuilderUiBlock]
+    ) -> Optional[CanvasBuilderUiBlock]:
         for block in blocks:
             api_block = block.to_api_model()
             if api_block.id == block_id:
@@ -270,13 +267,13 @@ class _FilteredCanvasBuilderBlockStream:
         """Return a count of the elements in the list of blocks."""
         return len(self._selected_blocks)
 
-    def first(self) -> _CanvasBuilderUiBlock:
+    def first(self) -> CanvasBuilderUiBlock:
         """Return the first block in the list."""
         if len(self._selected_blocks) < 1:
             raise NoMatchingBlocksError
         return self._selected_blocks[0]
 
-    def last(self) -> _CanvasBuilderUiBlock:
+    def last(self) -> CanvasBuilderUiBlock:
         """Return the last block in the list."""
         if len(self._selected_blocks) < 1:
             raise NoMatchingBlocksError
@@ -291,26 +288,27 @@ class _FilteredCanvasBuilderBlockStream:
         self._builder._source_canvas.blocks = updated_blocks
 
 
-class _CanvasBuilderBlockStream(_FilteredCanvasBuilderBlockStream):
+class CanvasBuilderBlockStream(FilteredCanvasBuilderBlockStream):
     """
     Internal UI block list wrapper for CanvasBuilder.
 
     Possesses some additional operations unavailable to filtered block streams.
     """
 
-    _parent: Optional[_CanvasBuilderUiBlock]
+    _parent: Optional[CanvasBuilderUiBlock]
 
     def __init__(
         self,
         builder: CanvasBuilder,
-        blocks: List[_CanvasBuilderUiBlock],
-        selected_blocks: List[_CanvasBuilderUiBlock],
-        parent: Optional[_CanvasBuilderUiBlock] = None,
+        blocks: List[CanvasBuilderUiBlock],
+        selected_blocks: List[CanvasBuilderUiBlock],
+        parent: Optional[CanvasBuilderUiBlock] = None,
     ):
+        """Init CanvasBuilderBlockStream."""
         super().__init__(builder, blocks, selected_blocks)
         self._parent = parent
 
-    def append(self, new_blocks: List[_UiBlock]) -> None:
+    def append(self, new_blocks: List[UiBlock]) -> None:
         """
         Append new_blocks to the end of list of blocks.
 
@@ -367,7 +365,7 @@ class CanvasBuilder:
         resource_id: str,
         enabled: bool = True,
         session_id: Optional[str] = None,
-        blocks: Optional[List[_UiBlock]] = None,
+        blocks: Optional[List[UiBlock]] = None,
     ):
         """
         Init AppCanvas.
@@ -410,25 +408,33 @@ class CanvasBuilder:
             blocks=self._source_canvas.blocks,
         )
 
-    def with_disabled(self) -> CanvasBuilder:
+    def with_enabled(self, enabled: bool = True) -> CanvasBuilder:
         """
-        Return a new CanvasBuilder with the underlying canvas disabled.
+        Return a new CanvasBuilder with the underlying canvas enabled set to the specified value.
 
+        Specify `False` to disable the canvas.
         This does not call the API, it only assigns state in the CanvasBuilder.
         """
-        return self._with_enabled(False)
+        return self._with_enabled(enabled)
 
-    def with_enabled(self) -> CanvasBuilder:
+    def with_blocks(self, new_blocks: List[UiBlock]) -> CanvasBuilder:
         """
-        Return a new CanvasBuilder with the underlying canvas enabled.
+        Return a new CanvasBuilder with the underlying blocks replaced.
 
         This does not call the API, it only assigns state in the CanvasBuilder.
         """
-        return self._with_enabled(True)
+        return CanvasBuilder(
+            app_id=self._source_canvas.app.id,
+            feature_id=self._source_canvas.feature_id,
+            resource_id=self._source_canvas.resource_id,
+            enabled=self._source_canvas.enabled,
+            session_id=self._source_canvas.session_id,
+            blocks=new_blocks,
+        )
 
-    def with_blocks(self, new_blocks: List[_UiBlock]) -> CanvasBuilder:
+    def with_session_id(self, session_id: Optional[str]) -> CanvasBuilder:
         """
-        Return a new CanvasBuilder with the underlying blocks replaced.
+        Return a new CanvasBuilder with an optional session_id set.
 
         This does not call the API, it only assigns state in the CanvasBuilder.
         """
@@ -437,8 +443,8 @@ class CanvasBuilder:
             feature_id=self._source_canvas.feature_id,
             resource_id=self._source_canvas.resource_id,
             enabled=self._source_canvas.enabled,
-            session_id=self._source_canvas.session_id,
-            blocks=new_blocks,
+            session_id=session_id,
+            blocks=self._source_canvas.blocks,
         )
 
     def inputs_to_dict(self) -> Dict[str, Union[str, List[str]]]:
@@ -503,7 +509,7 @@ class CanvasBuilder:
 
     def inputs_to_dict_multi_value(self) -> Dict[str, List[str]]:
         """
-        Read Inputs to dict, but only for multi-valued blocks.
+        Read Inputs to dict, but only for multivalued blocks.
 
         Return a dictionary of {block_id: block_value} for all blocks on the canvas with multivalued input values.
         Blocks that only have read attributes are omitted. Excludes TableUiBlock.
@@ -529,9 +535,9 @@ class CanvasBuilder:
 
     def _values_from_blocks(
         self,
-        blocks: List[_UiBlock],
+        blocks: List[UiBlock],
         existing_keys: Optional[List[str]] = None,
-        included_classes: Optional[Set[Type[_UiBlock]]] = None,
+        included_classes: Optional[Set[Type[UiBlock]]] = None,
     ) -> Dict[str, Union[str, List[str]]]:
         existing_keys = existing_keys if existing_keys else []
         values: Dict[str, Union[str, List[str]]] = dict()
@@ -582,15 +588,15 @@ class CanvasBuilder:
         )
 
     @property
-    def blocks(self) -> _CanvasBuilderBlockStream:
+    def blocks(self) -> CanvasBuilderBlockStream:
         """
         Blocks.
 
         Return a stream of blocks which can be iterated and operated on to mutate the canvas
         stored by the builder.
         """
-        return _CanvasBuilderBlockStream.from_builder(self)
+        return CanvasBuilderBlockStream.from_builder(self)
 
 
-def _is_included_class(included_classes: Set[Type[_UiBlock]], target_class: _UiBlock) -> bool:
+def _is_included_class(included_classes: Set[Type[UiBlock]], target_class: UiBlock) -> bool:
     return isinstance(target_class, tuple(c for c in included_classes))

benchling_sdk/apps/canvas/types.py

@@ -41,7 +41,7 @@ from benchling_sdk.models import (
     TextInputUiBlockUpdate,
 )
 
-_UiBlock = Union[
+UiBlock = Union[
     ButtonUiBlock,
     ChipUiBlock,
     DropdownMultiValueUiBlock,
@@ -57,9 +57,9 @@ _UiBlock = Union[
     UnknownType,
 ]
 
-_UiBlockType = TypeVar(
-    "_UiBlockType",
-    bound=_UiBlock,
+UiBlockType = TypeVar(
+    "UiBlockType",
+    bound=UiBlock,
 )
 
 _UiBlockCreate = Union[

benchling_sdk/apps/config/__init__.py

@@ -1,3 +0,0 @@
-from benchling_sdk.helpers.logging_helpers import log_stability_warning, StabilityLevel
-
-log_stability_warning(StabilityLevel.BETA)

benchling_sdk/apps/config/decryption_provider.py

@@ -11,9 +11,6 @@ class BaseDecryptionProvider(ABC):
     Various implementations might use AWS KMS, Azure, etc.
     """
 
-    # TODO BNCH-52772 should we loosen this method to accept None and not attempt decryption,
-    # now that config is no longer type safe?
-
     @abstractmethod
     def decrypt(self, ciphertext: str) -> str:
         """

benchling_sdk/apps/config/errors.py

@@ -6,3 +6,33 @@ class UnsupportedConfigItemError(Exception):
     """
 
     pass
+
+
+class MissingRequiredConfigItemError(Exception):
+    """
+    Missing required config item error.
+
+    A config item was invoked as required, but missing in the configuration item store.
+    """
+
+    pass
+
+
+class InaccessibleConfigItemError(Exception):
+    """
+    Inaccessible config item error.
+
+    A config item linked resource was inaccessible (the caller does not have permissions).
+    """
+
+    pass
+
+
+class ConfigItemLinkedResourceError(Exception):
+    """
+    Config item linked resource error.
+
+    A config item is not a type that has an associated linked resource.
+    """
+
+    pass