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

All Samples(80)  |  Call(65)  |  Derive(0)  |  Import(15)

src/p/e/PEATDB-2.3/PEATDB/Ekin/Web.py   PEATDB(Download)
import StringIO
import tempfile
from PEATDB.Ekin.Base import EkinProject
 
class EkinWeb():
	print project
        if ekindata != None: #convert from ekindata
            E = EkinProject(data=ekindata, mode='NMR titration')
        elif project != None: #just passed object
            E = project
        elif filename != None: #load project from file
            E = EkinProject()
                print '<td class="alt">'
                #use ekinproject to supply formatted fit and model info here..
                self.showMetaData(ekinproj=E, dataset=d)
                print '</td>'
                c=c+1
		if n==False:
		   print '<td>'
            	self.showMetaData(ekinproj=E, dataset=d)
		x+=1
            print '</td>'

src/p/e/PEATDB-2.3/PEATDB/plugins/KineticsAnalysis.py   PEATDB(Download)
import os, sys, math, random, glob, numpy, string
import ConfigParser, csv, xlrd
from PEATDB.Ekin.Base import EkinProject, EkinDataset
from PEATDB.Ekin.Web import EkinWeb
#from PEATDB.Ekin.Convert import EkinConvert
        for name in self.required:
            print name
            E = EkinProject(mode='General')
            for d in raw[name].keys():
                for t in raw[name][d].keys():
                    for p in raw[name][d][t].keys():
                        E.insertDataset(raw[name][d][t][p], d+'_'+t+'_'+str(p))
            E.fitDatasets('ALL', models=['Linear'], noiter=100, conv=1e-6, grad=1e-8, silent=True)
            for d in E.datasets:
                status = self.checkLinearFit(E, d, cutoff = 0.005, fromstart=False, percs=[0.7, 0.5])
        for name in self.required:
            #we create a plot for each variant of vel(slope) vs. temp @ each pH
            E = EkinProject()
            E.openProject(os.path.join(self.path, name.replace(' ','')+'_temp'))
            datasets = copy.deepcopy(E.datasets)
    def processKineticsRaw(self, variantdata, phvalues):
        """Get raw data for a variant into ekin projects, fit MM and save"""
 
        E = EkinProject(mode='General')
        for ph in variantdata.keys():

src/p/e/PEATDB-2.3/PEATDB/Ekin/Titration.py   PEATDB(Download)
from NMR import NMR_data
import Utils
from PEATDB.Ekin.Base import EkinProject, EkinDataset
import Fitting
from PEATDB.Ekin.Plotting import Options
            print prot
            edata = ekindata[prot]
            E = EkinProject(data=edata)
            E.printMeta()
 
                continue
            edata = ekindata[prot]
            E = EkinProject(data=edata)
            for d in E.datasets:
                if residues != None:
            ekindata[prot] = E.prepare_data()
 
        return E
 
    def findpKas(cls, E, titratable=True, reliable=True, minspan=0.06):
        proteins = ekindata1.keys()
        ekindatac = {}
        E1 = EkinProject(ekindata1)
        E2 = EkinProject(ekindata2)
        for prot in proteins:

src/p/e/PEATDB-2.3/PEATDB/plugins/titranalysis.py   PEATDB(Download)
from PEATDB.Ekin.Titration import TitrationAnalyser
from PEATDB.Base import PDatabase
from PEATDB.Ekin.Base import EkinProject
from PEATDB.Tables import TableCanvas, ColumnHeader
from PEATDB.Ekin.Tables import EkinProjModel, EkinProjTable
    def loadEkinProj(self, E=None):
        """Load an ekin project file"""
        import os, types
        if E == None:
            import tkFileDialog
                    import pickle
                    data=pickle.load(fd)
                    E=EkinProject(data=data)
                    self.ekinprojects[filename] = E
                    fd.close()
            else:
                return
        self.currprj = E

src/d/a/DataPipeline-1.2/DataPipeline/Utilities.py   DataPipeline(Download)
from math import *
import numpy as np
from PEATDB.Ekin.Base import EkinProject, EkinDataset
 
def setAttributesfromConfigParser(obj, cp):
         {label:([x],[y],[xerr],[yerr]),..}"""
 
    E = EkinProject(mode='General')
    for d in data.keys():
        if type(data[d]) is types.DictType:
            E.insertDataset(ek, d)
            #print ek.errors
    return E
 
def getFits(E, model, varname='a', filename=None,

src/p/e/PEATDB-2.3/PEATDB/scripts/titDB_Stats.py   PEATDB(Download)
from PEATDB.Base import PDatabase 
from PEATDB.Ekin.Titration import TitrationAnalyser
from PEATDB.Ekin.Base import EkinProject, EkinDataset
 
path=os.environ['HOME']
        for prot in proteins:
            edata = ekindata[prot]
            E = EkinProject(data=edata)
            for d in E.datasets:
                fdata = E.getMetaData(d)

src/p/e/PEATDB-2.3/PEATDB/plugins/VantHoffAnalysis.py   PEATDB(Download)
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties
from PEATDB.Ekin.Base import EkinProject,EkinDataset
import PEATDB.Ekin.Fitting
 
    def getCSV(self):
        """Import a csv file"""
        self.E = EkinProject()
        from PEATDB.Ekin.IO import Importer
        importer = Importer(self,parent_win=self.mainwin)
        if not os.path.isfile(filename):
            return
        self.E = EkinProject()
        self.E.openProject(filename)
        self.showDatasetSelector()
        app.loadDB(opts.file)
    if opts.ekinprj != None and os.path.exists(opts.ekinprj):
        E = EkinProject()
        E.openProject(opts.ekinprj)
        d = opts.dataset
    else:
        x,y = app.simulateCD()
        E = EkinProject()

src/p/e/PEATDB-2.3/PEATDB/Ekin/ModelDesign.py   PEATDB(Download)
import Pmw
from PEATDB.Ekin.Plotting import PlotPanel
from PEATDB.Ekin.Base import EkinProject, EkinDataset
import PEATDB.Ekin.Fitting as Fitting
import Ekin_images
    def sampleData(self):
        E =self.E = EkinProject()
        E.createSampleData()
        self.plotframe.setProject(E)
        self.datasets = sorted(self.E.datasets)

src/d/a/DataPipeline-1.2/DataPipeline/Base.py   DataPipeline(Download)
from Processing import Processor
import Utilities
from PEATDB.Ekin.Base import EkinProject, EkinDataset
import PEATDB.Ekin.Fitting as Fitting
 
            #if we have models to fit this means we might need to propagate fit data
            if self.model1 != '':
                Em = EkinProject()
                #grouping by file labels handled here
                if self.groupbyname == 1:
        if self.groupbyname == 1:
            results = Utilities.extractSecondaryKeysFromDict(results)
            Em = EkinProject()
            #print results
            E,fits = self.processFits(rawdata=results, Em=Em)

src/p/e/PEATDB-2.3/PEATDB/Sandbox.py   PEATDB(Download)
    #DB = PDatabase(local='olddb.fs')
    db = DB.db
    from PEATDB.Ekin.Base import EkinProject
    import copy
    DB.addField('stab', 'text')
    DB.addField('ekin', 'General')
    DB.addField('ekin2', 'General')
    DB.meta.info['cachesize'] = 50
    E = EkinProject()

  1 | 2  Next