
!samtools index

Usage: samtools index [-bc] [-m INT] <in.bam> [out.index]
Options:
  -b       Generate BAI-format index for BAM files [default]
  -c       Generate CSI-format index for BAM files
  -m INT   Set minimum interval size for CSI indices to 2^INT [14]
  -@ INT   Sets the number of threads [none]


!medaka --help

/bin/bash: medaka: command not found


!run medaka --help

usage: medaka [-h] [--version]
              {compress_bam,features,train,consensus,smolecule,consensus_from_features,fastrle,stitch,variant,snp,tools}
              ...

optional arguments:
  -h, --help            show this help message and exit
  --version             show program's version number and exit

subcommands:
  valid commands

  {compress_bam,features,train,consensus,smolecule,consensus_from_features,fastrle,stitch,variant,snp,tools}
                        additional help
    compress_bam        Compress an alignment into RLE form.
    features            Create features for inference.
    train               Train a model from features.
    consensus           Run inference from a trained model and alignments.
    smolecule           Create consensus sequences from single-molecule reads.
    consensus_from_features
                        Run inference from a trained model on existing
                        features.
    fastrle             Create run-length encoded fastq (lengths in quality
                        track).
    stitch              Stitch together output from medaka consensus into
                        final output.
    variant             Decode probabilities to VCF.
    snp                 Decode probabilities to SNPs.
    tools               tools subcommand.


from bokeh.io import output_notebook
from bokeh.plotting import figure, show
import numpy as np
import pandas as pd

output_notebook()
df = pd.DataFrame(
    np.random.randint(0,100, size=(100, 2)),
    columns=['x', 'y'])
df['color'] = np.random.choice(['red', 'blue'], size=100)
p = figure(height=200, width=400)
p.scatter('x', 'y', color='color', source=df)
show(p)


!mamba install -q -y rebaler


import snakemake

---------------------------------------------------------------------------
ModuleNotFoundError                       Traceback (most recent call last)
<ipython-input-19-1e2531e13514> in <module>
----> 1 import snakemake

ModuleNotFoundError: No module named 'snakemake'


!mamba install -q -y snakemake-minimal


import snakemake
print(snakemake.__version__)

5.31.1


!mamba create -y -n my_environment porechop


!run porechop

usage: porechop -i INPUT [-o OUTPUT]
                [--format {auto,fasta,fastq,fasta.gz,fastq.gz}] [-v VERBOSITY]
                [-t THREADS] [-b BARCODE_DIR]
                [--barcode_threshold BARCODE_THRESHOLD]
                [--barcode_diff BARCODE_DIFF] [--require_two_barcodes]
                [--untrimmed] [--discard_unassigned]
                [--adapter_threshold ADAPTER_THRESHOLD]
                [--check_reads CHECK_READS] [--scoring_scheme SCORING_SCHEME]
                [--end_size END_SIZE] [--min_trim_size MIN_TRIM_SIZE]
                [--extra_end_trim EXTRA_END_TRIM]
                [--end_threshold END_THRESHOLD] [--no_split]
                [--discard_middle] [--middle_threshold MIDDLE_THRESHOLD]
                [--extra_middle_trim_good_side EXTRA_MIDDLE_TRIM_GOOD_SIDE]
                [--extra_middle_trim_bad_side EXTRA_MIDDLE_TRIM_BAD_SIDE]
                [--min_split_read_size MIN_SPLIT_READ_SIZE] [-h] [--version]
porechop: error: the following arguments are required: -i/--input


!. /opt/conda/etc/profile.d/conda.sh \
    && conda activate my_environment \
    && pip install cowsay

Collecting cowsay
  Downloading cowsay-3.0-py2.py3-none-any.whl (19 kB)
Installing collected packages: cowsay
Successfully installed cowsay-3.0


!cowsay

/bin/bash: cowsay: command not found


!run cowsay Moo!

  ____
< Moo! >
  ====
         \
          \
            ^__^                             
            (oo)\_______                   
            (__)\       )\/\             
                ||----w |           
                ||     ||


print ("This code is hidden from the user")


# this cell contains code that prints a message
print("Hello world")


import ipywidgets as widgets
w = widgets.IntSlider()
display(w)

IntSlider(value=0)


print("The current value is: ", w.value)

The current value is:  46


import os
from epi2melabs.notebook import InputForm, InputSpec

form = InputForm(
    InputSpec(
        "item_a", "Item A", 10),
    InputSpec(
        "item_b", "Item B", (0,10), long_desc="I am the description for Item B"),
    InputSpec(
        "item_c", "Item C", 10, validator=lambda x: x<11),
    InputSpec(
        "item_d", "Item D", "Value of D", validator=lambda x: os.path.isfile(x),
        err_msg="'{value}' is not a valid file for '{param}'.")
)
form.display()

VBox(children=(HBox(children=(Label(value='Item A', layout=Layout(width='150px')), interactive(children=(IntSl…


form.item_a, form.item_d

(10, 'Value of D')


print(form.report())

Item A: 10
Item B: 5
Item C: 10
Item D: Value of D
 - 'Value of D' is not a valid file for 'Item D'.
One or more values failed validation.


form.validate()

(False, ["'Value of D' is not a valid file for 'Item D'."])


cpuinfo = None
def process_form(inputs):
    global cpuinfo
    with open(inputs.input_file, 'r') as fh:
        cpuinfo = list()
        cur = dict()
        for line in fh.readlines():
            if line == "\n":
                cpuinfo.append(cur)
                cur = dict()
            else:
                key, value = line.split(":")
                key = key.strip()
                value = value.lstrip().strip()
                cur[key] = value
        cpuinfo.append(cur)
    print("Finished processing file")
    
inputs = InputForm(
    InputSpec('input_file', 'A file', '/proc/cpuinfo'),)
inputs.add_process_button(process_form)
inputs.display()

VBox(children=(HBox(children=(Label(value='A file', layout=Layout(width='150px')), interactive(children=(Text(…


print("Number of CPUs:", len(cpuinfo))

Number of CPUs: 5


import numpy as np

x = np.random.normal(size=1000)
y = np.random.normal(size=1000)


import aplanat
from aplanat import points

plot_1 = points.points([x], [y], x_axis_label='x', y_axis_label='y')
aplanat.show(plot_1, background="#f4f4f4")


plot_2 = points.points(
    [x, y], [y, x],
    names=['y on the y-axis', 'x on the y-axis'],
    colors=['red', 'blue'],
    x_axis_label='item 1', y_axis_label='item 2',
    height=300, width=400)
aplanat.show(plot_2, background="#f4f4f4")


from aplanat import graphics

summary = graphics.InfoGraphItems()
summary.append(label='Total reads', value=1000000, icon='angle-up', unit='')
summary.append('Total yield', 1e9, 'signal', 'b')
summary.append('Mean read length', 50e3, 'align-center', 'b')
summary.append('Mean qscore (pass)', '14', 'thumbs-up')
plot = graphics.infographic(summary.values())
aplanat.show(plot, background='#f4f4f4')


# Code to generate a facet plot
import pandas as pd

from aplanat import show
from aplanat.layouts import facet_grid
from aplanat.points import points

df = pd.DataFrame({
    'ear_size': np.random.normal(size=1000),
    'paw_size': np.random.normal(size=1000),
    'animal': np.random.choice(['cat', 'dog'], size=1000),
    'size': np.random.choice(['big', 'small'], size=1000),
    'nature': np.random.choice(['docile', 'fierce'], size=1000)})

# plot the data facets
p = facet_grid(
    df, {'x':'ear_size', 'y':'paw_size', 'col':'animal'},
    points, facet=('animal', 'nature'), height=200, width=200,
    x_axis_label='ear_size', y_axis_label='paw_size',
    x_facet_heading='animal', y_facet_heading='nature')
# show the plot
show(p, background="#f4f4f4")


from aplanat import report

summary = report.HTMLReport(
    title="My report", lead="An exciting summary of results")
summary.markdown("This is the introduction section of my report.")
section_1 = summary.add_section('section_1')
section_2 = summary.add_section('section_2')


import numpy as np
from aplanat import points, hist

x = np.random.normal(size=1000)
y = np.random.normal(size=1000)

plot_0 = hist.histogram([x, y], colors=['red', 'blue'])
summary.plot(plot_0)

plot_1 = points.points([x], [y])
section_1.plot(plot_1)

plot_2 = points.points([x, y], [y, x], colors=['red', 'blue'])
section_2.plot(plot_2)


import pandas as pd

df = pd.DataFrame({'x':x, 'y':y})
section_1.table(df)


section_2.markdown("""
# Section 2

This is the start of section 2.
""")


summary.write("my_report.html")


summary.placeholder('intro')
summary.markdown('This text was added after the placeholder was inserted.')
summary.markdown('This text was given to the placeholder.', key='intro')


summary.markdown('This text will not be display in the final report', key='replaced')
summary.markdown('This text will be displayed.', key='replaced')


report_requiring_keys = report.HTMLReport(require_keys=True)

EPI2ME Labs Tutorial¶

Introduction¶

Included software¶

Commandline tools outside the base conda environment¶

Included Python packages¶

Installing additional software¶

Installing software into the base environment¶

Installing software into a new environment¶

JupyterLab Extensions¶

Cell play button¶

Code folding and hiding¶

Autorunning code cells¶

Creating user interfaces¶

Standard Jupyter Widgets¶

Form creation API¶

Best practices for form elements¶

Advanced actions¶

Plotting with aplanat¶

Design philosophy¶

Simple examples¶

Infographics¶

Facetted plots¶

Creating standalone reports¶

Structuring report elements¶

Feedback¶

References¶