benchling-sdk 1.9.0a4__py3-none-any.whl → 1.10.0__py3-none-any.whl

benchling_sdk/apps/canvas/errors.py

@@ -0,0 +1,14 @@
+class DuplicateBlockIdError(Exception):
+    """Error indicating that duplicate ids were present on blocks within a Canvas."""
+
+    pass
+
+
+class NoMatchingBlocksError(Exception):
+    """
+    Error indicating that blocks were expected, but none matched.
+
+    Used to prevent requiring developers to handle Optional[_UiBlock] for type safety.
+    """
+
+    pass

benchling_sdk/apps/{helpers/canvas_helpers.py → canvas/framework.py}

@@ -1,142 +1,40 @@
 from __future__ import annotations
 
+import json
 from typing import cast, Dict, Generic, List, Optional, Protocol, Set, Type, TypeVar, Union
 
 from benchling_api_client.v2.extensions import UnknownType
 
-from benchling_sdk.helpers.logging_helpers import log_stability_warning, StabilityLevel
+from benchling_sdk.apps.canvas.errors import DuplicateBlockIdError, NoMatchingBlocksError
+from benchling_sdk.apps.canvas.types import (
+    _UI_BLOCK_MAPPINGS_CREATE,
+    _UI_BLOCK_MAPPINGS_UPDATE,
+    _UiBlockCreate,
+    _UiBlockUpdate,
+    UiBlock,
+    UiBlockType,
+)
+from benchling_sdk.apps.types import JsonType
 from benchling_sdk.models import (
     AppCanvas,
     AppCanvasApp,
     AppCanvasCreate,
     AppCanvasUpdate,
-    ButtonUiBlock,
-    ButtonUiBlockCreate,
-    ButtonUiBlockUpdate,
-    ChipUiBlock,
-    ChipUiBlockCreate,
-    ChipUiBlockUpdate,
     DropdownMultiValueUiBlock,
-    DropdownMultiValueUiBlockCreate,
-    DropdownMultiValueUiBlockUpdate,
     DropdownUiBlock,
-    DropdownUiBlockCreate,
-    DropdownUiBlockUpdate,
-    MarkdownUiBlock,
-    MarkdownUiBlockCreate,
-    MarkdownUiBlockUpdate,
     SearchInputMultiValueUiBlock,
-    SearchInputMultiValueUiBlockCreate,
-    SearchInputMultiValueUiBlockUpdate,
     SearchInputUiBlock,
-    SearchInputUiBlockCreate,
-    SearchInputUiBlockUpdate,
     SectionUiBlock,
-    SectionUiBlockCreate,
-    SectionUiBlockUpdate,
     SelectorInputMultiValueUiBlock,
-    SelectorInputMultiValueUiBlockCreate,
-    SelectorInputMultiValueUiBlockUpdate,
     SelectorInputUiBlock,
-    SelectorInputUiBlockCreate,
-    SelectorInputUiBlockUpdate,
     TableUiBlock,
-    TableUiBlockCreate,
-    TableUiBlockUpdate,
     TextInputUiBlock,
-    TextInputUiBlockCreate,
-    TextInputUiBlockUpdate,
 )
 
-log_stability_warning(StabilityLevel.BETA)
-
-S = TypeVar("S", bound="_FilteredCanvasBuilderBlockStream")
-
-_UiBlock = Union[
-    ButtonUiBlock,
-    ChipUiBlock,
-    DropdownMultiValueUiBlock,
-    DropdownUiBlock,
-    MarkdownUiBlock,
-    SearchInputMultiValueUiBlock,
-    SearchInputUiBlock,
-    SectionUiBlock,
-    SelectorInputMultiValueUiBlock,
-    SelectorInputUiBlock,
-    TableUiBlock,
-    TextInputUiBlock,
-    UnknownType,
-]
+S = TypeVar("S", bound="FilteredCanvasBuilderBlockStream")
 
-_UiBlockType = TypeVar(
-    "_UiBlockType",
-    bound=_UiBlock,
-)
 
-_UiBlockCreate = Union[
-    ButtonUiBlockCreate,
-    ChipUiBlockCreate,
-    DropdownMultiValueUiBlockCreate,
-    DropdownUiBlockCreate,
-    MarkdownUiBlockCreate,
-    SearchInputMultiValueUiBlockCreate,
-    SearchInputUiBlockCreate,
-    SectionUiBlockCreate,
-    SelectorInputMultiValueUiBlockCreate,
-    SelectorInputUiBlockCreate,
-    TableUiBlockCreate,
-    TextInputUiBlockCreate,
-    UnknownType,
-]
-
-_UiBlockUpdate = Union[
-    ButtonUiBlockUpdate,
-    ChipUiBlockUpdate,
-    DropdownMultiValueUiBlockUpdate,
-    DropdownUiBlockUpdate,
-    MarkdownUiBlockUpdate,
-    SearchInputMultiValueUiBlockUpdate,
-    SearchInputUiBlockUpdate,
-    SectionUiBlockUpdate,
-    SelectorInputMultiValueUiBlockUpdate,
-    SelectorInputUiBlockUpdate,
-    TableUiBlockUpdate,
-    TextInputUiBlockUpdate,
-    UnknownType,
-]
-
-_UI_BLOCK_MAPPINGS_CREATE = {
-    ButtonUiBlock: ButtonUiBlockCreate,
-    ChipUiBlock: ChipUiBlockCreate,
-    DropdownMultiValueUiBlock: DropdownMultiValueUiBlockCreate,
-    DropdownUiBlock: DropdownUiBlockCreate,
-    MarkdownUiBlock: MarkdownUiBlockCreate,
-    SearchInputMultiValueUiBlock: SearchInputMultiValueUiBlockCreate,
-    SearchInputUiBlock: SearchInputUiBlockCreate,
-    SectionUiBlock: SectionUiBlockCreate,
-    SelectorInputMultiValueUiBlock: SelectorInputMultiValueUiBlockCreate,
-    SelectorInputUiBlock: SelectorInputUiBlockCreate,
-    TableUiBlock: TableUiBlockCreate,
-    TextInputUiBlock: TextInputUiBlockCreate,
-}
-
-_UI_BLOCK_MAPPINGS_UPDATE = {
-    ButtonUiBlock: ButtonUiBlockUpdate,
-    ChipUiBlock: ChipUiBlockUpdate,
-    DropdownMultiValueUiBlock: DropdownMultiValueUiBlockUpdate,
-    DropdownUiBlock: DropdownUiBlockUpdate,
-    MarkdownUiBlock: MarkdownUiBlockUpdate,
-    SearchInputMultiValueUiBlock: SearchInputMultiValueUiBlockUpdate,
-    SearchInputUiBlock: SearchInputUiBlockUpdate,
-    SectionUiBlock: SectionUiBlockUpdate,
-    SelectorInputMultiValueUiBlock: SelectorInputMultiValueUiBlockUpdate,
-    SelectorInputUiBlock: SelectorInputUiBlockUpdate,
-    TableUiBlock: TableUiBlockUpdate,
-    TextInputUiBlock: TextInputUiBlockUpdate,
-}
-
-
-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
@@ -150,7 +48,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
@@ -166,44 +64,27 @@ def _ui_block_to_update(block: _UiBlock) -> _UiBlockUpdate:
     return block  # type: ignore
 
 
-class DuplicateBlockIdError(Exception):
-    """Error indicating that duplicate ids were present on blocks within a Canvas."""
-
-    pass
-
-
-class NoMatchingBlocksError(Exception):
-    """
-    Error indicating that blocks were expected, but none matched.
-
-    Used to prevent requiring developers to handle Optional[_UiBlock] for type safety.
-    """
-
-    pass
-
-
-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.
 
@@ -214,16 +95,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
@@ -237,7 +118,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))
@@ -246,15 +127,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.
 
@@ -269,7 +150,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())
@@ -278,9 +159,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):
@@ -295,26 +174,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
@@ -339,26 +221,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.
 
@@ -370,8 +252,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:
@@ -387,13 +269,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
@@ -408,26 +290,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.
 
@@ -484,7 +367,8 @@ class CanvasBuilder:
         resource_id: str,
         enabled: bool = True,
         session_id: Optional[str] = None,
-        blocks: Optional[List[_UiBlock]] = None,
+        blocks: Optional[List[UiBlock]] = None,
+        data: Optional[JsonType] = None,
     ):
         """
         Init AppCanvas.
@@ -498,6 +382,7 @@ class CanvasBuilder:
             enabled=enabled,
             session_id=session_id,
             blocks=blocks if blocks else [],
+            data=json.dumps(data) if data is not None else None,
         )
 
     @classmethod
@@ -514,6 +399,7 @@ class CanvasBuilder:
             enabled=canvas.enabled,
             session_id=canvas.session_id,
             blocks=canvas.blocks,
+            data=json.loads(canvas.data) if isinstance(canvas.data, str) else None,
         )
 
     def _with_enabled(self, value: bool) -> CanvasBuilder:
@@ -525,23 +411,65 @@ class CanvasBuilder:
             enabled=value,
             session_id=self._source_canvas.session_id,
             blocks=self._source_canvas.blocks,
+            data=self.data_to_json(),
         )
 
-    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,
+            data=self.data_to_json(),
+        )
+
+    def with_data(self, new_data: Optional[JsonType]) -> CanvasBuilder:
+        """
+        Return a new CanvasBuilder with the underlying data replaced.
+
+        This does not call the API, it only assigns state in the CanvasBuilder.
+        """
+        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=self._source_canvas.blocks,
+            data=new_data,
+        )
+
+    def with_session_id(self, session_id: Optional[str]) -> CanvasBuilder:
+        """
+        Return a new CanvasBuilder with an optional session_id set.
+
+        This does not call the API, it only assigns state in the CanvasBuilder.
+        """
+        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=session_id,
+            blocks=self._source_canvas.blocks,
+            data=self.data_to_json(),
+        )
 
     def inputs_to_dict(self) -> Dict[str, Union[str, List[str]]]:
         """
@@ -605,7 +533,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.
@@ -631,9 +559,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()
@@ -670,6 +598,7 @@ class CanvasBuilder:
             enabled=self._source_canvas.enabled,
             session_id=self._source_canvas.session_id,
             blocks=[_ui_block_to_update(block) for block in self._source_canvas.blocks],
+            data=self._source_canvas.data,
         )
 
     def to_create(self) -> AppCanvasCreate:
@@ -681,18 +610,30 @@ class CanvasBuilder:
             enabled=self._source_canvas.enabled,
             session_id=self._source_canvas.session_id,
             blocks=[_ui_block_to_create(block) for block in self._source_canvas.blocks],
+            data=self._source_canvas.data,
         )
 
     @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 data_to_json(self) -> Optional[JsonType]:
+        """
+        Convert Canvas data to JSON.
+
+        Return a JSON object parsed from the string of the canvas's `data`, if present. Otherwise, return None.
+        """
+        return json.loads(self._source_canvas.data) if self._source_canvas.data is not None else None
+
+    def __eq__(self, other) -> bool:
+        return isinstance(other, CanvasBuilder) and self._source_canvas == other._source_canvas
 
 
-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))