From 3b1331de51411d52d60100a4ebe07d9d66f2ca38 Mon Sep 17 00:00:00 2001 From: John Chilton Date: Mon, 12 Sep 2022 14:48:22 -0400 Subject: [PATCH] Remove code and config option related to loading shed datatypes. --- lib/galaxy/app.py | 13 +- lib/galaxy/config/sample/galaxy.yml.sample | 9 - lib/galaxy/config/schemas/config_schema.yml | 11 - lib/galaxy/datatypes/registry.py | 230 +++--------------- .../galaxy_install/datatypes/__init__.py | 0 .../datatypes/custom_datatype_manager.py | 182 -------------- .../installed_repository_manager.py | 26 -- 7 files changed, 39 insertions(+), 432 deletions(-) delete mode 100644 lib/galaxy/tool_shed/galaxy_install/datatypes/__init__.py delete mode 100644 lib/galaxy/tool_shed/galaxy_install/datatypes/custom_datatype_manager.py diff --git a/lib/galaxy/app.py b/lib/galaxy/app.py index f3d208869d3..7d4227e1902 100644 --- a/lib/galaxy/app.py +++ b/lib/galaxy/app.py @@ -328,18 +328,10 @@ class ConfiguresGalaxyMixin: raise def _configure_datatypes_registry( - self, installed_repository_manager=None, use_display_applications=True, use_converters=True + self, use_display_applications=True, use_converters=True ): # Create an empty datatypes registry. self.datatypes_registry = Registry(self.config) - if installed_repository_manager and self.config.load_tool_shed_datatypes: - # Load proprietary datatypes defined in datatypes_conf.xml files in all installed tool shed repositories. We - # load proprietary datatypes before datatypes in the distribution because Galaxy's default sniffers include some - # generic sniffers (eg text,xml) which catch anything, so it's impossible for proprietary sniffers to be used. - # However, if there is a conflict (2 datatypes with the same extension) between a proprietary datatype and a datatype - # in the Galaxy distribution, the datatype in the Galaxy distribution will take precedence. If there is a conflict - # between 2 proprietary datatypes, the datatype from the repository that was installed earliest will take precedence. - installed_repository_manager.load_proprietary_datatypes() # Load the data types in the Galaxy distribution, which are defined in self.config.datatypes_config. datatypes_configs = self.config.datatypes_config for datatypes_config in listify(datatypes_configs): @@ -583,7 +575,6 @@ class GalaxyManagerApplication(MinimalManagerApp, MinimalGalaxyApplication): ) self.dynamic_tool_manager = self._register_singleton(DynamicToolManager) self._configure_datatypes_registry( - self.installed_repository_manager, use_converters=use_converters, use_display_applications=use_display_applications, ) @@ -659,8 +650,6 @@ class UniverseApplication(StructuredApp, GalaxyManagerApplication): self.update_repository_manager = self._register_singleton( UpdateRepositoryManager, UpdateRepositoryManager(self) ) - # Load proprietary datatype converters and display applications. - self.installed_repository_manager.load_proprietary_converters_and_display_applications() # Load datatype display applications defined in local datatypes_conf.xml self.datatypes_registry.load_display_applications(self) # Load datatype converters defined in local datatypes_conf.xml diff --git a/lib/galaxy/config/sample/galaxy.yml.sample b/lib/galaxy/config/sample/galaxy.yml.sample index 7e78c567d4f..d1ed27adfc1 100644 --- a/lib/galaxy/config/sample/galaxy.yml.sample +++ b/lib/galaxy/config/sample/galaxy.yml.sample @@ -466,15 +466,6 @@ galaxy: # . #tool_sheds_config_file: tool_sheds_conf.xml - # This option controls whether legacy datatypes are loaded from - # installed tool shed repositories. We're are in the process of - # disabling Tool Shed datatypes. This option with a default of true - # will be added in 22.01, we will disable the datatypes on the big - # public servers during that release. This option will be switched to - # False by default in 22.05 and this broken functionality will be - # removed all together during some future release. - #load_tool_shed_datatypes: true - # Monitor the tools and tool directories listed in any tool config # file specified in tool_config_file option. If changes are found, # tools are automatically reloaded. Watchdog ( diff --git a/lib/galaxy/config/schemas/config_schema.yml b/lib/galaxy/config/schemas/config_schema.yml index 841cbe61a8b..d73f00840e0 100644 --- a/lib/galaxy/config/schemas/config_schema.yml +++ b/lib/galaxy/config/schemas/config_schema.yml @@ -443,17 +443,6 @@ mapping: File containing the Galaxy Tool Sheds that should be made available to install from in the admin interface (.sample used if default does not exist). - load_tool_shed_datatypes: - type: bool - default: true - required: false - desc: | - This option controls whether legacy datatypes are loaded from installed tool shed repositories. - We're are in the process of disabling Tool Shed datatypes. This option with a default of true - will be added in 22.01, we will disable the datatypes on the big public servers during that - release. This option will be switched to False by default in 22.05 and this broken functionality - will be removed all together during some future release. - watch_tools: type: str default: 'false' diff --git a/lib/galaxy/datatypes/registry.py b/lib/galaxy/datatypes/registry.py index c7431d846d2..532decfafc9 100644 --- a/lib/galaxy/datatypes/registry.py +++ b/lib/galaxy/datatypes/registry.py @@ -68,8 +68,6 @@ class Registry: # Converters defined in local datatypes_conf.xml self.converters = [] self.converter_tools = set() - # Converters defined in datatypes_conf.xml included in installed tool shed repositories. - self.proprietary_converters = [] self.converter_deps = {} self.available_tracks = [] self.set_external_metadata_tool = None @@ -77,9 +75,6 @@ class Registry: self.upload_file_formats = [] # Datatype elements defined in local datatypes_conf.xml that contain display applications. self.display_app_containers = [] - # Datatype elements in datatypes_conf.xml included in installed - # tool shed repositories that contain display applications. - self.proprietary_display_app_containers = [] # Map a display application id to a display application self.display_applications: Dict[str, DisplayApplication] = {} # The following 2 attributes are used in the to_xml_file() @@ -91,8 +86,6 @@ class Registry: # The 'default' display_path defined in local datatypes_conf.xml self.display_applications_path = None self.inherit_display_application_by_class = [] - # Keep a list of imported proprietary datatype class modules. - self.imported_modules = [] self.datatype_elems = [] self.datatype_info_dicts = [] self.sniffer_elems = [] @@ -134,15 +127,7 @@ class Registry: return module if root_dir and config: - # If handling_proprietary_datatypes is determined as True below, we'll have an elem that looks something like this: - # compressed_sniffers = {} - handling_proprietary_datatypes = False if isinstance(config, (str, Path)): # Parse datatypes_conf.xml tree = galaxy.util.parse_xml(config) @@ -182,15 +167,7 @@ class Registry: os.path.join(os.path.dirname(__file__), "display_applications", "configs") ) self.display_applications_path = self.display_path_attr - # Proprietary datatype's tag may have special attributes, proprietary_converter_path and proprietary_display_path. - proprietary_converter_path = registration.get("proprietary_converter_path", None) - proprietary_display_path = registration.get("proprietary_display_path", None) - if ( - proprietary_converter_path is not None - or proprietary_display_path is not None - and not handling_proprietary_datatypes - ): - handling_proprietary_datatypes = True + for elem in registration.findall("datatype"): # Keep a status of the process steps to enable stopping the process of handling the datatype if necessary. ok = True @@ -217,18 +194,6 @@ class Registry: if edam_data and not make_subclass: self.log.warning("Cannot specify edam_data without setting subclass to True, skipping datatype.") continue - # Proprietary datatypes included in installed tool shed repositories will include two special attributes - # (proprietary_path and proprietary_datatype_module) if they depend on proprietary datatypes classes. - # The value of proprietary_path is the path to the cloned location of the tool shed repository's contained - # datatypes_conf.xml file. - proprietary_path = elem.get("proprietary_path", None) - proprietary_datatype_module = elem.get("proprietary_datatype_module", None) - if ( - proprietary_path is not None - or proprietary_datatype_module is not None - and not handling_proprietary_datatypes - ): - handling_proprietary_datatypes = True if deactivate: # We are deactivating or uninstalling an installed tool shed repository, so eliminate the datatype # elem from the in-memory list of datatype elems. @@ -276,24 +241,6 @@ class Registry: ok = False if ok: datatype_class = None - if proprietary_path and proprietary_datatype_module and datatype_class_name: - # TODO: previously comments suggested this needs to be locked because it modifies - # the sys.path, probably true but the previous lock wasn't doing that. - try: - imported_module = __import_module(proprietary_path, proprietary_datatype_module) - if imported_module not in self.imported_modules: - self.imported_modules.append(imported_module) - if hasattr(imported_module, datatype_class_name): - datatype_class = getattr(imported_module, datatype_class_name) - except Exception as e: - full_path = os.path.join(proprietary_path, proprietary_datatype_module) - self.log.debug( - "Exception importing proprietary code file %s: %s", - full_path, - e, - ) - # Either the above exception was thrown because the proprietary_datatype_module is not derived from a class - # in the repository, or we are loading Galaxy's datatypes. In either case we'll look in the registry. if datatype_class is None: try: # The datatype class name must be contained in one of the datatype modules in the Galaxy distribution. @@ -374,12 +321,7 @@ class Registry: self.converter_deps[extension] = {} self.converter_deps[extension][target_datatype] = depends_on.split(",") if converter_config and target_datatype: - if proprietary_converter_path: - self.proprietary_converters.append( - (converter_config, extension, target_datatype) - ) - else: - self.converters.append((converter_config, extension, target_datatype)) + self.converters.append((converter_config, extension, target_datatype)) # Add composite files. for composite_file in elem.findall("composite_file"): name = composite_file.get("name", None) @@ -393,12 +335,8 @@ class Registry: name, optional=optional, mimetype=mimetype ) for _display_app in elem.findall("display"): - if proprietary_display_path: - if elem not in self.proprietary_display_app_containers: - self.proprietary_display_app_containers.append(elem) - else: - if elem not in self.display_app_containers: - self.display_app_containers.append(elem) + if elem not in self.display_app_containers: + self.display_app_containers.append(elem) datatype_info_dict = { "display_in_upload": display_in_upload, "extension": extension, @@ -489,7 +427,6 @@ class Registry: self.load_datatype_sniffers( root, deactivate=deactivate, - handling_proprietary_datatypes=handling_proprietary_datatypes, override=override, compressed_sniffers=compressed_sniffers, ) @@ -571,7 +508,7 @@ class Registry: return self.display_sites.get(site_type, []) def load_datatype_sniffers( - self, root, deactivate=False, handling_proprietary_datatypes=False, override=False, compressed_sniffers=None + self, root, deactivate=False, override=False, compressed_sniffers=None ): """ Process the sniffers element from a parsed a datatypes XML file located at root_dir/config (if processing the Galaxy @@ -598,12 +535,6 @@ class Registry: self.log.exception("Error determining datatype class or module for dtype %s", str(dtype)) ok = False if ok: - if handling_proprietary_datatypes: - # See if one of the imported modules contains the datatype class name. - for imported_module in self.imported_modules: - if hasattr(imported_module, datatype_class_name): - module = imported_module - break if module is None: try: # The datatype class name must be contained in one of the datatype modules in the Galaxy distribution. @@ -734,149 +665,64 @@ class Registry: data.init_meta(copy_from=data) return data - def load_datatype_converters(self, toolbox, installed_repository_dict=None, deactivate=False, use_cached=False): + def load_datatype_converters(self, toolbox, use_cached=False): """ - If deactivate is False, add datatype converters from self.converters or self.proprietary_converters - to the calling app's toolbox. If deactivate is True, eliminates relevant converters from the calling - app's toolbox. + Add datatype converters from self.converters to the calling app's toolbox. """ - if installed_repository_dict: - # Load converters defined by datatypes_conf.xml included in installed tool shed repository. - converters = self.proprietary_converters - else: - # Load converters defined by local datatypes_conf.xml. - converters = self.converters + # Load converters defined by local datatypes_conf.xml. + converters = self.converters for elem in converters: tool_config = elem[0] source_datatype = elem[1] target_datatype = elem[2] - if installed_repository_dict: - converter_path = installed_repository_dict["converter_path"] - else: - converter_path = self.converters_path + converter_path = self.converters_path try: config_path = os.path.join(converter_path, tool_config) converter = toolbox.load_tool(config_path, use_cached=use_cached) self.converter_tools.add(converter) - if installed_repository_dict: - # If the converter is included in an installed tool shed repository, set the tool - # shed related tool attributes. - converter.tool_shed = installed_repository_dict["tool_shed"] - converter.repository_name = installed_repository_dict["repository_name"] - converter.repository_owner = installed_repository_dict["repository_owner"] - converter.installed_changeset_revision = installed_repository_dict["installed_changeset_revision"] - converter.old_id = converter.id - # The converter should be included in the list of tools defined in tool_dicts. - tool_dicts = installed_repository_dict["tool_dicts"] - for tool_dict in tool_dicts: - if tool_dict["id"] == converter.id: - converter.guid = tool_dict["guid"] - converter.id = tool_dict["guid"] - break - if deactivate: - toolbox.remove_tool_by_id(converter.id, remove_from_panel=False) - if source_datatype in self.datatype_converters: - if target_datatype in self.datatype_converters[source_datatype]: - del self.datatype_converters[source_datatype][target_datatype] - self.log.debug("Deactivated converter: %s", converter.id) - else: - toolbox.register_tool(converter) - if source_datatype not in self.datatype_converters: - self.datatype_converters[source_datatype] = {} - self.datatype_converters[source_datatype][target_datatype] = converter - if not hasattr(toolbox.app, "tool_cache") or converter.id in toolbox.app.tool_cache._new_tool_ids: - self.log.debug("Loaded converter: %s", converter.id) + toolbox.register_tool(converter) + if source_datatype not in self.datatype_converters: + self.datatype_converters[source_datatype] = {} + self.datatype_converters[source_datatype][target_datatype] = converter + if not hasattr(toolbox.app, "tool_cache") or converter.id in toolbox.app.tool_cache._new_tool_ids: + self.log.debug("Loaded converter: %s", converter.id) except Exception: - if deactivate: - self.log.exception(f"Error deactivating converter from ({converter_path})") - else: - self.log.exception(f"Error loading converter ({converter_path})") + self.log.exception(f"Error loading converter ({converter_path})") - def load_display_applications(self, app, installed_repository_dict=None, deactivate=False): + def load_display_applications(self, app): """ - If deactivate is False, add display applications from self.display_app_containers or - self.proprietary_display_app_containers to appropriate datatypes. If deactivate is - True, eliminates relevant display applications from appropriate datatypes. + Add display applications from self.display_app_containers or to appropriate datatypes. """ - if installed_repository_dict: - # Load display applications defined by datatypes_conf.xml included in installed tool shed repository. - datatype_elems = self.proprietary_display_app_containers - else: - # Load display applications defined by local datatypes_conf.xml. - datatype_elems = self.display_app_containers + # Load display applications defined by local datatypes_conf.xml. + datatype_elems = self.display_app_containers for elem in datatype_elems: extension = self.get_extension(elem) for display_app in elem.findall("display"): display_file = display_app.get("file", None) - if installed_repository_dict: - display_path = installed_repository_dict["display_path"] - display_file_head, display_file_tail = os.path.split(display_file) - config_path = os.path.join(display_path, display_file_tail) - else: - config_path = os.path.join(self.display_applications_path, display_file) + config_path = os.path.join(self.display_applications_path, display_file) try: inherit = galaxy.util.string_as_bool(display_app.get("inherit", "False")) display_app = DisplayApplication.from_file(config_path, app) if display_app: if display_app.id in self.display_applications: - if deactivate: - del self.display_applications[display_app.id] - else: - # If we already loaded this display application, we'll use the first one loaded. - display_app = self.display_applications[display_app.id] - elif installed_repository_dict: - # If the display application is included in an installed tool shed repository, - # set the tool shed related tool attributes. - display_app.tool_shed = installed_repository_dict["tool_shed"] - display_app.repository_name = installed_repository_dict["repository_name"] - display_app.repository_owner = installed_repository_dict["repository_owner"] - display_app.installed_changeset_revision = installed_repository_dict[ - "installed_changeset_revision" - ] - display_app.old_id = display_app.id - # The display application should be included in the list of tools defined in tool_dicts. - tool_dicts = installed_repository_dict["tool_dicts"] - for tool_dict in tool_dicts: - if tool_dict["id"] == display_app.id: - display_app.guid = tool_dict["guid"] - display_app.id = tool_dict["guid"] - break - if deactivate: - if display_app.id in self.display_applications: - del self.display_applications[display_app.id] - if extension in self.datatypes_by_extension: - if display_app.id in self.datatypes_by_extension[extension].display_applications: - del self.datatypes_by_extension[extension].display_applications[display_app.id] - if ( - inherit - and (self.datatypes_by_extension[extension], display_app) - in self.inherit_display_application_by_class - ): - self.inherit_display_application_by_class.remove( - (self.datatypes_by_extension[extension], display_app) - ) - self.log.debug( - f"Deactivated display application '{display_app.id}' for datatype '{extension}'." - ) - else: - self.display_applications[display_app.id] = display_app - self.datatypes_by_extension[extension].add_display_application(display_app) - if ( - inherit - and (self.datatypes_by_extension[extension], display_app) - not in self.inherit_display_application_by_class - ): - self.inherit_display_application_by_class.append( - (self.datatypes_by_extension[extension], display_app) - ) - self.log.debug( - f"Loaded display application '{display_app.id}' for datatype '{extension}', inherit={inherit}." + # If we already loaded this display application, we'll use the first one loaded. + display_app = self.display_applications[display_app.id] + + self.display_applications[display_app.id] = display_app + self.datatypes_by_extension[extension].add_display_application(display_app) + if ( + inherit + and (self.datatypes_by_extension[extension], display_app) + not in self.inherit_display_application_by_class + ): + self.inherit_display_application_by_class.append( + (self.datatypes_by_extension[extension], display_app) ) + self.log.debug( + f"Loaded display application '{display_app.id}' for datatype '{extension}', inherit={inherit}." + ) except Exception: - if deactivate: - self.log.exception(f"Error deactivating display application ({config_path})") - else: - self.log.exception(f"Error loading display application ({config_path})") + self.log.exception(f"Error loading display application ({config_path})") # Handle display_application subclass inheritance. for extension, d_type1 in self.datatypes_by_extension.items(): for d_type2, display_app in self.inherit_display_application_by_class: diff --git a/lib/galaxy/tool_shed/galaxy_install/datatypes/__init__.py b/lib/galaxy/tool_shed/galaxy_install/datatypes/__init__.py deleted file mode 100644 index e69de29bb2d..00000000000 diff --git a/lib/galaxy/tool_shed/galaxy_install/datatypes/custom_datatype_manager.py b/lib/galaxy/tool_shed/galaxy_install/datatypes/custom_datatype_manager.py deleted file mode 100644 index 8edc6bb7250..00000000000 --- a/lib/galaxy/tool_shed/galaxy_install/datatypes/custom_datatype_manager.py +++ /dev/null @@ -1,182 +0,0 @@ -import logging -import os - -from galaxy.tool_shed.util.basic_util import strip_path -from galaxy.tool_shed.util.hg_util import get_config_from_disk -from galaxy.tool_shed.util.shed_util_common import DATATYPES_CONFIG_FILENAME -from galaxy.util.tool_shed.xml_util import parse_xml - -log = logging.getLogger(__name__) - - -class CustomDatatypeLoader: - def __init__(self, app): - self.app = app - - def _alter_config_and_load_proprietary_datatypes( - self, datatypes_config, relative_install_dir, deactivate=False, override=True - ): - """ - Parse a custom datatypes config (a datatypes_conf.xml file included in an installed - tool shed repository) and add information to appropriate element attributes that will - enable custom datatype class modules, datatypes converters and display applications - to be discovered and properly imported by the datatypes registry. The value of override - will be False when a tool shed repository is being installed. Since installation is - occurring after the datatypes registry has been initialized, the registry's contents - cannot be overridden by conflicting data types. - """ - tree, error_message = parse_xml(datatypes_config) - if tree is None: - return None, None - datatypes_config_root = tree.getroot() - registration = datatypes_config_root.find("registration") - if registration is None: - # We have valid XML, but not a valid custom datatypes definition. - return None, None - converter_path, display_path = self._get_converter_and_display_paths(registration, relative_install_dir) - if converter_path: - # Path to datatype converters - registration.attrib["proprietary_converter_path"] = converter_path - if display_path: - # Path to datatype display applications - registration.attrib["proprietary_display_path"] = display_path - relative_path_to_datatype_file_name = None - datatype_files = datatypes_config_root.find("datatype_files") - datatype_class_modules = [] - if datatype_files is not None: - # The tag set contains any number of tags. - # - # - # - # - # We'll add attributes to the datatype tag sets so that the modules can be properly imported - # by the datatypes registry. - for elem in datatype_files.findall("datatype_file"): - datatype_file_name = elem.get("name", None) - if datatype_file_name: - # Find the file in the installed repository. - for root, _dirs, files in os.walk(relative_install_dir): - if root.find(".hg") < 0: - for name in files: - if name == datatype_file_name: - datatype_class_modules.append(os.path.join(root, name)) - break - break - if datatype_class_modules: - for relative_path_to_datatype_file_name in datatype_class_modules: - datatype_file_name_path, datatype_file_name = os.path.split(relative_path_to_datatype_file_name) - for elem in registration.findall("datatype"): - # Handle 'type' attribute which should be something like one of the following: - # type="gmap:GmapDB" - # type="galaxy.datatypes.gmap:GmapDB" - dtype = elem.get("type", None) - if dtype: - fields = dtype.split(":") - proprietary_datatype_module = fields[0] - if proprietary_datatype_module.find(".") >= 0: - # Handle the case where datatype_module is "galaxy.datatypes.gmap". - proprietary_datatype_module = proprietary_datatype_module.split(".")[-1] - # The value of proprietary_path must be an absolute path due to job_working_directory. - elem.attrib["proprietary_path"] = os.path.abspath(datatype_file_name_path) - elem.attrib["proprietary_datatype_module"] = proprietary_datatype_module - # Load custom datatypes - self.app.datatypes_registry.load_datatypes( - root_dir=self.app.config.root, config=datatypes_config_root, deactivate=deactivate, override=override - ) - return converter_path, display_path - - def _create_repository_dict_for_proprietary_datatypes( - self, tool_shed, name, owner, installed_changeset_revision, tool_dicts, converter_path=None, display_path=None - ): - return dict( - tool_shed=tool_shed, - repository_name=name, - repository_owner=owner, - installed_changeset_revision=installed_changeset_revision, - tool_dicts=tool_dicts, - converter_path=converter_path, - display_path=display_path, - ) - - def _get_converter_and_display_paths(self, registration_elem, relative_install_dir): - """ - Find the relative path to data type converters and display applications included - in installed tool shed repositories. - """ - converter_path = None - display_path = None - for elem in registration_elem.findall("datatype"): - if not converter_path: - # If any of the tag sets contain tags, set the converter_path - # if it is not already set. This requires developers to place all converters in the - # same subdirectory within the repository hierarchy. - for converter in elem.findall("converter"): - converter_config = converter.get("file", None) - if converter_config: - converter_config_file_name = strip_path(converter_config) - for root, _dirs, files in os.walk(relative_install_dir): - if root.find(".hg") < 0: - for name in files: - if name == converter_config_file_name: - # The value of converter_path must be absolute due to job_working_directory. - converter_path = os.path.abspath(root) - break - if converter_path: - break - if not display_path: - # If any of the tag sets contain tags, set the display_path - # if it is not already set. This requires developers to place all display acpplications - # in the same subdirectory within the repository hierarchy. - for display_app in elem.findall("display"): - display_config = display_app.get("file", None) - if display_config: - display_config_file_name = strip_path(display_config) - for root, _dirs, files in os.walk(relative_install_dir): - if root.find(".hg") < 0: - for name in files: - if name == display_config_file_name: - # The value of display_path must be absolute due to job_working_directory. - display_path = os.path.abspath(root) - break - if display_path: - break - if converter_path and display_path: - break - return converter_path, display_path - - def load_installed_datatype_converters(self, installed_repository_dict, deactivate=False): - """Load or deactivate proprietary datatype converters.""" - self.app.datatypes_registry.load_datatype_converters( - self.app.toolbox, installed_repository_dict=installed_repository_dict, deactivate=deactivate - ) - - def load_installed_datatypes(self, repository, relative_install_dir, deactivate=False): - """ - Load proprietary datatypes and return information needed for loading custom - datatypes converters and display applications later. - """ - metadata = repository.metadata_ - repository_dict = None - datatypes_config = get_config_from_disk(DATATYPES_CONFIG_FILENAME, relative_install_dir) - if datatypes_config: - converter_path, display_path = self._alter_config_and_load_proprietary_datatypes( - datatypes_config, relative_install_dir, deactivate=deactivate - ) - if converter_path or display_path: - # Create a dictionary of tool shed repository related information. - repository_dict = self._create_repository_dict_for_proprietary_datatypes( - tool_shed=repository.tool_shed, - name=repository.name, - owner=repository.owner, - installed_changeset_revision=repository.installed_changeset_revision, - tool_dicts=metadata.get("tools", []), - converter_path=converter_path, - display_path=display_path, - ) - return repository_dict - - def load_installed_display_applications(self, installed_repository_dict, deactivate=False): - """Load or deactivate custom datatype display applications.""" - self.app.datatypes_registry.load_display_applications( - self.app, installed_repository_dict=installed_repository_dict, deactivate=deactivate - ) diff --git a/lib/galaxy/tool_shed/galaxy_install/installed_repository_manager.py b/lib/galaxy/tool_shed/galaxy_install/installed_repository_manager.py index 22ac9abe823..d09d881d654 100644 --- a/lib/galaxy/tool_shed/galaxy_install/installed_repository_manager.py +++ b/lib/galaxy/tool_shed/galaxy_install/installed_repository_manager.py @@ -653,32 +653,6 @@ class InstalledRepositoryManager: deleted_tool_dependency_names.append(original_dependency_val_dict["name"]) return updated_tool_dependency_names, deleted_tool_dependency_names - def load_proprietary_datatypes(self): - cdl = custom_datatype_manager.CustomDatatypeLoader(self.app) - for tool_shed_repository in ( - self.context.query(self.install_model.ToolShedRepository) - .filter( - and_( - self.install_model.ToolShedRepository.table.c.includes_datatypes == true(), - self.install_model.ToolShedRepository.table.c.deleted == false(), - ) - ) - .order_by(self.install_model.ToolShedRepository.table.c.id) - ): - relative_install_dir = self.get_repository_install_dir(tool_shed_repository) - if relative_install_dir: - installed_repository_dict = cdl.load_installed_datatypes(tool_shed_repository, relative_install_dir) - if installed_repository_dict: - self.installed_repository_dicts.append(installed_repository_dict) - - def load_proprietary_converters_and_display_applications(self, deactivate=False): - cdl = custom_datatype_manager.CustomDatatypeLoader(self.app) - for installed_repository_dict in self.installed_repository_dicts: - if installed_repository_dict["converter_path"]: - cdl.load_installed_datatype_converters(installed_repository_dict, deactivate=deactivate) - if installed_repository_dict["display_path"]: - cdl.load_installed_display_applications(installed_repository_dict, deactivate=deactivate) - def uninstall_repository(self, repository, remove_from_disk=True): errors = "" shed_tool_conf, tool_path, relative_install_dir = suc.get_tool_panel_config_tool_path_install_dir(