if __name__ == "__main__":
bud_session_maker = prepare_schema_connection(bud, config.BUD_DBTYPE, 'pastry.stanford.edu:1521', config.BUD_DBNAME, config.BUD_SCHEMA, config.BUD_DBUSER, config.BUD_DBPASS)
nex_session_maker = prepare_schema_connection(nex, config.NEX_DBTYPE, 'sgd-master-db.stanford.edu:1521', config.NEX_DBNAME, config.NEX_SCHEMA, config.NEX_DBUSER, config.NEX_DBPASS)
perf_session_maker = prepare_schema_connection(perf, config.PERF_DBTYPE, 'sgd-db1.stanford.edu:1521', config.PERF_DBNAME, config.PERF_SCHEMA, config.PERF_DBUSER, config.PERF_DBPASS)
nex_backend = SGDBackend(config.NEX_DBTYPE, 'sgd-master-db.stanford.edu:1521', config.NEX_DBNAME, config.NEX_SCHEMA, config.NEX_DBUSER, config.NEX_DBPASS, None)
from src.sgd.model.nex.bioitem import Reservedname
from src.sgd.model.nex.paragraph import Paragraph, Bioentityparagraph, ParagraphReference
from src.sgd.convert.from_bud.paragraph import make_bioentity_paragraph_starter, make_paragraph_reference_starter
do_conversion(make_bioentity_paragraph_starter(bud_session_maker, nex_session_maker),
[Json2Obj(Bioentityparagraph),
Obj2NexDB(nex_session_maker, lambda x: x.query(Bioentityparagraph),
name='convert.from_bud.paragraph.bioentity',
delete_untouched=True,
commit=True,
already_deleted=clean_up_orphans(nex_session_maker, Bioentityparagraph, Paragraph, 'BIOENTITY'))])
do_conversion(make_paragraph_reference_starter(nex_session_maker),
[Json2Obj(ParagraphReference),
Obj2NexDB(nex_session_maker, lambda x: x.query(ParagraphReference),
name='convert.from_bud.paragraph_reference',
delete_untouched=True,
commit=True)])
from src.sgd.model.perf.core import Bioentity as PerfBioentity
do_conversion(make_backend_starter(nex_backend, 'all_bioentities', 1000),
[Json2CorePerfDB(perf_session_maker, PerfBioentity, name='convert.from_backend.bioentity', commit_interval=1000, delete_untouched=True)])
make_orphan_backend_starter
__author__ = 'kpaskov'
if __name__ == "__main__":
nex_session_maker = prepare_schema_connection(nex, config.NEX_DBTYPE, 'sgd-master-db.stanford.edu:1521', config.NEX_DBNAME, config.NEX_SCHEMA, config.NEX_DBUSER, config.NEX_DBPASS)
perf_session_maker = prepare_schema_connection(perf, config.PERF_DBTYPE, 'sgd-db1.stanford.edu:1521', config.PERF_DBNAME, config.PERF_SCHEMA, config.PERF_DBUSER, config.PERF_DBPASS)
nex_backend = SGDBackend(config.NEX_DBTYPE, 'sgd-master-db.stanford.edu:1521', config.NEX_DBNAME, config.NEX_SCHEMA, config.NEX_DBUSER, config.NEX_DBPASS, None)
# ------------------------------------------ Perf ------------------------------------------
# ------------------------------------------ Disambig ------------------------------------------
do_conversion(make_backend_starter(nex_backend, 'all_disambigs', 1000),
[Json2DisambigPerfDB(perf_session_maker, commit_interval=1000)])
# ------------------------------------------ Evelements ------------------------------------------
from src.sgd.model.perf.core import Strain as PerfStrain
do_conversion(make_backend_starter(nex_backend, 'all_strains', 1000),
[Json2CorePerfDB(perf_session_maker, PerfStrain, name='convert.from_backend.strain', commit_interval=1000, delete_untouched=True)])
# ------------------------------------------ Bioentity ------------------------------------------
from src.sgd.model.perf.core import Bioentity as PerfBioentity, Locustab as PerfLocustab, Locusentry as PerfLocusentry, Tag as PerfTag
do_conversion(make_backend_starter(nex_backend, 'all_bioentities', 1000),
[Json2CorePerfDB(perf_session_maker, PerfBioentity, name='convert.from_backend.bioentity', commit_interval=1000, delete_untouched=True)])
do_conversion(make_backend_starter(nex_backend, 'all_locustabs', 1000),
[Json2CorePerfDB(perf_session_maker, PerfLocustab, name='convert.from_backend.all_locustabs', commit_interval=1000, delete_untouched=True)])
do_conversion(make_backend_starter(nex_backend, 'all_locusentries', 1000),
# name='convert.from_bud.evidence.alignment_evidence',
# delete_untouched=True,
# commit_interval=1000),
# OutputTransformer(1000)])
# ------------------------------------------ Perf ------------------------------------------
from src.sgd.model.perf.bioentity_data import BioentityDetails
from src.sgd.model.nex.bioentity import Locus
nex_session = nex_session_maker()
locus_ids = [x.id for x in nex_session.query(Locus).all()]
nex_session.close()
do_conversion(make_locus_data_backend_starter(nex_backend, 'alignment_bioent', locus_ids),
[Json2DataPerfDB(perf_session_maker, BioentityDetails, 'ALIGNMENT', locus_ids, name='convert.from_backend.alignment_details', commit_interval=100, sure=True),
OutputTransformer(100)])
do_conversion(make_orphan_backend_starter(nex_backend, ['alignments']),
[Json2OrphanPerfDB(perf_session_maker, name='convert.from_backend.orphans', commit_interval=1000)])
# ------------------------------------------ Perf2 ------------------------------------------
perf_session_maker = prepare_schema_connection(perf, config.PERF_DBTYPE, 'sgd-db2.stanford.edu:1521', config.PERF_DBNAME, config.PERF_SCHEMA, config.PERF_DBUSER, config.PERF_DBPASS)
perf_backend = PerfBackend(config.PERF_DBTYPE, 'sgd-db1.stanford.edu:1521', config.PERF_DBNAME, config.PERF_SCHEMA, config.PERF_DBUSER, config.PERF_DBPASS, None)
do_conversion(make_locus_data_backend_starter(perf_backend, 'alignment_bioent', locus_ids),
[Json2DataPerfDB(perf_session_maker, BioentityDetails, 'ALIGNMENT', locus_ids, name='convert.from_backend.alignment_details', commit_interval=100, sure=True),
OutputTransformer(100)])
do_conversion(make_orphan_backend_starter(perf_backend, ['alignments']),
[Json2OrphanPerfDB(perf_session_maker, name='convert.from_backend.orphans', commit_interval=1000)])
if __name__ == "__main__":
bud_session_maker = prepare_schema_connection(bud, config.BUD_DBTYPE, 'pastry.stanford.edu:1521', config.BUD_DBNAME, config.BUD_SCHEMA, config.BUD_DBUSER, config.BUD_DBPASS)
nex_session_maker = prepare_schema_connection(nex, config.NEX_DBTYPE, 'sgd-master-db.stanford.edu:1521', config.NEX_DBNAME, config.NEX_SCHEMA, config.NEX_DBUSER, config.NEX_DBPASS)
perf_session_maker = prepare_schema_connection(perf, config.PERF_DBTYPE, 'sgd-db1.stanford.edu:1521', config.PERF_DBNAME, config.PERF_SCHEMA, config.PERF_DBUSER, config.PERF_DBPASS)
nex_backend = SGDBackend(config.NEX_DBTYPE, 'sgd-master-db.stanford.edu:1521', config.NEX_DBNAME, config.NEX_SCHEMA, config.NEX_DBUSER, config.NEX_DBPASS, None)
# ------------------------------------------ Evidence ------------------------------------------
from src.sgd.model.nex.evidence import Evidence, Geninteractionevidence, Physinteractionevidence
from src.sgd.convert.from_bud.evidence import make_interaction_evidence_starter
do_conversion(make_interaction_evidence_starter(bud_session_maker, nex_session_maker, 'genetic interactions'),
[Json2Obj(Geninteractionevidence),
Evidence2NexDB(nex_session_maker, lambda x: x.query(Geninteractionevidence),
name='convert.from_bud.evidence.geninteraction',
delete_untouched=True,
commit_interval=1000,
already_deleted=clean_up_orphans(nex_session_maker, Geninteractionevidence, Evidence, 'GENINTERACTION'))])
do_conversion(make_interaction_evidence_starter(bud_session_maker, nex_session_maker, 'physical interactions'),
[Json2Obj(Physinteractionevidence),
Evidence2NexDB(nex_session_maker, lambda x: x.query(Physinteractionevidence),
name='convert.from_bud.evidence.physinteraction',
delete_untouched=True,
commit_interval=1000,
already_deleted=clean_up_orphans(nex_session_maker, Physinteractionevidence, Evidence, 'PHYSINTERACTION'))])
# ------------------------------------------ Perf ------------------------------------------
from src.sgd.model.perf.bioentity_data import BioentityDetails
from src.sgd.model.perf.reference_data import ReferenceDetails
bud_session_maker = prepare_schema_connection(bud, config.BUD_DBTYPE, 'pastry.stanford.edu:1521', config.BUD_DBNAME, config.BUD_SCHEMA, config.BUD_DBUSER, config.BUD_DBPASS)
nex_session_maker = prepare_schema_connection(nex, config.NEX_DBTYPE, 'sgd-master-db.stanford.edu:1521', config.NEX_DBNAME, config.NEX_SCHEMA, config.NEX_DBUSER, config.NEX_DBPASS)
from src.sgd.model.nex.evidence import Evidence, Goevidence, Literatureevidence, Domainevidence, ECNumberevidence, \
Proteinexperimentevidence, Phenotypeevidence, Historyevidence, Pathwayevidence, Goslimevidence, Posttranslationalevidence
from src.sgd.convert.from_bud.evidence import make_go_evidence_starter, make_literature_evidence_starter, \
make_domain_evidence_starter, make_protein_experiment_evidence_starter, \
make_ecnumber_evidence_starter, make_protein_experiment_evidence_starter, make_go_slim_evidence_starter, \
make_phenotype_evidence_starter, make_history_evidence_starter, make_pathway_evidence_starter, make_posttranslational_evidence_starter
from src.sgd.convert.from_bud.auxiliary import make_bioconcept_count_starter
do_conversion(make_go_evidence_starter(bud_session_maker, nex_session_maker),
[Json2Obj(Goevidence),
Evidence2NexDB(nex_session_maker, lambda x: x.query(Goevidence),
name='convert.from_bud.evidence.go',
delete_untouched=True,
commit_interval=1000,
already_deleted=clean_up_orphans(nex_session_maker, Goevidence, Evidence, 'GO'))])
do_conversion(make_go_slim_evidence_starter(nex_session_maker),
[Json2Obj(Goslimevidence),
Evidence2NexDB(nex_session_maker, lambda x: x.query(Goslimevidence),
name='convert.from_bud.evidence.goslim',
delete_untouched=True,
commit_interval=1000,
already_deleted=clean_up_orphans(nex_session_maker, Goslimevidence, Evidence, 'GOSLIM'))])
do_conversion(make_literature_evidence_starter(bud_session_maker, nex_session_maker),
[Json2Obj(Literatureevidence),
Evidence2NexDB(nex_session_maker, lambda x: x.query(Literatureevidence),
from src.sgd.model.nex.bioconcept import Go, ECNumber, Phenotype, Observable
from src.sgd.model.nex.bioitem import Domain, Chemical
nex_session = nex_session_maker()
locus_ids = [x.id for x in nex_session.query(Locus).all()]
reference_ids = [x.id for x in nex_session.query(Reference).all()]
go_ids = [x.id for x in nex_session.query(Go).all()]
domain_ids = [x.id for x in nex_session.query(Domain).all()]
ecnumber_ids = [x.id for x in nex_session.query(ECNumber).all()]
phenotype_ids = [x.id for x in nex_session.query(Phenotype).all()]
observable_ids = [x.id for x in nex_session.query(Observable).all()]
chemical_ids = [x.id for x in nex_session.query(Chemical).all()]
nex_session.close()
# ------------------------------------------ GO Perf ------------------------------------------
do_conversion(make_locus_data_backend_starter(nex_backend, 'go_details', locus_ids),
[Json2DataPerfDB(perf_session_maker, BioentityDetails, 'GO', locus_ids, name='convert.from_backend.go_details', commit_interval=1000, sure=True)])
do_conversion(make_go_data_backend_starter(nex_backend, 'go_details', go_ids),
[Json2DataPerfDB(perf_session_maker, BioconceptDetails, 'GO_LOCUS', go_ids, name='convert.from_backend.go_details', commit_interval=1000, sure=True)])
do_conversion(make_reference_data_backend_starter(nex_backend, 'go_details', reference_ids),
[Json2DataPerfDB(perf_session_maker, ReferenceDetails, 'GO', reference_ids, name='convert.from_backend.go_details', commit_interval=1000, sure=True)])
do_conversion(make_go_data_with_children_backend_starter(nex_backend, 'go_details', go_ids),
[Json2DataPerfDB(perf_session_maker, BioconceptDetails, 'GO_LOCUS_ALL_CHILDREN', go_ids, name='convert.from_backend.go_details', commit_interval=1000, sure=True)])
# ------------------------------------------ Misc Perf ------------------------------------------
do_conversion(make_locus_data_backend_starter(nex_backend, 'ec_number_details', locus_ids),
[Json2DataPerfDB(perf_session_maker, BioentityDetails, 'EC_NUMBER', locus_ids, name='convert.from_backend.ec_number_details', commit_interval=1000, sure=True)])
do_conversion(make_ecnumber_data_backend_starter(nex_backend, 'ec_number_details', ecnumber_ids),
if __name__ == "__main__":
bud_session_maker = prepare_schema_connection(bud, config.BUD_DBTYPE, 'pastry.stanford.edu:1521', config.BUD_DBNAME, config.BUD_SCHEMA, config.BUD_DBUSER, config.BUD_DBPASS)
nex_session_maker = prepare_schema_connection(nex, config.NEX_DBTYPE, 'sgd-master-db.stanford.edu:1521', config.NEX_DBNAME, config.NEX_SCHEMA, config.NEX_DBUSER, config.NEX_DBPASS)
perf_session_maker = prepare_schema_connection(perf, config.PERF_DBTYPE, 'sgd-db1.stanford.edu:1521', config.PERF_DBNAME, config.PERF_SCHEMA, config.PERF_DBUSER, config.PERF_DBPASS)
nex_backend = SGDBackend(config.NEX_DBTYPE, 'sgd-master-db.stanford.edu:1521', config.NEX_DBNAME, config.NEX_SCHEMA, config.NEX_DBUSER, config.NEX_DBPASS, None)
from src.sgd.model.nex.evidence import Posttranslationalevidence, Evidence
from src.sgd.convert.from_bud.evidence import make_posttranslational_evidence_starter
do_conversion(make_posttranslational_evidence_starter(nex_session_maker),
[Json2Obj(Posttranslationalevidence),
Evidence2NexDB(nex_session_maker, lambda x: x.query(Posttranslationalevidence),
name='convert.from_bud.evidence.posttranslationsl',
delete_untouched=True,
commit_interval=1000,
already_deleted=clean_up_orphans(nex_session_maker, Posttranslationalevidence, Evidence, 'POSTTRANSLATIONAL')),
OutputTransformer(1000)])
from src.sgd.model.nex.bioentity import Locus
nex_session = nex_session_maker()
locus_ids = [x.id for x in nex_session.query(Locus).all()]
nex_session.close()
from src.sgd.model.perf.bioentity_data import BioentityDetails
do_conversion(make_locus_data_backend_starter(nex_backend, 'posttranslational_details', locus_ids),
[Json2DataPerfDB(perf_session_maker, BioentityDetails, 'POSTTRANSLATIONAL', locus_ids, name='convert.from_backend.posttranslational_details',
commit_interval=1000, sure=True),
OutputTransformer(1000)])
# [Json2DataPerfDB(perf_session_maker, BioentityGraph, 'GO', locus_ids, name='convert.from_backend.go_graph', commit_interval=1000)])
#
# do_conversion(make_locus_data_backend_starter(nex_backend, 'protein_domain_graph', locus_ids),
# [Json2DataPerfDB(perf_session_maker, BioentityGraph, 'PROTEIN_DOMAIN', locus_ids, name='convert.from_backend.protein_domain_graph', commit_interval=1000)])
#
# do_conversion(make_locus_data_backend_starter(nex_backend, 'literature_graph', locus_ids),
# [Json2DataPerfDB(perf_session_maker, BioentityGraph, 'LITERATURE', locus_ids, name='convert.from_backend.literature_graph', commit_interval=1000)])
#
# do_conversion(make_locus_data_backend_starter(nex_backend, 'regulation_graph', locus_ids),
# [Json2DataPerfDB(perf_session_maker, BioentityGraph, 'REGULATION', locus_ids, name='convert.from_backend.regulation_graph', commit_interval=1000)])
#
# do_conversion(make_go_data_backend_starter(nex_backend, 'go_ontology_graph', go_ids),
# [Json2DataPerfDB(perf_session_maker, BioconceptGraph, 'GO_ONTOLOGY', go_ids, name='convert.from_backend.go_ontology_graph', commit_interval=1000)])
do_conversion(make_observable_data_backend_starter(nex_backend, 'phenotype_ontology_graph', [99]),
[Json2DataPerfDB(perf_session_maker, BioconceptGraph, 'PHENOTYPE_ONTOLOGY', [99],
name='convert.from_backend.phenotype_ontology_graph', commit_interval=1000, delete_untouched=False)])
# # ------------------------------------------ Perf2 ------------------------------------------
# perf_session_maker = prepare_schema_connection(perf, config.PERF_DBTYPE, 'sgd-db2.stanford.edu:1521', config.PERF_DBNAME, config.PERF_SCHEMA, config.PERF_DBUSER, config.PERF_DBPASS)
# perf_backend = PerfBackend(config.PERF_DBTYPE, 'sgd-db1.stanford.edu:1521', config.PERF_DBNAME, config.PERF_SCHEMA, config.PERF_DBUSER, config.PERF_DBPASS, None)
#
# do_conversion(make_locus_data_backend_starter(perf_backend, 'interaction_graph', locus_ids),
# [Json2DataPerfDB(perf_session_maker, BioentityGraph, 'INTERACTION', locus_ids, name='convert.from_backend.interaction_graph', commit_interval=1000)])
#
# do_conversion(make_locus_data_backend_starter(perf_backend, 'phenotype_graph', locus_ids),
# [Json2DataPerfDB(perf_session_maker, BioentityGraph, 'PHENOTYPE', locus_ids, name='convert.from_backend.phenotype_graph', commit_interval=1000)])
#
# do_conversion(make_locus_data_backend_starter(perf_backend, 'go_graph', locus_ids),
# [Json2DataPerfDB(perf_session_maker, BioentityGraph, 'GO', locus_ids, name='convert.from_backend.go_graph', commit_interval=1000)])
#
__author__ = 'kpaskov'
if __name__ == "__main__":
nex_session_maker = prepare_schema_connection(nex, config.NEX_DBTYPE, 'sgd-master-db.stanford.edu:1521', config.NEX_DBNAME, config.NEX_SCHEMA, config.NEX_DBUSER, config.NEX_DBPASS)
perf_session_maker = prepare_schema_connection(perf, config.PERF_DBTYPE, 'sgd-db1.stanford.edu:1521', config.PERF_DBNAME, config.PERF_SCHEMA, config.PERF_DBUSER, config.PERF_DBPASS)
nex_backend = SGDBackend(config.NEX_DBTYPE, 'sgd-master-db.stanford.edu:1521', config.NEX_DBNAME, config.NEX_SCHEMA, config.NEX_DBUSER, config.NEX_DBPASS, None)
# ------------------------------------------ Perf ------------------------------------------
# ------------------------------------------ Reference ------------------------------------------
from src.sgd.model.perf.core import Reference as PerfReference, Author as PerfAuthor, Bibentry as PerfBibentry
do_conversion(make_backend_starter(nex_backend, 'all_references', 1000),
[Json2CorePerfDB(perf_session_maker, PerfReference, name='convert.from_backend.reference', delete_untouched=True, commit_interval=1000)])
do_conversion(make_backend_starter(nex_backend, 'all_authors', 1000),
[Json2CorePerfDB(perf_session_maker, PerfAuthor, name='convert.from_backend.author', delete_untouched=True, commit_interval=1000)])
do_conversion(make_backend_starter(nex_backend, 'all_bibentries', 1000),
[Json2CorePerfDB(perf_session_maker, PerfBibentry, name='convert.from_backend.all_bibentries', commit_interval=1000, delete_untouched=True)])
do_conversion(make_orphan_backend_starter(nex_backend, ['references_this_week']),
[Json2OrphanPerfDB(perf_session_maker, name='convert.from_backend.orphans', commit_interval=1000)])
# ------------------------------------------ Perf2 ------------------------------------------
perf_session_maker = prepare_schema_connection(perf, config.PERF_DBTYPE, 'sgd-db2.stanford.edu:1521', config.PERF_DBNAME, config.PERF_SCHEMA, config.PERF_DBUSER, config.PERF_DBPASS)
perf_backend = PerfBackend(config.PERF_DBTYPE, 'sgd-db1.stanford.edu:1521', config.PERF_DBNAME, config.PERF_SCHEMA, config.PERF_DBUSER, config.PERF_DBPASS, None)
# ------------------------------------------ Reference ------------------------------------------
from src.sgd.model.nex.bioentity import Locus
from src.sgd.model.nex.reference import Reference
from src.sgd.model.nex.bioconcept import Go, ECNumber, Phenotype, Observable
from src.sgd.model.nex.bioitem import Domain, Chemical
nex_session = nex_session_maker()
locus_ids = [x.id for x in nex_session.query(Locus).all()]
reference_ids = [x.id for x in nex_session.query(Reference).all()]
phenotype_ids = [x.id for x in nex_session.query(Phenotype).all()]
observable_ids = [x.id for x in nex_session.query(Observable).all()]
chemical_ids = [x.id for x in nex_session.query(Chemical).all()]
nex_session.close()
# ------------------------------------------ Literature Perf ------------------------------------------
do_conversion(make_locus_data_backend_starter(nex_backend, 'literature_details', locus_ids),
[Json2DataPerfDB(perf_session_maker, BioentityDetails, 'LITERATURE', locus_ids, name='convert.from_backend.literature_details', commit_interval=1000, sure=True)])
do_conversion(make_reference_data_backend_starter(nex_backend, 'literature_details', reference_ids),
[Json2DataPerfDB(perf_session_maker, ReferenceDetails, 'LITERATURE', reference_ids, name='convert.from_backend.literature_details', commit_interval=1000, sure=True)])
# ------------------------------------------ Phenotype Perf ------------------------------------------
do_conversion(make_locus_data_backend_starter(nex_backend, 'phenotype_details', locus_ids),
[Json2DataPerfDB(perf_session_maker, BioentityDetails, 'PHENOTYPE', locus_ids, name='convert.from_backend.phenotype_details', commit_interval=1000, sure=True)])
do_conversion(make_phenotype_data_backend_starter(nex_backend, 'phenotype_details', phenotype_ids),
[Json2DataPerfDB(perf_session_maker, BioconceptDetails, 'PHENOTYPE_LOCUS', phenotype_ids, name='convert.from_backend.phenotype_details', commit_interval=1000, sure=True)])
do_conversion(make_reference_data_backend_starter(nex_backend, 'phenotype_details', reference_ids),
[Json2DataPerfDB(perf_session_maker, ReferenceDetails, 'PHENOTYPE', reference_ids, name='convert.from_backend.phenotype_details', commit_interval=1000, sure=True)])
do_conversion(make_chemical_data_backend_starter(nex_backend, 'phenotype_details', chemical_ids),
from src.sgd.convert.from_bud.auxiliary import make_bioentity_expression_interaction_starter, make_disambig_starter
import os
# do_conversion(make_dataset_starter(nex_session_maker, 'src/sgd/convert/data/microarray_05_14'),
# [Json2Obj(Dataset),
# Obj2NexDB(nex_session_maker, lambda x: x.query(Dataset),
# name='convert.from_bud.bioitem.dataset',
# delete_untouched=True,
# commit_interval=1000,
# already_deleted=clean_up_orphans(nex_session_maker, Dataset, Bioitem, 'DATASET'))])
do_conversion(make_datasetcolumn_starter(nex_session_maker, 'src/sgd/convert/data/microarray_05_14'),
[Json2Obj(Datasetcolumn),
Obj2NexDB(nex_session_maker, lambda x: x.query(Datasetcolumn),
name='convert.from_bud.bioitem.datasetcolumn',
delete_untouched=False,
commit_interval=1000,
already_deleted=clean_up_orphans(nex_session_maker, Datasetcolumn, Bioitem, 'DATASETCOLUMN'))])
# do_conversion(make_tag_starter(nex_session_maker),
# [Json2Obj(Tag),
# Obj2NexDB(nex_session_maker, lambda x: x.query(Tag),
# name='convert.from_bud.tag',
# delete_untouched=True,
# commit=True)])
#
# do_conversion(make_disambig_starter(nex_session_maker, Tag, ['id', 'format_name'], 'TAG', None),
# [Json2Obj(Disambig),
# Obj2NexDB(nex_session_maker, lambda x: x.query(Disambig).filter(Disambig.class_type == 'TAG'),
# name='convert.from_bud.bioitem.disambig.tag',
bud_session_maker = prepare_schema_connection(bud, config.BUD_DBTYPE, 'pastry.stanford.edu:1521', config.BUD_DBNAME, config.BUD_SCHEMA, config.BUD_DBUSER, config.BUD_DBPASS)
nex_session_maker = prepare_schema_connection(nex, config.NEX_DBTYPE, 'sgd-master-db.stanford.edu:1521', config.NEX_DBNAME, config.NEX_SCHEMA, config.NEX_DBUSER, config.NEX_DBPASS)
perf_session_maker = prepare_schema_connection(perf, config.PERF_DBTYPE, 'sgd-db1.stanford.edu:1521', config.PERF_DBNAME, config.PERF_SCHEMA, config.PERF_DBUSER, config.PERF_DBPASS)
nex_backend = SGDBackend(config.NEX_DBTYPE, 'sgd-master-db.stanford.edu:1521', config.NEX_DBNAME, config.NEX_SCHEMA, config.NEX_DBUSER, config.NEX_DBPASS, None)
# ------------------------------------------ Evelements ------------------------------------------
# Bud -> Nex
from src.sgd.model.nex.misc import Strain, Url, Strainurl
from src.sgd.model.nex.auxiliary import Disambig
from src.sgd.convert.from_bud.evelements import make_strain_starter, make_strain_url_starter
from src.sgd.convert.from_bud.auxiliary import make_disambig_starter
do_conversion(make_strain_starter(bud_session_maker, nex_session_maker),
[Json2Obj(Strain),
Obj2NexDB(nex_session_maker, lambda x: x.query(Strain),
name='convert.from_bud.strain',
delete_untouched=True,
commit=True)])
do_conversion(make_strain_url_starter(nex_session_maker),
[Json2Obj(Strainurl),
Obj2NexDB(nex_session_maker, lambda x: x.query(Strainurl),
name='convert.from_bud.strain.url',
delete_untouched=True,
commit_interval=1000,
already_deleted=clean_up_orphans(nex_session_maker, Strainurl, Url, 'STRAIN'))])
do_conversion(make_disambig_starter(nex_session_maker, Strain, ['id', 'format_name'], 'STRAIN', None),
[Json2Obj(Disambig),
Obj2NexDB(nex_session_maker, lambda x: x.query(Disambig).filter(Disambig.class_type == 'STRAIN'),
name='convert.from_bud.strain.disambig',
#
# do_conversion(make_ref_dna_sequence_evidence_starter(bud_session_maker, nex_session_maker, ["src/sgd/convert/data/strains/orf_coding_all.fasta", "src/sgd/convert/data/strains/rna_coding.fasta"]),
# [Json2Obj(DNAsequenceevidence),
# Obj2NexDB(nex_session_maker, lambda x: x.query(DNAsequenceevidence).filter(DNAsequenceevidence.strain_id == 1), name='convert.from_bud.evidence.reference_dnasequence', delete_untouched=True, commit_interval=1000)])
#
# do_conversion(make_dna_sequence_tag_starter(bud_session_maker, nex_session_maker),
# [Json2Obj(DNAsequencetag),
# Obj2NexDB(nex_session_maker, lambda x: x.query(DNAsequencetag), name='convert.from_bud.evidence.dnasequence.tags', delete_untouched=True, commit_interval=1000)])
#
nex_session = nex_session_maker()
strain_key_to_id = dict([(x.unique_key(), x.id) for x in nex_session.query(Strain).all()])
nex_session.close()
for sequence_filename, coding_sequence_filename, strain_key in sequence_files:
do_conversion(make_dna_sequence_evidence_starter(nex_session_maker, strain_key, sequence_filename, coding_sequence_filename),
[Json2Obj(DNAsequenceevidence),
Obj2NexDB(nex_session_maker, lambda x: x.query(DNAsequenceevidence).filter(DNAsequenceevidence.strain_id == strain_key_to_id[strain_key]), name='convert.from_bud.evidence.dnasequence', delete_untouched=True, commit_interval=1000)])
clean_up_orphans(nex_session_maker, DNAsequenceevidence, Evidence, 'DNASEQUENCE')
for sequence_filename, coding_sequence_filename, strain_key in new_sequence_files:
do_conversion(make_new_dna_sequence_evidence_starter(nex_session_maker, strain_key, sequence_filename, coding_sequence_filename),
[Json2Obj(DNAsequenceevidence),
Obj2NexDB(nex_session_maker, lambda x: x.query(DNAsequenceevidence).filter(DNAsequenceevidence.strain_id == strain_key_to_id[strain_key]).filter(DNAsequenceevidence.dna_type != '1KB'),
name='convert.from_bud.evidence.dnasequence',
delete_untouched=True,
commit_interval=1000)])
update_contig_centromeres(nex_session_maker)
update_contig_reference_alignment(nex_session_maker)
if __name__ == "__main__":
bud_session_maker = prepare_schema_connection(bud, config.BUD_DBTYPE, 'pastry.stanford.edu:1521', config.BUD_DBNAME, config.BUD_SCHEMA, config.BUD_DBUSER, config.BUD_DBPASS)
nex_session_maker = prepare_schema_connection(nex, config.NEX_DBTYPE, 'sgd-master-db.stanford.edu:1521', config.NEX_DBNAME, config.NEX_SCHEMA, config.NEX_DBUSER, config.NEX_DBPASS)
# ------------------------------------------ Evelements ------------------------------------------
# Bud -> Nex
from src.sgd.model.nex.misc import Source, Strain, Experiment, Experimentalias, Experimentrelation, Url, Alias, Relation, Strainurl
from src.sgd.model.nex.auxiliary import Disambig
from src.sgd.convert.from_bud.evelements import make_source_starter, make_strain_starter, make_experiment_starter, \
make_experiment_alias_starter, make_experiment_relation_starter, make_strain_url_starter
from src.sgd.convert.from_bud.auxiliary import make_disambig_starter
do_conversion(make_source_starter(bud_session_maker, nex_session_maker),
[Json2Obj(Source),
Obj2NexDB(nex_session_maker, lambda x: x.query(Source),
name='convert.from_bud.source',
delete_untouched=True,
commit=True)])
do_conversion(make_experiment_starter(bud_session_maker, nex_session_maker),
[Json2Obj(Experiment),
Obj2NexDB(nex_session_maker, lambda x: x.query(Experiment),
name='convert.from_bud.experiment',
delete_untouched=True,
commit=True)])
do_conversion(make_strain_starter(bud_session_maker, nex_session_maker),
[Json2Obj(Strain),
Obj2NexDB(nex_session_maker, lambda x: x.query(Strain),
name='convert.from_bud.strain',
delete_untouched=True,
__author__ = 'kpaskov'
if __name__ == "__main__":
nex_session_maker = prepare_schema_connection(nex, config.NEX_DBTYPE, 'sgd-master-db.stanford.edu:1521', config.NEX_DBNAME, config.NEX_SCHEMA, config.NEX_DBUSER, config.NEX_DBPASS)
perf_session_maker = prepare_schema_connection(perf, config.PERF_DBTYPE, 'sgd-db1.stanford.edu:1521', config.PERF_DBNAME, config.PERF_SCHEMA, config.PERF_DBUSER, config.PERF_DBPASS)
nex_backend = SGDBackend(config.NEX_DBTYPE, 'sgd-master-db.stanford.edu:1521', config.NEX_DBNAME, config.NEX_SCHEMA, config.NEX_DBUSER, config.NEX_DBPASS, None)
# ------------------------------------------ Evidence ------------------------------------------
from src.sgd.model.nex.evidence import Evidence, Regulationevidence
from src.sgd.convert.from_bud.evidence import make_regulation_evidence_starter
do_conversion(make_regulation_evidence_starter(nex_session_maker),
[Json2Obj(Regulationevidence),
Evidence2NexDB(nex_session_maker, lambda x: x.query(Regulationevidence),
name='convert.from_bud.evidence.regulation',
delete_untouched=True,
commit_interval=1000,
already_deleted=clean_up_orphans(nex_session_maker, Regulationevidence, Evidence, 'REGULATION'))])
# ------------------------------------------ Perf ------------------------------------------
from src.sgd.model.perf.bioentity_data import BioentityDetails, BioentityEnrichment
from src.sgd.model.perf.reference_data import ReferenceDetails
from src.sgd.model.nex.bioentity import Locus
from src.sgd.model.nex.reference import Reference
nex_session = nex_session_maker()
locus_ids = [x.id for x in nex_session.query(Locus).all()]
reference_ids = [x.id for x in nex_session.query(Reference).all()]
nex_session.close()
