def index():
form = InputForm(request.form)
if request.method == 'POST' and form.validate():
arg_names = inspect.getargspec(compute).args
kwargs = {name: getattr(form, name).data
for name in arg_names if hasattr(form, name)}
# Run eval on the text
# Note that form.name.label is <label for="A">(list)</label>
for name in kwargs:
if hasattr(form, name) and \
hasattr(getattr(form, name), 'label'):
label = str(getattr(form, name).label)
for tp in ('(list)', '(tuple)', '(nd.array)'):
if tp in label:
kwargs[name] = eval(kwargs[name])
result = compute(**kwargs)
else:
result = None
# Concatenate view_forms.html and view_results.html
result_render = None
if result:
result_render = render_template('view_results.html', result=result)
return render_template('view_forms.html',
form=form, result=result_render)
def main():
a = random.randint(1, 20)
if a < 5:
b = random.randint(1, 50)
c = random.randint(1, 50)
C = compute(b, c)
d = C.add()
result = "%d + %d" % (b, c)
return (result, d)
if a >= 5 and a < 10:
b = random.randint(1, 50)
c = random.randint(b, 100)
C = compute(c, b)
d = C.sub()
result = "%d - %d" % (c, b)
return (result, d)
if a >= 10 and a < 15:
b = random.randint(1, 20)
c = random.randint(1, 5)
C = compute(c, b)
d = C.mul()
result = "%d * %d" % (c, b)
return (result, d)
else:
b = random.randint(1, 9)
c = random.randint(1, 9)
C = compute(c, b)
d = C.mul()
result = "%d / %d" % (d, b)
return (result, c)
def setData():
arg1 = var1.get()
arg2 = var2.get()
arg3 = var3.get()
arg4 = var4.get()
cp.compute(arg1, arg2, arg3, arg4)
tkinter.messagebox.showinfo(
"Result", "The given example belongs to " + cp.maxsp.upper())
def index():
form = InputForm(request.form)
if request.method == 'POST' and form.validate():
result = compute(form.STOCK_NAME.data)
else:
result = compute('AAPL')
return render_template('view.html', form=form, result=Markup(result))
def test_compute():
sequence = '3+6*2'
result = 15
assert(compute(sequence) == result)
sequence = '2*3+5/6*3+15'
result = 23.5
assert(compute(sequence) == result)
def run_compute(n, batch_size, max_compute):
count = 0
while True:
compute.compute()
count += 1
if count % batch_size == 0:
redis_client.incr(key, batch_size)
logging.info('[{}] Computed {} operations'.format(n, count))
if max_compute != 0 and count >= max_compute:
break
def test_decimal(self):
numsides = 1.5
error_occured = False
try:
Input.objects.create(Numsides=numsides)
compute(numsides)
except:
error_occured = True
self.assertTrue(error_occured)
def execute_query(query, socket):
# Do something here
def cbu(percentage):
socket.update_progress(percentage)
def cb(value):
cbu(100)
result = json.dumps({'type': 'result', 'value': value})
socket.write_message(result)
compute.compute(query, cb, cbu)
def test_alpha(self):
numsides = "xyz"
error_occured = False
try:
Input.objects.create(Numsides=numsides)
compute(numsides)
except:
error_occured = True
self.assertTrue(error_occured)
def test_negative(self):
#verify that the compute raises an exception for negative number
error_occured = False
numsides = -1
try:
Input.objects.create(Numsides=numsides)
print compute(numsides)
except:
error_occured = True
self.assertTrue(error_occured)
def index():
form = InputForm(request.form)
if request.method == 'POST' and form.validate():
arg_names = inspect.getargspec(compute).args
kwargs = {
name: getattr(form, name).data
for name in arg_names if hasattr(form, name)
}
# Run eval on the text
# Note that form.name.label is <label for="A">(list)</label>
for name in kwargs:
if hasattr(form, name) and \
hasattr(getattr(form, name), 'label'):
label = str(getattr(form, name).label)
for tp in ('(list)', '(tuple)', '(nd.array)'):
if tp in label:
kwargs[name] = eval(kwargs[name])
result = compute(**kwargs)
else:
result = None
# Concatenate view_forms.html and view_results.html
result_render = None
if result:
result_render = render_template('view_results.html', result=result)
return render_template('view_forms.html', form=form, result=result_render)
def index():
form = InputForm(request.form)
if request.method == "POST" and form.validate():
result = compute(form.A.data, form.b.data, form.w.data, form.T.data)
else:
result = None
return render_template("view.html", form=form, result=result)
def index():
form = InputForm(request.form)
if request.method == 'POST' and form.validate():
arg_names = inspect.getargspec(compute).args
kwargs = {
name: getattr(form, name).data
for name in arg_names if hasattr(form, name)
}
result = compute(**kwargs)
else:
result = None
# Concatenate view_forms.html and view_results.html
forms_html = os.path.join('templates', 'view_forms.html')
results_html = os.path.join('templates', 'view_results.html')
view_html = os.path.join('templates', 'view.html')
f_forms = open(forms_html, 'r')
f_res = open(results_html, 'r')
f_view = open(view_html, 'w')
f_view.write(f_forms.read() + f_res.read())
f_forms.close()
f_res.close()
f_view.close()
return render_template(os.path.basename(view_html),
form=form,
result=result)
def recompute_job(job, spec):
job['status'] = 'running'
code = compute(spec, data_dir)
print('job {} done with code:{}'.format(job['id'], code))
with jobs_lock:
job['status'] = 'done' if code == 0 else 'error'
job['code'] = code
def index():
form = InputForm(request.form)
if request.method == 'POST' and form.validate():
arg_names = inspect.getargspec(compute).args
kwargs = {
name: getattr(form, name).data
for name in arg_names if hasattr(form, name)
}
# Run eval on the text
# Note that form.name.label is <label for="A">(list)</label>
for name in kwargs:
if hasattr(form, name) and \
hasattr(getattr(form, name), 'label'):
label = str(getattr(form, name).label)
for tp in ('(list)', '(tuple)', '(nd.array)'):
if tp in label:
kwargs[name] = eval(kwargs[name])
result = compute(**kwargs)
else:
result = None
if result:
# result must be transformed to HTML and inserted as a
# string in the generic view.html file
result = render_template('view_results.html', result=result)
return render_template('view.html', form=form, result=result)
def new_entry():
probs = request.form.getlist('probs[]')
size = request.form['size']
functionLaw = request.form.getlist('functionLaw[]')
binsStart = request.form.getlist('binsStart[]')
binsEnd = request.form.getlist('binsEnd[]')
location = request.form['location']
species = request.form['species']
# print(functionLaw, size, probs, binsStart, binsEnd)
data = compute(functionLaw, size, probs, binsStart, binsEnd)
# print(functionLaw, size, probs, binsStart, binsEnd, location, species)
# year = random.randint(2010, 2019)
# month = random.randint(1, 11)
# day = random.randint(1, 28)
t = datetime.datetime.now()
# t = datetime.datetime(year, month, day)
s = t.strftime('%Y-%m-%d %H:%M:%S.%f')
dict = {"location": location, "species": species, "size": size, "binStart": binsStart, "binEnd": binsEnd,
"Probability": probs, "Models": functionLaw, "date": s[:-3]}
r = json.dumps(dict, indent=4, sort_keys=True, default=str)
loaded_r = json.loads(r)
# print(loaded_r)
if mongoflag:
mongo.db.data.insert_one(loaded_r)
loaded_r.pop('_id', None)
data["download"] = str(loaded_r)
return jsonify(data), 200
def test_handleslowest(self):
# verify that for n=1, results=1
numsides = 1
Input.objects.create(Numsides=numsides)
self.assertEqual(compute(numsides), 1)
def index():
form = InputForm(request.form)
if request.method == 'POST' and form.validate():
# if request.method == 'POST':
ticker = form.ticker.data
ticker = ticker.upper()
p1 = form.p1.data
p2 = form.p2.data
p3 = form.p3.data
p4 = form.p4.data
cols = []
if p1:
cols.append('close')
if p2:
cols.append('adj_close')
if p3:
cols.append('open')
if p4:
cols.append('adj_open')
s = True
s, js_resources, css_resources, script, div = compute(ticker, cols)
if s:
return render_template("view_output.html",
js_resources=js_resources,
css_resources=css_resources,
plot_script=script,
plot_div=div,
ticker=ticker)
else:
return render_template("view_error.html")
else:
return render_template("view_input.html", form=form)
def usingdata():
form = InputForm(request.form)
if request.method == 'POST' and form.validate():
result = compute(form.a.data, form.b.data,form.c.data, form.d.data,form.e.data,form.z.data,form.g.data,form.h.data,form.i.data)
else:
result = None
return render_template('usingdata.html', form=form, result=result)
def index():
form = InputForm(request.form)
if form.validate():
result = compute(form.A.data, form.b.data, form.w.data, form.T.data)
else:
result = None
return render_template('view.html', form=form, result=result)
def index():
form = InputForm(request.form)
if request.method == 'POST' and form.validate():
r = form.r.data
s = compute(r)
return render_template("view_output.html", form=form, s=s)
else:
return render_template("view_input.html", form=form)
def index():
form = InputForm(request.form)
if request.method == 'POST' and form.validate():
r = form.r.data
s = compute(r)
return render_template("view_output.html", form=form, s=s)
else:
return render_template("view_input.html", form=form)
def index():
form = InputForm(request.form) #form represents an instance of the InputForm
if form.validate():
result = compute(form.A.data, form.B.data) #Result holds the output image
else:
result = None
return render_template('view.html', form=form, result=result)
def index():
form = InputForm(request.form)
if request.method == 'POST' and form.validate():
result = compute(form.Formula.data, form.Domain.data, form.Erase.data)
else:
result = None
return render_template('view.html', form=form, result=result)
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
'-p',
'--package',
help='Run on selected package [auto-sklearn, h2o, mljar]',
required=True,
choices=['auto-sklearn', 'h2o', 'mljar'])
parser.add_argument('-d', '--dataset', help='Dataset id', required=True)
parser.add_argument('-s',
'--seed',
help='Seed for computation',
required=True,
type=int)
args = parser.parse_args()
compute(args.package, args.dataset, args.seed)
def index():
form = InputForm(request.form)
if request.method == 'POST' and form.validate():
result = compute(form.A.data, form.w.data, form.fi0.data)
else:
result = None
return render_template('view_plain.html', form=form, result=result)
def set_class(queue):
global class_data
for node in queue:
if not node.get('name'):
class_data.append(
base.Base(trace_id=node['trace_id'], level=node['level']))
elif node.get('name') == 'db':
class_data.append(
db.DB(node['project'], node['service'], node['level'],
node['trace_id'], node['parent_id'], node['starttime'],
node['time']))
elif node.get('name') == 'wsgi':
class_data.append(
wsgi.WSGI(node['project'], node['service'], node['level'],
node['trace_id'], node['parent_id'],
node['starttime'], node['time']))
elif node.get('name') == 'compute_api':
class_data.append(
compute.compute(node['project'], node['service'],
node['level'], node['trace_id'],
node['parent_id'], node['starttime'],
node['time']))
elif node.get('name') == 'rpc':
class_data.append(
rpc.RPC(node['project'], node['service'], node['level'],
node['trace_id'], node['parent_id'], node['starttime'],
node['time']))
elif node.get('name') == 'driver':
class_data.append(
driver.driver(node['project'], node['service'], node['level'],
node['trace_id'], node['parent_id'],
node['starttime'], node['time']))
elif node.get('name') == 'vif_driver':
class_data.append(
vif_driver.vif(node['project'], node['service'], node['level'],
node['trace_id'], node['parent_id'],
node['starttime'], node['time']))
elif node.get('name') == 'neutron_api':
class_data.append(
neutron.neutron(node['project'], node['service'],
node['level'], node['trace_id'],
node['parent_id'], node['starttime'],
node['time']))
elif node.get('name') == 'volume_api':
class_data.append(
volume.volume(node['project'], node['service'], node['level'],
node['trace_id'], node['parent_id'],
node['starttime'], node['time']))
elif node.get('name') == 'nova_image':
class_data.append(
nova.nova(node['project'], node['service'], node['level'],
node['trace_id'], node['parent_id'],
node['starttime'], node['time']))
else:
class_data.append(
stack.stack(node['project'], node['service'], node['level'],
node['trace_id'], node['parent_id'],
node['starttime'], node['time']))
def home():
# mapped = mapper()
form = InputForm(request.form)
if request.method == 'POST' and form.validate():
result = compute(form.A.data, form.b.data, form.w.data, form.T.data)
else:
result = None
return render_template("home.html", form=form, result=result)
def main():
""" 主函数
"""
# 语义理解部分，读取文本信息，提取条件和问题
cond_roman, cond_price, ques_roman, ques_price, unknown = load_file("task.txt")
# 逻辑运算部分，根据条件和问题，计算结果
answer_roman, answer_price = compute(cond_roman, cond_price, ques_roman, ques_price)
# 结果输出部分，按照规则描述进行输出
output("task.txt", answer_roman, answer_price, unknown)
def main():
tables = TableImporter()
writer = CSVWriter()
table = tables.get_table()
while table is not None:
writer.write(compute(table))
table = tables.get_table()
def index():
form = InputForm(request.form)
if request.method == "POST" and form.validate():
r = form.r.data
s = compute(r)
else:
s = None
return render_template("view.html", form=form, s=s)
def index():
form = InputForm(request.form)
if request.method == 'POST' and form.validate():
result = compute(form.A.data, form.b.data,
form.w.data, form.T.data)
else:
result = None
return render_template('view_plain.html', form=form, result=result)
def index():
form = InputForm(request.form)
if request.method == "POST" and form.validate():
quantity = form.quantity.data
wanted = request.form["wanted"]
conversion = compute(quantity, wanted)
return render_template("result.html", form=form, conversion=conversion, wanted=wanted)
else:
return render_template("conversion.html", form=form)
def get_new_tweet():
tweet = handle_request(request)
shorten = (not 'shorten' in request.json) or (request.json['shorten'])
links = (not 'links' in request.json) or (request.json['links'])
hashtags = (not 'hashtags' in request.json) or (request.json['hashtags'])
mentions = (not 'mentions' in request.json) or (request.json['mentions'])
return jsonify({'tweet' : compute.compute(tweet, shorten, links, hashtags, mentions)}), 201
def index():
form = InputForm(request.form)
if request.method == 'POST' and form.validate():
result = compute(form.Formula.data, form.Domain.data,
form.Erase.data)
else:
result = None
return render_template('view.html', form=form, result=result)
def live_record1(filters, filters_fq, time_res, amp_res, fs, last, formants, drc_tl, drc_th, drc_r, duration, adc_res, predict):
import pyaudio
# Durée de l'enregistrement
duration = 0.1
# Taille des blocs enregistrés
chunk_size = 4096
# Initialisation
plt.ion()
f, ax = plt.subplots(2, 1, figsize=(24, 12), dpi= 80, facecolor="w", edgecolor="k")
f.show()
# Initialisation
rfreqs = []
for i in range(len(filters_fq)):
rfreqs.append(filters_fq[i]["fc"])
# Ouverture du flux
p = pyaudio.PyAudio()
stream = p.open(format=pyaudio.paInt16, channels=1, rate=fs, input=True, frames_per_buffer=chunk_size)
# Boucle principale
try:
frames = np.array([])
while True:
# Enregistrement
for i in range(0, int(np.ceil(fs / chunk_size * duration))):
data = stream.read(chunk_size)
got = np.fromstring(data, dtype=np.int16)/32768
frames = np.concatenate([frames, got])
frames = frames[-int(np.ceil(fs * last)):]
# Traitement
ax[0].clear() ; ax[1].clear()
if len(frames) == 0:
continue
rsegs, _, rseqs = compute(file=frames, fs=fs, filters=filters, filters_fq=filters_fq, time_res=time_res, amp_res=amp_res, ax=ax, dbfs=False, drc_tl=drc_tl, drc_th=drc_th, drc_r=drc_r, adc_res=adc_res)
if len(formants) > 0:
plot_formants(np.array(formants, copy=True).tolist(), rfreqs, ax[1], rsegs)
# Prédiction
if predict:
f.suptitle(predict(rseqs, name=False, debug=False)[0], fontsize=30)
# Affichage
f.canvas.draw()
# Masque l'erreur en cas d'interruption du Kernel
except KeyboardInterrupt:
# Fermeture du flux
stream.stop_stream()
stream.close()
p.terminate()
clear_output()
plt.close()
print("Terminé !")
return
def main():
""" 主函数
"""
# 语义理解部分，读取文本信息，提取条件和问题
cond_roman, cond_price, ques_roman, ques_price, unknown = load_file(
"task.txt")
# 逻辑运算部分，根据条件和问题，计算结果
answer_roman, answer_price = compute(cond_roman, cond_price, ques_roman,
ques_price)
# 结果输出部分，按照规则描述进行输出
output("task.txt", answer_roman, answer_price, unknown)
def index():
form = InputForm(request.form)
if request.method == 'POST' and form.validate():
result = compute(form.A.data, form.B.data,
form.C.data, form.D.data,
form.E.data, form.F.data)
else:
result = None
#return render_template('view_errcheck.html', form=form, result=result)
return render_template('view_ttl.html', form=form, result=result)
def index():
form = InputForm(request.form)
if request.method == 'POST' and form.validate():
for field in form:
# Make local variable (name field.name)
exec('%s = %s' % (field.name, field.data))
result = compute(A, b, w, T)
else:
result = None
return render_template('view.html', form=form, result=result)
def index():
form = InputForm(request.form)
if request.method == 'POST' and form.validate():
for field in form:
# Make local variable (name field.name)
exec('%s = %s' % (field.name, field.data))
result = compute(A, b, w, T)
else:
result = None
return render_template(template, form=form, result=result)
def index():
# breast-cancer prediction
formbreastcancer = InputForm(request.form)
if request.method == 'POST' and formbreastcancer.validate():
result = compute(formbreastcancer.a.data, formbreastcancer.b.data,
formbreastcancer.c.data, formbreastcancer.d.data,
formbreastcancer.e.data, formbreastcancer.z.data,
formbreastcancer.g.data, formbreastcancer.h.data,
formbreastcancer.i.data)
else:
result = None
return render_template('index2.html', form=formbreastcancer, result=result)
def index():
form = InputForm(request.form)
if request.method == "POST" and form.validate():
arg_names = inspect.getargspec(compute).args
kwargs = {name: getattr(form, name).data for name in arg_names if hasattr(form, name)}
result = compute(**kwargs)
else:
result = None
if result:
# result must be transformed to HTML and inserted as a
# string in the generic view.html file
result = render_template("view_results.html", result=result)
return render_template("view.html", form=form, result=result)
def index(request):
os.chdir(os.path.dirname(__file__))
result = None
if request.method == "POST":
form = InputForm(request.POST)
if form.is_valid():
form2 = form.save(commit=False)
result = compute(form2.A, form2.b, form2.w, form2.T)
result = result.replace("static/", "")
else:
form = InputForm()
return render_to_response("vib1.html", {"form": form, "result": result}, context_instance=RequestContext(request))
def index(request):
s = None # initial value of result
if request.method == 'POST':
form = InputForm(request.POST)
if form.is_valid():
form = form.save(commit=False)
r = form.r
s = compute(r)
else:
form = InputForm()
return render(request, 'math_app/index.html',
{'form': form,
's': s if isinstance(s, float) else ''})
def index(request):
s = None # initial value of result
if request.method == 'POST':
form = InputForm(request.POST)
if form.is_valid():
form = form.save(commit=False)
r = form.r
s = compute(r)
else:
form = InputForm()
return render_to_response('hw2.html',
{'form': form,
's': '%.5f' % s if isinstance(s, float) else ''
}, context_instance=RequestContext(request))
def index():
form = InputForm(request.form)
if request.method == 'POST' and form.validate():
result = compute(form.A.data, form.b.data,
form.w.data, form.T.data)
else:
result = None
print form, dir(form)
#print form.keys()
for f in form:
print f.id
print f.name
print f.label
return render_template(template_name + '.html',
form=form, result=result)
def index(request):
os.chdir(os.path.dirname(__file__))
result = None
if request.method == 'POST':
form = InputForm(request.POST)
if form.is_valid():
form2 = form.save(commit=False)
result = compute(form2.A, form2.b, form2.w, form2.T)
result = result.replace('static/', '')
else:
form = InputForm()
return render_to_response('vib2.html',
{'form': form,
'result': result,
}, context_instance=RequestContext(request))
def index():
form = InputForm(request.form)
if request.method == 'POST' and form.validate():
result = compute(formula=form.Formula.data,
independent_variable=form.Variable.data,
N=form.N.data,
xmin=form.xmin.data,
xmax=form.xmax.data,
ymin=form.ymin.data,
ymax=form.ymax.data,
legend_loc=form.legend_loc.data,
x0=form.x0.data,
erase=form.Erase.data)
else:
result = None
print request.method, [field.errors for field in form]
return render_template('view.html', form=form, result=result)
def index():
form = InputForm(request.form)
if request.method == 'POST' and form.validate():
arg_names = inspect.getargspec(compute).args
kwargs = {name: getattr(form, name).data
for name in arg_names if hasattr(form, name)}
result = compute(**kwargs)
else:
result = None
# Concatenate view_forms.html and view_results.html
forms_html = os.path.join('templates', 'view_forms.html')
results_html = os.path.join('templates', 'view_results.html')
view_html = os.path.join('templates', 'view.html')
f_forms = open(forms_html, 'r')
f_res = open(results_html, 'r')
f_view = open(view_html, 'w')
f_view.write(f_forms.read() + f_res.read())
f_forms.close(); f_res.close(); f_view.close()
return render_template(os.path.basename(view_html),
form=form, result=result)
def index():
form = InputForm(request.form)
if request.method == 'POST' and form.validate():
arg_names = inspect.getargspec(compute).args
kwargs = {name: getattr(form, name).data
for name in arg_names if hasattr(form, name)}
# Run eval on the text
# Note that form.name.label is <label for="A">(list)</label>
for name in kwargs:
if hasattr(form, name) and \
hasattr(getattr(form, name), 'label'):
label = str(getattr(form, name).label)
for tp in ('(list)', '(tuple)', '(nd.array)'):
if tp in label:
kwargs[name] = eval(kwargs[name])
result = compute(**kwargs)
else:
result = None
if result:
# result must be transformed to HTML and inserted as a
# string in the generic view.html file
result = render_template('view_results.html', result=result)
return render_template('view.html', form=form, result=result)
def present_output(form):
r = form.r
s = compute(r)
return HttpResponse('Hello, World! sin(%s)=%s' % (r, s))
def main():
if sys.argv[1:]:
input_file = sys.argv[1]
else:
input_file = "Data_name_convention.csv"
dirname = os.path.abspath(os.path.dirname(__file__))
data_path = os.path.join(dirname, "..", "Data")
bin_path = os.path.join(dirname, "..", "bin")
results_path = os.path.join(dirname, "..", "Data", "results")
col_map = {}
reader = csv.DictReader(open(input_file))
results = {"Hanoi":{}, "Randstad":{}}
csvs = {"Hanoi":{}, "Randstad":{}}
for row in reader:
area = row['Area']
Type = row['Type']
scenario = row['Scenario']
network_csv = row['Network csv']
job_csv = row['Job csv']
alpha = float(row['alpha'])
Tmax = float(row['Tmax'])
update_module = row['Update script'].replace(".py","")
access_alpha = row['access_alpha']
access_beta = row['access_beta']
run = row['Run']
layername = row['Layername']
csvs[area][scenario] = (network_csv, job_csv)
if area not in ["Hanoi", "Randstad"]:
raise Exception("Unrecognized zone %s"%area)
if scenario == "0" and update_module != "":
raise Exception("scenario must be non-scenario by convention! No update script allowed")
if run != "x" or access_alpha == "":
print "Skipping %s,%s scenario %s, alpha=%s, Tmax=%s"%(area, Type, scenario, alpha, Tmax)
continue
db_file = os.path.join(results_path,
"%s_%s_%s.sqlite"%(area, Type, scenario))
db_file_0 = os.path.join(results_path,
"%s_%s_%s.sqlite"%(area, Type, "0"))
# load network and job into database
# if None of the files exists:
network_csv = os.path.join(data_path, area, "source", network_csv)
job_csv = os.path.join(data_path, area, "source", job_csv)
if not os.path.exists(network_csv):
raise Exception("missing network_csv %s"%network_csv)
if not os.path.exists(job_csv):
raise Exception("missing job_csv %s"%job_csv)
# if db_file not exists, then try to create it
if not os.path.exists(db_file):
# if db_file_0 exists and scenario 0 use the same csvs
if ( scenario != "0" and os.path.exists(db_file_0)
and csvs[area].has_key("0")
and csvs[area]["0"] == csvs[area][scenario]
):
shutil.copyfile(db_file_0, db_file)
# load a fresh db
else:
if area == "Hanoi":
print "loading %s, %s"%(network_csv, job_csv)
import load_hanoi
load_hanoi.load(db_file, network_csv, job_csv)
else:
import load_randstad
load_randstad.load(db_file, network_csv)
# add columns and constants table
conn = sqlite3.connect(db_file)
conn.executescript(open("add_columns.sql").read())
conn.commit()
# clone db_file from db_file_0
# update according to scenario if needed
if scenario != "0" and update_module !="":
updater = __import__(update_module)
updater.update(db_file)
# compute stuff
# update parameters
conn = sqlite3.connect(db_file)
conn.execute("UPDATE constants SET c_val = %f WHERE c_key in ('alpha','beta')"
%alpha)
conn.execute("UPDATE constants SET c_val = %f WHERE c_key in ('Tmax')"
%Tmax)
conn.commit()
compute.compute(db_file)
# memory_result
cursor = conn.cursor()
if "com_id" not in results[area].keys():
results[area]["com_id"] = []
cursor.execute("SELECT com_id FROM communes ORDER BY com_id")
for row in cursor:
results[area]["com_id"].append(int(row[0]))
if area == "Randstad" and "WK_CODE" not in results[area].keys():
results[area]["WK_CODE"] = []
cursor.execute("SELECT WK_CODE FROM communes ORDER BY com_id")
for row in cursor:
results[area]["WK_CODE"].append(row[0])
if area == "Hanoi" and "ID_4" not in results[area].keys():
results[area]["ID_4"] = []
cursor.execute("SELECT ID_4 FROM communes ORDER BY com_id")
for row in cursor:
results[area]["ID_4"].append(int(row[0]))
results[area][access_alpha] = []
results[area][access_beta] = []
cursor.execute("SELECT accessibility_alpha, accessibility_beta FROM communes ORDER BY com_id")
for row in cursor:
results[area][access_alpha].append(int(row[0]))
results[area][access_beta].append(int(row[1]))
print "Finished %s,%s scenario %s, alpha=%s, Tmax=%s"%(area, Type, scenario, alpha, Tmax)
print "Updating to %s"%layername
import arcpy
if area == "Hanoi":
index_dict = {}
for i,com_id in enumerate(results['Hanoi']['com_id']):
id4 = results['Hanoi']['ID_4'][i]
index_dict[id4] = i
rows = arcpy.UpdateCursor(layername)
for row in rows:
id4 = row.ID_4
idx = index_dict[id4]
exec("row.%s = results['Hanoi']['%s'][%d]"%(access_alpha,
access_alpha,
idx
))
exec("row.%s = results['Hanoi']['%s'][%d]"%(access_beta,
access_beta,
idx
))
rows.updateRow(row)
elif area == "Randstad":
index_dict = {}
for i,com_id in enumerate(results['Randstad']['com_id']):
wkcode = results['Randstad']['WK_CODE'][i]
index_dict[wkcode] = i
rows = arcpy.UpdateCursor(layername)
for row in rows:
wkcode = row.WK_CODE
idx = index_dict[wkcode]
exec("row.%s = results['Randstad']['%s'][%d]"%(access_alpha,
access_alpha,
idx
))
exec("row.%s = results['Randstad']['%s'][%d]"%(access_beta,
access_beta,
idx
))
rows.updateRow(row)
# output to csv
for an_area in ("Hanoi", "Randstad"):
rs = results[an_area]
keys = sorted(rs.keys())
if len(keys) == 0:
continue
csv_file = os.path.join(results_path, "%s.csv"%an_area)
f = open(csv_file, 'w')
writer = csv.writer(f)
writer.writerow(keys)
writer = csv.DictWriter(f, keys)
for i, com_id in enumerate(rs['com_id']):
row = {}
for key in keys:
row[key] = rs[key][i]
writer.writerow(row)
f.close()
#!/usr/bin/env python
import sys
import compute
if len(sys.argv) != 2:
exit("Usage: compute_it.py <expression>")
if 'C' in compute.VALID_DNA:
print "C is a base"
if 'D' in compute.VALID_DNA:
print "D is a base"
else:
print "D is not a base"
compute.hello()
print compute.compute(sys.argv[1])
def run(self):
compute(self.n)
def output(): conversion = compute.compute(quantity) print conversion
def present_output(r): """Write results to terminal window""" s = compute.compute(r) print "Hello, World! sin(%g)=%g" % (r,s)
