"""
# load modules
from ruffus import *
import CGATCore.Experiment as E
import sys
import os
import glob
import sqlite3
from CGATCore import Pipeline as P
import CGATPipelines.PipelineTracks as PipelineTracks
# load options from the config file
P.getParameters([
"%s/pipeline.ini" % __file__[:-len(".py")], "../pipeline.ini",
"pipeline.ini"
])
PARAMS = P.PARAMS
PARAMS_ANNOTATIONS = P.peekParameters(PARAMS["annotations_dir"],
"pipeline_annotations.py")
Sample = PipelineTracks.Sample
TRACKS = PipelineTracks.Tracks(Sample).loadFromDirectory(
glob.glob("medip_*"), "medip_(\S+)")
def connect():
'''connect to database.
import os
import glob
import sqlite3
import CGATCore.IOTools as IOTools
from CGATCore import Pipeline as P
import CGATPipelines.PipelineTracks as PipelineTracks
###################################################
###################################################
###################################################
# Pipeline configuration
###################################################
# load options from the config file
P.getParameters(
["%s/pipeline.ini" % os.path.splitext(__file__)[0],
"../pipeline.ini",
"pipeline.ini"])
PARAMS = P.PARAMS
PARAMS_ANNOTATIONS = P.peekParameters(PARAMS["annotations_dir"],
"pipeline_annotations.py")
###################################################################
###################################################################
# Helper functions mapping tracks to conditions, etc
###################################################################
TRACKS = PipelineTracks.Tracks(PipelineTracks.Sample).loadFromDirectory(
glob.glob("*.fastq.gz"), "(\S+).fastq.gz")
USECLUSTER = True
import CGATCore.Experiment as E
from CGATCore import Pipeline as P
import CGATCore.IOTools as IOTools
import CGAT.IndexedFasta as IndexedFasta
###################################################
###################################################
###################################################
# Pipeline configuration
###################################################
# load options from the config file
P.getParameters([
"%s/pipeline.ini" % os.path.splitext(__file__)[0], "../pipeline.ini",
"pipeline.ini"
],
defaults={"maps": ""})
PARAMS = P.PARAMS
###################################################################
###################################################################
###################################################################
##
###################################################################
if os.path.exists("pipeline_conf.py"):
L.info("reading additional configuration from pipeline_conf.py")
exec(compile(open("pipeline_conf.py").read(), "pipeline_conf.py", 'exec'))
PARAMS = P.getParameters()
print(INI_file)
elif (f_count > 1 or f_count == 0):
print('You have no project configuration (".yml") file or more than one',
'in the directory:', '\n', path)
sys.exit(''' Exiting.
You will have to manually edit the Sphinx conf.py file.
''')
return(INI_file)
modulename = 'P'
if modulename in sys.modules:
ini_file = 'pipelin{}.yml'.format(r'(.*)')
P.getParameters(
["{}/{}".format(os.path.splitext(__file__)[0], ini_file),
"../{}".format(ini_file),
"{}".format(ini_file),
],
)
PARAMS = P.PARAMS
else:
# Get location to this file:
here = os.path.abspath(os.path.dirname(__file__))
ini_file = getINIdir(os.path.abspath(here))
# Print keys (sections):
if not os.path.exists(ini_file):
sys.exit('''Something isn't right with the paths. The yml/ini file does
not seem to exist...''')
else:
import CGATCore.Experiment as E
from CGATCore import Pipeline as P
import CGAT.GTF as GTF
import CGATCore.IOTools as IOTools
import CGATPipelines.PipelineLncRNA as PipelineLncRNA
###################################################
# Pipeline configuration
###################################################
P.getParameters(
[
"%s/pipeline.ini" % os.path.splitext(__file__)[0], "../pipeline.ini",
"pipeline.ini"
],
defaults={
"annotations_dir": "",
"genesets_abinitio_coding": "pruned.gtf.gz",
"genesets_abinitio_lncrna": "pruned.gtf.gz",
"genesets_reference": "reference.gtf.gz",
"genesets_refcoding": "refcoding.gtf.gz",
"genesets_previous": ""
})
PARAMS = P.PARAMS
PARAMS.update(
P.peekParameters(PARAMS["annotations_annotations_dir"],
"pipeline_annotations.py",
prefix="annotations_",
update_interface=True))
import CGAT.GTF as GTF
import CGATCore.IOTools as IOTools
###################################################
###################################################
###################################################
# Pipeline configuration
###################################################
# load options from the config file
from CGATCore import Pipeline as P
from functools import reduce
P.getParameters(
["%s/pipeline.ini" % os.path.splitext(__file__)[0],
"../pipeline.ini",
"pipeline.ini"],
defaults={
'annotations_dir': "",
'paired_end': False})
PARAMS = P.PARAMS
PARAMS_ANNOTATIONS = P.peekParameters(
PARAMS["annotations_dir"],
"pipeline_annotations.py")
# get options that are to be tested
cufflinks_options = {}
if "cufflinks_test_options" in PARAMS:
options = P.asList(PARAMS["cufflinks_test_options"])
for option in options:
if os.path.exists("conf.py"):
exec(compile(open("conf.py").read(), "conf.py", 'exec'))
TARGET_ANNOTATION = 'ensembl_regions.gff'
TARGET_GENESET = 'ensembl.gtf'
TARGET_PROMOTORS = 'promotors.gtf'
TARGET_TSS = 'tss.gtf'
TARGET_REPEATS = 'repeats.gff'
TARGET_TRANSCRIPTS = 'transcripts.gtf.gz'
TARGET_PROBESET = 'probeset.gtf'
TARGET_TRANSCRIPTS_TSS = 'transcripts_tss.gtf'
TARGET_TRANSCRIPTS_PROMOTORS = 'transcripts_promotors.gtf'
TARGET_ANNOTATOR_GENETERRITORIES = 'annotator_geneterritories.gff'
TARGET_MAPPABILITY = 'mappability.bed'
PARAMS = P.getParameters()
@files(((None, "probeset2gene.table"), ))
def buildProbeset2Gene(infile, outfile):
'''build map relating a probeset to an ENSEMBL gene_id'''
Expression.buildProbeset2Gene(infile, outfile)
@follows(buildProbeset2Gene)
def prepare():
pass
@files([((x, "%s.map" % x),
"%s_levels.import" % x[:-len("_series_matrix.txt.gz")])
import CGATCore.Experiment as E
import logging as L
import CGATPipelines.PipelineUCSC as PipelineUCSC
from ruffus import *
###################################################
###################################################
###################################################
# Pipeline configuration
###################################################
from CGATCore import Pipeline as P
P.getParameters([
"%s/pipeline.ini" % os.path.splitext(__file__)[0], "../pipeline.ini",
"pipeline.ini"
],
defaults={
'query': "",
'target': ""
})
PARAMS = P.PARAMS
if os.path.exists("pipeline_conf.py"):
L.info("reading additional configuration from pipeline_conf.py")
exec(compile(open("pipeline_conf.py").read(), "pipeline_conf.py", 'exec'))
def getGenomes():
'''return genome names of query and target.'''
genome_query = os.path.join(PARAMS["genome_dir"], PARAMS["query"])
genome_target = os.path.join(PARAMS["genome_dir"], PARAMS["target"])
import sys
import glob
import os
import itertools
import sqlite3
import CGATCore.Experiment as E
from CGATCore import Pipeline as P
import PipelineGeneset as PGeneset
###################################################################
###################################################################
###################################################################
# read global options from configuration file
P.getParameters([
"%s/pipeline.ini" % os.path.splitext(__file__)[0], "../pipeline.ini",
"pipeline.ini"
],
defaults={'polyphen_modes': ""})
P.PARAMS.update({
"transcripts": "transcripts.gtf.gz",
"genes": 'genes.gtf.gz',
"annotation": 'geneset_regions.gff.gz',
"peptides": 'peptides.fasta',
"cdna": 'cdna.fasta',
"cds": 'cds.fasta'
})
PARAMS = P.PARAMS
PGeneset.PARAMS = PARAMS
import sqlite3
import io
import fileinput
import CGAT.Fastq as fq
import logging as L
import CGATCore.Experiment as E
import CGATPipelines.PipelineMapping as PipelineMapping
from ruffus import *
###################################################################
###################################################################
###################################################################
# Pipeline configuration
from CGATCore import Pipeline as P
P.getParameters(["pipeline.ini"])
PARAMS = P.PARAMS
USECLUSTER = True
###################################################################
###################################################################
###################################################################
# Count raw reads
@transform("*.fastq.1.gz", regex(r"(\S+).fastq.1.gz"), r"\1.nreads")
def countReads(infile, outfile):
'''count number of reads in input files.'''
to_cluster = True
m = PipelineMapping.Counter()
statement = m.build((infile,), outfile)
'pipeline_docs', 'themes')
logopath = os.path.join(themedir, "cgat_logo.png")
################################################################
# Import pipeline configuration from pipeline.ini in the current
# directory and the common one.
# PATH were code for pipelines is stored
pipelinesdir = os.path.dirname(CGATPipelines.__file__)
# The default configuration file - 'inifile' is read by
# sphinx-report.
inifile = os.path.join(os.path.dirname(CGATPipelines.__file__),
'configuration', 'pipeline.ini')
PARAMS = P.getParameters([inifile, "pipeline.ini"])
def setup(app):
app.add_config_value('PARAMS', {}, True)
################################################################
################################################################
################################################################
# The pipeline assumes that sphinxreport is called within the
# working directory. If the report is in a separate build directory,
# change the paths below.
#
# directory with export directory from pipeline
# This should be a directory in the build directory - you can
Code
====
"""
from ruffus import *
import sys
import os
import sqlite3
from CGATCore import Experiment as E
from CGATCore import Pipeline as P
import re
# load options from the config file
PARAMS = P.getParameters([
"%s/pipeline.yml" % os.path.splitext(__file__)[0], "../pipeline.yml",
"pipeline.yml"
])
PARAMS["projectsrc"] = os.path.dirname(__file__)
#for key, value in PARAMS.iteritems():
# print "%s:\t%s" % (key,value)
# add configuration values from associated pipelines
#
# 1. pipeline_annotations: any parameters will be added with the
# prefix "annotations_". The interface will be updated with
# "annotations_dir" to point to the absolute path names.
PARAMS.update(
P.peekParameters(PARAMS["annotations_dir"],
"pipeline_annotations.py",
on_error_raise=__name__ == "__main__",
