Did I find the right examples for you? yes no      Crawl my project      Python Jobs

All Samples(56)  |  Call(40)  |  Derive(0)  |  Import(16)

src/p/e/PEATDB-2.3/PEATDB/scripts/titDB_Stats.py   PEATDB(Download)
import pickle, sys, os, copy, time, types
import numpy
from PEATDB.Base import PDatabase 
from PEATDB.Ekin.Titration import TitrationAnalyser
from PEATDB.Ekin.Base import EkinProject, EkinDataset
def loadDB():
    from PEATDB.Base import PDatabase
    DB = PDatabase(server='peat.ucd.ie', username='guest',
                             password='123', project='titration_db',port=8080)
    return DB

src/p/e/PEATDB-2.3/PEATDB/scripts/manyGhosts.py   PEATDB(Download)
 
from PEATDB.Ekin.Titration import TitrationAnalyser
from PEATDB.Base import PDatabase
from PEATDB.Ekin.Base import EkinProject
from PEATDB.DictEdit import DictEditor
 
#ghost mapping..
DB = PDatabase(server='peat.ucd.ie', username='guest',
               password='123', project='titration_db',
               port=8080)
p=t.extractpKas(DB, col, names=['HEWL'], titratable=False, reliable=False, minspan=0.06)
t.mappKas(DB,col,p,names=['HEWL'],

src/p/e/PEATDB-2.3/PEATDB/plugins/exampleplugin.py   PEATDB(Download)
    def loadDB(self):
        """Load a DB"""
        from PEATDB.Base import PDatabase
        if local != None:
            self.DB = PDatabase(local=local)

src/p/e/PEATDB-2.3/PEATDB/web.py   PEATDB(Download)
import sys,os, string, types
os.environ['MPLCONFIGDIR']='/tmp'
from PEATDB.Base import PDatabase
from PEATDB.Record import PEATRecord
from PEATDB.PEATTables import PEATTableModel, PEATTable
        sys.stdout.flush()
        print self.server
        DB = PDatabase(server=self.server, port=self.port,
                      username=self.user,
                      password=self.password,
                      project=self.project)
        sys.stdout.flush()
        sys.stdout = saveout
        fsock.close()
        return DB

src/p/e/PEATDB-2.3/PEATDB/plugins/titranalysis.py   PEATDB(Download)
from PEATDB.GUI_helper import *
from PEATDB.Ekin.Titration import TitrationAnalyser
from PEATDB.Base import PDatabase
from PEATDB.Ekin.Base import EkinProject
from PEATDB.Tables import TableCanvas, ColumnHeader
        app.loadDB(opts.file)
    elif opts.server != None:
        DB = PDatabase(server='localhost', username='guest',
                       password='123', project='titration_db',
                       port=8080)
            print 'provide a column'
        else:
            app.analyseTitDB(DB, opts.col)#, complete)
            #app.addpKaTables(DB, complete)
 
    elif opts.benchmark == True:
        app.benchmarkExpErr(DB)
    elif opts.col != None or E != None:
        app.titDBUtils(DB, opts.col, opts.protein, a=opts.atom, E=E,

src/p/e/PEATDB-2.3/PEATDB/plugins/KineticsAnalysis.py   PEATDB(Download)
    def sendtoPEAT(self, server='localhost'):
        """Send all the data to PEATDB"""
        from PEATDB.Base import PDatabase
        self.DB = PDatabase(server=server, username='farrell',
                         password='123', project='novo')
        print self.DB
        DB=self.DB
if __name__ == '__main__':
    try:
        from PEATDB.Base import PDatabase
        DB = PDatabase(server='localhost', username='farrell',
                         password='123', project='novo')

src/p/e/PEATDB-2.3/PEATDB/zodbtest.py   PEATDB(Download)
from ZODB.PersistentMapping import PersistentMapping
from ZODB.PersistentList import PersistentList
from PEATDB.Base import PDatabase, zDatabase
from PEATDB.Record import PEATRecord, Meta, FileRecord
from PEATDB.Ekin.Base import EkinProject
def speedTest1():
    """benchmark read and write"""
    DB = PDatabase(server='localhost',port=8090)
    #DB = PDatabase(local='./Data.fs')
    for i in range(100,300):
        DB.add(i)
    for i in range(100,290):
        DB.delete(i)
    DB.commit()
    print DB
                except:
                    pass
        DB = PDatabase(local=local)
    elif server!=None:
        DB = PDatabase(server=server, username=username,

src/p/e/PEATDB-2.3/PEATDB/scripts/multiProjects.py   PEATDB(Download)
import pickle, sys, os, copy, time, types, math
import numpy
from PEATDB.Base import PDatabase 
from PEATDB import Utils
from PEATDB.Actions import DBActions
def PEATSAJobs(prjs, resubmit=False):
    """Submit PEATSA runs for all projects or merge results if done"""
    for name in prjs:
        print name
        DB = PDatabase(local=os.path.join(savepath,name))
        pdb = DB['wt'].Structure
        PS = PEATSAPlugin()
        PS.main(DB=DB)
                print 'job is present'
                #try to merge results
                S = PEATTableModel(DB)
                job,n = PS.getJob('mycalc')
                PS.mergeResults(job, 'prediction', S)
        name = os.path.splitext(filename)[0]
        #create/open db
        DB = PDatabase(local=os.path.join(savepath,name))
        DB.add('wt')
        #add wt pdb

src/p/e/PEATDB-2.3/PEATDB/Utils.py   PEATDB(Download)
import pickle, sys, os, copy, time, types
import numpy
from PEATDB.Base import PDatabase 
 
"""Helper methods for handling PEAT Datbases, such as copying, merging
        settings['port'] = int(settings['port'])
    if remote==True:
        DB = PDatabase(project=prj,**settings)
    else:
        DB = PDatabase(local=prj)
    return DB
 
def mergeDBs(DB1, DB2):
    """Combine two databases"""
    newDB = PDatabase()

src/p/e/PEATDB-2.3/PEATDB/plugins/PEATSAplugin.py   PEATDB(Download)
            prjdata = jobmeta['project']
            print 'trying to loading exp data from external project(s)'
            from PEATDB.Base import PDatabase
            from PEATTables import PEATTableModel
 
            tmpdb = PDatabase(**prjdata)
    if opts.file != None and os.path.exists(opts.file):
        path=os.path.abspath(opts.file)        
        from PEATDB.Base import PDatabase
        DB = PDatabase(local=path) 
        P = PEATSAPlugin()
        P.main(DB=DB)

  1 | 2  Next