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

benchling_sdk/apps/config/framework.py

@@ -1,13 +1,38 @@
-import collections
-from typing import Dict, List, Optional, OrderedDict, Protocol, Tuple
+from __future__ import annotations
+
+from typing import Dict, List, Optional, OrderedDict, Protocol, Tuple, Union
 
 from benchling_api_client.v2.extensions import UnknownType
 from ordered_set import OrderedSet
 
-from benchling_sdk.apps.config.errors import UnsupportedConfigItemError
+from benchling_sdk.apps.config.errors import (
+    ConfigItemLinkedResourceError,
+    InaccessibleConfigItemError,
+    MissingRequiredConfigItemError,
+    UnsupportedConfigItemError,
+)
 from benchling_sdk.apps.config.types import ConfigItemPath, ConfigurationReference
 from benchling_sdk.benchling import Benchling
-from benchling_sdk.models import AppConfigItem, ListAppConfigurationItemsSort
+from benchling_sdk.models import (
+    AppConfigItem,
+    EntitySchemaAppConfigItem,
+    FieldAppConfigItem,
+    GenericApiIdentifiedAppConfigItem,
+    InaccessibleResource,
+    LinkedAppConfigResourceSummary,
+    ListAppConfigurationItemsSort,
+)
+
+
+class _DefaultOrderedDict(OrderedDict):
+    _root_path: List[str]
+
+    def __init__(self, root_path: List[str]) -> None:
+        super().__init__()
+        self._root_path = root_path
+
+    def __missing__(self, key):
+        return ConfigItemWrapper(None, [*self._root_path, key])
 
 
 class ConfigProvider(Protocol):
@@ -52,7 +77,8 @@ class BenchlingConfigProvider(ConfigProvider):
 
         # Eager load all config items for now since we don't yet have a way of lazily querying by path
         all_config_pages = list(app_pages)
-        # Punt on UnknownType for now as apps using manifests with new types + older client could lead to unpredictable results
+        # Punt on UnknownType for now as apps using manifests with new types +
+        # older client could lead to unpredictable results
         all_config_items = [
             _supported_config_item(config_item) for page in all_config_pages for config_item in page
         ]
@@ -82,17 +108,126 @@ class StaticConfigProvider(ConfigProvider):
         return self._configuration_items
 
 
+class ConfigItemWrapper:
+    """
+    Config Item Wrapper.
+
+    A decorator class for AppConfigItem to assist with typesafe access to its values.
+    Access the `item` attribute for the original config item, if present.
+    """
+
+    item: Optional[ConfigurationReference]
+    path: List[str]
+
+    def __init__(self, item: Optional[ConfigurationReference], path: List[str]) -> None:
+        """Init Pathed Config Item."""
+        self.item = item
+        self.path = path
+
+    def required(self) -> RequiredConfigItemWrapper:
+        """Return a `RequiredPathedConfigItem` to enforce that config item is not optional."""
+        if self.item is None:
+            raise MissingRequiredConfigItemError(
+                f"Required config item {self.path} is missing from the config store"
+            )
+        return RequiredConfigItemWrapper(self.item, self.path)
+
+    def linked_resource(self) -> Optional[LinkedAppConfigResourceSummary]:
+        """
+        Return an optional LinkedAppConfigResourceSummary.
+
+        Raises exceptions if the config item is not of the type that supports linked resources,
+        or the linked resource is inaccessible.
+        """
+        if self.item is not None:
+            # Python can't compare isinstance for Union types until Python 3.10 so just do this for now
+            # from: https://github.com/python/typing/discussions/1132#discussioncomment-2560441
+            # elif isinstance(self.item, get_args(LinkedResourceConfigurationReference)):
+            if isinstance(
+                self.item, (EntitySchemaAppConfigItem, FieldAppConfigItem, GenericApiIdentifiedAppConfigItem)
+            ):
+                if self.item.linked_resource is None:
+                    return None
+                elif isinstance(self.item.linked_resource, LinkedAppConfigResourceSummary):
+                    return self.item.linked_resource
+                elif isinstance(self.item.linked_resource, InaccessibleResource):
+                    raise InaccessibleConfigItemError(
+                        f"The linked resource for config item {self.path} was inaccessible. "
+                        f"The caller does not have permissions to the resource."
+                    )
+                raise UnsupportedConfigItemError(
+                    f"Unable to read app configuration with unsupported type: {self.item}"
+                )
+            raise ConfigItemLinkedResourceError(
+                f"Type mismatch: The config item {self.item} type never has a linked resource"
+            )
+        return None
+
+    def value(self) -> Union[str, float, int, bool, None]:
+        """Return the value of the config item, if present."""
+        return self.item.value if self.item else None
+
+    def value_str(self) -> Optional[str]:
+        """Return the value of the config item as a string, if present."""
+        return str(self.value()) if self.value() else None
+
+    def __bool__(self) -> bool:
+        return self.value() is not None
+
+
+class RequiredConfigItemWrapper(ConfigItemWrapper):
+    """
+    Required Config Item Wrapper.
+
+    A decorator class for AppConfigItem to assist with typesafe access to its values.
+    Enforces that a config item is present, and that it's value is not None.
+    Access the `item` attribute for the original config item.
+    """
+
+    item: ConfigurationReference
+
+    def __init__(self, item: ConfigurationReference, path: List[str]) -> None:
+        """Init Required Pathed Config Item."""
+        super().__init__(item, path)
+
+    def linked_resource(self) -> LinkedAppConfigResourceSummary:
+        """
+        Return a LinkedAppConfigResourceSummary.
+
+        Raises exceptions if the config item is not of the type that supports linked resources,
+        or the linked resource is inaccessible.
+        """
+        linked_resource = super().linked_resource()
+        if linked_resource is None:
+            raise MissingRequiredConfigItemError(
+                f"Required config item {self.path} is missing a linked resource"
+            )
+        return linked_resource
+
+    def value(self) -> Union[str, float, int, bool]:
+        """Return the value of the config item."""
+        if self.item.value is None:
+            raise MissingRequiredConfigItemError(
+                f"Required config item {self.path} is missing from the config store"
+            )
+        return self.item.value
+
+    def value_str(self) -> str:
+        """Return the value of the config item as a string."""
+        return str(self.value())
+
+
 class ConfigItemStore:
     """
     Dependency Link Store.
 
-    Marshalls an app configuration from the configuration provider into an indexable structure.
+    Marshals an app configuration from the configuration provider into an indexed structure.
     Only retrieves app configuration once unless its cache is invalidated.
     """
 
     _configuration_provider: ConfigProvider
     _configuration: Optional[List[ConfigurationReference]] = None
-    _configuration_map: Optional[Dict[ConfigItemPath, ConfigurationReference]] = None
+    _configuration_dict: Optional[Dict[ConfigItemPath, ConfigItemWrapper]] = None
     _array_path_row_names: Dict[Tuple[str, ...], OrderedSet[str]] = dict()
 
     def __init__(self, configuration_provider: ConfigProvider):
@@ -118,17 +253,19 @@ class ConfigItemStore:
         return self._configuration
 
     @property
-    def configuration_path_map(self) -> Dict[ConfigItemPath, ConfigurationReference]:
+    def configuration_path_dict(self) -> Dict[ConfigItemPath, ConfigItemWrapper]:
         """
         Config links.
 
-        Return a map of configuration item paths to their corresponding configuration items.
+        Return a dict of configuration item paths to their corresponding configuration items.
         """
-        if not self._configuration_map:
-            self._configuration_map = {tuple(item.path): item for item in self.configuration}
-        return self._configuration_map
+        if not self._configuration_dict:
+            self._configuration_dict = {
+                tuple(item.path): ConfigItemWrapper(item, item.path) for item in self.configuration
+            }
+        return self._configuration_dict
 
-    def config_by_path(self, path: List[str]) -> Optional[ConfigurationReference]:
+    def config_by_path(self, path: List[str]) -> ConfigItemWrapper:
         """
         Config by path.
 
@@ -136,7 +273,7 @@ class ConfigItemStore:
         """
         # Since we eager load all config now, we know that missing path means it's not configured in Benchling
         # Later if we support lazy loading, we'll need to differentiate what's in our cache versus missing
-        return self.configuration_path_map.get(tuple(path))
+        return self.configuration_path_dict.get(tuple(path), ConfigItemWrapper(None, path))
 
     def config_keys_by_path(self, path: List[str]) -> OrderedSet[str]:
         """
@@ -160,7 +297,7 @@ class ConfigItemStore:
             self._array_path_row_names[path_tuple] = OrderedSet(
                 [
                     config_item.path[len(path)]
-                    # Use the list instead of configuration_map to preserve order
+                    # Use the list instead of configuration_dict to preserve order
                     for config_item in self.configuration
                     # The +1 is the name of the array row
                     if len(config_item.path) >= len(path) + 1
@@ -171,22 +308,21 @@ class ConfigItemStore:
             )
         return self._array_path_row_names[path_tuple]
 
-    def array_rows_to_dict(self, path: List[str]) -> OrderedDict[str, Dict[str, ConfigurationReference]]:
+    def array_rows_to_dict(self, path: List[str]) -> OrderedDict[str, Dict[str, ConfigItemWrapper]]:
         """Given a path to the root of a config array, return each element as a named dict."""
-        # TODO BNCH-52772 Improve docstring if we keep this method
         array_keys = self.config_keys_by_path(path)
         # Although we don't have a way of preserving order when pulling array elements from the API right now
         # we should intentionally order these to accommodate a potential ordered future
-        array_elements_map = collections.OrderedDict()
+        array_elements_map = _DefaultOrderedDict(root_path=path)
         for key in array_keys:
+            array_elements_map[key] = _DefaultOrderedDict(root_path=[*path, key])
             # Don't care about order for the keys within a row, only the order of the rows themselves
-            array_elements_map[key] = {
-                array_element_key: self.config_by_path([*path, key, array_element_key])
-                for array_element_key in self.config_keys_by_path([*path, key])
-                if self.config_by_path([*path, key, array_element_key]) is not None
-            }
-        # TODO BNCH-52772 MyPy thinks the inner dict values can be None
-        return array_elements_map  # type: ignore
+            for array_element_key in self.config_keys_by_path([*path, key]):
+                if self.config_by_path([*path, key, array_element_key]) is not None:
+                    array_elements_map[key][array_element_key] = self.config_by_path(
+                        [*path, key, array_element_key]
+                    )
+        return array_elements_map
 
     def invalidate_cache(self) -> None:
         """
@@ -195,7 +331,7 @@ class ConfigItemStore:
         Will force retrieval of configuration from the ConfigProvider the next time the link store is accessed.
         """
         self._configuration = None
-        self._configuration_map = None
+        self._configuration_dict = None
         self._array_path_row_names = dict()
 
 

benchling_sdk/apps/{helpers/config_helpers.py → config/helpers.py}

@@ -1,7 +1,6 @@
-from datetime import date, datetime
+from datetime import datetime
 from typing import List, Optional, Union
 
-from benchling_api_client.v2.beta.models.app_config_field_type import AppConfigFieldType
 from benchling_api_client.v2.beta.models.base_manifest_config import BaseManifestConfig
 from benchling_api_client.v2.beta.models.dropdown_dependency import DropdownDependency
 from benchling_api_client.v2.beta.models.dropdown_dependency_types import DropdownDependencyTypes
@@ -29,92 +28,7 @@ from benchling_api_client.v2.beta.models.workflow_task_schema_dependency_type im
 from benchling_api_client.v2.extensions import UnknownType
 from benchling_api_client.v2.stable.extensions import NotPresentError
 
-from benchling_sdk.apps.config.scalars import JsonType
-from benchling_sdk.models import (
-    AaSequence,
-    AssayResult,
-    AssayRun,
-    Box,
-    Container,
-    CustomEntity,
-    DnaOligo,
-    DnaSequence,
-    Entry,
-    Location,
-    Mixture,
-    Molecule,
-    Plate,
-    Request,
-    RnaOligo,
-    RnaSequence,
-    WorkflowTask,
-)
-
-_MODEL_TYPES_FROM_SCHEMA_TYPE = {
-    SchemaDependencyTypes.CONTAINER_SCHEMA: Container,
-    SchemaDependencyTypes.PLATE_SCHEMA: Plate,
-    SchemaDependencyTypes.BOX_SCHEMA: Box,
-    SchemaDependencyTypes.LOCATION_SCHEMA: Location,
-    SchemaDependencyTypes.ENTRY_SCHEMA: Entry,
-    SchemaDependencyTypes.REQUEST_SCHEMA: Request,
-    SchemaDependencyTypes.RESULT_SCHEMA: AssayResult,
-    SchemaDependencyTypes.RUN_SCHEMA: AssayRun,
-    SchemaDependencyTypes.WORKFLOW_TASK_SCHEMA: WorkflowTask,
-}
-
-
-_SCALAR_TYPES_FROM_CONFIG = {
-    ScalarConfigTypes.BOOLEAN: bool,
-    ScalarConfigTypes.DATE: date,
-    ScalarConfigTypes.DATETIME: datetime,
-    ScalarConfigTypes.FLOAT: float,
-    ScalarConfigTypes.INTEGER: int,
-    ScalarConfigTypes.JSON: JsonType,
-    ScalarConfigTypes.TEXT: str,
-}
-
-
-_FIELD_SCALAR_TYPES_FROM_CONFIG = {
-    AppConfigFieldType.BOOLEAN: bool,
-    AppConfigFieldType.DATE: date,
-    AppConfigFieldType.DATETIME: datetime,
-    AppConfigFieldType.FLOAT: float,
-    AppConfigFieldType.INTEGER: int,
-    AppConfigFieldType.JSON: JsonType,
-    AppConfigFieldType.TEXT: str,
-}
-
-
-ModelType = Union[AssayResult, AssayRun, Box, Container, Entry, Location, Plate, Request]
-
-_INSTANCE_FROM_SCHEMA_SUBTYPE = {
-    SchemaDependencySubtypes.AA_SEQUENCE: AaSequence,
-    SchemaDependencySubtypes.CUSTOM_ENTITY: CustomEntity,
-    SchemaDependencySubtypes.DNA_SEQUENCE: DnaSequence,
-    SchemaDependencySubtypes.DNA_OLIGO: DnaOligo,
-    SchemaDependencySubtypes.MIXTURE: Mixture,
-    SchemaDependencySubtypes.MOLECULE: Molecule,
-    SchemaDependencySubtypes.RNA_OLIGO: RnaOligo,
-    SchemaDependencySubtypes.RNA_SEQUENCE: RnaSequence,
-}
-
-EntitySubtype = Union[
-    AaSequence, CustomEntity, DnaOligo, DnaSequence, Mixture, Molecule, RnaOligo, RnaSequence
-]
-
-AnyDependency = Union[
-    BaseManifestConfig,
-    DropdownDependency,
-    EntitySchemaDependency,
-    FieldDefinitionsManifest,
-    ManifestArrayConfig,
-    ManifestScalarConfig,
-    ResourceDependency,
-    SchemaDependency,
-    WorkflowTaskSchemaDependency,
-]
-
-ArrayElementDependency = Union[
+_ArrayElementDependency = Union[
     SchemaDependency,
     EntitySchemaDependency,
     WorkflowTaskSchemaDependency,
@@ -124,13 +38,13 @@ ArrayElementDependency = Union[
 ]
 
 
-class UnsupportedSubTypeError(Exception):
+class _UnsupportedSubTypeError(Exception):
     """Error when an unsupported subtype is encountered."""
 
     pass
 
 
-def field_definitions_from_dependency(
+def _field_definitions_from_dependency(
     dependency: Union[
         EntitySchemaDependency,
         SchemaDependency,
@@ -148,7 +62,7 @@ def field_definitions_from_dependency(
     return []
 
 
-def element_definition_from_dependency(dependency: ManifestArrayConfig) -> List[ArrayElementDependency]:
+def _element_definition_from_dependency(dependency: ManifestArrayConfig) -> List[_ArrayElementDependency]:
     """Safely return an element definition as a list of dependencies from an array dependency or empty list."""
     try:
         if hasattr(dependency, "element_definition"):
@@ -161,7 +75,7 @@ def element_definition_from_dependency(dependency: ManifestArrayConfig) -> List[
     return []
 
 
-def enum_from_dependency(
+def _enum_from_dependency(
     dependency: Union[
         ManifestFloatScalarConfig,
         ManifestIntegerScalarConfig,
@@ -180,8 +94,8 @@ def enum_from_dependency(
 
 # TODO BNCH-57036 All element definitions currently deserialize to UnknownType. Hack around this temporarily
 def _fix_element_definition_deserialization(
-    element: Union[UnknownType, ArrayElementDependency]
-) -> ArrayElementDependency:
+    element: Union[UnknownType, _ArrayElementDependency]
+) -> _ArrayElementDependency:
     if isinstance(element, UnknownType):
         if "type" in element.value:
             element_type = element.value["type"]
@@ -201,7 +115,7 @@ def _fix_element_definition_deserialization(
     return element
 
 
-def workflow_task_schema_output_from_dependency(
+def _workflow_task_schema_output_from_dependency(
     dependency: WorkflowTaskSchemaDependency,
 ) -> Optional[WorkflowTaskSchemaDependencyOutput]:
     """Safely return a workflow task schema output from a workflow task schema or None."""
@@ -214,7 +128,7 @@ def workflow_task_schema_output_from_dependency(
     return None
 
 
-def options_from_dependency(dependency: DropdownDependency) -> List[BaseManifestConfig]:
+def _options_from_dependency(dependency: DropdownDependency) -> List[BaseManifestConfig]:
     """Safely return a list of options from a dropdown dependency or empty list."""
     try:
         if hasattr(dependency, "options"):
@@ -225,7 +139,7 @@ def options_from_dependency(dependency: DropdownDependency) -> List[BaseManifest
     return []
 
 
-def subtype_from_entity_schema_dependency(
+def _subtype_from_entity_schema_dependency(
     dependency: EntitySchemaDependency,
 ) -> Optional[SchemaDependencySubtypes]:
     """Safely return an entity schema dependency's subtype, if present."""
@@ -236,3 +150,8 @@ def subtype_from_entity_schema_dependency(
     except NotPresentError:
         pass
     return None
+
+
+def datetime_config_value_to_str(value: datetime) -> str:
+    """Convert a datetime value to a valid string accepted by a datetime app config item."""
+    return value.strftime("%Y-%m-%d %I:%M:%S %p")