def property_update(self):
if "guid" not in self.q:
self.r["status"]="error"
self.r["message"]=["'guid' field missing from query"]
return False
else:
p = prop.prop(guid=self.q.get("guid"),db=self.db,creator=self.user.id)
if p.is_valid:
newrec={}
for f in ['value','to','from','alive','complete','proptype']:
if f in self.q:
newrec[f]=self.q[f]
newp = p.update(newrec)
if newp:
if newp.errors:
self.r["status"]="error"
self.r["message"]=newp.errors
return False
else:
p = prop.prop(guid=p.rec["guid"],db=self.db)
self.r["response"] = {"old":p.rec,"new":newp.rec}
return True
else:
self.r["status"]="error"
self.r["message"]=["Unable to create updated property object. "+(" ".join(p.errors))+(" ".join(self.db.errors))]
return False
else:
self.r["status"]="error"
self.r["message"]=p.errors
return False
def parse_properties(self):
for k, vlist in self.rec.items():
if not isinstance(vlist, list):
vlist = [vlist]
for v in vlist:
proptype = self.db.schema.index["properties"].get(k, k)
self.log.debug(
"PARSE_PROPERTIES: RENDERED PROP =",
proptype,
v,
self.rec.get("urn:lri:property_type:guid", self.creator),
)
p = prop.prop(
entity=self, proptype=proptype, creator=self.creator, value=v, db=self.db, validate_entity=False
)
if p.is_valid:
self.log.debug("VALID PROPERTY:", k, p.rec)
if k not in self.props:
self.props[k] = []
self.props[k].append(p)
else:
self.log.debug("INVALID PROPERTY:", k, p.rec, p.errors)
self.errors.append("INVALID PROPERTY: " + repr(k))
self.errors.extend(p.errors)
if k not in self.invalid_properties:
self.invalid_properties[k] = []
self.invalid_properties[k].append(p)
self.log.debug(
"PARSED PROPERTIES IN INIT =\n", repr(dict([(k, [i.rec for i in v]) for k, v in self.props.items()]))
)
def forward(self, parameter_table):
# make sure a value has been provided for each input
for i in self.parameter_nodes:
if i.name not in parameter_table:
raise Exception('missing value for parameter {}'.format(
i.name))
# we store output_table as we'll use it for backprop and viz
output, self.output_table = prop(self.nodes, parameter_table)
return output, self.output_table
def property_create(self):
p = prop.prop(rec=self.q,db=self.db,creator=self.user.id)
p.create()
if p.errors:
self.r["status"]="error"
self.r["message"]=p.errors
return False
else:
self.r["response"] = p.rec
return True
def update_property(self,oldrec=None,newrec={}):
self.log.debug("UPDATE PROP REC",oldrec)
if "proptype" in newrec and oldrec["proptype"] != newrec["proptype"]:
self.errors.append("UPDATE: Changing proptype is not allowed.")
oldrec["internal"].append("UPDATE: Changing proptype is not allowed.")
return None
# Create the record for our replacement property
finalrec={"proptype":oldrec["proptype"],
"creator":oldrec["creator"]}
for k in ["from","to","value","complete"]:
if k in newrec:
finalrec[k]=newrec[k]
elif k in oldrec:
finalrec[k]=oldrec[k]
if "to" in finalrec and "from" in finalrec and "value" in finalrec:
del finalrec["value"] # Can't be both link and literal
if newrec.get("alive") == False:
# This update is a property deletion
finalrec["alive"] = False
# Make the new property
self.log.debug("MAKING REPLACEMENT PROP REC",oldrec)
newp = prop.prop(rec=finalrec,db=self)
if newp.is_valid:
self.log.debug("CREATE UPDATED PROP:",finalrec)
newp.create(is_update=True)
if newp.errors:
self.errors.append("PROPERTY UPDATE: "+(" ".join(newp.errors)))
return None
self.log.debug("CREATE UPDATED PROP FINAL:",newp.link["rec"])
# Point old property to its replacement
oldrec["internal"]["replaced_by"] = newp.link["guid"]
#oldrec["internal"]["alive"] = False
oldrec["replaced_by"] = newp.link["guid"]
#oldrec["alive"] = False -- Don't make old property dead
oldrec["internal"]["rec"] = json.dumps(dict([(k,v) for k,v in oldrec.items() if k not in ["internal","rec"]]))
# Update our index
self.log.debug(oldrec)
self.link_index.remove(key="replaced_by",entity=oldrec["internal"])
self.link_index.add(key="replaced_by",value=newp.rec["guid"],entity=oldrec["internal"])
#self.link_index.remove(key="alive",value="true",entity=oldrec["internal"])
#self.link_index.add(key="alive",value="false",entity=oldrec["internal"])
return newp
else:
self.errors.append("PROPERTY UPDATE: "+(" ".join(newp.errors)))
oldrec["internal"].errors.append("PROPERTY UPDATE: "+(" ".join(newp.errors)))
return None
def prop(self, proptag, create=False, proptype=None):
"""Return :class:`property <Property>` with given property tag.
:param proptag: MAPI property tag
:param create: create property if it doesn't exist
"""
return _prop.prop(self,
self.mapiobj,
proptag,
create=create,
proptype=proptype)
print(str(zscore(data)))
elif c == 7:
from stdscore import stdscore
print(float(stdscore(data)))
elif c == 8:
from popcorcoeff import popcorcoeff
print(float(popcorcoeff(data)))
elif c == 9:
from conint import conint
print(conint(data))
elif c == 10:
from popvar import popvar
print(popvar(data))
elif c == 11:
from pval import pval
print(pval(data))
elif c == 12:
from prop import prop
print((prop(data)))
elif c == 13:
from smean import smean
print((smean(data)))
elif c == 14:
from sstddev import sstddev
print((sstddev(data)))
elif c == 15:
from vsampprop import vsampprop
print((vsampprop(data)))
else:
print("error")
def __init__(self,
name,
pin0=18,
pin1=23,
pin2=24,
pin3=25,
simulation=True):
#GPIO: 18 23 24 25
#pin : 12 16 18 22
self.logger = logging.getLogger('myQ.quadcptr')
self.name = name
self.simulation = simulation
self.version = 1
self.motor = [motor('M' + str(i), 0) for i in xrange(4)]
self.motor[0] = motor('M0',
pin0,
kv=1000,
WMin=0,
WMax=100,
simulation=self.simulation)
self.motor[1] = motor('M1',
pin1,
kv=1000,
WMin=0,
WMax=100,
simulation=self.simulation)
self.motor[2] = motor('M2',
pin2,
kv=1000,
WMin=0,
WMax=100,
simulation=self.simulation)
self.motor[3] = motor('M3',
pin3,
kv=1000,
WMin=0,
WMax=100,
simulation=self.simulation)
self.sensor = sensor(simulation=self.simulation)
self.pidR = pid()
self.pidP = pid()
self.pidY = pid()
self.pidR_rate = pid()
self.pidP_rate = pid()
self.pidY_rate = pid()
self.ip = '192.168.1.1'
self.netscan = netscan(self.ip)
self.webserver = webserver(self)
self.display = display(self)
self.rc = rc(self.display.screen)
self.imulog = False
self.savelog = False
self.calibIMU = False
self.debuglev = 0
self.netscanning = False
#for quadricopter phisics calculations- not used yet
self.prop = prop(9, 4.7, 1)
self.voltage = 12 # [V]
self.mass = 2 # [Kg]
self.barLenght = 0.23 # [mm]
self.barMass = 0.15 # [kg]
self.datalog = ''
self.initLog()
def test_prop(self):
from prop import prop
assert prop(data) == 0.002564102564102564
def create(self):
if self.errors:
return False
self.node = self.db.create_entity(creator=self.creator)
if not self.node:
self.errors.append("COULD NOT CREATE NODE IN DATABASE")
return False
# Set up our intrinsic node properties
nodeprops = {
"urn:lri:property_type:guid": self.node["guid"],
"urn:lri:property_type:timestamp": self.node["timestamp"],
"urn:lri:property_type:creator": self.node["creator"],
}
self.log.debug("INTERNAL PROPERTIES", list(self.db.internal_properties(self.node)))
rec = copy.deepcopy(self.db.internal_properties(self.node))
self.log.debug("CREATED NODE =", rec)
for k, v in nodeprops.items():
self.rec[k] = v
self.props[k] = [prop.prop(entity=self, proptype=k, creator=self.creator, value=v, db=self.db)]
self.log.debug(
"\n\n\n\n\n\n\n\n NEW ENTITY PROPERTIES =", [(k, [i.rec for i in v]) for k, v in self.props.items()]
)
# The properties we successfully create
done_props = []
# First do our id because we'll need that for the other properties
if "urn:lri:property_type:id" in self.props:
plist = self.props["urn:lri:property_type:id"]
for p in plist:
p.rec["from"] = rec["guid"]
if not p.create(allow_nodeprops=True):
self.errors.extend(["ENTITY ID CREATION FAILURE"] + p.errors)
self.errors.append("FAILED TO CREATE PROPERTY: " + json.dumps(p.rec))
else:
done_props.append(p)
if self.errors:
# We failed to create our IDs so let's bail
for dp in done_props:
r = dp.delete()
if not r:
self.errors.extend(dp.errors)
# Now let's delete our node
self.errors.append("Destroying node '%s' " % (rec.get("guid")))
self.delete()
return False
# Now we can do the rest of the properties
for pname, plist in self.props.items():
if pname != "urn:lri:property_type:id":
for p in plist:
p.rec["from"] = rec["guid"]
# if 'types' in pname:
# self.log.debug("ZZZ CREATE TYPES PROP",pname,p.rec
if not p.create(allow_nodeprops=True):
self.errors.extend(p.errors)
self.errors.extend(["FAILED TO CREATE PROPERTY:", json.dumps(p.rec)])
for dp in done_props:
# We failed to create a property so fail the entire entity creation.
try:
dp.delete()
except Exception, e:
self.errors.extend(["Could not destroy link"] + traceback.format_exc().split("\n"))
# Now let's delete our node
self.delete()
self.errors.append("Destroying node '%s' " % (rec.get("guid")))
return False
def features(seqID, sequence):
parameters = ""
seq = sequence.replace("X", "").replace("*", "").upper()
X = ProtParam.ProteinAnalysis(seq)
count = X.count_amino_acids()
parameters = parameters + str(len(sequence)) + ","
percent = X.get_amino_acids_percent()
parameters=parameters+str(percent["A"])+","+str(percent["C"])+","+str(percent["D"])+","+str(percent["E"])+","+str(percent["F"])\
+","+str(percent["G"])+","+str(percent["H"])+","+str(percent["I"])+","+str(percent["K"])+","+str(percent["L"])+","+str(percent["M"])\
+","+str(percent["N"])+","+str(percent["P"])+","+str(percent["Q"])+","+str(percent["R"])+","+str(percent["S"])+","+str(percent["T"])\
+","+str(percent["V"])+","+str(percent["W"])+","+str(percent["Y"])+","
parameters = parameters + str(X.molecular_weight()) + ","
parameters = parameters + str(X.aromaticity()) + ","
parameters = parameters + str(X.instability_index()) + ","
parameters = parameters + str(X.isoelectric_point()) + ","
parameters = parameters + str(X.gravy()) + ","
parameters = parameters + str(
X.secondary_structure_fraction()[0]) + "," + str(
X.secondary_structure_fraction()[1]) + "," + str(
X.secondary_structure_fraction()[2]) + ","
parameters = parameters + str(X.molecular_weight() / len(seq)) + ","
#-----------------------PEPSTATS-------------------------------
inFileName = seqID.replace("|", "_").replace(":", "_") + "_" + hashlib.md5(
time.asctime()).hexdigest()
inFasta = open(inFileName, "w")
inFasta.write(">" + seqID.replace("|", "_") + "\n" + seq + "\n")
inFasta.close()
parameters = parameters + pepstat(inFileName) + ","
tiny = count["A"] + count["C"] + count["G"] + count["S"] + count["T"]
tiny_per = round(((float(tiny) / len(seq)) * 100), 3)
parameters = parameters + str(tiny_per) + ","
small = count["A"] + count["C"] + count["D"] + count["G"] + count[
"N"] + count["P"] + count["S"] + count["T"] + count["V"]
small_per = round(((float(small) / len(seq)) * 100), 3)
parameters = parameters + str(small_per) + ","
aliphatic = count["I"] + count["L"] + count["V"]
aliphatic_per = round(((float(aliphatic) / len(seq)) * 100), 3)
parameters = parameters + str(aliphatic_per) + ","
aromatic = count["F"] + count["H"] + count["W"] + count["Y"]
aromatic_per = round(((float(aromatic) / len(seq)) * 100), 3)
parameters = parameters + str(aromatic_per) + ","
polar = count["D"] + count["E"] + count["H"] + count["K"] + count[
"N"] + count["Q"] + count["R"] + count["S"] + count["T"]
polar_per = round(((float(polar) / len(seq)) * 100), 3)
parameters = parameters + str(polar_per) + ","
nonPolar = count["A"] + count["C"] + count["F"] + count["G"] + count[
"I"] + count["L"] + count["M"] + count["P"] + count["V"] + count[
"W"] + count["Y"]
nonPolar_per = round(((float(nonPolar) / len(seq)) * 100), 3)
parameters = parameters + str(nonPolar_per) + ","
charged = count["D"] + count["E"] + count["H"] + count["K"] + count["R"]
charged_per = round(((float(charged) / len(seq)) * 100), 3)
parameters = parameters + str(charged_per) + ","
acidic = count["D"] + count["E"]
acidic_per = round(((float(acidic) / len(seq)) * 100), 3)
parameters = parameters + str(acidic_per) + ","
basic = count["H"] + count["K"] + count["R"]
basic_per = round(((float(basic) / len(seq)) * 100), 3)
parameters = parameters + str(basic_per) + ","
#------------------------GARNIER--------------------------------
parameters = parameters + garnier(inFileName) + ","
#--------------------------NetCGlyc--------------------------------
parameters = parameters + netcglyc(inFileName) + ","
#--------------------------NetChop--------------------------------
parameters = parameters + netchop(inFileName) + ","
#--------------------------NetNGlyc--------------------------------
parameters = parameters + netnglyc(inFileName) + ","
#--------------------------NetPhos--------------------------------
parameters = parameters + netphos(inFileName) + ","
#--------------------------TMHMM----------------------------------
parameters = parameters + tmhmm(inFileName) + ","
#--------------------------ProP----------------------------------
parameters = parameters + prop(inFileName) + ","
#--------------------------SignalP----------------------------------
parameters = parameters + signalp(inFileName)
os.remove(inFileName)
return parameters
