def merge(self, dependencies):
"""Merge one dependencies with another one
Use case: merging the dependencies of model and dataloader
Args:
dependencies: Dependencies instance
Returns:
new Dependencies instance
"""
return Dependencies(
conda=unique_list(list(self.conda) + list(dependencies.conda)),
pip=kconda.normalize_pip(list(self.pip) + list(dependencies.pip)),
conda_channels=unique_list(
list(self.conda_channels) + list(dependencies.conda_channels)))
def _get_channels_packages(self):
"""Get conda channels and packages separated from each other(by '::')
"""
if len(self.conda) == 0:
return self.conda_channels, self.conda
channels, packages = list(zip(*map(kconda.parse_conda_package, self.conda)))
channels = unique_list(list(channels) + list(self.conda_channels))
packages = unique_list(list(packages))
# Handle channel order
if "bioconda" in channels and "conda-forge" not in channels:
# Insert 'conda-forge' right after bioconda if it is not included
channels.insert(channels.index("bioconda") + 1, "conda-forge")
if "pysam" in packages and "bioconda" in channels:
if channels.index("defaults") < channels.index("bioconda"):
logger.warning("Swapping channel order - putting defaults last. " +
"Using pysam bioconda instead of anaconda")
channels.remove("defaults")
channels.insert(len(channels), "defaults")
return channels, packages
def involved_directories(dataloader_kwargs, output_files=[], exclude_dirs=[]):
"""Infer the involved directories given dataloader kwargs
"""
dirs = []
# dataloader kwargs
for k, v in dataloader_kwargs.items():
if os.path.exists(v):
dirs.append(os.path.dirname(os.path.abspath(v)))
# output files
for v in output_files:
dirs.append(os.path.dirname(os.path.abspath(v)))
# optionally exclude directories
def in_any_dir(fname, dirs):
return any([is_subdir(fname, os.path.expanduser(d))
for d in dirs])
dirs = [x for x in dirs
if not in_any_dir(x, exclude_dirs)]
return unique_list(dirs)
def fn(x):
# remove the templates
return pd.Series(OrderedDict([
("N_models", x.shape[0]),
("N_subgroups", n_subgroups(x.child.fillna(""))),
("is_group", x.is_group.any()),
("authors", unique_list([author for authors in x.authors
for author in authors])),
("contributors", unique_list([contributor for contributors in x.contributors
for contributor in contributors])),
("veff_score_variants", x.veff_score_variants.any()),
("type", unique_list([t for t in x.type])),
("license", unique_list([l for l in x.license])),
("cite_as", unique_list([c for c in x.cite_as if c is not None])),
("tags", unique_list([tag for tags in x.tags
for tag in tags])),
]))
def align_clustered_patterns(patterns, cluster_order, cluster,
align_track='contrib/mean',
metric='continousjaccard',
max_shift=30,
trials=10):
"""Align clustered patterns
In addition to normal features under p.attrs['features'] it adds
logo_contrib, logo_seq, profile scores and the directness score
Args:
patterns: list of patterns
cluster_order: order rank for each pattern id. e.g. cluster_order[1] = 5
means that patterns[1] needs to be at position 5 at the end
cluster: cluster identity for each pattern
align_track: which track to use for alignment
max_shift: maximum allowed shift of the motif
trials: how many times to run the alignment algorithm with different ordering
Returns: list of motifs of the same length as patterns. They are ordered
as they should be plotted in the table. Also 'cluster' field is added
"""
# Order of the clusters
cluster_order_ind = unique_list(cluster[np.argsort(cluster_order)])
# 1. Get major patterns and align them
major_patterns = optimal_align_patterns(get_major_patterns(patterns, cluster),
cluster_order_ind,
max_shift=max_shift,
metric=metric,
trials=trials,
align_track=align_track)
# align patterns to major patterns in the cluster and add the cluster/group information
return [patterns[i].align(major_patterns[cluster[i]],
metric=metric,
track=align_track).add_attr('cluster', cluster[i])
for i in tqdm(np.argsort(cluster_order))]