def __init__(self, name, spec, arg=None): super().__init__(name, spec, arg) self.branches = {} def _sanitize(t): return galaxy_ui_var(value=galaxy_esc(str(t).replace('%', 'X'))) for type_ in spec.qiime_type: if type_.predicate is not None and is_union(type_.predicate): for pred in type_.predicate.unpack_union(): new_type = type_.duplicate(predicate=pred) self.branches[_sanitize(new_type)] = new_type elif (type_.predicate is not None and type_.predicate.name == 'Choices'): for choice in type_.predicate.template.choices: new_type = type_.duplicate(predicate=Choices(choice)) self.branches[galaxy_esc(choice)] = new_type elif type_.name == 'Bool': for choice in [True, False]: new_type = type_.duplicate(predicate=Choices(choice)) self.branches[galaxy_esc(choice)] = new_type else: self.branches[_sanitize(type_)] = type_ if self.spec.default is None: self.branches[galaxy_esc(None)] = {None}
def bool_params(): yield ParamTemplate('boolean', Bool, bool, (True, False)) yield ParamTemplate('boolean_true', Bool % Choices(True), bool, (True, )) yield ParamTemplate('boolean_false', Bool % Choices(False), bool, (False, )) yield ParamTemplate('boolean_choice', Bool % Choices(True, False), bool, (True, False))
def primitive_unions(): yield ParamTemplate('disjoint', Int % (Range(5, 10) | Range(15, 20)), int, (5, 9, 15, 19)) yield ParamTemplate('auto_int', Int % Range(1, None) | Str % Choices('auto'), object, (1, 10, 'auto')) yield ParamTemplate( 'kitchen_sink', Float % Range(0, 1) | Int | Str % Choices('auto', 'Beef') | Bool | Float % Range(10, 11), object, (0.5, 1000, 'Beef', 'auto', True, False, 10.103))
def test_primitive_predicate(self): self.assert_roundtrip(Int % Range(0, 10)) self.assert_roundtrip( Int % (Range(0, 10) | Range(50, 100, inclusive_end=True))) self.assert_roundtrip(Float % Range(None, 10)) self.assert_roundtrip(Float % Range(0, None)) self.assert_roundtrip(Str % Choices("A")) self.assert_roundtrip(Str % Choices(["A"])) self.assert_roundtrip(Str % Choices("A", "B")) self.assert_roundtrip(Str % Choices(["A", "B"])) self.assert_roundtrip(Bool % Choices(True)) self.assert_roundtrip(Bool % Choices(False))
def test_typevars(self): T, U, V, W, X = TypeMap({ (Foo, Bar, Str % Choices('A', 'B')): (C1[Foo], C1[Bar]), (Foo | Bar, Foo, Str): (C1[Bar], C1[Foo]) }) scope = {} T1 = ast_to_type(T.to_ast(), scope=scope) U1 = ast_to_type(U.to_ast(), scope=scope) V1 = ast_to_type(V.to_ast(), scope=scope) W1 = ast_to_type(W.to_ast(), scope=scope) X1 = ast_to_type(X.to_ast(), scope=scope) self.assertEqual(len(scope), 1) self.assertEqual(scope[id(T.mapping)], [T1, U1, V1, W1, X1]) self.assertEqual(T1.mapping.lifted, T.mapping.lifted) self.assertIs(T1.mapping, U1.mapping) self.assertIs(U1.mapping, V1.mapping) self.assertIs(V1.mapping, W1.mapping) self.assertIs(W1.mapping, X1.mapping)
package='q2_diversity', description=('This QIIME 2 plugin supports metrics for calculating ' 'and exploring community alpha and beta diversity through ' 'statistics and visualizations in the context of sample ' 'metadata.'), short_description='Plugin for exploring community diversity.', ) plugin.methods.register_function( function=q2_diversity.beta_phylogenetic, inputs={ 'table': FeatureTable[Frequency], 'phylogeny': Phylogeny[Rooted] }, parameters={ 'metric': Str % Choices(beta.phylogenetic_metrics()), 'n_jobs': Int % Range(1, None) }, outputs=[('distance_matrix', DistanceMatrix % Properties('phylogenetic'))], input_descriptions={ 'table': ('The feature table containing the samples over which beta ' 'diversity should be computed.'), 'phylogeny': ('Phylogenetic tree containing tip identifiers that ' 'correspond to the feature identifiers in the table. ' 'This tree can contain tip ids that are not present in ' 'the table, but all feature ids in the table must be ' 'present in this tree.') }, parameter_descriptions={ 'metric': 'The beta diversity metric to be computed.', 'n_jobs':
inputs = {'table': FeatureTable[Frequency]} input_descriptions = { 'table': 'Feature table containing all features that ' 'should be used for target prediction.', 'probabilities': 'Predicted class probabilities for ' 'each input sample.' } parameters = { 'base': { 'random_state': Int, 'n_jobs': Int, 'n_estimators': Int % Range(1, None), 'missing_samples': Str % Choices(['error', 'ignore']) }, 'splitter': { 'test_size': Float % Range(0.0, 1.0, inclusive_end=False, inclusive_start=False) }, 'rfe': { 'step': Float % Range(0.0, 1.0, inclusive_end=False, inclusive_start=False), 'optimize_feature_selection': Bool }, 'cv': { 'cv': Int % Range(1, None), 'parameter_tuning': Bool }, 'modified_metadata': {
index_f.write('<html><body>\n') index_f.write('<h1>Dendrogram heatmap</h1>\n') index_f.write('<img src="heatmap.svg" alt="heatmap">') index_f.write('</body></html>\n') plugin.visualizers.register_function( function=dendrogram_heatmap, inputs={ 'table': FeatureTable[Composition], 'tree': Phylogeny[Rooted] }, parameters={ 'metadata': MetadataCategory, 'ndim': Int, 'method': Str % Choices(_transform_methods), 'color_map': Str % Choices(_mpl_colormaps) }, input_descriptions={ 'table': ('The feature table that will be plotted as a heatmap. ' 'This table is assumed to have strictly positive values.'), 'tree': ('A hierarchy of feature identifiers where each tip' 'corresponds to the feature identifiers in the table. ' 'This tree can contain tip ids that are not present in ' 'the table, but all feature ids in the table must be ' 'present in this tree.') }, parameter_descriptions={ 'metadata': ('Metadata to group the samples. '), 'ndim': 'Number of dimensions to highlight.',
from q2_types.tree import Phylogeny, Rooted from q2_types.ordination import PCoAResults plugin = Plugin( name='diversity', version=q2_diversity.__version__, website='https://github.com/qiime2/q2-diversity', package='q2_diversity' ) plugin.methods.register_function( function=q2_diversity.beta_phylogenetic, inputs={'table': FeatureTable[Frequency] % Properties('uniform-sampling'), 'phylogeny': Phylogeny[Rooted]}, parameters={'metric': Str % Choices(beta.phylogenetic_metrics())}, outputs=[('distance_matrix', DistanceMatrix % Properties('phylogenetic'))], input_descriptions={ 'table': ('The feature table containing the samples over which beta ' 'diversity should be computed.'), 'phylogeny': ('Phylogenetic tree containing tip identifiers that ' 'correspond to the feature identifiers in the table. ' 'This tree can contain tip ids that are not present in ' 'the table, but all feature ids in the table must be ' 'present in this tree.') }, parameter_descriptions={ 'metric': 'The beta diversity metric to be computed.' }, output_descriptions={'distance_matrix': 'The resulting distance matrix.'}, name='Beta diversity (phylogenetic)',
'details. (Use 0 to automatically use all available ' 'cores)' }, output_descriptions={'tree': 'The resulting phylogenetic tree.'}, name='Construct a phylogenetic tree with FastTree.', description=("Construct a phylogenetic tree with FastTree."), citations=[citations['price2010fasttree']]) plugin.methods.register_function( function=q2_phylogeny.raxml, inputs={'alignment': FeatureData[AlignedSequence]}, parameters={ 'seed': Int, 'n_searches': Int % Range(1, None), 'n_threads': Int % Range(1, None), 'substitution_model': Str % Choices(_RAXML_MODEL_OPT), 'raxml_version': Str % Choices(_RAXML_VERSION_OPT) }, outputs=[('tree', Phylogeny[Unrooted])], input_descriptions={ 'alignment': ('Aligned sequences to be used for phylogenetic ' 'reconstruction.'), }, parameter_descriptions={ 'n_searches': ('The number of independent maximum likelihood ' 'searches to perform. The single best scoring ' 'tree is returned.'), 'n_threads': ('The number of threads to use for multithreaded ' 'processing. Using more than one thread ' 'will enable the PTHREADS version of RAxML.'), 'raxml_version': ('Select a specific CPU optimization of RAxML to '
plugin.register_formats(GraphModelingLanguageFormat) plugin.register_formats(GraphModelingLanguageDirectoryFormat) plugin.register_formats(PairwiseFeatureDataFormat) plugin.register_formats(PairwiseFeatureDataDirectoryFormat) plugin.register_semantic_type_to_format( Network, artifact_format=GraphModelingLanguageDirectoryFormat) plugin.register_semantic_type_to_format( PairwiseFeatureData, artifact_format=PairwiseFeatureDataDirectoryFormat) plugin.methods.register_function( function=calculate_correlations, inputs={'table': FeatureTable[Frequency] }, # TODO: Generalize, don't require frequency parameters={ 'corr_method': Str % Choices(["kendall", "pearson", "spearman"]), 'p_adjustment_method': Str }, outputs=[('correlation_table', PairwiseFeatureData)], input_descriptions={ 'table': ('Normalized and filtered feature table to use for microbial interdependence test.' ) }, parameter_descriptions={ 'corr_method': 'The correlation test to be applied.', 'p_adjustment_method': 'The method for p-value adjustment to be applied. ' 'This can be selected from the list of methods in ' 'statsmodels multipletests'
name='Spatial Ornstein Uhlenbeck microbial community simulation', description=('This method simulates microbial behavior over time using' +'Ornstein Uhlenbeck models. This are similar to Brownian Motion' +'with the exception that they include reversion to a mean.') ) """""" # Modify to allow for PCoAResults as input plugin.visualizers.register_function( function=fit_timeseries, inputs={ 'pcoa' : PCoAResults }, parameters={ #'pcoa':Str, 'method':Str % Choices({'basinhopping'}), 'metadata':Str, 'individual_col':Str, 'timepoint_col':Str, 'treatment_col':Str }, input_descriptions = { 'pcoa':'filepath to PCoA results' } parameter_descriptions = { 'method':'global optimization method', 'metadata':'filepath to Sample metadata', 'individual_col':'individual column identifier', 'timepoint_col':'timepoint column identifier', 'treatment_col':'treatment column identifier' }, name='Fit OU Models to PCoA Ordination output',
def test_collection_primitive(self): self.assert_roundtrip(Set[Str % Choices('A', 'B', 'C')]) self.assert_roundtrip(List[Int % Range(1, 3, inclusive_end=True) | Str % Choices('A', 'B', 'C')])
'Plugin for quality control of feature and sequence data.') ) seq_inputs = {'query_sequences': FeatureData[Sequence], 'reference_sequences': FeatureData[Sequence]} seq_inputs_descriptions = { 'query_sequences': 'Sequences to test for exclusion', 'reference_sequences': ('Reference sequences to align against feature ' 'sequences')} taxa_inputs = {'depth': Int, 'palette': Str % Choices([ 'Set1', 'Set2', 'Set3', 'Pastel1', 'Pastel2', 'Paired', 'Accent', 'Dark2', 'tab10', 'tab20', 'tab20b', 'tab20c', 'viridis', 'plasma', 'inferno', 'magma', 'terrain', 'rainbow'])} taxa_inputs_descriptions = { 'depth': 'Maximum depth of semicolon-delimited taxonomic ranks to ' 'test (e.g., 1 = root, 7 = species for the greengenes ' 'reference sequence database).', 'palette': 'Color palette to utilize for plotting.'} plugin.methods.register_function( function=exclude_seqs, inputs=seq_inputs, parameters={'method': Str % Choices(['blast', 'vsearch', 'blastn-short']), 'perc_identity': Float % Range(0.0, 1.0, inclusive_end=True),
description=('This QIIME 2 plugin supports metrics for calculating ' 'and exploring community alpha and beta diversity through ' 'statistics and visualizations in the context of sample ' 'metadata.'), short_description='Plugin for exploring community diversity.', ) plugin.pipelines.register_function( function=q2_diversity.beta_phylogenetic, inputs={ 'table': FeatureTable[Frequency | RelativeFrequency | PresenceAbsence], 'phylogeny': Phylogeny[Rooted] }, parameters={ 'metric': Str % Choices(beta.METRICS['PHYLO']['IMPL'] | beta.METRICS['PHYLO']['UNIMPL']), 'threads': Int % Range(1, None) | Str % Choices(['auto']), 'variance_adjusted': Bool, 'alpha': Float % Range(0, 1, inclusive_end=True), 'bypass_tips': Bool }, outputs=[('distance_matrix', DistanceMatrix)], input_descriptions={ 'table': ('The feature table containing the samples over which beta ' 'diversity should be computed.'), 'phylogeny': ('Phylogenetic tree containing tip identifiers that ' 'correspond to the feature identifiers in the table. '
parameters={}, outputs=[ ('x', R) ], name="Double Bound Variable Method", description="Test reuse of variables" ) del T, R def bool_flag_swaps_output_method(a: EchoFormat, b: bool) -> EchoFormat: return a P, R = TypeMap({ Choices(True): C1[Foo], Choices(False): Foo }) dummy_plugin.methods.register_function( function=bool_flag_swaps_output_method, inputs={ 'a': Bar }, parameters={ 'b': Bool % P }, outputs=[ ('x', R) ], name='Bool Flag Swaps Output Method', description='Test if a parameter can change output'
'without replacement.') }, output_descriptions={ 'rarefied_table': 'The resulting rarefied feature table.' }, name='Rarefy table', description=("Subsample frequencies from all samples so that the sum of " "frequencies in each sample is equal to sampling-depth."), citations=[citations['Weiss2017']]) plugin.methods.register_function( function=q2_feature_table.subsample, inputs={'table': FeatureTable[Frequency]}, parameters={ 'subsampling_depth': Int % Range(1, None), 'axis': Str % Choices(['sample', 'feature']) }, outputs=[('sampled_table', FeatureTable[Frequency])], input_descriptions={'table': 'The feature table to be sampled.'}, parameter_descriptions={ 'subsampling_depth': ('The total number of samples or features to be ' 'randomly sampled. Samples or features that are ' 'reduced to a zero sum will not be included in ' 'the resulting table.'), 'axis': ('The axis to sample over. If "sample" then samples will be ' 'randomly selected to be retained. If "feature" then ' 'a random set of features will be selected to be retained.') }, output_descriptions={ 'sampled_table': 'The resulting subsampled feature table.' },
'information.'), 'replicate_handling': ( 'Choose how replicate samples are handled. If replicates are ' 'detected, "error" causes method to fail; "drop" will discard all ' 'replicated samples; "random" chooses one representative at random ' 'from among replicates.') } plugin.methods.register_function( function=beta_dispersion, inputs={'distance_matrix': DistanceMatrix}, parameters={ 'metadata': Metadata, 'palette': Str % Choices([ 'Set1', 'Set2', 'Set3', 'Pastel1', 'Pastel2', 'Paired', 'Accent', 'Dark2', 'tab10', 'tab20', 'tab20b', 'tab20c', 'viridis', 'plasma', 'inferno', 'magma', 'terrain', 'rainbow']), 'metric': Str, 'group_column': Str, 'replicate_handling': miscellaneous_parameters['replicate_handling'] 'state_column': miscellaneous_parameters['state_column'], outputs=[('beta_volaility', SampleData[FirstDifferences])], #UNKNOWN WHAT TO PUT INSTEAD OF SAMPLEDATA input_descriptions={ 'distance_matrix': 'Matrix of distances between pairs of samples.'}, parameter_descriptions={ 'metadata': ('Metadata'), 'palette': Str % Choices([ 'Set1', 'Set2', 'Set3', 'Pastel1', 'Pastel2', 'Paired', 'Accent', 'Dark2', 'tab10', 'tab20', 'tab20b', 'tab20c', 'viridis', 'plasma', 'inferno', 'magma', 'terrain', 'rainbow'] 'metric': ('The beta diversity metric used to compute the beta distance matrix.'
artifact_format=NexusDirFmt) importlib.import_module('q2_beast.transformers') NONZERO_INT = Int % Range(1, None) NONNEGATIVE_INT = Int % Range(0, None) plugin.methods.register_function( function=gtr_single_partition, inputs={'alignment': FeatureData[AlignedSequence]}, parameters={ 'time': MetadataColumn[Numeric], 'n_generations': NONZERO_INT, 'sample_every': NONZERO_INT, 'time_uncertainty': MetadataColumn[Numeric], 'base_freq': Str % Choices("estimated", "empirical"), 'site_gamma': Int % Range(0, 10, inclusive_end=True), 'site_invariant': Bool, 'clock': Str % Choices("ucln", "strict"), 'coalescent_model': Str % Choices("skygrid", "constant", "exponential"), 'skygrid_intervals': NONZERO_INT, 'skygrid_duration': Float % Range(0, None, inclusive_start=False), 'print_every': NONZERO_INT, 'use_gpu': Bool, 'n_threads': NONZERO_INT }, outputs=[('chain', Chain[BEAST])], input_descriptions={ 'alignment': 'The alignment to construct a tree with.', },
description=( 'Evaluate taxonomic classification accuracy by comparing one or more ' 'sets of true taxonomic labels to the predicted taxonomies for the ' 'same set(s) of features. Output an interactive line plot of ' 'classification accuracy for each pair of expected/observed ' 'taxonomies. ' + VOLATILITY_PLOT_XAXIS_INTERPRETATION), citations=[citations['bokulich2018optimizing'], citations['bokulich2017q2']] ) plugin.methods.register_function( function=merge_taxa, inputs={'data': List[FeatureData[Taxonomy]]}, parameters={ 'mode': Str % Choices(['len', 'lca', 'score', 'super', 'majority']), 'rank_handle_regex': Str, 'new_rank_handle': Str % Choices(list(_rank_handles.keys()))}, outputs=[('merged_data', FeatureData[Taxonomy])], input_descriptions={ 'data': 'Two or more feature taxonomies to be merged.'}, parameter_descriptions={ 'mode': 'How to merge feature taxonomies: "len" will select the ' 'taxonomy with the most elements (e.g., species level will ' 'beat genus level); "lca" will find the least common ancestor ' 'and report this consensus taxonomy; "score" will select the ' 'taxonomy with the highest score (e.g., confidence or ' 'consensus score). Note that "score" assumes that this score ' 'is always contained as the second column in a feature ' 'taxonomy dataframe. "majority" finds the LCA consensus while ' 'giving preference to majority labels. ' + super_lca_desc,
plugin.register_semantic_types(ZodiacFolder) plugin.register_semantic_type_to_format(ZodiacFolder, artifact_format=ZodiacDirFmt) plugin.register_views(CSIDirFmt) plugin.register_semantic_types(CSIFolder) plugin.register_semantic_type_to_format(CSIFolder, artifact_format=CSIDirFmt) plugin.register_views(TSVMoleculesFormat) plugin.register_semantic_types(Molecules) plugin.register_semantic_type_to_format(FeatureData[Molecules], artifact_format=TSVMoleculesFormat) PARAMS = { 'ionization_mode': Str % Choices(['positive', 'negative', 'auto']), 'database': Str % Choices(['all', 'pubchem']), 'sirius_path': Str, 'profile': Str % Choices(['qtof', 'orbitrap', 'fticr']), 'fingerid_db': Str % Choices(['all', 'pubchem', 'bio', 'kegg', 'hmdb']), 'ppm_max': Int % Range(0, 30, inclusive_end=True), 'n_jobs': Int % Range(1, None), 'num_candidates': Int % Range(5, 100, inclusive_end=True), 'tree_timeout': Int % Range(600, 3000, inclusive_end=True), 'maxmz': Int % Range(100, 850, inclusive_end=True), 'zodiac_threshold': Float % Range(0, 1, inclusive_end=True), 'java_flags': Str } PARAMS_DESC = { 'ionization_mode': 'Ionization mode for mass spectrometry',
name=('Interactively evaluate taxonomic classification accuracy.'), description=( 'Evaluate taxonomic classification accuracy by comparing one or more ' 'sets of true taxonomic labels to the predicted taxonomies for the ' 'same set(s) of features. Output an interactive line plot of ' 'classification accuracy for each pair of expected/observed ' 'taxonomies. ' + VOLATILITY_PLOT_XAXIS_INTERPRETATION), citations=[ citations['bokulich2018optimizing'], citations['bokulich2017q2'] ]) plugin.methods.register_function( function=merge_taxa, inputs={'data': List[FeatureData[Taxonomy]]}, parameters={ 'mode': Str % Choices(['len', 'lca', 'score', 'super', 'majority']), 'rank_handle_regex': Str, 'new_rank_handle': Str % Choices(list(_rank_handles.keys())) }, outputs=[('merged_data', FeatureData[Taxonomy])], input_descriptions={ 'data': 'Two or more feature taxonomies to be merged.' }, parameter_descriptions={ 'mode': 'How to merge feature taxonomies: "len" will select the ' 'taxonomy with the most elements (e.g., species level will ' 'beat genus level); "lca" will find the least common ancestor ' 'and report this consensus taxonomy; "score" will select the ' 'taxonomy with the highest score (e.g., confidence or ' 'consensus score). Note that "score" assumes that this score '
plugin.register_semantic_type_to_format(ReferenceSequence, DNASequencesDirectoryFormat) plugin.register_semantic_type_to_format(SampleData[PileUp], PileUpFilesDirFmt) plugin.register_semantic_type_to_format(SampleData[AlignmentMap], BAMFilesDirFmt) plugin.register_semantic_type_to_format(SampleData[ConsensusSequences], FASTAFilesDirFmt) importlib.import_module('q2_phylogenomics._transformers') prinseq_input = {'demultiplexed_sequences': 'The sequences to be trimmed.'} prinseq_output = {'trimmed_sequences': 'The resulting trimmed sequences.'} prinseq_parameters = { 'trim_qual_right': Int % Range(1, None), 'trim_qual_type': Str % Choices(['min', 'mean', 'max', 'sum']), 'trim_qual_window': Int % Range(1, None), 'min_qual_mean': Int % Range(1, None), 'min_len': Int % Range(1, None), 'lc_method': Str % Choices(['dust', 'entropy']), 'lc_threshold': Int % Range(0, 100), 'derep': List[Str % Choices(list('12345'))] } prinseq_parameter_descriptions = { 'trim_qual_right': 'Trim sequence by quality score from the 3\'-end with ' 'this threshold score.', 'trim_qual_type': 'Type of quality score calculation to use. Allowed ' 'options are min, mean, max and sum.',
'and reconstructs them into a single table with region-' 'normalized abundance counts.'), inputs={ 'regional_alignment': List[FeatureData[KmerAlignment]], 'regional_table': List[FeatureTable[Frequency]], 'database_map': FeatureData[SidleReconstruction], 'database_summary': FeatureData[ReconstructionSummary], }, outputs=[ ('reconstructed_table', FeatureTable[Frequency]), ], parameters={ 'region': List[Str], 'per_nucleotide_error': Float % Range(0, 1), 'min_abund': Float % Range(0, 1), 'region_normalize': Str % Choices('average', 'weighted', 'unweighted'), 'min_counts': Int % Range(0, None), 'block_size': Int, 'n_workers': Int % Range(1, None), 'client_address': Str, 'debug': Bool, }, input_descriptions={ 'regional_alignment': ('A mapping between the kmer names (in the kmer' ' map) and the features (found in the regional' ' table)'), 'regional_table': ('A feature-table for each region, where the ' 'features in the table correspond to the ASVs ' 'which were aligned in the regional alignment ' 'artifact'), 'database_map': ('A map between the final kmer name and the '
'pseudocount': 'The value to add to all counts in the feature table.' }, output_descriptions={'composition_table': 'The resulting feature table.'}, name='Add pseudocount to table', description="Increment all counts in table by pseudocount.") _ancom_statistical_tests = q2_composition._ancom.statistical_tests() _transform_functions = q2_composition._ancom.transform_functions() _difference_functions = q2_composition._ancom.difference_functions() plugin.visualizers.register_function( function=q2_composition.ancom, inputs={'table': FeatureTable[Composition]}, parameters={ 'metadata': MetadataCategory, 'statistical_test': Str % Choices(_ancom_statistical_tests), 'transform_function': Str % Choices(_transform_functions), 'difference_function': Str % Choices(_difference_functions) }, input_descriptions={ 'table': 'The feature table to be used for ANCOM computation.' }, parameter_descriptions={ 'metadata': ('The sample metadata category to test for ' 'differential abundance across.'), 'statistical_test': ('The test to be applied to detect ' 'differential abundance across groups.'), 'transform_function': ('The method applied to transform feature ' 'values before generating volcano plots.'), 'difference_function': 'The method applied to visualize fold '
plugin.methods.register_function( function=q2_phylogeny.midpoint_root, inputs={'tree': Phylogeny[Unrooted]}, parameters={}, outputs=[('rooted_tree', Phylogeny[Rooted])], input_descriptions={'tree': 'The phylogenetic tree to be rooted.'}, parameter_descriptions={}, output_descriptions={'rooted_tree': 'The rooted phylogenetic tree.'}, name='Midpoint root an unrooted phylogenetic tree.', description=("Midpoint root an unrooted phylogenetic tree.")) plugin.methods.register_function( function=q2_phylogeny.fasttree, inputs={'alignment': FeatureData[AlignedSequence]}, parameters={'n_threads': Int % Range(1, None) | Str % Choices(['auto'])}, outputs=[('tree', Phylogeny[Unrooted])], input_descriptions={ 'alignment': ('Aligned sequences to be used for phylogenetic ' 'reconstruction.') }, parameter_descriptions={ 'n_threads': 'The number of threads. Using more than one thread ' 'runs the non-deterministic variant of `FastTree` ' '(`FastTreeMP`), and may result in a different tree than ' 'single-threading. See ' 'http://www.microbesonline.org/fasttree/#OpenMP for ' 'details. (Use `auto` to automatically use all available ' 'cores)' },
function=params_only_method, inputs={}, parameters={ 'name': Str, 'age': Int }, outputs=[('out', Mapping)], name='Parameters only method', description='This method only accepts parameters.', ) dummy_plugin.methods.register_function( function=unioned_primitives, inputs={}, parameters={ 'foo': Int % Range(1, None) | Str % Choices(['auto_foo']), 'bar': Int % Range(1, None) | Str % Choices(['auto_bar']), }, outputs=[('out', Mapping)], name='Unioned primitive parameter', description='This method has a unioned primitive parameter') dummy_plugin.methods.register_function( function=no_input_method, inputs={}, parameters={}, outputs=[('out', Mapping)], name='No input method', description='This method does not accept any type of input.') dummy_plugin.methods.register_function(
raise RuntimeError("No matches found") return ff plugin.methods.register_function( function=extract_reads, inputs={'sequences': FeatureData[Sequence]}, parameters={'trunc_len': Int, 'trim_left': Int, 'f_primer': Str, 'r_primer': Str, 'identity': Float, 'min_length': Int % Range(0, None), 'max_length': Int % Range(0, None), 'n_jobs': Int % Range(1, None), 'batch_size': Int % Range(1, None) | Str % Choices(['auto'])}, outputs=[('reads', FeatureData[Sequence])], name='Extract reads from reference', description='Extract sequencing-like reads from a reference database.', parameter_descriptions={'f_primer': 'forward primer sequence', 'r_primer': 'reverse primer sequence', 'trunc_len': 'read is cut to trunc_len if ' 'trunc_len is positive. Applied ' 'before trim_left.', 'trim_left': 'trim_left nucleotides are removed ' 'from the 5\' end if trim_left is ' 'positive. Applied after trunc_len.', 'identity': 'minimum combined primer match ' 'identity threshold.', 'min_length': 'Minimum amplicon length. Shorter ' 'amplicons are discarded. Applied '
'a': T, 'b': T, 'extra': Foo }, parameters={}, outputs=[('x', R)], name="Double Bound Variable Method", description="Test reuse of variables") del T, R def bool_flag_swaps_output_method(a: EchoFormat, b: bool) -> EchoFormat: return a P, R = TypeMap({Choices(True): C1[Foo], Choices(False): Foo}) dummy_plugin.methods.register_function( function=bool_flag_swaps_output_method, inputs={'a': Bar}, parameters={'b': Bool % P}, outputs=[('x', R)], name='Bool Flag Swaps Output Method', description='Test if a parameter can change output') del P, R def predicates_preserved_method(a: EchoFormat) -> EchoFormat: return a P = TypeMatch(
citations = Citations.load('citations.bib', package='q2_alignment') plugin = Plugin( name='alignment', version=q2_alignment.__version__, website='https://github.com/qiime2/q2-alignment', package='q2_alignment', description=('This QIIME 2 plugin provides support for generating ' 'and manipulating sequence alignments.'), short_description='Plugin for generating and manipulating alignments.') plugin.methods.register_function( function=q2_alignment.mafft, inputs={'sequences': FeatureData[Sequence]}, parameters={ 'n_threads': Int % Range(1, None) | Str % Choices(['auto']), 'parttree': Bool }, outputs=[('alignment', FeatureData[AlignedSequence])], input_descriptions={'sequences': 'The sequences to be aligned.'}, parameter_descriptions={ 'n_threads': 'The number of threads. (Use `auto` to automatically use ' 'all available cores)', 'parttree': 'This flag is required if the number of sequences being ' 'aligned are larger than 1000000. Disabled by default' }, output_descriptions={'alignment': 'The aligned sequences.'}, name='De novo multiple sequence alignment with MAFFT', description=("Perform de novo multiple sequence alignment using MAFFT."),