def get_descriptor_element_impls(): """ Discover and return Descriptor implementation classes found in the plugin directory. Keys in the returned map are the names of the discovered classes and the paired values are the actual class type objects. We look for modules (directories or files) that start with and alphanumeric character ('_' prefixed files/directories are hidden, but not recommended). Within a module, we first look for a helper variable by the name ``DESCRIPTOR_ELEMENT_CLASS``, which can either be a single class object or an iterable of class objects, to be exported. If the variable is set to None, we skip that module and do not import anything. If the variable is not present, we look for a class by the same na e and casing as the module's name. If neither are found, the module is skipped. :return: Map of discovered class objects of type ``DescriptorElement`` whose keys are the string names of the classes. :rtype: dict[str, type] """ import os from smqtk.utils.plugin import get_plugins this_dir = os.path.abspath(os.path.dirname(__file__)) helper_var = "DESCRIPTOR_ELEMENT_CLASS" return get_plugins(__name__, this_dir, helper_var, DescriptorElement)
def get_data_element_impls(reload_modules=False): """ Discover and return discovered ``DataElement`` classes. Keys in the returned map are the names of the discovered classes, and the paired values are the actual class type objects. We search for implementation classes in: - modules next to this file this function is defined in (ones that begin with an alphanumeric character), - python modules listed in the environment variable ``DATA_ELEMENT_PATH`` - This variable should contain a sequence of python module specifications, separated by the platform specific PATH separator character (``;`` for Windows, ``:`` for unix) Within a module we first look for a helper variable by the name ``DATA_ELEMENT_CLASS``, which can either be a single class object or an iterable of class objects, to be specifically exported. If the variable is set to None, we skip that module and do not import anything. If the variable is not present, we look at attributes defined in that module for classes that descend from the given base class type. If none of the above are found, or if an exception occurs, the module is skipped. :param reload_modules: Explicitly reload discovered modules from source. :type reload_modules: bool :return: Map of discovered class object of type ``DataElement`` whose keys are the string names of the classes. :rtype: dict[str, type] """ this_dir = os.path.abspath(os.path.dirname(__file__)) env_var = "DATA_ELEMENT_PATH" helper_var = "DATA_ELEMENT_CLASS" return plugin.get_plugins(__name__, this_dir, env_var, helper_var, DataElement, reload_modules=reload_modules)
def get_catalysts(): """ Discover and return Catalyst classes found in the given plugin search directory. Keys in the returned map are the names of the discovered classes, and the paired values are the actual class type objects. We look for modules (directories or files) that start with an alphanumeric character ('_' prefixed files/directories are hidden, but not recommended). Within a module we first look for a helper variable by the name ``CATALYST_CLASS``, which can either be a single class object or an iterable of class objects, to be exported. If the variable is set to None, we skip that module and do not import anything. If the variable is not present, we look for a class by the same name and casing as the module. If neither are found, the module is skipped. :return: Map of discovered class object of type ``Catalyst`` whose keys are the string names of the classes. :rtype: dict of (str, type) """ from smqtk.utils.plugin import get_plugins this_dir = os.path.abspath(os.path.dirname(__file__)) helper_var = "CATALYST_CLASS" return get_plugins(__name__, this_dir, helper_var, Catalyst)
def get_descriptor_element_impls(reload_modules=False): """ Discover and return discovered ``DescriptorElement`` classes. Keys in the returned map are the names of the discovered classes, and the paired values are the actual class type objects. We search for implementation classes in: - modules next to this file this function is defined in (ones that begin with an alphanumeric character), - python modules listed in the environment variable ``DESCRIPTOR_ELEMENT_PATH`` - This variable should contain a sequence of python module specifications, separated by the platform specific PATH separator character (``;`` for Windows, ``:`` for unix) Within a module we first look for a helper variable by the name ``DESCRIPTOR_ELEMENT_CLASS``, which can either be a single class object or an iterable of class objects, to be specifically exported. If the variable is set to None, we skip that module and do not import anything. If the variable is not present, we look at attributes defined in that module for classes that descend from the given base class type. If none of the above are found, or if an exception occurs, the module is skipped. :param reload_modules: Explicitly reload discovered modules from source. :type reload_modules: bool :return: Map of discovered class object of type ``DescriptorElement`` whose keys are the string names of the classes. :rtype: dict[str, type] """ this_dir = os.path.abspath(os.path.dirname(__file__)) env_var = "DESCRIPTOR_ELEMENT_PATH" helper_var = "DESCRIPTOR_ELEMENT_CLASS" return plugin.get_plugins(__name__, this_dir, env_var, helper_var, DescriptorElement, reload_modules)
def get_code_index_impls(reload_modules=False): """ Discover and return small-code index implementation classes found in the plugin directory. Keys in the returned map are the names of the discovered implementations and the paired values are the actual class type objects. We look for modules (directories or files) that start with and alphanumeric character ('_' prefixed files/directories are hidden, but not recommended). Within a module, we first look for a helper variable by the name ``CODE_INDEX_CLASS``, which can either be a single class object or an iterable of class objects, to be exported. If the variable is set to None, we skip that module and do not import anything. If the variable is not present, we look for a class by the same na e and casing as the module's name. If neither are found, the module is skipped. :param reload_modules: Explicitly reload discovered modules from source. :type reload_modules: bool :return: Map of discovered class objects of type ``CodeIndex`` whose keys are the string names of the classes. :rtype: dict[str, type] """ import os.path as osp from smqtk.utils.plugin import get_plugins this_dir = osp.abspath(osp.dirname(__file__)) helper_var = 'CODE_INDEX_CLASS' fltr = lambda cls: cls.is_usable() return get_plugins(__name__, this_dir, helper_var, CodeIndex, fltr, reload_modules)
def get_descriptor_generator_impls(reload_modules=False): """ Discover and return ``DescriptorGenerator`` classes found in the given plugin search directory. Keys in the returned map are the names of the discovered classes, and the paired values are the actual class type objects. We look for modules (directories or files) that start with an alphanumeric character ('_' prefixed files/directories are hidden, but not recommended). Within a module we first look for a helper variable by the name ``DESCRIPTOR_GENERATOR_CLASS``, which can either be a single class object or an iterable of class objects, to be exported. If the variable is set to None, we skip that module and do not import anything. If the variable is not present, we look for a class by the same name and casing as the module. If neither are found, the module is skipped. :param reload_modules: Explicitly reload discovered modules from source. :type reload_modules: bool :return: Map of discovered class object of type ``DescriptorGenerator`` whose keys are the string names of the classes. :rtype: dict[str, type] """ from smqtk.utils.plugin import get_plugins this_dir = os.path.abspath(os.path.dirname(__file__)) env_var = "DESCRIPTOR_GENERATOR_PATH" helper_var = "DESCRIPTOR_GENERATOR_CLASS" return get_plugins(__name__, this_dir, env_var, helper_var, DescriptorGenerator, reload_modules=reload_modules)
def get_web_applications(reload_modules=False): """ Discover and return SmqtkWebApp implementation classes found in the plugin directory. Keys in the returned map are the names of the discovered classes and the paired values are the actual class type objects. We look for modules (directories or files) that start with and alphanumeric character ('_' prefixed files/directories are hidden, but not recommended). Within a module, we first look for a helper variable by the name ``APPLICATION_CLASS``, which can either be a single class object or an iterable of class objects, to be exported. If the variable is set to None, we skip that module and do not import anything. If the variable is not present, we look for a class by the same na e and casing as the module's name. If neither are found, the module is skipped. :param reload_modules: Explicitly reload discovered modules from source. :type reload_modules: bool :return: Map of discovered class objects of type ``SmqtkWebApp`` whose keys are the string names of the classes. :rtype: dict[str, type] """ import os from smqtk.utils.plugin import get_plugins this_dir = os.path.abspath(os.path.dirname(__file__)) env_var = "APPLICATION_PATH" helper_var = "APPLICATION_CLASS" return get_plugins(__name__, this_dir, env_var, helper_var, SmqtkWebApp, reload_modules=reload_modules)
def get_code_index_impls(reload_modules=False): """ Discover and return small-code index implementation classes found in the plugin directory. Keys in the returned map are the names of the discovered implementations and the paired values are the actual class type objects. We look for modules (directories or files) that start with and alphanumeric character ('_' prefixed files/directories are hidden, but not recommended). Within a module, we first look for a helper variable by the name ``CODE_INDEX_CLASS``, which can either be a single class object or an iterable of class objects, to be exported. If the variable is set to None, we skip that module and do not import anything. If the variable is not present, we look for a class by the same na e and casing as the module's name. If neither are found, the module is skipped. :param reload_modules: Explicitly reload discovered modules from source. :type reload_modules: bool :return: Map of discovered class objects of type ``CodeIndex`` whose keys are the string names of the classes. :rtype: dict[str, type] """ import os.path as osp from smqtk.utils.plugin import get_plugins this_dir = osp.abspath(osp.dirname(__file__)) env_var = 'CODE_INDEX_PATH' helper_var = 'CODE_INDEX_CLASS' return get_plugins(__name__, this_dir, env_var, helper_var, CodeIndex, reload_modules=reload_modules)
def get_plugins_for_class(cls, warn=False): """ Test standard wrapper on get_plugins call using test constants. This is not a fixture due to environment variable mocking. """ # Suppressing warnings for testing purposes. return get_plugins(cls, ENV_VAR, HELP_VAR, warn=warn)
def get_classifier_impls(reload_modules=False, sub_interface=None): """ Discover and return discovered ``Classifier`` classes. Keys in the returned map are the names of the discovered classes, and the paired values are the actual class type objects. We search for implementation classes in: - modules next to this file this function is defined in (ones that begin with an alphanumeric character), - python modules listed in the environment variable :envvar:`CLASSIFIER_PATH` - This variable should contain a sequence of python module specifications, separated by the platform specific PATH separator character (``;`` for Windows, ``:`` for unix) Within a module we first look for a helper variable by the name ``CLASSIFIER_CLASS``, which can either be a single class object or an iterable of class objects, to be specifically exported. If the variable is set to None, we skip that module and do not import anything. If the variable is not present, we look at attributes defined in that module for classes that descend from the given base class type. If none of the above are found, or if an exception occurs, the module is skipped. :param reload_modules: Explicitly reload discovered modules from source. :type reload_modules: bool :param sub_interface: Only return implementations that also descend from the given sub-interface. The given interface must also descend from :class:`Classifier`. :return: Map of discovered class object of type :class:`Classifier` whose keys are the string names of the classes. :rtype: dict[str, type] """ this_dir = os.path.abspath(os.path.dirname(__file__)) env_var = "CLASSIFIER_PATH" helper_var = "CLASSIFIER_CLASS" if sub_interface is None: base_class = Classifier else: assert issubclass(sub_interface, Classifier), \ "The given sub-interface type must descend from `Classifier`." base_class = sub_interface return plugin.get_plugins(__name__, this_dir, env_var, helper_var, base_class, reload_modules=reload_modules)
def get_classifier_impls(reload_modules=False, sub_interface=None): """ Discover and return discovered ``Classifier`` classes. Keys in the returned map are the names of the discovered classes, and the paired values are the actual class type objects. We search for implementation classes in: - modules next to this file this function is defined in (ones that begin with an alphanumeric character), - python modules listed in the environment variable :envvar:`CLASSIFIER_PATH` - This variable should contain a sequence of python module specifications, separated by the platform specific PATH separator character (``;`` for Windows, ``:`` for unix) Within a module we first look for a helper variable by the name ``CLASSIFIER_CLASS``, which can either be a single class object or an iterable of class objects, to be specifically exported. If the variable is set to None, we skip that module and do not import anything. If the variable is not present, we look at attributes defined in that module for classes that descend from the given base class type. If none of the above are found, or if an exception occurs, the module is skipped. :param reload_modules: Explicitly reload discovered modules from source. :type reload_modules: bool :param sub_interface: Only return implementations that also descend from the given sub-interface. The given interface must also descend from :class:`Classifier`. :return: Map of discovered class object of type :class:`Classifier` whose keys are the string names of the classes. :rtype: dict[str, type] """ this_dir = os.path.abspath(os.path.dirname(__file__)) env_var = "CLASSIFIER_PATH" helper_var = "CLASSIFIER_CLASS" if sub_interface is None: base_class = Classifier else: assert issubclass(sub_interface, Classifier), \ "The given sub-interface type must descend from `Classifier`." base_class = sub_interface # __package__ resolves to the containing module of this module, or # `smqtk.algorithms.classifier` in this case. return plugin.get_plugins(__package__, this_dir, env_var, helper_var, base_class, reload_modules=reload_modules)
def get_nn_index_impls(reload_modules=False): """ Discover and return ``NearestNeighborsIndex`` implementation classes found in the given plugin search directory. Keys in the returned map are the names of the discovered classes, and the paired values are the actual class type objects. We look for modules (directories or files) that start with an alphanumeric character ('_' prefixed files/directories are hidden, but not recommended). Within a module we first look for a helper variable by the name ``NN_INDEX_CLASS``, which can either be a single class object or an iterable of class objects, to be exported. If the variable is set to None, we skip that module and do not import anything. If the variable is not present, we look for a class by the same name and casing as the module. If neither are found, the module is skipped. :param reload_modules: Explicitly reload discovered modules from source. :type reload_modules: bool :return: Map of discovered class object of type ``NearestNeighborsIndex`` whose keys are the string names of the classes. :rtype: dict of (str, type) """ from smqtk.utils.plugin import get_plugins import os this_dir = os.path.abspath(os.path.dirname(__file__)) helper_var = "NN_INDEX_CLASS" def class_filter(cls): log = logging.getLogger('.'.join([__name__, 'get_nn_index_impls', 'class_filter'])) if not cls.is_usable(): log.warn("Class type '%s' not usable, filtering out.", cls.__name__) return False return True return get_plugins(__name__, this_dir, helper_var, NearestNeighborsIndex, class_filter, reload_modules)
def get_dummy_plugins(cls): return get_plugins(cls.INTERNAL_PLUGIN_MOD_PATH, cls.INTERNAL_PLUGIN_DIR, cls.ENV_VAR, cls.HELP_VAR, DummyInterface)