示例#1
0
def load_environment(global_conf, app_conf):
    """Configure the Pylons environment via the ``pylons.config``
	object
	"""
    # Pylons paths
    root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
    paths = dict(
        root=root,
        controllers=os.path.join(root, "controllers"),
        static_files=os.path.join(root, "public"),
        templates=[os.path.join(root, "templates")],
    )

    # Initialize config with the basic options
    config.init_app(global_conf, app_conf, package="helloworld", template_engine="mako", paths=paths)

    config["routes.map"] = make_map()
    config["pylons.g"] = app_globals.Globals()
    config["pylons.h"] = helloworld.lib.helpers

    # Customize templating options via this variable
    # tmpl_options = config['buffet.template_options']

    # CONFIGURATION OPTIONS HERE (note: all config options will override
    # any Pylons config options)

    # 2008-10-05 Use the strict behaviour of the template context object
    # config['pylons.strict_c'] = True

    # 2008-10-05 Create the Mako TemplateLookup, with the default auto-escaping. it doesn't work though.
    config["pylons.g"].mako_lookup = TemplateLookup(
        directories=paths["templates"],
        module_directory=os.path.join(app_conf["cache_dir"], "templates"),
        input_encoding="utf-8",
        output_encoding="utf-8",
        imports=["from webhelpers.html import escape"],
        default_filters=["escape"],
    )

    # 2008-10-05 setup the database connection
    drivername = config["app_conf"]["drivername"]
    hostname = config["app_conf"]["hostname"]
    dbname = config["app_conf"]["dbname"]
    schema = config["app_conf"]["schema"]
    db_user = config["app_conf"]["db_user"]
    db_passwd = config["app_conf"]["db_passwd"]
    pool_recycle = int(config["app_conf"]["pool_recycle"])
    # model.setup()

    model.db = model.Stock_250kDB.Stock_250kDB(
        drivername=drivername,
        username=db_user,
        password=db_passwd,
        hostname=hostname,
        database=dbname,
        schema=schema,
        pool_recycle=pool_recycle,
    )
    model.db.setup(create_tables=False)

    model.genome_db = model.GenomeDB.GenomeDatabase(
        drivername=drivername,
        username=db_user,
        password=db_passwd,
        hostname=hostname,
        database="genome",
        schema=schema,
        pool_recycle=pool_recycle,
    )

    # from variation.src import dbsnp
    # snp_db = dbsnp.DBSNP(drivername=drivername, username=db_user, password=db_passwd, \
    # 				hostname=hostname, database='dbsnp', schema=schema, pool_recycle=pool_recycle)

    # from variation.src import StockDB
    model.stock_db = model.StockDB.StockDB(
        drivername=drivername,
        username=db_user,
        password=db_passwd,
        hostname=hostname,
        database="stock",
        schema=schema,
        pool_recycle=pool_recycle,
    )

    model.at_db = model.AtDB.AtDB(
        drivername=drivername,
        username=db_user,
        password=db_passwd,
        hostname=hostname,
        database="at",
        schema=schema,
        pool_recycle=pool_recycle,
    )
    """
	for entity in entities:
		if entity.__module__==db.__module__:	#entity in the same module
			entity.metadata = metadata
			#using_table_options_handler(entity, schema=self.schema)
	"""
    model.genome_db.setup(create_tables=False)
    # snp_db.setup(create_tables=False)
    model.stock_db.setup(create_tables=False)
    model.at_db.setup(create_tables=False)

    from variation.src.DrawSNPRegion import DrawSNPRegion

    def dealWithGeneAnnotation():
        gene_annotation_picklef = "/Network/Data/250k/tmp-yh/at_gene_model_pickelf"
        DrawSNPRegion_ins = DrawSNPRegion(
            db_user=db_user,
            db_passwd=db_passwd,
            hostname=hostname,
            database=dbname,
            input_fname="/tmp/dumb",
            output_dir="/tmp",
            debug=0,
        )
        gene_annotation = DrawSNPRegion_ins.dealWithGeneAnnotation(
            gene_annotation_picklef, cls_with_db_args=DrawSNPRegion_ins
        )
        return gene_annotation

    model.gene_annotation = dealWithGeneAnnotation()

    # 2008-11-05 a dictionary to link two tables of types in order for cross-linking between pages of DisplayTopSNPTestRM and ScoreRankHistogram/DisplayResultsGene
    model.CandidateGeneTopSNPTestRMType_id_min_distance2ScoreRankHistogramType_id = {}
    ScoreRankHistogramType = model.Stock_250kDB.ScoreRankHistogramType
    CandidateGeneTopSNPTestRMType = model.Stock_250kDB.CandidateGeneTopSNPTestRMType

    rows = model.db.metadata.bind.execute(
        "select s.id as sid, s.min_distance, s.call_method_id, c.id as cid from %s s, %s c where s.null_distribution_type_id=c.null_distribution_type_id and\
					s.results_type=c.results_type and s.get_closest=c.get_closest and s.min_MAF=c.min_MAF and \
					s.allow_two_sample_overlapping=c.allow_two_sample_overlapping"
        % (ScoreRankHistogramType.table.name, CandidateGeneTopSNPTestRMType.table.name)
    )  # 2008-1-8 temporarily set call_method_id=17 cuz CandidateGeneTopSNPTestRMType doesn't include call_method_id

    for row in rows:
        key_tuple = (row.cid, row.min_distance, row.call_method_id)
        model.CandidateGeneTopSNPTestRMType_id_min_distance2ScoreRankHistogramType_id[key_tuple] = row.sid

        # 2009-4-10 takes too long in individual request, put here. used in Accession.py
    from variation.src.common import map_perlegen_ecotype_name2accession_id, fillInPhenotypeMethodID2ecotype_id_set

    model.ecotype_name2accession_id = map_perlegen_ecotype_name2accession_id(model.db.metadata.bind)
    # 2009-11-17
    model.PhenotypeMethodID2ecotype_id_set = fillInPhenotypeMethodID2ecotype_id_set(model.Stock_250kDB.PhenotypeAvg)
    # 2009-11-17
    from variation.src.common import fillInCallMethodID2ecotype_id_set

    model.CallMethodID2ecotype_id_set = fillInCallMethodID2ecotype_id_set(model.Stock_250kDB.CallInfo)
示例#2
0
	def run(self):
		import MySQLdb
		conn = MySQLdb.connect(db=self.dbname, host=self.hostname, user=self.user, passwd = self.passwd)
		curs = conn.cursor()
		if self.debug:
			import pdb
			pdb.set_trace()
		"""
		#2008-02-08 old way to get 2010 data is from raw alignments. didn't realize all SNPs are put into db.
		alignment_id2positions_to_be_checked_ls, alignment_id2chr_start_end = self.get_alignment_id2positions_to_be_checked_ls(curs, self.alignment_table)
		SNPpos_snpacc_ls = self.get_SNPpos_snpacc_ls(curs, self.snp_locus_table)
		SNPpos2col_index, snp_acc_ls = self.setup_SNP_dstruc(SNPpos_snpacc_ls, alignment_id2chr_start_end)

		ecotype_id2accession_id, ecotype_id2row_index, ecotype_id2info_ls, ecotype_id_ls, accession_id2row_index, accession_id_ls, nativename_ls = self.setup_accession_ecotype_dstruc(curs, self.accession2ecotype_table, self.ecotype_table)
		accession_X_snp_matrix, accession_X_snp_matrix_touched, snp_index2alignment_id = self.get_accession_X_snp_matrix(curs, accession_id2row_index, SNPpos2col_index, self.sequence_table, self.alignment_table, alignment_id2positions_to_be_checked_ls)
		"""
		if self.processing_bits[3]==0:
			#2009-2-12 will be a problem if snp_locus_table doesn't have field offset
			SNPpos2col_index, snp_acc_ls = self.setup_SNP_dstruc2(curs, self.snp_locus_table, offset=self.offset)
		elif self.processing_bits[3]==1:
			SNPpos2col_index, snp_acc_ls = self.setup_SNP_dstruc2(curs, self.snp_locus_table, \
																cross_linking_table=self.data_type2data_table[self.processing_bits[1]], \
																offset=self.offset)
		elif self.processing_bits[3]==2:
			SNPpos2col_index, snp_acc_ls = self.setup_SNP_dstruc2(curs, self.data_type2data_table[self.processing_bits[1]], \
																offset=self.offset)
		else:
			sys.stderr.write("Error: unsupported 3rd bit in processing_bits %s.\n"%self.processing_bits[3])
			sys.exit(3)
		from variation.src.common import get_accession_id2name
		accession_id2name = get_accession_id2name(curs)
		if self.processing_bits[1]==0:
			row_id2dstruc = self.setup_row_dstruc(curs, SNPpos2col_index, accession_id2name, offset=self.offset, version=self.version)
		elif self.processing_bits[1]==1:
			from variation.src.common import map_perlegen_ecotype_name2accession_id
			ecotype_name2accession_id = map_perlegen_ecotype_name2accession_id(curs)
			row_id2dstruc = self.setup_row_dstruc(curs, SNPpos2col_index, accession_id2name, data_type=self.processing_bits[1], \
												ecotype_name2accession_id=ecotype_name2accession_id,\
												offset=self.offset, version=self.version)
		else:
			sys.stderr("Unsupported data type: %s or no ecotype_name2accession_id specified.\n"%self.processing_bits[1])
			sys.exit(2)
		accession_id_ls, accession_name_ls, data_matrix = self.transform_row_id2dstruc_2_matrix(row_id2dstruc)
		
		from variation.src.FilterStrainSNPMatrix import FilterStrainSNPMatrix
		FilterStrainSNPMatrix_instance = FilterStrainSNPMatrix()
		
		#2008-02-08 which type of row id/1st column
		if self.processing_bits[0]==0:
			from variation.src.common import map_accession_id2ecotype_id
			accession_id2ecotype_id = map_accession_id2ecotype_id(curs, accession2ecotype_table=self.accession2ecotype_table)
			accession_id2ecotype_id[99] = 6909	#accession 99 is the reference genome, which col-0 (ecotype_id=6909)
			ecotype_id_ls = []
			rows_to_be_tossed_out=Set()
			for i in range(len(accession_id_ls)):
				ecotype_id = accession_id2ecotype_id.get(accession_id_ls[i])
				if not ecotype_id:	#mapping failed
					rows_to_be_tossed_out.add(i)
				ecotype_id_ls.append(ecotype_id)
			strain_acc_list = ecotype_id_ls
			header = ['ecotype_id']	#1st column in the header
		else:
			rows_to_be_tossed_out=Set()
			strain_acc_list = accession_id_ls
			header = ['accession_id']
		#2008-02-08 which type of 2nd column
		if self.processing_bits[2]==0:
			category_list = [1]*len(accession_name_ls)
			header.append('duplicate')	#2nd column in the header
		elif self.processing_bits[2]==1:
			category_list = accession_name_ls
			header.append('accession_name')
		else:
			category_list = accession_name_ls
			header.append('accession_name')
		
		header += snp_acc_ls
		FilterStrainSNPMatrix_instance.write_data_matrix(data_matrix, self.output_fname, header, strain_acc_list, category_list, rows_to_be_tossed_out=rows_to_be_tossed_out)