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

benchling_sdk/apps/config/{mock_dependencies.py → mock_config.py}

@@ -4,7 +4,7 @@ from datetime import date, datetime
 import json
 import random
 import string
-from typing import Dict, get_args, List, Optional, Protocol, Type, TypeVar, Union
+from typing import cast, Dict, get_args, List, Optional, Protocol, Union
 
 from benchling_api_client.v2.beta.models.base_manifest_config import BaseManifestConfig
 from benchling_api_client.v2.beta.models.benchling_app_manifest import BenchlingAppManifest
@@ -34,34 +34,20 @@ from benchling_api_client.v2.extensions import UnknownType
 from benchling_api_client.v2.stable.types import UNSET, Unset
 
 from benchling_sdk.apps.config.decryption_provider import BaseDecryptionProvider
-from benchling_sdk.apps.config.dependencies import (
-    _supported_config_item,
-    BaseDependencies,
-    ConfigurationReference,
-    DependencyLinkStore,
-    StaticConfigProvider,
-)
-from benchling_sdk.apps.config.scalars import (
-    BoolScalar,
-    DateScalar,
-    DateTimeScalar,
-    FloatScalar,
-    IntScalar,
-    JsonScalar,
-    JsonType,
-    ScalarDefinition,
-    ScalarType,
-    SecureTextScalar,
-    TextScalar,
-)
-from benchling_sdk.apps.helpers.config_helpers import (
-    element_definition_from_dependency,
-    enum_from_dependency,
-    field_definitions_from_dependency,
-    options_from_dependency,
-    subtype_from_entity_schema_dependency,
-    workflow_task_schema_output_from_dependency,
+from benchling_sdk.apps.config.errors import UnsupportedConfigItemError
+from benchling_sdk.apps.config.framework import _supported_config_item, ConfigItemStore, StaticConfigProvider
+from benchling_sdk.apps.config.helpers import (
+    _element_definition_from_dependency,
+    _enum_from_dependency,
+    _field_definitions_from_dependency,
+    _options_from_dependency,
+    _subtype_from_entity_schema_dependency,
+    _workflow_task_schema_output_from_dependency,
+    datetime_config_value_to_str,
 )
+from benchling_sdk.apps.config.types import ConfigurationReference
+from benchling_sdk.apps.types import JsonType
+from benchling_sdk.helpers.logging_helpers import log_stability_warning, StabilityLevel
 from benchling_sdk.models import (
     AppConfigItem,
     ArrayElementAppConfigItem,
@@ -103,7 +89,7 @@ ManifestDependencies = Union[
     UnknownType,
 ]
 
-D = TypeVar("D", bound=BaseDependencies)
+log_stability_warning(StabilityLevel.BETA)
 
 
 class MockDecryptionFunction(Protocol):
@@ -141,7 +127,7 @@ class MockDecryptionProvider(BaseDecryptionProvider):
         return self._mock_decryption_function(ciphertext)
 
 
-class MockBenchlingAppConfig:
+class MockConfigItemStore(ConfigItemStore):
     """
     Mock App Config.
 
@@ -152,42 +138,28 @@ class MockBenchlingAppConfig:
     """
 
     _config_items: List[AppConfigItem]
-    _decryption_provider: Optional[MockDecryptionProvider]
 
-    def __init__(
-        self, config_items: List[AppConfigItem], decryption_provider: Optional[MockDecryptionProvider]
-    ):
+    def __init__(self, config_items: List[AppConfigItem]):
         """
         Init Mock Benchling App Config.
 
         The class can be initialized by providing a list of AppConfigItem, but the recommended
         usage is to mock directly from a manifest, like `MockBenchlingAppConfig.from_manifest()`
         """
+        super().__init__(StaticConfigProvider([_supported_config_item(item) for item in config_items]))
         self._config_items = config_items
-        self._decryption_provider = decryption_provider
 
     @classmethod
-    def from_manifest(
-        cls, manifest: BenchlingAppManifest, decryption_provider: Optional[MockDecryptionProvider] = None
-    ) -> MockBenchlingAppConfig:
+    def from_manifest(cls, manifest: BenchlingAppManifest) -> MockConfigItemStore:
         """
         From Manifest.
 
         Reads a manifest amd mocks out all dependencies.
         """
         config_items = mock_app_config_items_from_manifest(manifest)
-        return cls(config_items, decryption_provider)
-
-    def to_dependencies(self, target_dependencies: Type[D]) -> D:
-        """
-        To Dependencies.
-
-        Convenience method for providing mocked app config to a target class extending BaseDependencies.
-        """
-        link_store = DependencyLinkStore(StaticConfigProvider(self.config_items))
-        return target_dependencies.from_store(link_store, decryption_provider=self._decryption_provider)
+        return cls(config_items)
 
-    def with_replacement(self, replacement: AppConfigItem) -> MockBenchlingAppConfig:
+    def with_replacement(self, replacement: AppConfigItem) -> MockConfigItemStore:
         """
         With Replacement.
 
@@ -197,9 +169,9 @@ class MockBenchlingAppConfig:
         replaced_app_config = replace_mocked_config_item_by_path(
             list(self.config_items), _config_path(replacement), replacement
         )
-        return MockBenchlingAppConfig(replaced_app_config, self._decryption_provider)
+        return MockConfigItemStore(replaced_app_config)
 
-    def with_replacements(self, replacements: List[AppConfigItem]) -> MockBenchlingAppConfig:
+    def with_replacements(self, replacements: List[AppConfigItem]) -> MockConfigItemStore:
         """
         With Replacement.
 
@@ -211,7 +183,7 @@ class MockBenchlingAppConfig:
             replaced_app_config = replace_mocked_config_item_by_path(
                 list(replaced_app_config), _config_path(replacement), replacement
             )
-        return MockBenchlingAppConfig(list(replaced_app_config), self._decryption_provider)
+        return MockConfigItemStore(list(replaced_app_config))
 
     @property
     def config_items(self) -> List[ConfigurationReference]:
@@ -317,7 +289,7 @@ def mock_datetime_app_config_item(path: List[str], value: Optional[datetime]) ->
     """Mock a datetime app config item with a path and specified value."""
     return DatetimeAppConfigItem(
         path=path,
-        value=value.strftime(DateTimeScalar.expected_format()) if isinstance(value, datetime) else value,
+        value=datetime_config_value_to_str(value) if value else None,
         type=DatetimeAppConfigItemType.DATETIME,
         id=_random_string("aci_"),
     )
@@ -375,9 +347,10 @@ def mock_text_app_config_item(path: List[str], value: Optional[str]) -> TextAppC
 
 def _mock_dependency(
     dependency: ManifestDependencies,
-    parent_path: List[str] = list(),
+    parent_path: Optional[List[str]] = None,
 ) -> List[AppConfigItem]:
     """Mock a dependency from its manifest definition."""
+    parent_path = parent_path if parent_path else []
     # MyPy has trouble inferring lists with [config_item] + sub_items so use the syntax like:
     # [*[config_item], *sub_items]
     # See https://github.com/python/mypy/issues/3933#issuecomment-808739063
@@ -392,12 +365,12 @@ def _mock_dependency(
         )
         sub_items = [
             _mock_subdependency(subdependency, dependency, parent_path=parent_path)
-            for subdependency in options_from_dependency(dependency)
+            for subdependency in _options_from_dependency(dependency)
         ]
         return [*[config_item], *sub_items]
     elif isinstance(dependency, EntitySchemaDependency):
         linked_resource_id = _random_string("val_")
-        subtype = subtype_from_entity_schema_dependency(dependency)
+        subtype = _subtype_from_entity_schema_dependency(dependency)
         optional_subtype: Union[SchemaDependencySubtypes, Unset] = (
             _convert_entity_subtype(subtype) if subtype is not None else UNSET
         )
@@ -411,7 +384,7 @@ def _mock_dependency(
         )
         sub_items = [
             _mock_subdependency(subdependency, dependency, parent_path=parent_path)
-            for subdependency in field_definitions_from_dependency(dependency)
+            for subdependency in _field_definitions_from_dependency(dependency)
         ]
         return [*[entity_item], *sub_items]
     elif isinstance(dependency, SchemaDependency):
@@ -425,7 +398,7 @@ def _mock_dependency(
         )
         sub_items = [
             _mock_subdependency(subdependency, dependency, parent_path=parent_path)
-            for subdependency in field_definitions_from_dependency(dependency)
+            for subdependency in _field_definitions_from_dependency(dependency)
         ]
         return [*[config_item], *sub_items]
     elif isinstance(dependency, WorkflowTaskSchemaDependency):
@@ -439,11 +412,11 @@ def _mock_dependency(
         )
         sub_items = [
             _mock_subdependency(subdependency, dependency, parent_path=parent_path)
-            for subdependency in field_definitions_from_dependency(dependency)
+            for subdependency in _field_definitions_from_dependency(dependency)
         ]
-        workflow_task_output = workflow_task_schema_output_from_dependency(dependency)
+        workflow_task_output = _workflow_task_schema_output_from_dependency(dependency)
         if workflow_task_output:
-            output_fields = field_definitions_from_dependency(workflow_task_output)
+            output_fields = _field_definitions_from_dependency(workflow_task_output)
             output_items = [
                 _mock_workflow_output_subdependency(subdependency, dependency, parent_path=parent_path)
                 for subdependency in output_fields
@@ -479,39 +452,40 @@ def _convert_entity_subtype(manifest_subtype: SchemaDependencySubtypesBeta) -> S
 
 
 def _mock_scalar_dependency(
-    dependency: ManifestScalarConfig, parent_path: List[str] = list()
+    dependency: ManifestScalarConfig, parent_path: Optional[List[str]] = None
 ) -> AppConfigItem:
+    parent_path = parent_path if parent_path else []
     if isinstance(dependency, ManifestBooleanScalarConfig):
-        bool_value = _mock_scalar_value_with_conversion(dependency, BoolScalar)
+        bool_value = cast(bool, _mock_scalar_value(dependency))
         bool_config = mock_bool_app_config_item([dependency.name], bool_value)
         return _append_config_item_path(bool_config, parent_path)
     elif isinstance(dependency, ManifestDateScalarConfig):
-        date_value = _mock_scalar_value_with_conversion(dependency, DateScalar)
+        date_value = cast(date, _mock_scalar_value(dependency))
         date_config = mock_date_app_config_item([dependency.name], date_value)
         return _append_config_item_path(date_config, parent_path)
     elif isinstance(dependency, ManifestDatetimeScalarConfig):
-        datetime_value = _mock_scalar_value_with_conversion(dependency, DateTimeScalar)
+        datetime_value = cast(datetime, _mock_scalar_value(dependency))
         datetime_config = mock_datetime_app_config_item([dependency.name], datetime_value)
         return _append_config_item_path(datetime_config, parent_path)
     elif isinstance(dependency, ManifestFloatScalarConfig):
-        float_value = _mock_scalar_value_with_conversion(dependency, FloatScalar)
+        float_value = cast(float, _mock_scalar_value(dependency))
         float_config = mock_float_app_config_item([dependency.name], float_value)
         return _append_config_item_path(float_config, parent_path)
     elif isinstance(dependency, ManifestIntegerScalarConfig):
-        int_value = _mock_scalar_value_with_conversion(dependency, IntScalar)
+        int_value = cast(int, _mock_scalar_value(dependency))
         int_config = mock_int_app_config_item([dependency.name], int_value)
         return _append_config_item_path(int_config, parent_path)
     elif isinstance(dependency, ManifestJsonScalarConfig):
-        json_value = _mock_scalar_value_with_conversion(dependency, JsonScalar)
+        json_value = cast(JsonType, _mock_scalar_value(dependency))
         json_config = mock_json_app_config_item([dependency.name], json_value)
         return _append_config_item_path(json_config, parent_path)
     elif isinstance(dependency, ManifestSecureTextScalarConfig):
-        secure_text_value = _mock_scalar_value_with_conversion(dependency, SecureTextScalar)
+        secure_text_value = cast(str, _mock_scalar_value(dependency))
         secure_text_config = mock_secure_text_app_config_item([dependency.name], secure_text_value)
         return _append_config_item_path(secure_text_config, parent_path)
     else:
         assert not isinstance(dependency, UnknownType), f"Unable to mock unknown type {dependency}"
-        text_value = _mock_scalar_value_with_conversion(dependency, TextScalar)
+        text_value = cast(str, _mock_scalar_value(dependency))
         text_config = mock_text_app_config_item([dependency.name], text_value)
         return _append_config_item_path(text_config, parent_path)
 
@@ -524,12 +498,13 @@ def _append_config_item_path(config_item: AppConfigItem, parent_path: List[str])
 
 
 def _mock_array_dependency(
-    dependency: ManifestArrayConfig, parent_path: List[str] = list(), rows: int = 1
+    dependency: ManifestArrayConfig, parent_path: Optional[List[str]] = None, rows: int = 1
 ) -> List[AppConfigItem]:
     config_rows = []
+    parent_path = parent_path if parent_path else []
     for i in range(rows):
         row = _mock_array_row(dependency, parent_path=parent_path)
-        elements = element_definition_from_dependency(dependency)
+        elements = _element_definition_from_dependency(dependency)
         element_configs = [_mock_dependency(element, row.path) for element in elements]
         flattened_configs = [element for sublist in element_configs for element in sublist]
         config_rows.append(row)
@@ -537,8 +512,9 @@ def _mock_array_dependency(
     return config_rows
 
 
-def _mock_array_row(dependency: ManifestArrayConfig, parent_path: List[str] = list()):
+def _mock_array_row(dependency: ManifestArrayConfig, parent_path: Optional[List[str]] = None):
     row_name = _random_string("Row ")
+    parent_path = parent_path if parent_path else []
     return ArrayElementAppConfigItem(
         id=_random_string("aci_"),
         path=parent_path + [dependency.name, row_name],
@@ -547,25 +523,16 @@ def _mock_array_row(dependency: ManifestArrayConfig, parent_path: List[str] = li
     )
 
 
-def _mock_scalar_value_with_conversion(
-    dependency: ManifestScalarConfig, scalar_definition_type: Type[ScalarDefinition[ScalarType]]
-) -> Optional[ScalarType]:
-    assert not isinstance(dependency, UnknownType), f"Unable to mock unknown type {dependency}"
-    # These types should be equivalent and this appeases MyPy
-    mocked_value_type = ScalarConfigTypes(dependency.type)
-    mocked_value_str = (
-        _mock_scalar_with_enum(dependency)
-        if _is_scalar_with_enum(dependency)
-        else _mock_scalar_value(mocked_value_type)
-    )
-    return scalar_definition_type.from_str(mocked_value_str)
-
-
-def _mock_scalar_with_enum(dependency: ManifestScalarConfig) -> str:
+def _mock_scalar_with_enum(dependency: ManifestScalarConfig) -> Union[float, int, str]:
     assert isinstance(
         dependency, (ManifestFloatScalarConfig, ManifestIntegerScalarConfig, ManifestTextScalarConfig)
     )
-    return str(random.choice(dependency.enum))
+    value = random.choice(dependency.enum)
+    if isinstance(dependency, ManifestFloatScalarConfig):
+        return cast(float, value)
+    elif isinstance(dependency, ManifestIntegerScalarConfig):
+        return cast(int, value)
+    return str(value)
 
 
 def _is_scalar_with_enum(dependency: ManifestScalarConfig) -> bool:
@@ -573,15 +540,16 @@ def _is_scalar_with_enum(dependency: ManifestScalarConfig) -> bool:
         dependency, (ManifestFloatScalarConfig, ManifestIntegerScalarConfig, ManifestTextScalarConfig)
     ):
         # MyPy doesn't find this to be truthy without a specific len check
-        return len(enum_from_dependency(dependency)) > 0
+        return len(_enum_from_dependency(dependency)) > 0
     return False
 
 
 def _mock_subdependency(
     subdependency: Union[BaseManifestConfig, FieldDefinitionsManifest],
     parent_config,
-    parent_path: List[str] = list(),
+    parent_path: Optional[List[str]] = None,
 ) -> AppConfigItem:
+    parent_path = parent_path if parent_path else []
     if isinstance(parent_config, DropdownDependency):
         linked_resource_id = _random_string("opt_")
         return GenericApiIdentifiedAppConfigItem(
@@ -608,8 +576,9 @@ def _mock_subdependency(
 def _mock_workflow_output_subdependency(
     subdependency: Union[BaseManifestConfig, FieldDefinitionsManifest],
     parent_config,
-    parent_path: List[str] = list(),
+    parent_path: Optional[List[str]] = None,
 ) -> AppConfigItem:
+    parent_path = parent_path if parent_path else []
     linked_resource_id = _random_string("tsf_")
     app_config = FieldAppConfigItem(
         id=_random_string("aci_"),
@@ -625,18 +594,28 @@ def _mock_linked_resource(id: str, name: Optional[str] = None) -> LinkedAppConfi
     return LinkedAppConfigResourceSummary(id=id, name=name if name else _random_string("Resource Name"))
 
 
-def _mock_scalar_value(scalar_type: ScalarConfigTypes) -> str:
+def _mock_scalar_value(
+    dependency: ManifestScalarConfig,
+) -> Union[bool, date, datetime, int, float, str, Dict[str, Union[str, float]]]:
     """Mock a scalar config value from its manifest definition."""
-    if scalar_type == scalar_type.BOOLEAN:
-        return "true"
+    if isinstance(dependency, UnknownType):
+        raise UnsupportedConfigItemError(
+            f"Unable to mock scalar value for unsupported dependency type {dependency}"
+        )
+    # These types should be equivalent and this appeases MyPy
+    scalar_type = ScalarConfigTypes(dependency.type)
+    if _is_scalar_with_enum(dependency):
+        return _mock_scalar_with_enum(dependency)
+    elif scalar_type == scalar_type.BOOLEAN:
+        return True
     elif scalar_type == scalar_type.DATE:
-        return date.today().strftime("%Y-%m-%d")
+        return date.today()
     elif scalar_type == scalar_type.DATETIME:
-        return datetime.now().strftime(DateTimeScalar.expected_format())
+        return datetime.now()
     elif scalar_type == scalar_type.FLOAT:
-        return str(random.random())
+        return random.random()
     elif scalar_type == scalar_type.INTEGER:
-        return str(random.randint(-1000, 1000))
+        return random.randint(-1000, 1000)
     elif scalar_type == scalar_type.JSON:
         return json.dumps(
             {_random_string(): [_random_string(), _random_string()], _random_string(): random.random()}

benchling_sdk/apps/config/types.py

@@ -0,0 +1,36 @@
+# Tuple instead of list so it's hashable and preserves order
+from typing import Tuple, Union
+
+from benchling_sdk.models import (
+    ArrayElementAppConfigItem,
+    BooleanAppConfigItem,
+    DateAppConfigItem,
+    DatetimeAppConfigItem,
+    EntitySchemaAppConfigItem,
+    FieldAppConfigItem,
+    FloatAppConfigItem,
+    GenericApiIdentifiedAppConfigItem,
+    IntegerAppConfigItem,
+    JsonAppConfigItem,
+    SecureTextAppConfigItem,
+    TextAppConfigItem,
+)
+
+# Tuple for an ordered collection that's hashable
+ConfigItemPath = Tuple[str, ...]
+
+# Everything from AppConfigItem except UnknownType
+ConfigurationReference = Union[
+    ArrayElementAppConfigItem,
+    DateAppConfigItem,
+    DatetimeAppConfigItem,
+    JsonAppConfigItem,
+    EntitySchemaAppConfigItem,
+    FieldAppConfigItem,
+    BooleanAppConfigItem,
+    IntegerAppConfigItem,
+    FloatAppConfigItem,
+    GenericApiIdentifiedAppConfigItem,
+    SecureTextAppConfigItem,
+    TextAppConfigItem,
+]