balderhub-data 0.0.1__py3-none-any.whl

balderhub/data/__init__.py

@@ -0,0 +1,17 @@
+from balderhub.data.lib.utils.decorator_register_for_data_item import register_for_data_item
+
+__all__ = [
+
+    "register_for_data_item",
+
+    "__version__",
+
+    "__version_tuple__",
+
+]
+
+try:
+    from ._version import __version__, __version_tuple__
+except ImportError:
+    __version__ = ""
+    __version_tuple__ = tuple()

balderhub/data/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.0.1'
+__version_tuple__ = version_tuple = (0, 0, 1)
+
+__commit_id__ = commit_id = None

balderhub/data/contrib/auth/setup_features/__init__.py

@@ -0,0 +1,6 @@
+from . import factories
+from .data_item_param_provider import DataItemParamProvider
+
+__all__ = [
+    'DataItemParamProvider'
+]

balderhub/data/contrib/auth/setup_features/data_item_param_provider.py

@@ -0,0 +1,71 @@
+import enum
+
+import balder
+
+import balderhub.data.lib.scenario_features
+from balderhub.auth.lib.scenario_features.client import UnresolvedResourceParameterConfig
+from balderhub.auth.lib.utils import ResourceRule
+
+from ..utils import ResourceForSpecificDataItem
+
+
+class DataItemParamProvider(UnresolvedResourceParameterConfig):
+    """
+    Handles configuration and provides parameters for resolving resources for specific data items.
+
+    This is a setup-level feature implementation for the
+    :class:`balderhub.auth.lib.scenario_features.client.UnresolvedResourceParameterConfig`. It uses a
+    defined `ResolvingMode` to specify how parameters should be selected out of the remote server feature
+    :class:`balderhub.data.lib.scenario_features.InitialDataConfig`.
+
+    """
+    class ResolvingMode(enum.Enum):
+        """
+        Defines modes for resolving entities.
+
+        This class provides an enumeration of possible resolving modes that dictate
+        how entities are retrieved or resolved.
+        """
+        # this will return all existing
+        ALL = 'all'
+        # will return the first {ENFORCING_PARAMETERS} items (ENFORCING_PARAMETERS needs to be >0)
+        MINIMUM = 'minimum'
+
+    #: defines the mode used to resolve parameters. It can either return all existing parameters
+    # (``ResolvingMode.ALL``) or enforce a minimum required number of parameters (``ResolvingMode.MINIMUM``).
+    RESOLVING_MODE: ResolvingMode = ResolvingMode.ALL
+    #: specifies the minimum number of parameters to enforce when in  ``ResolvingMode.MINIMUM``. Must be greater
+    #: than 0 for that mode.
+    ENFORCING_PARAMETERS = 0
+
+    class Server(balder.VDevice):
+        """server vdevice holding the specified initial data configuration feature"""
+        all_data = balderhub.data.lib.scenario_features.InitialDataConfig()
+
+    def get_parameters_for(self, resource_rule: ResourceRule) -> list[ResourceForSpecificDataItem.Parameter]:
+        data = self.Server.all_data.data_list
+
+        parameters = [ResourceForSpecificDataItem.Parameter(elem) for elem in data]
+
+        if resource_rule.cb_rule is not None:
+            # filter parameters
+            parameters = [param for param in parameters if resource_rule.cb_rule(param)]
+
+        if self.RESOLVING_MODE == self.ResolvingMode.ALL:
+            # do nothing
+            pass
+        elif self.RESOLVING_MODE == self.ResolvingMode.MINIMUM:
+            if self.ENFORCING_PARAMETERS <= 0:
+                raise ValueError(
+                    f'in resolving mode {self.ResolvingMode.MINIMUM} the ENFORCING_PARAMETERS needs to be >0'
+                )
+            parameters = parameters[:self.ENFORCING_PARAMETERS]
+        else:
+            raise ValueError(f'unexpected value for ResolvingMode {self.RESOLVING_MODE}')
+
+        if len(parameters) < self.ENFORCING_PARAMETERS:
+            raise ValueError(
+                f'{self.__class__.__name__}.ENFORCING_PARAMETERS requires at least {self.ENFORCING_PARAMETERS} '
+                f'parameters for every rule - but rule {resource_rule} only has {len(parameters)} possible parameters')
+
+        return parameters

balderhub/data/contrib/auth/setup_features/factories/__init__.py

@@ -0,0 +1,6 @@
+from .auto_data_param_provider_factory import AutoDataParamProviderFactory
+
+
+__all__ = [
+    'AutoDataParamProviderFactory',
+]

balderhub/data/contrib/auth/setup_features/factories/auto_data_param_provider_factory.py

@@ -0,0 +1,41 @@
+from balderhub.data.lib.scenario_features import AbstractDataItemRelatedFeature
+import balderhub.data.lib.scenario_features.factories
+from balderhub.data.lib.utils import SingleDataItem
+from balderhub.data.lib.utils.auto_feature_factory import AutoFeatureFactory
+
+
+class AutoDataParamProviderFactory(AutoFeatureFactory):
+    """
+    Represents a factory for creating parameter providers related to data items for auto-generated features.
+
+    The `AutoDataParamProviderFactory` is responsible for defining and constructing data item parameter
+    providers dynamically for use with auto-generated features. It creates data item bounded setup-level features
+    of :class:`balderhub.auth.contrib.data.setup_features.DataItemParamProvider`.
+    """
+
+    @classmethod
+    def _define_class(cls, data_item_cls: type[SingleDataItem], **kwargs) -> type[AbstractDataItemRelatedFeature]:
+        # pylint: disable-next=import-outside-toplevel
+        from ..data_item_param_provider import DataItemParamProvider
+
+        resolving_mode = kwargs.pop('resolving_mode') if 'resolving_mode' in kwargs else \
+            DataItemParamProvider.ResolvingMode.ALL
+
+        enforcing_parameters = kwargs.pop('enforcing_parameters') if 'enforcing_parameters' in kwargs else 0
+
+        class AutoDataItemParamProvider(DataItemParamProvider):
+            """
+            auto created data item bounded setup-level feature of
+            :class:`balderhub.auth.contrib.data.setup_features.DataItemParamProvider`
+            """
+            RESOLVING_MODE = resolving_mode
+            ENFORCING_PARAMETERS = enforcing_parameters
+            class Server(DataItemParamProvider.Server):
+                """
+                server vdevice with data-item bounded setup-level feature implementation of
+                :class:`balderhub.data.lib.scenario_features.InitialDataConfig`.
+                """
+                all_data = \
+                    balderhub.data.lib.scenario_features.factories.AutoInitialDataConfigFactory.get_for(data_item_cls)()
+
+        return AutoDataItemParamProvider

balderhub/data/contrib/auth/utils/__init__.py

@@ -0,0 +1,5 @@
+from .resource_for_specific_data_item import ResourceForSpecificDataItem
+
+__all__ = [
+    'ResourceForSpecificDataItem'
+]

balderhub/data/contrib/auth/utils/resource_for_specific_data_item.py

@@ -0,0 +1,59 @@
+from abc import ABC, abstractmethod
+from typing import Type
+
+import dataclasses
+from balderhub.data.lib.utils import SingleDataItem
+
+
+from balderhub.auth.lib.utils import Resource
+from balderhub.auth.lib.utils import UnresolvedResource
+
+
+class ResourceForSpecificDataItem(UnresolvedResource, ABC):
+    """
+    This class represents an unresolved resource that is specific for a certain data item type.
+    """
+
+    @dataclasses.dataclass
+    class Parameter(UnresolvedResource.Parameter):
+        """
+        The parameter class for the `ResourceForSpecificDataItem` class.
+        """
+        data_item: SingleDataItem
+
+    def __init__(
+            self,
+            data_item_type: Type[SingleDataItem],
+            **kwargs
+    ):
+        """
+        :param data_item_type: the type of the data item
+        :param kwargs: additional keyword arguments for the `UnresolvedResource` constructor
+        """
+        super().__init__(**kwargs)
+        self._data_item_type = data_item_type
+
+    def __str__(self):
+        return f"{super().__str__()}({self._data_item_type.__name__})"
+
+    def __eq__(self, other):
+        if self.__class__ != other.__class__:
+            return False
+        return self.data_item_type == other.data_item_type
+
+    def __hash__(self):
+        return hash(self.__class__) + hash(self._data_item_type)
+
+    @property
+    def data_item_type(self) -> Type[SingleDataItem]:
+        """returns the data item type of this resource"""
+        return self._data_item_type
+
+    @abstractmethod
+    def get_resolved_resource(self, param: Parameter) -> Resource:
+        """
+        Resolves the resource with the given parameter.
+
+        :param param: the parameter for the unresolved resource
+        :return: the resolved resource
+        """

balderhub/data/lib/__init__.py

@@ -0,0 +1,6 @@
+# TODO add classes / functions from module (if any)
+# TODO delete module if it has no sub elements
+
+__all__ = [
+
+]

balderhub/data/lib/scenario_features/__init__.py

@@ -0,0 +1,14 @@
+from . import factories
+
+from .abstract_data_item_related_feature import AbstractDataItemRelatedFeature
+from .accessible_initial_data_config import AccessibleInitialDataConfig
+from .data_environment_feature import DataEnvironmentFeature
+from .initial_data_config import InitialDataConfig
+
+
+__all__ = [
+    'AbstractDataItemRelatedFeature',
+    'AccessibleInitialDataConfig',
+    'DataEnvironmentFeature',
+    'InitialDataConfig',
+]

balderhub/data/lib/scenario_features/abstract_data_item_related_feature.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+from typing import Type
+import balder
+
+from ..utils.single_data_item import SingleDataItem
+
+
+class AbstractDataItemRelatedFeature(balder.Feature):
+    """
+    Base factory usable feature. All Features that should be creatable by a factory class needs to be a subclass of
+    this feature class.
+    """
+    #: static managing class property that stores parametrized feature class definitions per data item class
+    _features_by_data_item_type = {}
+
+    @property
+    def data_item_type(self) -> Type[SingleDataItem]:
+        """
+        :return: returns the type of the data item, this feature belongs too
+        """
+        if not hasattr(self.__class__, '_for_data_item_type'):
+            raise ValueError(
+                f'data item related feature `{self.__class__}` was not registered for a specific data item'
+            )
+        return getattr(self.__class__, '_for_data_item_type')
+
+    @classmethod
+    def set_data_item_type(cls, data_item_type: Type[SingleDataItem]) -> None:
+        """
+        This class method sets the data-item type. This method is normally called by the decorator
+        `@register_for_data_item()`.
+
+        :param data_item_type: the data item type
+        """
+        cls._for_data_item_type = data_item_type
+        cls.register_feature_with_data_item_type(feature_cls=cls, data_item_type=data_item_type)
+
+    @classmethod
+    def register_feature_with_data_item_type(
+            cls,
+            feature_cls: type[AbstractDataItemRelatedFeature],
+            data_item_type: Type[SingleDataItem]
+    ) -> None:
+        """
+        Internally used class for managing the correct assignment of data item type to that feature.
+
+        :param feature_cls: the feature class type that should be registered
+        :param data_item_type: the data item type that should be assigned to the provided `feature_cls`
+        """
+        if cls not in AbstractDataItemRelatedFeature._features_by_data_item_type.keys():
+            AbstractDataItemRelatedFeature._features_by_data_item_type[cls] = {}
+
+        if data_item_type not in AbstractDataItemRelatedFeature._features_by_data_item_type[cls]:
+            AbstractDataItemRelatedFeature._features_by_data_item_type[cls][data_item_type] = []
+
+        #: only add it if it was not added before
+        if feature_cls not in AbstractDataItemRelatedFeature._features_by_data_item_type[cls][data_item_type]:
+            AbstractDataItemRelatedFeature._features_by_data_item_type[cls][data_item_type].append(feature_cls)
+
+        # now register that for all parent classes that are based on :class:`AbstractDataItemRelatedFeature` too
+        for cur_base in cls.__bases__:
+            if issubclass(cur_base, AbstractDataItemRelatedFeature):
+                cur_base.register_feature_with_data_item_type(feature_cls=feature_cls, data_item_type=data_item_type)
+
+    @classmethod
+    def get_specific_feature_for(cls, data_item_type: Type[SingleDataItem], **vdevice_mapping):
+        """
+        This method returns an instantiated feature object that was previously registered for the provided
+        `data_item_type`.
+
+        :param data_item_type: the data item type the new instance should be for
+        :param vdevice_mapping: optional a vdevice mapping for the feature # TODO do use dict here
+        :return: returns a feature object of this type that was defined for the provided `data_item_type`
+        """
+
+        available_feature_classes = \
+            AbstractDataItemRelatedFeature._features_by_data_item_type.get(cls, {}).get(data_item_type, [])
+
+        if len(available_feature_classes) == 0:
+            raise KeyError(f'can not find a registered feature for data item `{data_item_type}` in `{cls.__name__}`')
+        if len(available_feature_classes) > 1:
+            raise KeyError(f'found more than one possible features for data item `{data_item_type}` in '
+                           f'`{cls.__name__}`')
+        return available_feature_classes[0](**vdevice_mapping)

balderhub/data/lib/scenario_features/accessible_initial_data_config.py

@@ -0,0 +1,15 @@
+from ..utils.single_data_item_collection import SingleDataItemCollection
+from .initial_data_config import InitialDataConfig
+
+
+class AccessibleInitialDataConfig(InitialDataConfig):
+    """
+    This config feature returns a list of data item elements, that is accessible for the using device.
+    """
+
+    @property
+    def data_list(self) -> SingleDataItemCollection:
+        """
+        :return: returns the data item collection this config feature describes
+        """
+        raise NotImplementedError()

balderhub/data/lib/scenario_features/data_environment_feature.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+from typing import Any, List, Dict, Type
+import balder
+
+from balderhub.data.lib.utils import SingleDataItemCollection
+from balderhub.data.lib.utils.single_data_item import SingleDataItem, SingleDataItemTypeT
+from balderhub.data.lib.utils.exceptions import DuplicateDataObjectError
+
+
+class DataEnvironmentFeature(balder.Feature):
+    """
+    The Data Environment Feature provides an interface for managing a big data set. It helps to configure your tests
+    depending on the selected data sets. You can use it to create a nested data-environment structure and define
+    different data sets for different setups.
+    """
+
+    # TODO do we need a plausibility check after the `load_data` call, that makes sure, that references between all data
+    #  exist?
+    # TODO make sure that `unique_identification` is unique everywhere
+
+    class DoesNotExist(Exception):
+        """
+        error that is thrown if an element does that is requested by some methods does not exist in the environment
+        """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        # holds the whole data
+        self._data: Dict[Type[SingleDataItemTypeT], Dict[Any, SingleDataItemTypeT]] = {}
+
+        self.load_data()
+
+    def load_data(self) -> None:
+        """
+        This method will be executed to generate / load the data for this environment into the object. You need to
+        overwrite it in subclass to fill the data environment with data.
+        """
+
+    def get_all_for(self, data_obj_type: Type[SingleDataItemTypeT]) -> SingleDataItemCollection:
+        """
+        This method returns all known data-items for a specific data item type.
+        :param data_obj_type: the data-item type
+        :return: a list of all known data-items
+        """
+        if data_obj_type not in self._data.keys():
+            return SingleDataItemCollection([])
+        return SingleDataItemCollection(list(self._data[data_obj_type].values()))
+
+    def get(self, data_obj_type: Type[SingleDataItemTypeT], unique_identification: Any) -> SingleDataItemTypeT:
+        """
+        This method returns exactly one element identified by the `unique_identification`.
+        It raises an exception if the requested element does not exist in the environment.
+
+        :param data_obj_type: the data-item type
+        :param unique_identification: the unique-identification value of the requested data-item type
+        :return: the specific data item
+        """
+        if data_obj_type not in self._data.keys():
+            raise self.DoesNotExist(f'no items from type `{data_obj_type}` exist in the environment')
+        if unique_identification not in self._data[data_obj_type].keys():
+            raise self.DoesNotExist(f'no element with unique-identification `{unique_identification}` of '
+                                    f'type `{data_obj_type}` exist in the environment')
+        return self._data[data_obj_type][unique_identification]
+
+    def _add_data(self, data_objects: SingleDataItem | List[SingleDataItem]) -> None:
+        """
+        Method to add a new data set to the internal data set storage.
+
+        :param data_objects: the data item object / objects that should be added
+        """
+        if isinstance(data_objects, SingleDataItem):
+            data_objects = [data_objects]
+        for cur_data_object in data_objects:
+            if cur_data_object.__class__ not in self._data.keys():
+                self._data[cur_data_object.__class__] = {}
+            if cur_data_object.get_unique_identification() in self._data[cur_data_object.__class__].keys():
+                raise DuplicateDataObjectError(
+                    'another data object with the same identifier already exists in environment data'
+                )
+            self._data[cur_data_object.__class__][cur_data_object.get_unique_identification()] = cur_data_object
+
+    def sync_environment(self) -> None:
+        """
+        This method executes the transfer of the environment in the related system. It should handle the creation of
+        the stored data with the related system.
+        It is expected that after calling this method, the environment data and the data within the related system are
+        in sync.
+        """
+        raise NotImplementedError

balderhub/data/lib/scenario_features/factories/__init__.py

@@ -0,0 +1,7 @@
+from .auto_accessible_initial_data_config_factory import AutoAccessibleInitialDataConfigFactory
+from .auto_initial_data_config_factory import AutoInitialDataConfigFactory
+
+__all__ = [
+    'AutoAccessibleInitialDataConfigFactory',
+    'AutoInitialDataConfigFactory',
+]

balderhub/data/lib/scenario_features/factories/auto_accessible_initial_data_config_factory.py

@@ -0,0 +1,25 @@
+from typing import Type
+
+from balderhub.data.lib.scenario_features.accessible_initial_data_config import AccessibleInitialDataConfig
+
+from balderhub.data.lib.utils.auto_feature_factory import AutoFeatureFactory
+from balderhub.data.lib.utils.single_data_item import SingleDataItem
+from balderhub.data.lib.utils.single_data_item_collection import SingleDataItemCollection
+
+
+class AutoAccessibleInitialDataConfigFactory(AutoFeatureFactory):
+    """
+    Factory for creating data-item bounded scenario-based config-feature :class:`AccessibleInitialDataConfig`
+    """
+
+    @classmethod
+    def _define_class(cls, data_item_cls: Type[SingleDataItem], **kwargs):
+
+        class AutoAccessibleInitialDataConfig(AccessibleInitialDataConfig):
+            """inner factory-created feature class"""
+
+            @property
+            def data_list(self) -> SingleDataItemCollection:
+                raise NotImplementedError()
+
+        return AutoAccessibleInitialDataConfig

balderhub/data/lib/scenario_features/factories/auto_initial_data_config_factory.py

@@ -0,0 +1,24 @@
+from typing import Type
+
+from balderhub.data.lib.utils import SingleDataItemCollection
+from balderhub.data.lib.utils.auto_feature_factory import AutoFeatureFactory
+from balderhub.data.lib.scenario_features.initial_data_config import InitialDataConfig
+from balderhub.data.lib.utils.single_data_item import SingleDataItem
+
+
+class AutoInitialDataConfigFactory(AutoFeatureFactory):
+    """
+    Factory for creating data-item bounded scenario-based config-feature :class:`InitialDataConfig`
+    """
+
+    @classmethod
+    def _define_class(cls, data_item_cls: Type[SingleDataItem], **kwargs):
+
+        class AutoInitialDataConfig(InitialDataConfig):
+            """inner factory-created feature class"""
+
+            @property
+            def data_list(self) -> SingleDataItemCollection:
+                raise NotImplementedError()
+
+        return AutoInitialDataConfig

balderhub/data/lib/scenario_features/initial_data_config.py

@@ -0,0 +1,15 @@
+from .abstract_data_item_related_feature import AbstractDataItemRelatedFeature
+from ..utils.single_data_item_collection import SingleDataItemCollection
+
+
+class InitialDataConfig(AbstractDataItemRelatedFeature):
+    """
+    This config feature returns a list of data item elements.
+    """
+
+    @property
+    def data_list(self) -> SingleDataItemCollection:
+        """
+        :return: returns the data item collection this config feature describes
+        """
+        raise NotImplementedError()

balderhub/data/lib/setup_features/__init__.py

@@ -0,0 +1,6 @@
+from . import factories
+
+
+__all__ = [
+
+]

balderhub/data/lib/setup_features/factories/__init__.py

@@ -0,0 +1,7 @@
+from .auto_accessible_initial_data_config_factory import AutoAccessibleInitialDataConfigFactory
+from .auto_initial_data_config_factory import AutoInitialDataConfigFactory
+
+__all__ = [
+    'AutoAccessibleInitialDataConfigFactory',
+    'AutoInitialDataConfigFactory',
+]

balderhub/data/lib/setup_features/factories/auto_accessible_initial_data_config_factory.py

@@ -0,0 +1,50 @@
+from typing import Callable, Union
+
+import balder
+
+from balderhub.data.lib.utils.auto_feature_factory import AutoFeatureFactory
+from balderhub.data.lib.utils import SingleDataItemCollection
+from balderhub.data.lib.utils.single_data_item import SingleDataItem
+from balderhub.data.lib import scenario_features
+from balderhub.data.lib.utils.filter import Filter
+
+
+class AutoAccessibleInitialDataConfigFactory(AutoFeatureFactory):
+    """
+    Factory for creating data-item bounded scenario-based config-feature :class:`MultipleDataConfig` by using the
+    defined data within a :class:`DataEnvironmentFeature`.
+    """
+    @classmethod
+    def get_for(
+            cls,
+            data_item_cls: type[SingleDataItem],
+            filter_func: Union[Callable[[SingleDataItem], bool], None] = None,
+            **kwargs
+    ):
+        return super().get_for(data_item_cls, filter_func=filter_func)
+
+    @classmethod
+    def _define_class(cls, data_item_cls: type[SingleDataItem], **kwargs):
+        filter_func = kwargs['filter_func']
+
+        class AutoAccessibleInitialDataConfig(
+            scenario_features.factories.AutoAccessibleInitialDataConfigFactory.get_for(data_item_cls)
+        ):
+            """inner factory-created feature class"""
+            class Master(balder.VDevice):
+                """inner vdevice referencing the master device that provides the full initial data config"""
+                full_initial_config = scenario_features.factories.AutoInitialDataConfigFactory.get_for(data_item_cls)()
+
+            class Filter(Filter):
+                """filter that filters the initial data"""
+                def apply(self, item: SingleDataItem) -> bool:
+                    return filter_func(item)
+
+            @property
+            def data_list(self) -> SingleDataItemCollection:
+                """returns the accessible data according to the provided filter"""
+                if filter_func is None:
+                    return self.Master.full_initial_config.data_list
+                return self.Master.full_initial_config.data_list.filter(self.Filter())
+
+        return AutoAccessibleInitialDataConfig

balderhub/data/lib/setup_features/factories/auto_initial_data_config_factory.py

@@ -0,0 +1,29 @@
+from typing import Type
+
+from balderhub.data.lib.utils.auto_feature_factory import AutoFeatureFactory
+from balderhub.data.lib.scenario_features import DataEnvironmentFeature
+from balderhub.data.lib.utils.single_data_item import SingleDataItem
+from balderhub.data.lib import scenario_features
+
+
+class AutoInitialDataConfigFactory(AutoFeatureFactory):
+    """
+    Factory for creating data-item bounded scenario-based config-feature :class:`MultipleDataConfig` by using the
+    defined data within a :class:`DataEnvironmentFeature`.
+    """
+
+    @classmethod
+    def _define_class(cls, data_item_cls: Type[SingleDataItem], **kwargs):
+
+        class AutoMultipleDataConfig(scenario_features.factories.AutoInitialDataConfigFactory.get_for(data_item_cls)):
+            """inner factory-created feature class"""
+            env = DataEnvironmentFeature()
+
+            @property
+            def data_list(self):
+                """
+                :return: returns the data item collection this config feature describes
+                """
+                return self.env.get_all_for(data_item_cls)
+
+        return AutoMultipleDataConfig

balderhub/data/lib/utils/__init__.py

@@ -0,0 +1,18 @@
+from .auto_feature_factory import AutoFeatureFactory
+from .base_response_message import BaseResponseMessage
+from .not_definable import NOT_DEFINABLE
+from .lookup_field_string import LookupFieldString
+from .response_message import ResponseMessage
+from .response_message_list import ResponseMessageList
+from .single_data_item import SingleDataItem
+from .single_data_item_collection import SingleDataItemCollection
+
+__all__ = [
+    'NOT_DEFINABLE',
+    'BaseResponseMessage',
+    'LookupFieldString',
+    'ResponseMessage',
+    'ResponseMessageList',
+    'SingleDataItem',
+    'SingleDataItemCollection'
+]