def run(args=()):
with open(TARGET, "w") as f:
f.write("""\
==================================================
pbreports specifications (automatically generated)
==================================================
""")
for spec in os.listdir(SPEC_DIR):
specfile = op.join(SPEC_DIR, spec)
meta_rpt = MetaReport.from_json(specfile)
if meta_rpt.id in blacklist:
continue
if meta_rpt.attributes:
f.write("\n\n\n")
f.write(
"**{t}** ({d}):\n\n".format(t=meta_rpt.title, d=meta_rpt.id))
f.write("{n}\n\n".format(n=meta_rpt.description))
table = []
for attr in meta_rpt.attributes:
row = [attr.id, attr.name, attr.description]
table.append(row)
HEADERS = ["Attribute ID", "Name", "Description"]
f.write(tabulate(table, HEADERS, tablefmt="rst"))
return 0
def setUp(self):
self.meta_rpt = MetaReport.from_json(TEST_JSON)
attributes = []
attributes.append(
self.meta_rpt.get_meta_attribute("attribute1").as_attribute(1))
attributes.append(
self.meta_rpt.get_meta_attribute("attribute2").as_attribute(2.2))
attributes.append(
self.meta_rpt.get_meta_attribute("attribute3").as_attribute(
"test_string"))
plotgroups = []
plots = []
plots.append(
self.meta_rpt.get_meta_plotgroup("plotgroup1").get_meta_plot(
"plot1").as_plot(image=PLOT1_FILE, thumbnail=THUMBNAIL1_FILE))
plotgroups.append(
self.meta_rpt.get_meta_plotgroup("plotgroup1").as_plotgroup(
thumbnail=THUMBNAIL2_FILE, plots=plots))
tables = []
columns = []
columns.append(
self.meta_rpt.get_meta_table("table1").get_meta_column(
"column1").as_column(values=[1, 22, 142]))
tables.append(
self.meta_rpt.get_meta_table("table1").as_table(columns=columns))
columns = []
columns.append(
self.meta_rpt.get_meta_table("table2").get_meta_column(
"column1").as_column(values=[1.0, 2.1, 3.37]))
columns.append(
self.meta_rpt.get_meta_table("table2").get_meta_column(
"column2").as_column(values=["string1", "string2", "string3"]))
tables.append(
self.meta_rpt.get_meta_table("table2").as_table(columns=columns))
self.rpt = self.meta_rpt.as_report(attributes=attributes,
plotgroups=plotgroups,
tables=tables)
self.rpt = self.meta_rpt.apply_view(self.rpt)
def setUp(self):
self.meta_rpt = MetaReport.from_json(TEST_JSON)
attributes = []
attributes.append(self.meta_rpt.get_meta_attribute("attribute1").as_attribute(1))
attributes.append(self.meta_rpt.get_meta_attribute("attribute2").as_attribute(2.2))
attributes.append(self.meta_rpt.get_meta_attribute("attribute3").as_attribute("test_string"))
plotgroups = []
plots = []
plots.append(self.meta_rpt.get_meta_plotgroup("plotgroup1").get_meta_plot("plot1").as_plot(image=PLOT1_FILE, thumbnail=THUMBNAIL1_FILE))
plotgroups.append(self.meta_rpt.get_meta_plotgroup("plotgroup1").as_plotgroup(thumbnail=THUMBNAIL2_FILE, plots=plots))
tables = []
columns = []
columns.append(self.meta_rpt.get_meta_table("table1").get_meta_column("column1").as_column(values=[1,22,142]))
tables.append(self.meta_rpt.get_meta_table("table1").as_table(columns=columns))
columns = []
columns.append(self.meta_rpt.get_meta_table("table2").get_meta_column("column1").as_column(values=[1.0,2.1,3.37]))
columns.append(self.meta_rpt.get_meta_table("table2").get_meta_column("column2").as_column(values=["string1","string2","string3"]))
tables.append(self.meta_rpt.get_meta_table("table2").as_table(columns=columns))
self.rpt = self.meta_rpt.as_report(attributes=attributes,plotgroups=plotgroups,tables=tables)
from pbcommand.models.report import Report, Table, Column
from pbreports.report.report_spec import (MetaAttribute, MetaPlotGroup, MetaPlot,
MetaColumn, MetaTable, MetaReport)
from pbcommand.models import TaskTypes, FileTypes, get_pbparser
from pbcommand.cli import pbparser_runner
from pbcommand.common_options import add_debug_option
from pbcommand.utils import setup_log
from pbcore.io import DataSet
__version__ = '0.1.0'
# Import Mapping MetaReport
_DIR_NAME = os.path.dirname(os.path.realpath(__file__))
SPEC_DIR = os.path.join(_DIR_NAME, 'specs/')
LOADING_SPEC = op.join(SPEC_DIR, 'loading_xml.json')
meta_rpt = MetaReport.from_json(LOADING_SPEC)
class Constants(object):
TOOL_ID = "pbreports.tasks.loading_report_xml"
DRIVER_EXE = ("python -m pbreports.report.loading_xml "
"--resolved-tool-contract ")
DECIMALS = 3
T_LOADING = "loading_xml_table"
C_CONTEXT = "collection_context"
C_ZMWS = "productive_zmws"
C_PROD_0 = "productivity_0"
C_PROD_1 = "productivity_1"
C_PROD_2 = "productivity_2"
log = logging.getLogger(__name__)
MetaColumn, MetaTable, MetaReport)
from pbcommand.validators import validate_dir, validate_file
from pbcommand.cli.core import pacbio_args_runner
from pbcommand.utils import setup_log
from pbcore.io.FastqIO import FastqReader
from pbreports.plot.helper import get_fig_axes_lpr
log = logging.getLogger(__name__)
__version__ = '1.2'
# Import Mapping MetaReport
_DIR_NAME = os.path.dirname(os.path.realpath(__file__))
SPEC_DIR = os.path.join(_DIR_NAME, 'specs/')
CCS_VAL_SPEC = op.join(SPEC_DIR, 'ccs_validator_report.json')
meta_rpt = MetaReport.from_json(CCS_VAL_SPEC)
class Constants(object):
PG_CCS = "ccs_validator_group"
P_RL = "readlength_hist"
P_QV = "qv_hist"
T_FASTQ = "fastq_table"
C_FN = 'file_name'
C_NREADS = 'n_reads'
C_TOT_BASES = 'total_bases'
C_READLENGTH = 'mean_readlength'
C_QV = 'mean_qv'
from pbreports.plot.helper import (get_fig_axes_lpr,
save_figure_with_thumbnail,
set_tick_label_font_size,
set_axis_label_font_size)
from pbreports.util import add_base_and_plot_options
log = logging.getLogger(__name__)
__version__ = '0.1'
# Import Mapping MetaReport
_DIR_NAME = op.dirname(op.realpath(__file__))
SPEC_DIR = op.join(_DIR_NAME, 'specs/')
CONTROL_SPEC = op.join(SPEC_DIR, 'control.json')
meta_rpt = MetaReport.from_json(CONTROL_SPEC)
CSV_COLUMN_MAP = {
"ReadId": ("|S128", str),
"Readlength": (int, int),
"ReadScore": (float, float),
"PassedFilter": (int, int)
}
class Constants(object):
A_CONTROL_SEQ = "control_sequence"
A_NCONTROL = "n_control_reads"
A_FRAC_CONTROL = "frac_control_reads"
A_ACCURACY = "control_subread_accuracy"
A_N50 = "control_n50"
from pbcommand.cli import pbparser_runner
from pbcommand.common_options import add_debug_option
from pbcommand.utils import setup_log
from pbreports.util import recfromcsv
from pbreports.util import validate_nonempty_file
log = logging.getLogger(__name__)
__version__ = '0.3.1'
# Import Mapping MetaReport
_DIR_NAME = os.path.dirname(os.path.realpath(__file__))
SPEC_DIR = os.path.join(_DIR_NAME, 'specs/')
AAC_SPEC = op.join(SPEC_DIR, 'amplicon_analysis_consensus.json')
meta_rpt = MetaReport.from_json(AAC_SPEC)
class Constants(object):
TOOL_ID = "pbreports.tasks.amplicon_analysis_consensus"
def create_table(d, barcode):
"""Long Amplicon Analysis results table"""
columns = []
if barcode:
columns.append(Column("barcodename", header=""))
columns.append(Column("coarsecluster", header=""))
from pbcommand.common_options import add_debug_option
from pbcommand.models import FileTypes, get_pbparser
from pbcommand.cli import pbparser_runner
from pbcommand.utils import setup_log
from pbcore.io import SubreadSet
from pbreports.plot.helper import (get_fig_axes_lpr,
save_figure_with_thumbnail, get_green)
__version__ = '0.1.0'
# Import Mapping MetaReport
_DIR_NAME = os.path.dirname(os.path.realpath(__file__))
SPEC_DIR = os.path.join(_DIR_NAME, 'specs/')
ADAPTER_SPEC = op.join(SPEC_DIR, 'adapter_xml.json')
meta_rpt = MetaReport.from_json(ADAPTER_SPEC)
class Constants(object):
TOOL_ID = "pbreports.tasks.adapter_report_xml"
DRIVER_EXE = ("python -m pbreports.report.adapter_xml "
"--resolved-tool-contract ")
A_DIMERS = "adapter_dimers"
A_SHORT_INSERTS = "short_inserts"
PG_ADAPTER = "adapter_xml_plot_group"
P_ADAPTER = "adapter_xml_plot"
log = logging.getLogger(__name__)
from pbcommand.models import TaskTypes, FileTypes, get_pbparser
from pbcommand.cli import pbparser_runner
from pbcommand.common_options import add_debug_option
from pbcore.io import SubreadSet
from pbreports.plot.helper import (get_fig_axes_lpr,
save_figure_with_thumbnail, get_green)
from pbreports.util import compute_n50, continuous_dist_shaper
__version__ = '0.1.0'
# Import Mapping MetaReport
_DIR_NAME = os.path.dirname(os.path.realpath(__file__))
SPEC_DIR = os.path.join(_DIR_NAME, 'specs/')
FILTER_SPEC = op.join(SPEC_DIR, 'filter_stats_xml.json')
meta_rpt = MetaReport.from_json(FILTER_SPEC)
class Constants(object):
TOOL_ID = "pbreports.tasks.filter_stats_report_xml"
DRIVER_EXE = ("python -m pbreports.report.filter_stats_xml "
"--resolved-tool-contract ")
A_NBASES = "nbases"
A_NREADS = "nreads"
A_READ_N50 = "read_n50"
A_READ_LENGTH = "read_length"
# A_READ_QUALITY = "read_quality"
A_INSERT_LENGTH = "insert_length"
# A_INSERT_QUALITY = "insert_quality"
def test_read_specs(self): for spec in os.listdir(SPEC_DIR): specfile = op.join(SPEC_DIR, spec) tmp_meta_rpt = MetaReport.from_json(specfile)
from pbcore.io import ContigSet
from pbreports.plot.helper import (get_fig_axes_lpr, apply_histogram_data,
get_blue)
from pbreports.util import validate_file
log = logging.getLogger(__name__)
__version__ = '0.1.0.132615' # The last 6 digits is changelist
# Import Mapping MetaReport
_DIR_NAME = os.path.dirname(os.path.realpath(__file__))
SPEC_DIR = os.path.join(_DIR_NAME, 'specs/')
ISOSEQ_CLASSIFY_SPEC = op.join(SPEC_DIR, 'isoseq_classify.json')
meta_rpt = MetaReport.from_json(ISOSEQ_CLASSIFY_SPEC)
class Constants(object):
TOOL_ID = "pbreports.tasks.isoseq_classify"
DRIVER_EXE = "python -m pbreports.report.isoseq_classify --resolved-tool-contract "
"""Names used within plot groups."""
R_ID = meta_rpt.id
# PlotGroup
PG_READLENGTH = "fulllength_nonchimeric_readlength_group"
# Plots
P_READLENGTH = "fulllength_nonchimeric_readlength_hist"
# Table
from pbcommand.models import get_pbparser, FileTypes
from pbreports.report.streaming_utils import PlotViewProperties
from pbreports.plot.helper import (get_fig_axes_lpr, apply_line_data, Line)
from pbreports.report.mapping_stats import *
from pbreports.report.mapping_stats import Constants as BaseConstants
from pbreports.report.ccs import create_plot
from pbreports.report.report_spec import (MetaAttribute, MetaPlotGroup, MetaPlot,
MetaColumn, MetaTable, MetaReport)
# Import Mapping MetaReport
_DIR_NAME = os.path.dirname(os.path.realpath(__file__))
SPEC_DIR = os.path.join(_DIR_NAME, 'specs/')
MAPPING_STATS_CCS_SPEC = op.join(SPEC_DIR, 'mapping_stats_ccs.json')
meta_rpt = MetaReport.from_json(MAPPING_STATS_CCS_SPEC)
class Constants(BaseConstants):
TOOL_ID = "pbreports.tasks.mapping_stats_ccs"
DRIVER_EXE = "python -m pbreports.report.mapping_stats_ccs --resolved-tool-contract"
T_STATS = "mapping_stats_table"
PG_READ_CONCORDANCE = "ccs_read_concordance_group"
P_READ_CONCORDANCE = "concordance_plot"
PG_READLENGTH = "ccs_readlength_group"
PG_QV_CALIBRATION = "qv_calibration_group"
P_QV_CALIBRATION = "qv_calibration_plot"
A_NREADS = "mapped_reads_n"
A_READLENGTH = "mapped_readlength_mean"
from pbcommand.cli import pbparser_runner
from pbcommand.common_options import add_debug_option
from pbcommand.utils import setup_log
from pbcore.io.GffIO import GffReader
import pbreports.plot.helper as PH
__version__ = '2.0'
log = logging.getLogger()
# Import Mapping MetaReport
_DIR_NAME = os.path.dirname(os.path.realpath(__file__))
SPEC_DIR = os.path.join(_DIR_NAME, 'specs/')
MOTIF_SPEC = op.join(SPEC_DIR, 'motifs.json')
meta_rpt = MetaReport.from_json(MOTIF_SPEC)
class Constants(object):
R_ID = meta_rpt.id
T_ID = "motif_records"
# Plot Groups
PG_MOD_QV = 'modification_qvs'
P_MOD_QV = "motifs"
PG_MOD = 'modifications'
P_MOD_COV = 'mod_qv_coverage'
P_MOD_HIST = 'qmod_hist'
from pbcommand.models import FileTypes, get_pbparser
from pbcommand.cli import pbparser_runner
from pbcommand.utils import setup_log
from pbcore.io import openDataSet, BamReader
from pbreports.util import movie_to_cell, path_to_movie
log = logging.getLogger(__name__)
__version__ = '2.0'
# Import Mapping MetaReport
_DIR_NAME = op.dirname(op.realpath(__file__))
SPEC_DIR = op.join(_DIR_NAME, 'specs/')
OV_SPEC = op.join(SPEC_DIR, 'overview.json')
meta_rpt = MetaReport.from_json(OV_SPEC)
class Constants(object):
TOOL_ID = "pbreports.tasks.overview"
TOOL_NAME = "Overview report"
DRIVER_EXE = "python -m pbreports.report.overview --resolved-tool-contract "
A_NCELLS = "ncells"
A_NMOVIES = "nmovies"
def run(dataset_file):
"""Reads in the input.fofn and counts movies and cells. Outputs in XML."""
with openDataSet(dataset_file) as ds:
movies = None
from pbreports.util import compute_n50
from pbreports.report.streaming_utils import (PlotViewProperties,
to_plot_groups,
custom_subread_length_histogram)
from pbreports.model.aggregators import (BaseAggregator, SumAggregator,
HistogramAggregator, MaxAggregator,
MeanAggregator, CountAggregator)
log = logging.getLogger(__name__)
__version__ = '1.2'
# Import Mapping MetaReport
_DIR_NAME = op.dirname(op.realpath(__file__))
SPEC_DIR = op.join(_DIR_NAME, 'specs/')
FS_SPEC = op.join(SPEC_DIR, 'filter_subread.json')
meta_rpt = MetaReport.from_json(FS_SPEC)
class Constants(object):
"""Ids used for Report, Table, PlotGroup, Plot, Attributes,
Using an a prefix for autocomplete
"""
R_ID = meta_rpt.id
# Table
#T_MY_ID = ''
# Plot Groups
PG_SUBREAD_LENGTH = 'subread'
def setUp(self):
self.meta_rpt = MetaReport.from_json(TEST_JSON)
from pbcommand.models import TaskTypes, FileTypes, get_pbparser
from pbcommand.cli import pbparser_runner
from pbcommand.common_options import add_debug_option
from pbcore.io import SubreadSet
from pbreports.plot.helper import (get_fig_axes_lpr,
save_figure_with_thumbnail, get_green)
from pbreports.util import compute_n50, continuous_dist_shaper
__version__ = '0.1.0'
# Import Mapping MetaReport
_DIR_NAME = os.path.dirname(os.path.realpath(__file__))
SPEC_DIR = os.path.join(_DIR_NAME, 'specs/')
FILTER_SPEC = op.join(SPEC_DIR, 'filter_stats_xml.json')
meta_rpt = MetaReport.from_json(FILTER_SPEC)
class Constants(object):
TOOL_ID = "pbreports.tasks.filter_stats_report_xml"
DRIVER_EXE = ("python -m pbreports.report.filter_stats_xml "
"--resolved-tool-contract ")
A_NBASES = "nbases"
A_NREADS = "nreads"
A_READ_N50 = "read_n50"
A_READ_LENGTH = "read_length"
# A_READ_QUALITY = "read_quality"
A_INSERT_LENGTH = "insert_length"
# A_INSERT_QUALITY = "insert_quality"
READ_ATTR = [A_NBASES, A_NREADS, A_READ_LENGTH, A_READ_N50]
from pbcommand.models import get_pbparser, FileTypes
from pbreports.report.streaming_utils import PlotViewProperties
from pbreports.plot.helper import get_fig_axes_lpr, apply_line_data, Line
from pbreports.report.mapping_stats import *
from pbreports.report.mapping_stats import Constants as BaseConstants
from pbreports.report.ccs import create_plot
from pbreports.report.report_spec import MetaAttribute, MetaPlotGroup, MetaPlot, MetaColumn, MetaTable, MetaReport
# Import Mapping MetaReport
_DIR_NAME = os.path.dirname(os.path.realpath(__file__))
SPEC_DIR = os.path.join(_DIR_NAME, "specs/")
MAPPING_STATS_CCS_SPEC = op.join(SPEC_DIR, "mapping_stats_ccs.json")
meta_rpt = MetaReport.from_json(MAPPING_STATS_CCS_SPEC)
class Constants(BaseConstants):
TOOL_ID = "pbreports.tasks.mapping_stats_ccs"
DRIVER_EXE = "python -m pbreports.report.mapping_stats_ccs --resolved-tool-contract"
T_STATS = "mapping_stats_table"
PG_READ_CONCORDANCE = "ccs_read_concordance_group"
P_READ_CONCORDANCE = "concordance_plot"
PG_READLENGTH = "ccs_readlength_group"
PG_QV_CALIBRATION = "qv_calibration_group"
P_QV_CALIBRATION = "qv_calibration_plot"
A_NREADS = "mapped_reads_n"
A_READLENGTH = "mapped_readlength_mean"
def setUp(self):
self.meta_rpt = MetaReport.from_json(TEST_JSON)
from pbreports.report.coverage import ContigCoverage
from pbreports.util import compute_n50
import pbreports.plot.helper as PH
log = logging.getLogger(__name__)
__version__ = '0.4'
__all__ = ['make_polished_assembly_report', 'ContigInfo',
'get_parser']
# Import Mapping MetaReport
_DIR_NAME = os.path.dirname(os.path.realpath(__file__))
SPEC_DIR = os.path.join(_DIR_NAME, 'specs/')
POLISHED_ASSEMBLY_SPEC = op.join(SPEC_DIR, 'polished_assembly.json')
meta_rpt = MetaReport.from_json(POLISHED_ASSEMBLY_SPEC)
class Constants(object):
TOOL_ID = "pbreports.tasks.polished_assembly"
A_N_CONTIGS = "polished_contigs"
A_MAX_LEN = "max_contig_length"
A_N50_LEN = "n_50_contig_length"
A_SUM_LEN = "sum_contig_lengths"
PG_COVERAGE = "coverage_based"
P_COVERAGE = "cov_vs_qual"
def make_polished_assembly_report(report, gff, fastq, output_dir):
"""
Entry to report.
:param gff: (str) path to alignment_summary.gff
:param fastq: (str) path to polished fastq file
def test_read_specs(self):
for spec in os.listdir(SPEC_DIR):
specfile = op.join(SPEC_DIR, spec)
tmp_meta_rpt = MetaReport.from_json(specfile)
from pbcommand.cli import pbparser_runner
from pbcommand.models.report import Report, Table, Column
from pbreports.report.report_spec import MetaAttribute, MetaPlotGroup, MetaPlot, MetaColumn, MetaTable, MetaReport
from pbcommand.models import FileTypes, get_pbparser
from pbcommand.utils import setup_log
from pbcore.io import openDataSet, BarcodeSet
log = logging.getLogger(__name__)
__version__ = "0.6"
# Import Mapping MetaReport
_DIR_NAME = os.path.dirname(os.path.realpath(__file__))
SPEC_DIR = os.path.join(_DIR_NAME, "specs/")
BC_SPEC = op.join(SPEC_DIR, "barcode.json")
meta_rpt = MetaReport.from_json(BC_SPEC)
class Constants(object):
TOOL_ID = "pbreports.tasks.barcode_report"
TOOL_NAME = "barcode_report"
DRIVER_EXE = "python -m pbreports.report.barcode --resolved-tool-contract"
C_BARCODE = "barcode"
C_NREADS = "number_of_reads"
C_NBASES = "number_of_bases"
def _labels_reads_iterator(reads, barcodes, subreads=True):
with openDataSet(reads) as ds:
for er in ds.externalResources:
if er.barcodes != barcodes:
from pbcommand.utils import setup_log
import pbreports.plot.helper as PH
from pbreports.util import (add_base_and_plot_options,
add_base_options_pbcommand)
from pbreports.util import Constants as BaseConstants
log = logging.getLogger(__name__)
__version__ = '2.1'
# Import Mapping MetaReport
_DIR_NAME = os.path.dirname(os.path.realpath(__file__))
SPEC_DIR = os.path.join(_DIR_NAME, 'specs/')
MOD_SPEC = op.join(SPEC_DIR, 'modifications.json')
meta_rpt = MetaReport.from_json(MOD_SPEC)
class Constants(BaseConstants):
TOOL_ID = "pbreports.tasks.modifications_report"
DRIVER_EXE = "python -m pbreports.report.modifications --resolved-tool-contract"
PG_KIN = "kinetic_detections"
P_SCAT = "kinetic_scatter"
P_HIST = "kinetic_histogram"
def _create_fig_template(dims=(8, 6), facecolor='#ffffff', gridcolor='#e0e0e0'):
fig, ax = PH.get_fig_axes_lpr(dims=dims)
ax = fig.add_subplot(111)
ax.axesPatch.set_facecolor(facecolor)
ax.grid(color=gridcolor, linewidth=0.5, linestyle='-')
ax.set_axisbelow(True)
from pbcore.io import GffReader, ReferenceSet
from pbreports.util import (openReference,
add_base_options_pbcommand,
get_top_contigs_from_ref_entry)
import pbreports.plot.helper as PH
log = logging.getLogger(__name__)
__version__ = '0.1'
# Import Mapping MetaReport
_DIR_NAME = os.path.dirname(os.path.realpath(__file__))
SPEC_DIR = os.path.join(_DIR_NAME, 'specs/')
VARIANTS_SPEC = op.join(SPEC_DIR, 'variants.json')
meta_rpt = MetaReport.from_json(VARIANTS_SPEC)
class Constants(object):
TOOL_ID = "pbreports.tasks.variants_report"
DRIVER_EXE = "python -m pbreports.report.variants --resolved-tool-contract "
MAX_CONTIGS_ID = "pbreports.task_options.max_contigs"
MAX_CONTIGS_DEFAULT = 25
MEAN_CONTIG_LENGTH = "mean_contig_length"
MEAN_BASES_CALLED = "weighted_mean_bases_called"
MEAN_CONCORDANCE = "weighted_mean_concordance"
MEAN_COVERAGE = "weighted_mean_coverage"
LONGEST_CONTIG = "longest_contig_name"
T_STATS = "consensus_table"
C_CONTIG_NAME = "contig_name"
C_CONTIG_LEN = "contig_len"
C_BASES_CALLED = "bases_called"
from pbcommand.common_options import add_debug_option
from pbcommand.cli import pbparser_runner
from pbcommand.utils import setup_log
from pbcore.io import AlignmentSet
from pbreports.util import movie_to_cell, add_base_options_pbcommand
log = logging.getLogger(__name__)
__version__ = '0.1'
# Import Mapping MetaReport
_DIR_NAME = os.path.dirname(os.path.realpath(__file__))
SPEC_DIR = os.path.join(_DIR_NAME, 'specs/')
SAT_SPEC = op.join(SPEC_DIR, 'sat.json')
meta_rpt = MetaReport.from_json(SAT_SPEC)
class Constants(object):
TOOL_ID = "pbreports.tasks.sat_report"
DRIVER_EXE = "python -m pbreports.report.sat --resolved-tool-contract "
A_INSTRUMENT = "instrument"
A_COVERAGE = "coverage"
A_CONCORDANCE = "concordance"
A_READLENGTH = "mapped_readlength_mean"
A_READS = "reads_in_cell"
V_COVERAGE = "weighted_mean_bases_called"
V_CONCORDANCE = "weighted_mean_concordance"
M_READLENGTH = "mapped_readlength_mean"
from pbcommand.utils import setup_log
from pbcore.io import ContigSet
from pbreports.plot.helper import (get_fig_axes_lpr, apply_histogram_data,
get_blue)
from pprint import pformat
log = logging.getLogger(__name__)
__version__ = '0.1.0.132615' # The last 6 digits is changelist
# Import Mapping MetaReport
_DIR_NAME = os.path.dirname(os.path.realpath(__file__))
SPEC_DIR = os.path.join(_DIR_NAME, 'specs/')
ISOSEQ_CLUSTER_SPEC = op.join(SPEC_DIR, 'isoseq_cluster.json')
meta_rpt = MetaReport.from_json(ISOSEQ_CLUSTER_SPEC)
class Constants(object):
TOOL_ID = "pbreports.tasks.isoseq_cluster"
DRIVER_EXE = "python -m pbreports.report.isoseq_cluster --resolved-tool-contract"
"""Names used within plot groups."""
R_ID = meta_rpt.id
# Attributes
A_LENGTH = "avg_consensus_isoform_length"
A_CONSENSUS = "num_consensus_isoforms"
A_BASES = "num_total_bases"
# PlotGroup
PG_READLENGTH = "consensus_isoforms_readlength_group"
from pbcommand.models import FileTypes, get_pbparser
from pbcommand.cli import pbparser_runner
from pbcommand.utils import setup_log
from pbcore.io import openDataSet, BamReader
from pbreports.util import movie_to_cell, path_to_movie
log = logging.getLogger(__name__)
__version__ = '2.0'
# Import Mapping MetaReport
_DIR_NAME = op.dirname(op.realpath(__file__))
SPEC_DIR = op.join(_DIR_NAME, 'specs/')
OV_SPEC = op.join(SPEC_DIR, 'overview.json')
meta_rpt = MetaReport.from_json(OV_SPEC)
class Constants(object):
TOOL_ID = "pbreports.tasks.overview"
TOOL_NAME = "Overview report"
DRIVER_EXE = "python -m pbreports.report.overview --resolved-tool-contract "
A_NCELLS = "ncells"
A_NMOVIES = "nmovies"
def run(dataset_file):
"""Reads in the input.fofn and counts movies and cells. Outputs in XML."""
with openDataSet(dataset_file) as ds:
movies = None
movies = set([])
for file_name in ds.toExternalFiles():
from pbreports.report.report_spec import (MetaAttribute, MetaPlotGroup,
MetaPlot, MetaColumn, MetaTable,
MetaReport)
from pbcommand.models import TaskTypes, FileTypes, get_pbparser
from pbcommand.cli import pbparser_runner
from pbcommand.common_options import add_debug_option
from pbcommand.utils import setup_log
from pbcore.io import DataSet
__version__ = '0.1.0'
# Import Mapping MetaReport
_DIR_NAME = os.path.dirname(os.path.realpath(__file__))
SPEC_DIR = os.path.join(_DIR_NAME, 'specs/')
LOADING_SPEC = op.join(SPEC_DIR, 'loading_xml.json')
meta_rpt = MetaReport.from_json(LOADING_SPEC)
class Constants(object):
TOOL_ID = "pbreports.tasks.loading_report_xml"
DRIVER_EXE = ("python -m pbreports.report.loading_xml "
"--resolved-tool-contract ")
DECIMALS = 3
T_LOADING = "loading_xml_table"
C_CONTEXT = "collection_context"
C_ZMWS = "productive_zmws"
C_PROD_0 = "productivity_0"
C_PROD_1 = "productivity_1"
C_PROD_2 = "productivity_2"
save_figure_with_thumbnail,
set_tick_label_font_size,
set_axis_label_font_size)
from pbreports.util import add_base_and_plot_options
log = logging.getLogger(__name__)
__version__ = '0.1'
# Import Mapping MetaReport
_DIR_NAME = op.dirname(op.realpath(__file__))
SPEC_DIR = op.join(_DIR_NAME, 'specs/')
CONTROL_SPEC = op.join(SPEC_DIR, 'control.json')
meta_rpt = MetaReport.from_json(CONTROL_SPEC)
CSV_COLUMN_MAP = {"ReadId": ("|S128", str),
"Readlength": (int, int),
"ReadScore": (float, float),
"PassedFilter": (int, int)}
class Constants(object):
A_CONTROL_SEQ = "control_sequence"
A_NCONTROL = "n_control_reads"
A_FRAC_CONTROL = "frac_control_reads"
A_ACCURACY = "control_subread_accuracy"
A_N50 = "control_n50"
A_PCT95 = "control_95_percentile_readlength"
A_LENGTH = "control_mean_readlength"
from pbcommand.cli import pbparser_runner
from pbcommand.utils import setup_log
from pbcore.io import GffReader, ReferenceSet
from pbreports.util import add_base_options, openReference, \
add_base_options_pbcommand
log = logging.getLogger(__name__)
__version__ = '0.1'
# Import Mapping MetaReport
_DIR_NAME = os.path.dirname(os.path.realpath(__file__))
SPEC_DIR = os.path.join(_DIR_NAME, 'specs/')
VARS_SPEC = op.join(SPEC_DIR, 'top_variants.json')
meta_rpt = MetaReport.from_json(VARS_SPEC)
class Constants(object):
R_ID = meta_rpt.id
TOOL_ID = "pbreports.tasks.top_variants"
DRIVER_EXE = "python -m pbreports.report.top_variants --resolved-tool-contract"
HOW_MANY_ID = "pbreports.task_options.how_many"
BATCH_SORT_SIZE_ID = "pbreports.task_options.batch_sort_size"
HOW_MANY_DEFAULT = 100
BATCH_SORT_SIZE_DEFAULT = 10000
T_MINOR = "top_minor_variants_table"
C_SEQ = 'sequence'
C_POS = 'position'
C_VAR = 'variant'
C_TYP = 'type'
from pbcommand.cli import pbparser_runner
from pbcommand.utils import setup_log
from pbcore.io import ConsensusReadSet, BarcodeSet
from pbreports.plot.helper import (get_fig_axes_lpr, apply_histogram_data,
get_blue, get_green, Line, apply_line_data)
from pbreports.util import accuracy_as_phred_qv
log = logging.getLogger(__name__)
__version__ = '0.44'
# Import MetaReport
_DIR_NAME = os.path.dirname(os.path.realpath(__file__))
SPEC_DIR = os.path.join(_DIR_NAME, 'specs/')
CCS_SPEC = op.join(SPEC_DIR, 'ccs.json')
meta_rpt = MetaReport.from_json(CCS_SPEC)
class Constants(object):
""" ids for the core Report objects (e.g., Plot, PlotGroup, etc...)"""
TOOL_ID = "pbreports.tasks.ccs_report"
TOOL_NAME = "ccs_report"
DRIVER_EXE = "python -m pbreports.report.ccs --resolved-tool-contract"
R_ID = meta_rpt.id
# PlotGroup
PG_READLENGTH = 'readlength_group'
PG_ACCURACY = "accuracy_group"
PG_NPASSES = "npasses_hist"
from pbcommand.common_options import add_debug_option
from pbcommand.cli import pbparser_runner
from pbcommand.utils import setup_log
from pbcore.io import AlignmentSet
from pbreports.util import movie_to_cell, add_base_options_pbcommand
log = logging.getLogger(__name__)
__version__ = '0.1'
# Import Mapping MetaReport
_DIR_NAME = os.path.dirname(os.path.realpath(__file__))
SPEC_DIR = os.path.join(_DIR_NAME, 'specs/')
SAT_SPEC = op.join(SPEC_DIR, 'sat.json')
meta_rpt = MetaReport.from_json(SAT_SPEC)
class Constants(object):
TOOL_ID = "pbreports.tasks.sat_report"
DRIVER_EXE = "python -m pbreports.report.sat --resolved-tool-contract "
A_INSTRUMENT = "instrument"
A_COVERAGE = "coverage"
A_CONCORDANCE = "concordance"
A_READLENGTH = "mapped_readlength_mean"
A_READS = "reads_in_cell"
V_COVERAGE = "weighted_mean_bases_called"
V_CONCORDANCE = "weighted_mean_concordance"
M_READLENGTH = "mapped_readlength_mean"
apply_line_fill_data, apply_histogram_data,
LineFill, save_figure_with_thumbnail)
from pbreports.report.report_spec import (MetaAttribute, MetaPlotGroup,
MetaPlot, MetaColumn, MetaTable,
MetaReport)
log = logging.getLogger(__name__)
__version__ = '0.1'
# Import Mapping MetaReport
_DIR_NAME = os.path.dirname(os.path.realpath(__file__))
SPEC_DIR = os.path.join(_DIR_NAME, 'specs/')
COVERAGE_SPEC = op.join(SPEC_DIR, 'coverage.json')
meta_rpt = MetaReport.from_json(COVERAGE_SPEC)
class Constants(object):
TOOL_ID = "pbreports.tasks.coverage_report"
DRIVER_EXE = "python -m pbreports.report.coverage --resolved-tool-contract "
MAX_CONTIGS_ID = "pbreports.task_options.max_contigs"
MAX_CONTIGS_DEFAULT = 25
COLOR_STEEL_BLUE_DARK = '#226F96'
COLOR_STEEL_BLUE_LIGHT = '#2B8CBE'
A_COVERAGE = "depth_coverage_mean"
A_MISSING = "missing_bases_pct"
PG_COVERAGE = "coverage_plots"
from pbreports.plot.helper import (get_fig_axes_lpr, apply_line_data,
apply_line_fill_data, apply_histogram_data,
LineFill, save_figure_with_thumbnail)
from pbreports.report.report_spec import (MetaAttribute, MetaPlotGroup, MetaPlot,
MetaColumn, MetaTable, MetaReport)
log = logging.getLogger(__name__)
__version__ = '0.1'
# Import Mapping MetaReport
_DIR_NAME = os.path.dirname(os.path.realpath(__file__))
SPEC_DIR = os.path.join(_DIR_NAME, 'specs/')
COVERAGE_SPEC = op.join(SPEC_DIR, 'coverage.json')
meta_rpt = MetaReport.from_json(COVERAGE_SPEC)
class Constants(object):
TOOL_ID = "pbreports.tasks.coverage_report"
DRIVER_EXE = "python -m pbreports.report.coverage --resolved-tool-contract "
MAX_CONTIGS_ID = "pbreports.task_options.max_contigs"
MAX_CONTIGS_DEFAULT = 25
COLOR_STEEL_BLUE_DARK = '#226F96'
COLOR_STEEL_BLUE_LIGHT = '#2B8CBE'
A_COVERAGE = "depth_coverage_mean"
A_MISSING = "missing_bases_pct"
PG_COVERAGE = "coverage_plots"
