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

benchling_sdk/apps/canvas/types.py

@@ -0,0 +1,125 @@
+from typing import TypeVar, Union
+
+from benchling_api_client.v2.extensions import UnknownType
+
+from benchling_sdk.models import (
+    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,
+)
+
+UiBlock = Union[
+    ButtonUiBlock,
+    ChipUiBlock,
+    DropdownMultiValueUiBlock,
+    DropdownUiBlock,
+    MarkdownUiBlock,
+    SearchInputMultiValueUiBlock,
+    SearchInputUiBlock,
+    SectionUiBlock,
+    SelectorInputMultiValueUiBlock,
+    SelectorInputUiBlock,
+    TableUiBlock,
+    TextInputUiBlock,
+    UnknownType,
+]
+
+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,
+}

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

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 
-from benchling_sdk.apps.helpers.cryptography_helpers import _create_key_type
+from benchling_sdk.apps.config.cryptography_helpers import _create_key_type
 from benchling_sdk.helpers.package_helpers import _required_packages_context, ExtrasPackage
 
 

benchling_sdk/apps/config/errors.py

@@ -0,0 +1,38 @@
+class UnsupportedConfigItemError(Exception):
+    """
+    Unsupported config item error.
+
+    The manifest and configuration specified an item which the SDK is incapable of handling yet.
+    """
+
+    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

benchling_sdk/apps/config/framework.py

@@ -0,0 +1,343 @@
+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 (
+    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,
+    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):
+    """
+    Config provider.
+
+    Provides a list of ConfigurationReference.
+    """
+
+    def config(self) -> List[ConfigurationReference]:
+        """Implement to provide a list of configuration items, for instance from Benchling APIs."""
+        pass
+
+
+class BenchlingConfigProvider(ConfigProvider):
+    """
+    Benchling Config provider.
+
+    Provides a BenchlingAppConfiguration retrieved from Benchling's API.
+    """
+
+    _app_id: str
+    _benchling: Benchling
+
+    def __init__(self, benchling: Benchling, app_id: str):
+        """
+        Initialize Benchling Config Provider.
+
+        :param benchling: A Benchling instance.
+        :param app_id: The app_id from which to retrieve configuration.
+        """
+        self._app_id = app_id
+        self._benchling = benchling
+
+    def config(self) -> List[ConfigurationReference]:
+        """Provide a Benchling app configuration from Benchling's APIs."""
+        app_pages = self._benchling.apps.list_app_configuration_items(
+            app_id=self._app_id,
+            page_size=100,
+            sort=ListAppConfigurationItemsSort.CREATEDATASC,
+        )
+
+        # 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
+        all_config_items = [
+            _supported_config_item(config_item) for page in all_config_pages for config_item in page
+        ]
+
+        return all_config_items
+
+
+class StaticConfigProvider(ConfigProvider):
+    """
+    Static Config provider.
+
+    Provides a BenchlingAppConfiguration from a static declaration. Useful for mocking or testing.
+    """
+
+    _configuration_items: List[ConfigurationReference]
+
+    def __init__(self, configuration_items: List[ConfigurationReference]):
+        """
+        Initialize Static Config Provider.
+
+        :param configuration_items: The configuration items to return.
+        """
+        self._configuration_items = configuration_items
+
+    def config(self) -> List[ConfigurationReference]:
+        """Provide Benchling app configuration items from a static reference."""
+        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.
+
+    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_dict: Optional[Dict[ConfigItemPath, ConfigItemWrapper]] = None
+    _array_path_row_names: Dict[Tuple[str, ...], OrderedSet[str]] = dict()
+
+    def __init__(self, configuration_provider: ConfigProvider):
+        """
+        Initialize Dependency Link Store.
+
+        :param configuration_provider: A ConfigProvider that will be invoked to provide the
+        underlying config from which to organize dependency links.
+        """
+        self._configuration_provider = configuration_provider
+        self._array_path_row_names = dict()
+
+    @property
+    def configuration(self) -> List[ConfigurationReference]:
+        """
+        Get the underlying configuration.
+
+        Return the raw, stored configuration. Can be used if the provided accessors are inadequate
+        to find particular configuration items.
+        """
+        if not self._configuration:
+            self._configuration = self._configuration_provider.config()
+        return self._configuration
+
+    @property
+    def configuration_path_dict(self) -> Dict[ConfigItemPath, ConfigItemWrapper]:
+        """
+        Config links.
+
+        Return a dict of configuration item paths to their corresponding configuration items.
+        """
+        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]) -> ConfigItemWrapper:
+        """
+        Config by path.
+
+        Find an app config item by its exact path match, if it exists. Does not search partial paths.
+        """
+        # 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_dict.get(tuple(path), ConfigItemWrapper(None, path))
+
+    def config_keys_by_path(self, path: List[str]) -> OrderedSet[str]:
+        """
+        Config keys by path.
+
+        Find a set of app config keys at the specified path, if any. Does not return keys that are nested
+        beyond the current level.
+
+        For instance, given paths:
+        ["One", "Two"]
+        ["One", "Two", "Three"]
+        ["One", "Two", "Four"]
+        ["One", "Two", "Three", "Five"]
+        ["Zero", "One", "Two", "Three"]
+
+        The expected return from this method when path=["One", "Two"] is a set {"Three", "Four"}.
+        """
+        # Convert path to tuple, as list is not hashable for dict keys
+        path_tuple = tuple(path)
+        if path_tuple not in self._array_path_row_names:
+            self._array_path_row_names[path_tuple] = OrderedSet(
+                [
+                    config_item.path[len(path)]
+                    # 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
+                    # Ignoring flake8 error E203 because black keeps putting in whitespace padding :
+                    and config_item.path[0 : len(path_tuple)] == path  # noqa: E203
+                    and config_item.value is not None
+                ]
+            )
+        return self._array_path_row_names[path_tuple]
+
+    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."""
+        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 = _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
+            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:
+        """
+        Invalidate Cache.
+
+        Will force retrieval of configuration from the ConfigProvider the next time the link store is accessed.
+        """
+        self._configuration = None
+        self._configuration_dict = None
+        self._array_path_row_names = dict()
+
+
+def _supported_config_item(config_item: AppConfigItem) -> ConfigurationReference:
+    if isinstance(config_item, UnknownType):
+        raise UnsupportedConfigItemError(
+            f"Unable to read app configuration with unsupported type: {config_item}"
+        )
+    return config_item

benchling_sdk/apps/config/helpers.py

@@ -0,0 +1,157 @@
+from datetime import datetime
+from typing import List, Optional, Union
+
+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
+from benchling_api_client.v2.beta.models.entity_schema_dependency import EntitySchemaDependency
+from benchling_api_client.v2.beta.models.entity_schema_dependency_type import EntitySchemaDependencyType
+from benchling_api_client.v2.beta.models.field_definitions_manifest import FieldDefinitionsManifest
+from benchling_api_client.v2.beta.models.manifest_array_config import ManifestArrayConfig
+from benchling_api_client.v2.beta.models.manifest_float_scalar_config import ManifestFloatScalarConfig
+from benchling_api_client.v2.beta.models.manifest_integer_scalar_config import ManifestIntegerScalarConfig
+from benchling_api_client.v2.beta.models.manifest_scalar_config import ManifestScalarConfig
+from benchling_api_client.v2.beta.models.manifest_text_scalar_config import ManifestTextScalarConfig
+from benchling_api_client.v2.beta.models.resource_dependency import ResourceDependency
+from benchling_api_client.v2.beta.models.resource_dependency_types import ResourceDependencyTypes
+from benchling_api_client.v2.beta.models.scalar_config_types import ScalarConfigTypes
+from benchling_api_client.v2.beta.models.schema_dependency import SchemaDependency
+from benchling_api_client.v2.beta.models.schema_dependency_subtypes import SchemaDependencySubtypes
+from benchling_api_client.v2.beta.models.schema_dependency_types import SchemaDependencyTypes
+from benchling_api_client.v2.beta.models.workflow_task_schema_dependency import WorkflowTaskSchemaDependency
+from benchling_api_client.v2.beta.models.workflow_task_schema_dependency_output import (
+    WorkflowTaskSchemaDependencyOutput,
+)
+from benchling_api_client.v2.beta.models.workflow_task_schema_dependency_type import (
+    WorkflowTaskSchemaDependencyType,
+)
+from benchling_api_client.v2.extensions import UnknownType
+from benchling_api_client.v2.stable.extensions import NotPresentError
+
+_ArrayElementDependency = Union[
+    SchemaDependency,
+    EntitySchemaDependency,
+    WorkflowTaskSchemaDependency,
+    DropdownDependency,
+    ResourceDependency,
+    ManifestScalarConfig,
+]
+
+
+class _UnsupportedSubTypeError(Exception):
+    """Error when an unsupported subtype is encountered."""
+
+    pass
+
+
+def _field_definitions_from_dependency(
+    dependency: Union[
+        EntitySchemaDependency,
+        SchemaDependency,
+        WorkflowTaskSchemaDependency,
+        WorkflowTaskSchemaDependencyOutput,
+    ]
+) -> List[FieldDefinitionsManifest]:
+    """Safely return a list of field definitions from a schema dependency or empty list."""
+    try:
+        if hasattr(dependency, "field_definitions"):
+            return dependency.field_definitions
+    # We can't seem to handle this programmatically by checking isinstance() or field truthiness
+    except NotPresentError:
+        pass
+    return []
+
+
+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"):
+            return [
+                _fix_element_definition_deserialization(element) for element in dependency.element_definition
+            ]
+    # We can't seem to handle this programmatically by checking isinstance() or field truthiness
+    except NotPresentError:
+        pass
+    return []
+
+
+def _enum_from_dependency(
+    dependency: Union[
+        ManifestFloatScalarConfig,
+        ManifestIntegerScalarConfig,
+        ManifestTextScalarConfig,
+    ]
+) -> List:
+    """Safely return an enum from a scalar config."""
+    try:
+        if hasattr(dependency, "enum"):
+            return dependency.enum
+    # We can't seem to handle this programmatically by checking isinstance() or field truthiness
+    except NotPresentError:
+        pass
+    return []
+
+
+# TODO BNCH-57036 All element definitions currently deserialize to UnknownType. Hack around this temporarily
+def _fix_element_definition_deserialization(
+    element: Union[UnknownType, _ArrayElementDependency]
+) -> _ArrayElementDependency:
+    if isinstance(element, UnknownType):
+        if "type" in element.value:
+            element_type = element.value["type"]
+            if element_type == WorkflowTaskSchemaDependencyType.WORKFLOW_TASK_SCHEMA:
+                return WorkflowTaskSchemaDependency.from_dict(element.value)
+            elif element_type == EntitySchemaDependencyType.ENTITY_SCHEMA:
+                return EntitySchemaDependency.from_dict(element.value)
+            elif element_type in [member.value for member in SchemaDependencyTypes]:
+                return SchemaDependency.from_dict(element.value)
+            elif element_type == DropdownDependencyTypes.DROPDOWN:
+                return DropdownDependency.from_dict(element.value)
+            elif element_type in [member.value for member in ResourceDependencyTypes]:
+                return ResourceDependency.from_dict(element.value)
+            elif element_type in [member.value for member in ScalarConfigTypes]:
+                return type(element_type).from_dict(element.value)
+        raise NotImplementedError(f"No array deserialization fix for {element}")
+    return element
+
+
+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."""
+    try:
+        if hasattr(dependency, "output"):
+            return dependency.output
+    # We can't seem to handle this programmatically by checking isinstance() or output truthiness
+    except NotPresentError:
+        pass
+    return None
+
+
+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"):
+            return dependency.options
+    # We can't seem to handle this programmatically by checking isinstance() or field truthiness
+    except NotPresentError:
+        pass
+    return []
+
+
+def _subtype_from_entity_schema_dependency(
+    dependency: EntitySchemaDependency,
+) -> Optional[SchemaDependencySubtypes]:
+    """Safely return an entity schema dependency's subtype, if present."""
+    try:
+        if hasattr(dependency, "subtype") and dependency.subtype:
+            return dependency.subtype
+    # We can't seem to handle this programmatically by checking isinstance() or field truthiness
+    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")