Python Pipeline.getParameters Exemples

Exemple #1

Fichier : pipeline_xtev.py Projet : logust79/cgat-apps

import CGAT.Masker as Masker
import fileinput
import CGAT.Experiment as E
import logging as L
from ruffus import *

USECLUSTER = True

###################################################
###################################################
###################################################
## Pipeline configuration
###################################################
import CGAT.Pipeline as P
P.getParameters([
    "pipeline.ini",
])
PARAMS = P.PARAMS
#PARAMS_ANNOTATIONS = P.peekParameters( PARAMS["geneset_dir"],"pipeline_annotations.py" )


###################################################
## Parse BED12 file
@follows(mkdir("exons"))
@transform("*.bed.gz", regex(r"(\S+)_xenTro2.bed.gz"),
           r"exons/\1.xenTro2.exon.bed")
def bed12ToBed6(infile, outfile):
    '''Convert bed12 inpout file to bed6'''
    track = P.snip(os.path.basename(infile), ".bed.gz")
    statement = '''zcat %(infile)s | bed12ToBed6 -i stdin > %(outfile)s'''
    P.run()

Exemple #2

Fichier : pipeline_hvc.py Projet : BioinformaticsArchive/cgat

import subprocess
import re
import csv
import os
import optparse
import shutil
import collections
import sqlite3
import numpy

import CGAT.Experiment as E
import CGAT.Pipeline as P
import CGAT.IOTools as IOTools

## global options
PARAMS = P.getParameters()

import CGAT.GTF as GTF

TRACKS = ("Down","NonDiff","Up","UpAndDown")

@files( ((PARAMS["filename_segments"], "segments.import"), ))
def importSegments( infile, outfile ):
    tablename = outfile[:-len(".import")]

    statement = '''
    python %(scriptsdir)s/gtf2tsv.py < %(infile)s |\
   python %(scriptsdir)s/csv2db.py %(csv2db_options)s \
              --index=gene_id \
              --table=%(tablename)s \
    > %(outfile)s

Exemple #3

Fichier : pipeline_chains.py Projet : santayana/cgat

import CGAT.IOTools as IOTools
import CGAT.IndexedFasta as IndexedFasta
from ruffus import *

###################################################
###################################################
###################################################
# Pipeline configuration
###################################################

# load options from the config file
import CGAT.Pipeline as P
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")
    execfile("pipeline_conf.py")

PARAMS = P.getParameters()

Exemple #4

Fichier : pipeline_rnaseqlncrna.py Projet : Charlie-George/cgat

import CGAT.CSV as CSV
import CGATPipelines.PipelineMappingQC as PipelineMappingQC
import CGAT.GTF as GTF
import CGAT.IOTools as IOTools
import CGATPipelines.PipelineRnaseq as PipelineRnaseq
import CGAT.Expression as Expression
import CGAT.IndexedGenome as IndexedGenome
import CGATPipelines.PipelineLncRNA as PipelineLncRNA

# get parameters
#    ["%s.ini" % __file__[:-len(".py")], "pipeline.ini"],
P.getParameters(
    ["%s/pipeline.ini" % os.path.splitext(__file__)[0],
     "pipeline.ini"],
    defaults={"annotations_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_ANNOTATIONS = P.peekParameters(
    PARAMS["annotations_annotations_dir"],
    "pipeline_annotations.py",
    on_error_raise=__name__ == "__main__")
PREVIOUS = P.asList(PARAMS["genesets_previous"])

#########################################################################
#########################################################################
#########################################################################

Exemple #5

Fichier : pipeline_metagenomebenchmark.py Projet : yangjl/cgat

import CGAT.Nucmer as Nucmer
import pysam
import CGAT.Fastq as Fastq
import sqlite3
import CGATPipelines.PipelineMetagenomeBenchmark as PipelineMetagenomeBenchmark
import CGATPipelines.PipelineMetagenomeAssembly as PipelineMetagenomeAssembly

###################################################
###################################################
###################################################
## Pipeline configuration
###################################################

# load options from the config file
import CGAT.Pipeline as P
P.getParameters( 
    "pipeline.ini" )

PARAMS = P.PARAMS

SEQUENCE_FILES = glob.glob("*.fastq.1.gz*") + glob.glob("*.fastq.gz")
GENOMES = glob.glob(os.path.join(PARAMS["genomes_genomesdir"], "*.fna"))
CONTIGS = glob.glob("*.fa")
ALIGNMENTS = glob.glob("*.bam")

######################################################
######################################################
######################################################
def dbList(xset):
    '''
    return a list for checking inclusion from a db query
    '''

Exemple #6

Fichier : pipeline_ancestral_repeats.py Projet : nishantthakur/cgat

import CGAT.IndexedGenome as IndexedGenome
import CGAT.FastaIterator as FastaIterator
import CGAT.Genomics as Genomics
import CGAT.GTF as GTF
import CGAT.Blat as Blat
import CGAT.IOTools as IOTools

###################################################
###################################################
###################################################
## Pipeline configuration
###################################################
import CGAT.Pipeline as P

P.getParameters(
    ["%s/pipeline.ini" % os.path.splitext(__file__)[0], "../pipeline.ini", "pipeline.ini"],
    defaults={"query": "", "target": ""},
)
PARAMS = P.PARAMS
USECLUSTER = True

#########################################################################
#########################################################################
#########################################################################
if os.path.exists("pipeline_conf.py"):
    L.info("reading additional configuration from pipeline_conf.py")
    execfile("pipeline_conf.py")


def getGenomes():
    """return genome names of query and target."""

Exemple #7

Fichier : pipeline_motifs.py Projet : BioinformaticsArchive/cgat

import PipelineChipseq as PipelineChipseq
import PipelineMotifs as PipelineMotifs
import PipelineGeneset as PGeneset
import CGATPipelines.PipelineTracks as PipelineTracks
import CGATPipelines.PipelineMapping as PipelineMapping

###################################################
###################################################
###################################################
## Pipeline configuration
###################################################
import CGAT.Pipeline as P
P.getParameters( 
    ["%s/pipeline.ini" % os.path.splitext(__file__)[0],
     "../pipeline.ini",
     "pipeline.ini" ],
    defaults = {
        'annotations_dir' : "" })

PARAMS = P.PARAMS

PARAMS_ANNOTATIONS = P.peekParameters( PARAMS["annotations_dir"],
                                       "pipeline_annotations.py" )

###################################################################
###################################################################
###################################################################
## Helper functions mapping tracks to conditions, etc
###################################################################
# load all tracks - exclude input/control tracks
Sample = PipelineTracks.Sample

Exemple #8

Fichier : pipeline_rnaseqlncrna.py Projet : lesheng/cgat

import CGAT.Database as Database
import CGAT.CSV as CSV
import CGATPipelines.PipelineMappingQC as PipelineMappingQC
import CGAT.GTF as GTF
import CGAT.IOTools as IOTools
import CGATPipelines.PipelineRnaseq as PipelineRnaseq
import CGAT.Expression as Expression
import CGAT.IndexedGenome as IndexedGenome
import CGATPipelines.PipelineLncRNA as PipelineLncRNA

# get parameters
P.getParameters(
    ["%s.ini" % __file__[:-len(".py")], "pipeline.ini"],
    defaults={
        "annotations_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_ANNOTATIONS = P.peekParameters(PARAMS["annotations_annotations_dir"],
                                      "pipeline_annotations.py")
PREVIOUS = P.asList(PARAMS["genesets_previous"])

#########################################################################
#########################################################################
#########################################################################

Exemple #9

import CGATPipelines.PipelineMappingQC as PipelineMappingQC
import CGAT.Stats as Stats

###################################################
###################################################
###################################################
## Pipeline configuration
###################################################

# load options from the config file
import CGAT.Pipeline as P

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:

Exemple #10

import gff2annotator
import CGAT.Experiment as E
import logging as L
import PipelineChipseq as PIntervals
import CGATPipelines.PipelineTracks as PipelineTracks
import CGATPipelines.PipelineMapping as PipelineMapping
from ruffus import *
from rpy2.robjects import r as R
import rpy2.robjects as ro

###################################################################
###################################################################
###################################################################
## Pipeline configuration
import CGAT.Pipeline as P
P.getParameters("pipeline_capseq.ini")
PARAMS = P.PARAMS
USECLUSTER = True

###################################################################
###################################################################
###################################################################
## Helper functions mapping tracks to conditions, etc
###################################################################
# load all tracks - exclude input/control tracks
Sample = PipelineTracks.Sample3

TRACKS = PipelineTracks.Tracks( Sample ).loadFromDirectory(
    [ x for x in glob.glob( "*.export.txt.gz" ) if PARAMS["tracks_control"] not in x ],
      "(\S+).export.txt.gz" ) +\
      PipelineTracks.Tracks( PipelineTracks.Sample3 ).loadFromDirectory(

Exemple #11

Fichier : pipeline_chains.py Projet : Charlie-George/cgat

import CGAT.IOTools as IOTools
import CGAT.IndexedFasta as IndexedFasta
from ruffus import *

###################################################
###################################################
###################################################
# Pipeline configuration
###################################################

# load options from the config file
import CGAT.Pipeline as P
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")
    execfile("pipeline_conf.py")

PARAMS = P.getParameters()

Exemple #12

Fichier : pipeline_proj012_chipseq.py Projet : BioinformaticsArchive/cgat

import gff2annotator
import CGAT.Experiment as E
import logging as L
import PipelineChipseq as PIntervals
import CGATPipelines.PipelineTracks as PipelineTracks
import CGATPipelines.PipelineMapping as PipelineMapping
from ruffus import *
from rpy2.robjects import r as R
import rpy2.robjects as ro

###################################################################
###################################################################
###################################################################
## Pipeline configuration
import CGAT.Pipeline as P
P.getParameters( "pipeline_capseq.ini" )
PARAMS = P.PARAMS
USECLUSTER = True

###################################################################
###################################################################
###################################################################
## Helper functions mapping tracks to conditions, etc
###################################################################
# load all tracks - exclude input/control tracks
Sample = PipelineTracks.Sample3

TRACKS = PipelineTracks.Tracks( Sample ).loadFromDirectory( 
    [ x for x in glob.glob( "*.export.txt.gz" ) if PARAMS["tracks_control"] not in x ],
      "(\S+).export.txt.gz" ) +\
      PipelineTracks.Tracks( PipelineTracks.Sample3 ).loadFromDirectory( 

Exemple #13

import CGAT.FastaIterator as FastaIterator
import CGAT.Genomics as Genomics
import CGAT.GTF as GTF
import CGAT.Blat as Blat
import CGAT.IOTools as IOTools

###################################################
###################################################
###################################################
# Pipeline configuration
###################################################
import CGAT.Pipeline as P
P.getParameters([
    "%s/pipeline.ini" % os.path.splitext(__file__)[0], "../pipeline.ini",
    "pipeline.ini"
],
                defaults={
                    'query': "",
                    'target': ""
                })
PARAMS = P.PARAMS
USECLUSTER = True

#########################################################################
#########################################################################
#########################################################################
if os.path.exists("pipeline_conf.py"):
    L.info("reading additional configuration from pipeline_conf.py")
    execfile("pipeline_conf.py")


def getGenomes():

Exemple #14

Fichier : pipeline_proj020.py Projet : yangjl/cgat

import gzip
import sqlite3
import cStringIO
import fileinput
import CGAT.Fastq as fq
import logging as L
import CGAT.Experiment as E
import CGATPipelines.PipelineMapping as PipelineMapping
from ruffus import *

###################################################################
###################################################################
###################################################################
## Pipeline configuration
import CGAT.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)
    P.run()

Exemple #15

Fichier : pipeline_ancestral_repeats.py Projet : siping/cgat

import CGAT.FastaIterator as FastaIterator
import CGAT.Genomics as Genomics
import CGAT.GTF as GTF
import CGAT.Blat as Blat
import CGAT.IOTools as IOTools

###################################################
###################################################
###################################################
## Pipeline configuration
###################################################
import CGAT.Pipeline as P
P.getParameters( 
    ["%s/pipeline.ini" % os.path.splitext(__file__)[0],
     "../pipeline.ini",
     "pipeline.ini" ],
    defaults = { 
        'query' : "",
        'target' : "" } )
PARAMS = P.PARAMS
USECLUSTER=True

#########################################################################
#########################################################################
#########################################################################
if os.path.exists("pipeline_conf.py"): 
    L.info( "reading additional configuration from pipeline_conf.py" )
    execfile("pipeline_conf.py")

def getGenomes():
    '''return genome names of query and target.'''

Exemple #16

Fichier : pipeline_polyphen.py Projet : lesheng/cgat

import CGAT.Pipeline as P
import CGAT.IOTools as IOTools
import CGAT.Genomics as Genomics
import CGAT.Database as Database
import CGAT.FastaIterator as FastaIterator
import PipelineGeneset as PGeneset
import CGAT.Stats as Stats
import pysam

###################################################################
###################################################################
###################################################################
# 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

if os.path.exists("conf.py"):

Exemple #17

Fichier : conf.py Projet : yangjl/cgat

if not os.path.exists(docsdir):
    raise ValueError( "documentation directory '%s' not found" % docsdir )

################################################################
# Import pipeline configuration from pipeline.ini in the current 
# directory and the common one.
import CGAT.Pipeline as P
import CGATPipelines

# 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
## link from here to a directory outside the build tree, though.
exportdir = os.path.abspath(PARAMS['exportdir'])

Exemple #18

import CGAT.Genomics as Genomics
import CGAT.IOTools as IOTools
import CGAT.Database as Database
import CGAT.GFF as GFF
import CGAT.GTF as GTF
import CGAT.Database as Database

import PipelineGeneset as PGeneset
import PipelineAnnotator as PAnnotator

if os.path.exists("conf.py"):
    execfile("conf.py")
else:
    EXPERIMENTAL_TRACKS = []

PARAMS = P.getParameters(
    defaults = { 'ancestral_repeats_filename': None } )

PARAMS.update( {
    "annotation" : "regions.gff",
    "genes": "genes.gtf.gz",
    "merged": "merged.gtf.gz",
    "transcripts": "transcripts.gtf.gz" } )

def getSourceTrack( track, all_tracks ):
    '''if track is in derived tracks, get the source track.

    returns None if track is not a derived track
    '''
    if len(all_tracks) == 0: return None

    # get rid of any extensions

Exemple #19

Fichier : pipeline_rnaseqlncrna.py Projet : nishantthakur/cgat

import collections
import random
from rpy2.robjects import r as R
import CGAT.Expression as Expression
import CGAT.IndexedGenome as IndexedGenome
import CGATPipelines.PipelineLncRNA as PipelineLncRNA

import CGAT.Pipeline as P

# get parameters
P.getParameters(
    ["%s.ini" % __file__[: -len(".py")], "pipeline.ini"],
    defaults={
        "annotations_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_ANNOTATIONS = P.peekParameters(PARAMS["annotations_annotations_dir"], "pipeline_annotations.py")
PREVIOUS = P.asList(PARAMS["genesets_previous"])

#########################################################################
#########################################################################
#########################################################################
def connect():
    """connect to database.

Exemple #20

if not os.path.exists(docsdir):
    raise ValueError("documentation directory '%s' not found" % docsdir)

################################################################
# Import pipeline configuration from pipeline.ini in the current
# directory and the common one.
import CGAT.Pipeline as P
import CGATPipelines

# 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

Exemple #21

Fichier : pipeline_polyphen.py Projet : jmadzo/cgat

import CGAT.Pipeline as P
import CGAT.IOTools as IOTools
import CGAT.Genomics as Genomics
import CGAT.Database as Database
import CGAT.FastaIterator as FastaIterator
import PipelineGeneset as PGeneset
import CGAT.Stats as Stats
import pysam

###################################################################
###################################################################
###################################################################
# 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

if os.path.exists("conf.py"):
    execfile("conf.py")

Exemple #22

import CGAT.BamTools as BamTools
import CGAT.IOTools as IOTools
from rpy2.robjects import r as R
import rpy2.robjects as ro
import rpy2.rinterface as ri
import rpy2.robjects.numpy2ri
rpy2.robjects.numpy2ri.activate()

import CGAT.Pipeline as P

###################################################
###################################################
###################################################
# Pipeline configuration
###################################################
P.getParameters(
    ["%s.ini" % __file__[:-len(".py")], "../pipeline.ini", "pipeline.ini"])

PARAMS = P.PARAMS

if os.path.exists("pipeline_conf.py"):
    E.info("reading additional configuration from pipeline_conf.py")
    execfile("pipeline_conf.py")

#############################################################
#############################################################
#############################################################
# UTR estimation
#############################################################
Utr = collections.namedtuple("Utr", "old new max status")

Exemple #23

Fichier : pipeline_rnaseq_geneset.py Projet : jmadzo/cgat

import CGAT.Masker as Masker
import fileinput
import CGAT.Experiment as E
import logging as L
from ruffus import *

USECLUSTER = True

###################################################
###################################################
###################################################
## Pipeline configuration
###################################################
import CGAT.Pipeline as P

P.getParameters(["pipeline.ini"])
PARAMS = P.PARAMS
# PARAMS_ANNOTATIONS = P.peekParameters( PARAMS["geneset_dir"],"pipeline_annotations.py" )

###################################################
## Parse GTF file
@follows(mkdir("exons"))
@transform("*.gtf", regex(r"(\S+).gtf"), r"exons/\1.exons.tab")
def getGTFexons(infile, outfile):
    """Copy replicated Bed files generated by capseq pipline to geneset-specific output directory"""
    track = P.snip(os.path.basename(infile), ".gtf")
    species, tissue = track.split("-")
    statement = """cat %(infile)s | grep "exon" | python %(scriptsdir)s/gtf2tsv.py -f --log=%(outfile)s.log | awk '{if (NR==1) {print $0"\\tTissue"} else {$0"\\t%(tissue)s"}}' > %(outfile)s"""
    P.run()

Exemple #24

Fichier : pipeline_rnaseqdiffexpression.py Projet : lesheng/cgat

# levels of cuffdiff analysis
# (no promotor and splice -> no lfold column)
CUFFDIFF_LEVELS = ("gene", "cds", "isoform", "tss")

###################################################
###################################################
###################################################
# Pipeline configuration
###################################################

# load options from the config file
import CGAT.Pipeline as P

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
###################################################################
import CGATPipelines.PipelineTracks as PipelineTracks

Sample = PipelineTracks.AutoSample

# collect sra nd fastq.gz tracks

Exemple #25

Fichier : pipeline_rnaseqdiffexpression.py Projet : jmadzo/cgat

import CGATPipelines.PipelineRnaseq as PipelineRnaseq

# levels of cuffdiff analysis
# (no promotor and splice -> no lfold column)
CUFFDIFF_LEVELS = ("gene", "cds", "isoform", "tss")

###################################################
###################################################
###################################################
# Pipeline configuration
###################################################

# load options from the config file
import CGAT.Pipeline as P
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", on_error_raise=__name__ == "__main__")

###################################################################
###################################################################
# Helper functions mapping tracks to conditions, etc
###################################################################
import CGATPipelines.PipelineTracks as PipelineTracks

Sample = PipelineTracks.AutoSample

# collect sra nd fastq.gz tracks

Exemple #26

Fichier : pipeline_expression.py Projet : yangjl/cgat

if os.path.exists("conf.py"):
    execfile("conf.py")

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")] ) 
          for x in glob.glob("*_series_matrix.txt.gz") ] )
def importFromSeries( infiles, outfile ):
    '''import expression levels from a GEO series.'''
    tablename = P.toTable( outfile )
    

Exemple #27

Fichier : pipeline_template.py Projet : BioinformaticsArchive/cgat

import sqlite3

import CGAT.Experiment as E
import CGAT.IOTools as IOTools
import CGAT.Database as Database

###################################################
###################################################
###################################################
## Pipeline configuration
###################################################

# load options from the config file
import CGAT.Pipeline as P
P.getParameters( 
    ["%s.ini" % __file__[:-len(".py")],
     "../pipeline.ini",
     "pipeline.ini" ] )

PARAMS = P.PARAMS
PARAMS_ANNOTATIONS = P.peekParameters( PARAMS["annotations_dir"],
                                       "pipeline_annotations.py" )

###################################################################
###################################################################
## Helper functions mapping tracks to conditions, etc
###################################################################
import CGATPipelines.PipelineTracks as PipelineTracks

# define some tracks if needed
TRACKS = PipelineTracks.Tracks( PipelineTracks.Sample ).loadFromDirectory( 
    glob.glob("*.ini" ), "(\S+).ini" )

Exemple #28

Fichier : pipeline_rnaseqlncrna.py Projet : santayana/cgat

import CGAT.CSV as CSV
import CGATPipelines.PipelineMappingQC as PipelineMappingQC
import CGAT.GTF as GTF
import CGAT.IOTools as IOTools
import CGATPipelines.PipelineRnaseq as PipelineRnaseq
import CGAT.Expression as Expression
import CGAT.IndexedGenome as IndexedGenome
import CGATPipelines.PipelineLncRNA as PipelineLncRNA

# get parameters
#    ["%s.ini" % __file__[:-len(".py")], "pipeline.ini"],
P.getParameters(
    ["%s/pipeline.ini" % os.path.splitext(__file__)[0], "pipeline.ini"],
    defaults={
        "annotations_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_ANNOTATIONS = P.peekParameters(PARAMS["annotations_annotations_dir"],
                                      "pipeline_annotations.py",
                                      on_error_raise=__name__ == "__main__")
PREVIOUS = P.asList(PARAMS["genesets_previous"])

#########################################################################
#########################################################################
#########################################################################