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 int_params(): yield ParamTemplate('single_int', Int, int, (-1, 0, 1)) yield ParamTemplate('int_range_1_param', Int % Range(3), int, (-42, 0, 2)) yield ParamTemplate('int_range_1_param_i_e', Int % Range(3, inclusive_end=True), int, (-43, 0, 3)) yield ParamTemplate('int_range_2_params', Int % Range(-3, 4), int, (-3, 0, 3)) yield ParamTemplate('int_range_2_params_i_e', Int % Range(-3, 4, inclusive_end=True), int, (-3, 0, 4)) yield ParamTemplate('int_range_2_params_no_i', Int % Range(-3, 4, inclusive_start=False), int, (-2, 0, 3)) yield ParamTemplate( 'int_range_2_params_i_e_ex_s', Int % Range(-3, 4, inclusive_start=False, inclusive_end=True), int, (-2, 0, 4))
def float_params(): yield ParamTemplate('single_float', Float, float, (-1.5, 0.0, 1.5)) yield ParamTemplate('float_range_1_param', Float % Range(2.5), float, (-42.5, 0.0, 2.49)) yield ParamTemplate('float_range_1_param_i_e', Float % Range(2.5, inclusive_end=True), float, (-42.5, 0.0, 2.5)) yield ParamTemplate('float_range_2_params', Float % Range(-3.5, 3.5), float, (-3.5, 0.0, 3.49)) yield ParamTemplate('float_range_2_params_i_e', Float % Range(-3.5, 3.5, inclusive_end=True), float, (-3.5, 0.0, 3.5)) yield ParamTemplate('float_range_2_params_no_i', Float % Range(-3.5, 3.5, inclusive_start=False), float, (-3.49, 0.0, 3.49)) yield ParamTemplate( 'float_range_2_params_i_e_ex_s', Float % Range(-3.5, 3.5, inclusive_start=False, inclusive_end=True), float, (-3.49, 0.0, 3.49))
'untangled later.'), inputs={ 'sequences': FeatureData[Sequence] }, outputs=[ ('collapsed_kmers', FeatureData[Sequence]), ('kmer_map', FeatureData[KmerMap]), ], parameters={ 'trim_length': Int, 'region': Str, 'fwd_primer': Str, 'rev_primer': Str, 'reverse_complement_rev': Bool, 'reverse_complement_result': Bool, 'chunk_size': (Int % Range(1, None)), 'n_workers': Int % Range(1, None), 'client_address': Str, 'debug': Bool, }, input_descriptions={ 'sequences': 'The full length sequences from the reference database.', }, output_descriptions={ 'collapsed_kmers': ('Reference kmer sequences for the region with ' 'the degenerate sequences expanded and ' 'duplicated sequences identified.' ), 'kmer_map': ('A mapping relationship between the name of the ' 'sequence in the database and the kmer identifier used '
citations = Citations.load('citations.bib', package='q2_phylogenomics') plugin = Plugin( name='phylogenomics', version=q2_phylogenomics.__version__, website='https://github.com/qiime2/q2-phylogenomics', package='q2_phylogenomics', description='A QIIME 2 plugin for phylogenomics analyses.', short_description='A QIIME 2 plugin for phylogenomics analyses.', ) 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.', 'trim_qual_window': 'The sliding window size used to calculate quality ' 'score by type. To stop at the first base that fails '
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(0, None), 'parttree': Bool}, outputs=[('alignment', FeatureData[AlignedSequence])], input_descriptions={'sequences': 'The sequences to be aligned.'}, parameter_descriptions={ 'n_threads': 'The number of threads. (Use 0 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."), citations=[citations['katoh2013mafft']] ) plugin.methods.register_function(
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', 'database': 'search formulas in given database', 'sirius_path': 'path to Sirius executable', 'ppm_max': 'allowed parts per million tolerance for decomposing masses', 'profile': 'configuration profile for mass-spec platform used', 'n_jobs': 'Number of cpu cores to use',
'the estimator.') 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 },
citations = Citations.load('citations.bib', package='q2_feature_table') plugin = Plugin( name='feature-table', version=q2_feature_table.__version__, website='https://github.com/qiime2/q2-feature-table', package='q2_feature_table', short_description=('Plugin for working with sample by feature tables.'), description=('This is a QIIME 2 plugin supporting operations on sample ' 'by feature tables, such as filtering, merging, and ' 'transforming tables.')) plugin.methods.register_function( function=q2_feature_table.rarefy, inputs={'table': FeatureTable[Frequency]}, parameters={ 'sampling_depth': Int % Range(1, None), 'with_replacement': Bool }, outputs=[('rarefied_table', FeatureTable[Frequency])], input_descriptions={'table': 'The feature table to be rarefied.'}, parameter_descriptions={ 'sampling_depth': ('The total frequency that each sample should be ' 'rarefied to. Samples where the sum of frequencies ' 'is less than the sampling depth will be not be ' 'included in the resulting table unless ' 'subsampling is performed with replacement.'), 'with_replacement': ('Rarefy with replacement by sampling from the ' 'multinomial distribution instead of rarefying ' 'without replacement.') }, output_descriptions={
citations=[] ) plugin.visualizers.register_function( function=heatmap, inputs={'ranks': FeatureData[Conditional]}, parameters={ 'microbe_metadata': MetadataColumn[Categorical], 'metabolite_metadata': MetadataColumn[Categorical], 'method': Str % Choices(_heatmap_choices['method']), 'metric': Str % Choices(_heatmap_choices['metric']), 'color_palette': Str % Choices(_cmaps['heatmap']), 'margin_palette': Str % Choices(_cmaps['margins']), 'x_labels': Bool, 'y_labels': Bool, 'level': Int % Range(-1, None), 'row_center': Bool, }, input_descriptions={'ranks': 'Conditional probabilities.'}, parameter_descriptions={ 'microbe_metadata': 'Optional microbe metadata for annotating plots.', 'metabolite_metadata': 'Optional metabolite metadata for annotating ' 'plots.', 'method': 'Hierarchical clustering method used in clustermap.', 'metric': 'Distance metric used in clustermap.', 'color_palette': 'Color palette for clustermap.', 'margin_palette': 'Name of color palette to use for annotating ' 'metadata along margin(s) of clustermap.', 'x_labels': 'Plot x-axis (metabolite) labels?', 'y_labels': 'Plot y-axis (microbe) labels?', 'level': 'taxonomic level for annotating clustermap. Set to -1 if not '
'selected. If input sequences are paired end, plots will be ' 'generated for both forward and reverse reads for the same `n` ' 'sequences.') }, name='Summarize counts per sample.', description=('Summarize counts per sample for all samples, and generate ' 'interactive positional quality plots based on `n` randomly ' 'selected sequences.') ) plugin.methods.register_function( function=q2_demux.subsample_single, inputs={'sequences': SampleData[SequencesWithQuality | PairedEndSequencesWithQuality]}, parameters={'fraction': Float % Range(0, 1, inclusive_start=False, inclusive_end=False)}, outputs=[ ('subsampled_sequences', SampleData[SequencesWithQuality]) ], input_descriptions={ 'sequences': 'The demultiplexed sequences to be subsampled.' }, parameter_descriptions={ 'fraction': ('The fraction of sequences to retain in subsample.') }, output_descriptions={ 'subsampled_sequences': 'The subsampled sequences.' }, name='Subsample single-end sequences without replacement.', description=('Generate a random subsample of single-end sequences '
'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), 'evalue': Float, 'perc_query_aligned': Float, 'threads': Int % Range(1, None)}, outputs=[('sequence_hits', FeatureData[Sequence]), ('sequence_misses', FeatureData[Sequence])], input_descriptions=seq_inputs_descriptions, parameter_descriptions={ 'method': ('Alignment method to use for matching feature sequences ' 'against reference sequences'), 'perc_identity': ('Reject match if percent identity to reference is ' 'lower. Must be in range [0.0, 1.0]'), 'evalue': ('BLAST expectation (E) value threshold for saving hits. ' 'Reject if E value is higher than threshold. This ' 'threshold is disabled by default.'), 'perc_query_aligned': (
'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. ' 'This tree can contain tip ids that are not present in ' 'the table, but all feature ids in the table must be '
return result @plugin.register_transformer def _2(fmt: IDSelectionDirFmt) -> qiime2.Metadata: md = fmt.metadata.view(IDMetadataFormat).to_metadata() return md.filter_ids(fmt.included.view(UNIXListFormat).to_list()) plugin.methods.register_function( function=subsample_random, inputs={}, parameters={ 'ids': Metadata, 'n': Int % Range(1, None), 'seed': Int }, outputs=[('selection', FeatureData[Selection])], parameter_descriptions={ 'ids': 'IDs to subsample from.', 'n': 'Number of IDs to sample.', 'seed': 'Random seed to use to initialize random number generator.' }, input_descriptions={}, output_descriptions={ 'selection': 'The selected IDs.' }, name='Randomly sample IDs', description='Randomly sample IDs without replacement.' )
return consensus plugin.methods.register_function( function=classify_consensus_blast, inputs={ 'query': FeatureData[Sequence], 'reference_reads': FeatureData[Sequence], 'reference_taxonomy': FeatureData[Taxonomy] }, parameters={ 'evalue': Float, 'maxaccepts': Int % Range(1, None), 'perc_identity': Float % Range(0.0, 1.0, inclusive_end=True), 'strand': Str % Choices(['both', 'plus', 'minus']), 'min_consensus': Float % Range(0.5, 1.0, inclusive_end=True, inclusive_start=False), 'unassignable_label': Str }, outputs=[('classification', FeatureData[Taxonomy])], input_descriptions={ 'query': 'Sequences to classify taxonomically.', 'reference_reads': 'reference sequences.', 'reference_taxonomy': 'reference taxonomy labels.' },
if amplicon is not None: skbio.write(amplicon, format='fasta', into=fh) if os.stat(str(ff)).st_size == 0: 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 '
description='', short_description='') plugin.register_formats(PosteriorLogFormat, NexusFormat, BEASTControlFileFormat, BEASTOpsFileFormat, BEASTPosteriorDirFmt, NexusDirFmt) plugin.register_semantic_types(Chain, BEAST, MCC) plugin.register_semantic_type_to_format(Chain[BEAST], artifact_format=BEASTPosteriorDirFmt) plugin.register_semantic_type_to_format(Phylogeny[MCC], 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':
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."),
'metadata': base_parameter_descriptions['metadata'], 'x': coords_description.format('x'), 'y': coords_description.format('y'), 'z': coords_description.format('z'), 'missing_data': base_parameter_descriptions['missing_data']}, name='Create a distance matrix from 2D or 3D cartesian coordinates.', description='Measure pairwise euclidean distances between cartesian ' 'coordinates. ' 'Note that samples with missing values are silently dropped.', ) plugin.visualizers.register_function( function=autocorr, inputs={'distance_matrix': DistanceMatrix}, parameters={'metadata': MetadataColumn[Numeric], 'permutations': Int % Range(0, None), 'two_tailed': Bool, 'transformation': Str % Choices(['R', 'B', 'D', 'V']), 'intersect_ids': Bool}, input_descriptions={'distance_matrix': 'Spatial distance matrix'}, parameter_descriptions={ 'metadata': 'Variable to test for spatial autocorrelation.', 'permutations': 'Number of random permutations for calculation of ' 'pseudo p-values.', 'two_tailed': 'If True (default) analytical p-values for Moran are ' 'two tailed, otherwise if False, they are one-tailed. ' 'This does not apply to Geary\'s C.', 'transformation': 'Weights transformation, default is "R" ' '(row-standardized). Other options include "B": ' 'binary, "D": doubly-standardized, "V": ' 'variance-stabilizing.',
}, output_descriptions={ 'correlation_table': 'The resulting table of pairwise correlations with R and p-value.' }, name='Build pairwise correlations between observations', description=( 'Build pairwise correlations between all observations in feature table' ), ) plugin.methods.register_function( function=build_correlation_network_r, inputs={'correlation_table': PairwiseFeatureData}, parameters={ 'min_val': Float % Range(0, 1, inclusive_end=True), 'cooccur': Bool }, outputs=[('correlation_network', Network)], input_descriptions={ 'correlation_table': ('Pairwise feature data table of correlations with r value.') }, parameter_descriptions={ 'min_val': 'The minimum r value to say an edge should exist.', 'cooccur': 'Whether or not to constrain the network to only positive edges.' }, output_descriptions={'correlation_network': 'The resulting network.'}, name='Build a correlation network based on an r value cutoff',
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.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(0, None)}, 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 0 to automatically use all available ' 'cores)' },
plugin = Plugin( name='ipcress', version=q2_ipcress.__version__, website='https://github.com/BenKaehler/q2-ipcress', package='q2_ipcress', description=('This QIIME 2 plugin provides support for generating ' 'synthetic PCR reads from a set of reference sequences.'), short_description='Wrapper for ipcress, an in-silico PCR program.') plugin.methods.register_function( function=q2_ipcress.ipcress, inputs={'sequence': FeatureData[Sequence]}, parameters={ 'primer_a': Str, 'primer_b': Str, 'min_product_len': Int % Range(0, None), 'max_product_len': Int % Range(0, None), 'mismatch': Int % Range(0, None), 'memory': Int % Range(0, None), 'seed': Int % Range(0, None) }, outputs=[('reads', FeatureData[Sequence])], name='Run in-silico PCR on references', description='Extract sequencing-like reads from a reference database.', parameter_descriptions={ 'primer_a': 'Sequence for the first primer', 'primer_b': 'Sequence for the second primer', 'min_product_len': 'Minimum product length to report',
# plugin.register_semantic_type_to_format(ReferenceSequence, GenBankDirFmt) 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 '
'are present in a fully comprehensive reference database. To simulate ' 'more realistic conditions, see `evaluate_cross_validate`. THE ' 'CLASSIFIER OUTPUT BY THIS PIPELINE IS PRODUCTION-READY and can be ' 're-used for classification of other sequences (provided the ' 'reference data are viable), hence THIS PIPELINE IS USEFUL FOR ' 'TRAINING FEATURE CLASSIFIERS AND THEN EVALUATING THEM ON-THE-FLY.'), citations=[citations['bokulich2018optimizing']] ) plugin.pipelines.register_function( function=evaluate_cross_validate, inputs={'sequences': FeatureData[Sequence], 'taxonomy': FeatureData[Taxonomy]}, parameters={ 'k': Int % Range(2, None), 'random_state': Int % Range(0, None), 'reads_per_batch': _classify_parameters['reads_per_batch'], 'n_jobs': _classify_parameters['n_jobs'], 'confidence': _classify_parameters['confidence']}, outputs=[('expected_taxonomy', FeatureData[Taxonomy]), ('observed_taxonomy', FeatureData[Taxonomy]), ('evaluation', Visualization)], input_descriptions={ 'sequences': 'Reference sequences to use for classifier ' 'training/testing.', 'taxonomy': 'Reference taxonomy to use for classifier ' 'training/testing.'}, parameter_descriptions={ 'k': 'Number of stratified folds.', 'random_state': 'Seed used by the random number generator.',
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(
description='This QIIME 2 plugin uses cutadapt to work with ' 'adapters (e.g. barcodes, primers) in sequence data.', short_description='Plugin for removing adapter sequences, primers, and ' 'other unwanted sequence from sequence data.', citation_text='Martin, M. (2011). Cutadapt removes adapter sequences from ' 'high-throughput sequencing reads. EMBnet.Journal, 17(1), ' 'pp. 10-12.\ndoi:http://dx.doi.org/10.14806/ej.17.1.200', ) plugin.methods.register_function( function=q2_cutadapt._trim.trim_single, inputs={ 'demultiplexed_sequences': SampleData[SequencesWithQuality], }, parameters={ 'cores': Int % Range(1, None), 'adapter': List[Str], 'front': List[Str], 'anywhere': List[Str], 'error_rate': Float % Range(0, 1, inclusive_start=True, inclusive_end=True), 'indels': Bool, 'times': Int % Range(1, None), 'overlap': Int % Range(1, None), 'match_read_wildcards': Bool, 'match_adapter_wildcards': Bool, }, outputs=[ ('trimmed_sequences', SampleData[SequencesWithQuality]), ], input_descriptions={
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': '[Excluding weighted_unifrac] - %s' % sklearn_n_jobs_description
'are present in a fully comprehensive reference database. To simulate ' 'more realistic conditions, see `evaluate_cross_validate`. THE ' 'CLASSIFIER OUTPUT BY THIS PIPELINE IS PRODUCTION-READY and can be ' 're-used for classification of other sequences (provided the ' 'reference data are viable), hence THIS PIPELINE IS USEFUL FOR ' 'TRAINING FEATURE CLASSIFIERS AND THEN EVALUATING THEM ON-THE-FLY.'), citations=[citations['bokulich2018optimizing']]) plugin.pipelines.register_function( function=evaluate_cross_validate, inputs={ 'sequences': FeatureData[Sequence], 'taxonomy': FeatureData[Taxonomy] }, parameters={ 'k': Int % Range(2, None), 'random_state': Int % Range(0, None), 'reads_per_batch': _classify_parameters['reads_per_batch'], 'n_jobs': _classify_parameters['n_jobs'], 'confidence': _classify_parameters['confidence'] }, outputs=[('expected_taxonomy', FeatureData[Taxonomy]), ('observed_taxonomy', FeatureData[Taxonomy]), ('evaluation', Visualization)], input_descriptions={ 'sequences': 'Reference sequences to use for classifier ' 'training/testing.', 'taxonomy': 'Reference taxonomy to use for classifier ' 'training/testing.' }, parameter_descriptions={