Mercurial > repos > shellac > sam_consensus_v3
comparison env/lib/python3.9/site-packages/galaxy/tool_util/deps/resolvers/galaxy_packages.py @ 0:4f3585e2f14b draft default tip
"planemo upload commit 60cee0fc7c0cda8592644e1aad72851dec82c959"
author | shellac |
---|---|
date | Mon, 22 Mar 2021 18:12:50 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:4f3585e2f14b |
---|---|
1 import logging | |
2 from os import listdir | |
3 from os.path import ( | |
4 basename, | |
5 exists, | |
6 isdir, | |
7 islink, | |
8 join, | |
9 realpath, | |
10 ) | |
11 | |
12 from . import ( | |
13 Dependency, | |
14 DependencyResolver, | |
15 ListableDependencyResolver, | |
16 MappableDependencyResolver, | |
17 NullDependency, | |
18 ) | |
19 from .resolver_mixins import UsesToolDependencyDirMixin | |
20 | |
21 log = logging.getLogger(__name__) | |
22 | |
23 | |
24 class GalaxyPackageDependency(Dependency): | |
25 dict_collection_visible_keys = Dependency.dict_collection_visible_keys + ['script', 'path', 'version', 'name', 'dependency_resolver'] | |
26 dependency_type = 'galaxy_package' | |
27 | |
28 def __init__(self, script, path, name, type, version, exact=True, dependency_resolver=None): | |
29 self.script = script | |
30 self.path = path | |
31 self.name = name | |
32 self.type = type | |
33 self.version = version | |
34 self._exact = exact | |
35 assert self.script is not None or self.path is not None | |
36 self.dependency_resolver = dependency_resolver | |
37 | |
38 @property | |
39 def exact(self): | |
40 return self._exact | |
41 | |
42 def shell_commands(self): | |
43 base_path = self.path | |
44 if self.type == 'package' and self.script is None: | |
45 commands = f'PACKAGE_BASE={base_path}; export PACKAGE_BASE; PATH="{base_path}/bin:$PATH"; export PATH' | |
46 else: | |
47 commands = f'PACKAGE_BASE={base_path}; export PACKAGE_BASE; . {self.script}' | |
48 return commands | |
49 | |
50 | |
51 class ToolShedDependency(GalaxyPackageDependency): | |
52 dependency_type = 'tool_shed_package' | |
53 | |
54 | |
55 class BaseGalaxyPackageDependencyResolver(DependencyResolver, UsesToolDependencyDirMixin): | |
56 dict_collection_visible_keys = DependencyResolver.dict_collection_visible_keys + ['base_path', 'versionless'] | |
57 dependency_type = GalaxyPackageDependency | |
58 | |
59 def __init__(self, dependency_manager, **kwds): | |
60 # Galaxy tool shed requires explicit versions on XML elements, | |
61 # this in inconvient for testing or Galaxy instances not utilizing | |
62 # the tool shed so allow a fallback version of the Galaxy package | |
63 # resolver that will just grab 'default' version of exact version | |
64 # unavailable. | |
65 self.versionless = str(kwds.get('versionless', "false")).lower() == "true" | |
66 self._init_base_path(dependency_manager, **kwds) | |
67 | |
68 def resolve(self, requirement, **kwds): | |
69 """ | |
70 Attempt to find a dependency named `name` at version `version`. If version is None, return the "default" version as determined using a | |
71 symbolic link (if found). Returns a triple of: env_script, base_path, real_version | |
72 """ | |
73 name, version, type = requirement.name, requirement.version, requirement.type | |
74 | |
75 if version is None or self.versionless: | |
76 exact = not self.versionless or version is None | |
77 return self._find_dep_default(name, type=type, exact=exact, **kwds) | |
78 else: | |
79 return self._find_dep_versioned(name, version, type=type, **kwds) | |
80 | |
81 def _find_dep_versioned(self, name, version, type='package', **kwds): | |
82 base_path = self.base_path | |
83 path = join(base_path, name, version) | |
84 return self._galaxy_package_dep(path, version, name, type, True) | |
85 | |
86 def _find_dep_default(self, name, type='package', exact=True, **kwds): | |
87 base_path = self.base_path | |
88 path = join(base_path, name, 'default') | |
89 if islink(path): | |
90 real_path = realpath(path) | |
91 real_version = basename(real_path) | |
92 return self._galaxy_package_dep(real_path, real_version, name, type, exact) | |
93 else: | |
94 return NullDependency(version=None, name=name) | |
95 | |
96 def _galaxy_package_dep(self, path, version, name, type, exact): | |
97 script = join(path, 'env.sh') | |
98 if exists(script): | |
99 return self.dependency_type(script, path, name, type, version, exact, dependency_resolver=self) | |
100 elif exists(join(path, 'bin')): | |
101 return self.dependency_type(None, path, name, type, version, exact, dependency_resolver=self) | |
102 return NullDependency(version=version, name=name) | |
103 | |
104 | |
105 class GalaxyPackageDependencyResolver(BaseGalaxyPackageDependencyResolver, ListableDependencyResolver, MappableDependencyResolver): | |
106 resolver_type = "galaxy_packages" | |
107 | |
108 def __init__(self, dependency_manager, **kwds): | |
109 super().__init__(dependency_manager, **kwds) | |
110 self._setup_mapping(dependency_manager, **kwds) | |
111 | |
112 def resolve(self, requirement, **kwds): | |
113 requirement = self._expand_mappings(requirement) | |
114 return super().resolve(requirement, **kwds) | |
115 | |
116 def list_dependencies(self): | |
117 base_path = self.base_path | |
118 for package_name in listdir(base_path): | |
119 package_dir = join(base_path, package_name) | |
120 if isdir(package_dir): | |
121 for version in listdir(package_dir): | |
122 version_dir = join(package_dir, version) | |
123 if version == "default": | |
124 version = None | |
125 valid_dependency = _is_dependency_directory(version_dir) | |
126 if valid_dependency: | |
127 yield self._to_requirement(package_name, version) | |
128 | |
129 | |
130 def _is_dependency_directory(directory): | |
131 return exists(join(directory, 'env.sh')) or exists(join(directory, 'bin')) | |
132 | |
133 | |
134 __all__ = ( | |
135 'GalaxyPackageDependency', | |
136 'GalaxyPackageDependencyResolver', | |
137 'ToolShedDependency' | |
138 ) |