def api_status():
try:
from scorpion.util import Status
rid = int(request.args.get('requestid'))
status = Status(rid)
ret = status.latest_status()
label_rules = status.get_rules()
status.close()
partial_rules = []
for label, rules in label_rules:
partial_rules.extend(rules)
rules_hash = hash(str(partial_rules))
return {
'status': ret,
'results': partial_rules,
'hash': rules_hash
}
except Exception as e:
return {
'status': str(e),
'results': []
}
def requestid():
try:
from scorpion.util import Status
status = Status()
requestid = status.reqid
status.close()
return {'requestid': requestid}
except Exception as e:
return {'error': str(e)}
def requestid(request):
if not has_scorpion():
return {'error': "Scorpion not installed"}
from scorpion.util import Status
status = Status()
requestid = status.reqid
status.close()
print "requestid", requestid
return {'requestid': requestid}
def requestid(request):
if not has_scorpion():
return {'error': "Scorpion not installed"}
from scorpion.util import Status
status = Status()
requestid = status.reqid
status.close()
print "requestid", requestid
return {'requestid': requestid}
def api_status(request):
if not has_scorpion():
return {'error': "Scorpion not installed"}
from scorpion.util import Status
rid = int(request.GET.get('requestid'))
status = Status(rid)
ret = status.latest_status()
label_rules = status.get_rules()
status.close()
partial_rules = []
for label, rules in label_rules:
partial_rules.extend(rules)
rules_hash = hash(str(partial_rules))
return {'status': ret, 'results': partial_rules, 'hash': rules_hash}
def api_status(request):
if not has_scorpion():
return {"error": "Scorpion not installed"}
from scorpion.util import Status
rid = int(request.GET.get("requestid"))
status = Status(rid)
ret = status.latest_status()
label_rules = status.get_rules()
status.close()
partial_rules = []
for label, rules in label_rules:
partial_rules.extend(rules)
rules_hash = hash(str(partial_rules))
return {"status": ret, "results": partial_rules, "hash": rules_hash}
def scorpion(request):
if not has_scorpion():
print >>sys.stderr, "Could not load scorpionutil. Maybe scorpion has not been installed?"
return {'status': "error: could not load scorpion"}
try:
data = json.loads(str(request.GET.get('json')))
username = request.GET.get('username')
fake = request.GET.get('fake', False)
requestid = request.GET.get('requestid')
if not fake or fake == 'false':
import core.db.backend.pg as pg
qjson = data.get('query', {})
repo = qjson['db']
qjson['db'] = username
qjson['table'] = "%s.%s" % (repo, qjson['table'])
tablename = qjson['table']
host = pg.host
port = pg.port
dburl = "postgresql://%s@%s:%s/%s" % (username,host, port, username)
engine = create_engine(dburl)
db = engine.connect()
import scorpionutil
try:
results = scorpionutil.scorpion_run(db, data, requestid)
return results
except:
traceback.print_exc()
return {}
finally:
try:
db.close()
except:
pass
try:
engine.dispose()
except:
pass
except:
traceback.print_exc()
return {}
ret = {}
results = [
{
'score': 0.2,
'c_range': [0, 1],
'count': 100,
'clauses': [
{'col': 'sensor', 'type': 'str', 'vals': map(str, [18])}
],
'alt_rules': [
[ {'col': 'humidity', 'type': 'num', 'vals': [0, 1.4]}]
]
},
{
'score': 0.2,
'c_range': [0, 1],
'count': 100,
'clauses': [
{'col': 'voltage', 'type': 'num', 'vals': [0, 2.15]},
{'col': 'sensor', 'type': 'str', 'vals': ['18']}
],
'alt_rules': [
[ {'col': 'humidity', 'type': 'num', 'vals': [0, 1.4]},
{'col': 'humidity', 'type': 'num', 'vals': [0, 1.4]} ],
[ {'col': 'humidity', 'type': 'num', 'vals': [0, 1.4]},
{'col': 'humidity', 'type': 'num', 'vals': [0, 1.4]} ]
]
}
]
top_k = [
{
'c': 0,
'score': 0.2,
'c_range': [0, 0],
'count': 100,
'clauses': [
{'col': 'sensor', 'type': 'str', 'vals': map(str, [18])}
]
},
{
'c': 0,
'score': 0.2,
'c_range': [0, 0],
'count': 100,
'clauses': [
{'col': 'voltage', 'type': 'num', 'vals': [0, 2.15]},
{'col': 'sensor', 'type': 'str', 'vals': ['18']}
]
},
{
'c': 0.5,
'score': 0.2,
'c_range': [0.5, .5],
'count': 100,
'clauses': [
{'col': 'sensor', 'type': 'str', 'vals': map(str, [18, 15])}
]
},
{
'c': 0.5,
'score': 0.2,
'c_range': [0.5, .5],
'count': 100,
'clauses': [
{'col': 'voltage', 'type': 'num', 'vals': [-5, 2.5]},
{'col': 'sensor', 'type': 'str', 'vals': ['18', '15']}
]
},
{
'c': 1.0,
'score': 0.2,
'c_range': [1.0, 1.0],
'count': 100,
'clauses': [
{'col': 'sensor', 'type': 'str', 'vals': map(str, [18, 30, 35])}
]
},
{
'c': 1.0,
'score': 0.2,
'c_range': [1.0, 1.0],
'count': 100,
'clauses': [
{'col': 'humidity', 'type': 'num', 'vals': [-100, 40]},
{'col': 'sensor', 'type': 'str', 'vals': ['18', '19']}
]
}
]
from scorpion.util import Status
status = Status(requestid)
status.update_rules('label', results)
status.close()
time.sleep(1)
ret['results'] = results
ret['top_k_results'] = top_k
return ret
def scorpion(request):
if not has_scorpion():
print >> sys.stderr, "Could not load scorpionutil. Maybe scorpion has not been installed?"
return {'status': "error: could not load scorpion"}
try:
data = json.loads(str(request.GET.get('json')))
username = request.GET.get('username')
fake = request.GET.get('fake', False)
requestid = request.GET.get('requestid')
if not fake or fake == 'false':
import core.db.backend.pg as pg
qjson = data.get('query', {})
repo = qjson['db']
qjson['db'] = username
qjson['table'] = "%s.%s" % (repo, qjson['table'])
tablename = qjson['table']
host = pg.host
port = pg.port
dburl = "postgresql://%s@%s:%s/%s" % (username, host, port,
username)
engine = create_engine(dburl)
db = engine.connect()
import scorpionutil
try:
results = scorpionutil.scorpion_run(db, data, requestid)
return results
except:
traceback.print_exc()
return {}
finally:
try:
db.close()
except:
pass
try:
engine.dispose()
except:
pass
except:
traceback.print_exc()
return {}
ret = {}
results = [{
'score':
0.2,
'c_range': [0, 1],
'count':
100,
'clauses': [{
'col': 'sensor',
'type': 'str',
'vals': map(str, [18])
}],
'alt_rules': [[{
'col': 'humidity',
'type': 'num',
'vals': [0, 1.4]
}]]
}, {
'score':
0.2,
'c_range': [0, 1],
'count':
100,
'clauses': [{
'col': 'voltage',
'type': 'num',
'vals': [0, 2.15]
}, {
'col': 'sensor',
'type': 'str',
'vals': ['18']
}],
'alt_rules': [[{
'col': 'humidity',
'type': 'num',
'vals': [0, 1.4]
}, {
'col': 'humidity',
'type': 'num',
'vals': [0, 1.4]
}],
[{
'col': 'humidity',
'type': 'num',
'vals': [0, 1.4]
}, {
'col': 'humidity',
'type': 'num',
'vals': [0, 1.4]
}]]
}]
top_k = [{
'c':
0,
'score':
0.2,
'c_range': [0, 0],
'count':
100,
'clauses': [{
'col': 'sensor',
'type': 'str',
'vals': map(str, [18])
}]
}, {
'c':
0,
'score':
0.2,
'c_range': [0, 0],
'count':
100,
'clauses': [{
'col': 'voltage',
'type': 'num',
'vals': [0, 2.15]
}, {
'col': 'sensor',
'type': 'str',
'vals': ['18']
}]
}, {
'c':
0.5,
'score':
0.2,
'c_range': [0.5, .5],
'count':
100,
'clauses': [{
'col': 'sensor',
'type': 'str',
'vals': map(str, [18, 15])
}]
}, {
'c':
0.5,
'score':
0.2,
'c_range': [0.5, .5],
'count':
100,
'clauses': [{
'col': 'voltage',
'type': 'num',
'vals': [-5, 2.5]
}, {
'col': 'sensor',
'type': 'str',
'vals': ['18', '15']
}]
}, {
'c':
1.0,
'score':
0.2,
'c_range': [1.0, 1.0],
'count':
100,
'clauses': [{
'col': 'sensor',
'type': 'str',
'vals': map(str, [18, 30, 35])
}]
}, {
'c':
1.0,
'score':
0.2,
'c_range': [1.0, 1.0],
'count':
100,
'clauses': [{
'col': 'humidity',
'type': 'num',
'vals': [-100, 40]
}, {
'col': 'sensor',
'type': 'str',
'vals': ['18', '19']
}]
}]
from scorpion.util import Status
status = Status(requestid)
status.update_rules('label', results)
status.close()
time.sleep(1)
ret['results'] = results
ret['top_k_results'] = top_k
return ret
def scorpion():
try:
import scorpionutil
except:
print >>sys.stderr, "Could not load scorpionutil. Maybe scorpion has not been installed?"
traceback.print_exc()
return {}
try:
data = json.loads(str(request.form['json']))
fake = request.form.get('fake', False)
requestid = request.form.get('requestid')
if not fake or fake == 'false':
results = scorpionutil.scorpion_run(g.db, data, requestid)
return results
except:
return {}
ret = {}
results = [
{
'score': 0.2,
'c_range': [0, 1],
'count': 100,
'clauses': [
{'col': 'sensor', 'type': 'str', 'vals': map(str, [18])}
],
'alt_rules': [
[ {'col': 'humidity', 'type': 'num', 'vals': [0, 1.4]}]
]
},
{
'score': 0.2,
'c_range': [0, 1],
'count': 100,
'clauses': [
{'col': 'voltage', 'type': 'num', 'vals': [0, 2.15]},
{'col': 'sensor', 'type': 'str', 'vals': ['18']}
],
'alt_rules': [
[ {'col': 'humidity', 'type': 'num', 'vals': [0, 1.4]},
{'col': 'humidity', 'type': 'num', 'vals': [0, 1.4]} ],
[ {'col': 'humidity', 'type': 'num', 'vals': [0, 1.4]},
{'col': 'humidity', 'type': 'num', 'vals': [0, 1.4]} ]
]
}
]
top_k = [
{
'c': 0,
'score': 0.2,
'c_range': [0, 0],
'count': 100,
'clauses': [
{'col': 'sensor', 'type': 'str', 'vals': map(str, [18])}
]
},
{
'c': 0,
'score': 0.2,
'c_range': [0, 0],
'count': 100,
'clauses': [
{'col': 'voltage', 'type': 'num', 'vals': [0, 2.15]},
{'col': 'sensor', 'type': 'str', 'vals': ['18']}
]
},
{
'c': 0.5,
'score': 0.2,
'c_range': [0.5, .5],
'count': 100,
'clauses': [
{'col': 'sensor', 'type': 'str', 'vals': map(str, [18, 15])}
]
},
{
'c': 0.5,
'score': 0.2,
'c_range': [0.5, .5],
'count': 100,
'clauses': [
{'col': 'voltage', 'type': 'num', 'vals': [-5, 2.5]},
{'col': 'sensor', 'type': 'str', 'vals': ['18', '15']}
]
},
{
'c': 1.0,
'score': 0.2,
'c_range': [1.0, 1.0],
'count': 100,
'clauses': [
{'col': 'sensor', 'type': 'str', 'vals': map(str, [18, 30, 35])}
]
},
{
'c': 1.0,
'score': 0.2,
'c_range': [1.0, 1.0],
'count': 100,
'clauses': [
{'col': 'humidity', 'type': 'num', 'vals': [-100, 40]},
{'col': 'sensor', 'type': 'str', 'vals': ['18', '19']}
]
}
]
from scorpion.util import Status
status = Status(requestid)
status.update_rules('label', results)
status.close()
time.sleep(1)
ret['results'] = results
ret['top_k_results'] = top_k
return ret
def scorpion(request):
if not has_scorpion():
print >> sys.stderr, "Could not load scorpionutil. Maybe scorpion has not been installed?"
return {"status": "error: could not load scorpion"}
try:
data = json.loads(str(request.GET.get("json")))
username = request.GET.get("username")
fake = request.GET.get("fake", False)
requestid = request.GET.get("requestid")
if not fake or fake == "false":
import core.db.backend.pg as pg
qjson = data.get("query", {})
repo = qjson["db"]
qjson["db"] = username
qjson["table"] = "%s.%s" % (repo, qjson["table"])
tablename = qjson["table"]
host = pg.host
port = pg.port
dburl = "postgresql://%s@%s:%s/%s" % (username, host, port, username)
engine = create_engine(dburl)
db = engine.connect()
import scorpionutil
try:
results = scorpionutil.scorpion_run(db, data, requestid)
return results
except:
traceback.print_exc()
return {}
finally:
try:
db.close()
except:
pass
try:
engine.dispose()
except:
pass
except:
traceback.print_exc()
return {}
ret = {}
results = [
{
"score": 0.2,
"c_range": [0, 1],
"count": 100,
"clauses": [{"col": "sensor", "type": "str", "vals": map(str, [18])}],
"alt_rules": [[{"col": "humidity", "type": "num", "vals": [0, 1.4]}]],
},
{
"score": 0.2,
"c_range": [0, 1],
"count": 100,
"clauses": [
{"col": "voltage", "type": "num", "vals": [0, 2.15]},
{"col": "sensor", "type": "str", "vals": ["18"]},
],
"alt_rules": [
[
{"col": "humidity", "type": "num", "vals": [0, 1.4]},
{"col": "humidity", "type": "num", "vals": [0, 1.4]},
],
[
{"col": "humidity", "type": "num", "vals": [0, 1.4]},
{"col": "humidity", "type": "num", "vals": [0, 1.4]},
],
],
},
]
top_k = [
{
"c": 0,
"score": 0.2,
"c_range": [0, 0],
"count": 100,
"clauses": [{"col": "sensor", "type": "str", "vals": map(str, [18])}],
},
{
"c": 0,
"score": 0.2,
"c_range": [0, 0],
"count": 100,
"clauses": [
{"col": "voltage", "type": "num", "vals": [0, 2.15]},
{"col": "sensor", "type": "str", "vals": ["18"]},
],
},
{
"c": 0.5,
"score": 0.2,
"c_range": [0.5, 0.5],
"count": 100,
"clauses": [{"col": "sensor", "type": "str", "vals": map(str, [18, 15])}],
},
{
"c": 0.5,
"score": 0.2,
"c_range": [0.5, 0.5],
"count": 100,
"clauses": [
{"col": "voltage", "type": "num", "vals": [-5, 2.5]},
{"col": "sensor", "type": "str", "vals": ["18", "15"]},
],
},
{
"c": 1.0,
"score": 0.2,
"c_range": [1.0, 1.0],
"count": 100,
"clauses": [{"col": "sensor", "type": "str", "vals": map(str, [18, 30, 35])}],
},
{
"c": 1.0,
"score": 0.2,
"c_range": [1.0, 1.0],
"count": 100,
"clauses": [
{"col": "humidity", "type": "num", "vals": [-100, 40]},
{"col": "sensor", "type": "str", "vals": ["18", "19"]},
],
},
]
from scorpion.util import Status
status = Status(requestid)
status.update_rules("label", results)
status.close()
time.sleep(1)
ret["results"] = results
ret["top_k_results"] = top_k
return ret
