def run(select, verbose, wait_time=0.0, amount=100):
global f, s
# clear_fcfs() # clear (previous) FCFS select results
# clear_sjf() # clear (previous) SJF select results
if select != "none":
prepare(select, amount)
if select.lower() == "fcfs":
w = load(select)
f = fcfs(w, wait_time, verbose)
elif select.lower() == "sjf":
w = load(select)
s = sjf(w, wait_time, verbose)
elif select.lower() == "both":
w = load(select)
f = fcfs(w, wait_time, verbose)
w = load(select)
s = sjf(w, wait_time, verbose)
elif select.lower() == "none":
pass
else:
exit(1)
return [f, s]
def start_offline(dataset):
#sys.path.append(envpath)
os.chdir(envpath)
import prepare
prepare.prepare(dataset)
import train
train.train(dataset)
def load_data(configuration_path, DATA_ID):
configuration = io.load_yml(configuration_path, DATA_ID)
try:
data = io.load_pickle(configuration['pkl_file'])
except:
prepare.prepare(DATA_ID, configuration_path)
data = io.load_pickle(configuration['pkl_file'])
return data
def load_data(cfg_path, DATA_ID):
cfg = io.load_yml(cfg_path, DATA_ID)
try:
data = io.load_pickle(cfg['pkl_file'])
except:
prepare.prepare(DATA_ID, cfg['pkl_file'])
data = io.load_pickle(cfg['pkl_file'])
return data
def main(_):
config = flags.FLAGS
if config.mode == "prepare":
prepare(config)
elif config.mode == "test":
test(config)
elif config.mode == "train":
train(config)
else:
print("Unknown mode")
exit(0)
def train(fold, model, last):
# read the training data with folds
df = pd.read_csv(config.TRAIN_FILE)
if last:
# train on whole dataset
x_train = df.drop([config.TARGET_LABEL, "FOLD"], axis=1)
y_train = df[config.TARGET_LABEL]
else:
# training data is where kfold is not equal to provided fold
df_train = df[df["FOLD"] != fold].reset_index(drop=True)
# validation data is where kfold is equal to provided fold
df_valid = df[df["FOLD"] == fold].reset_index(drop=True)
# create training samples
x_train = df_train.drop([config.TARGET_LABEL, "FOLD"], axis=1)
y_train = df_train[config.TARGET_LABEL]
# create validation samples
x_valid = df_valid.drop([config.TARGET_LABEL, "FOLD"], axis=1)
y_valid = df_valid[config.TARGET_LABEL]
# perform cleaning, feature engineering,
# categorical variables encoding & scaling
x_train = prepare(x_train)
# fetch the model from models
clf = models[model]
# fit the model on training data
clf.fit(x_train, y_train)
if not last:
# calculate & print metric
predictions = clf.predict(prepare(x_valid))
scorer = metrics.get_scorer(config.METRIC)
metric = scorer._score_func(y_valid, predictions)
print(f"Fold={fold}, {config.METRIC}={metric}")
model_path = f"{model}.bin" if last else f"{model}_fold{fold}.bin"
# save the model
joblib.dump(clf, os.path.join(config.MODEL_OUTPUT, model_path))
if last:
print("Last model saved at: " + model_path)
def main():
collection = prepare()
collection.insert_many([{'_id': i} for i in range(7)])
search_condictions = {
'collection': collection,
'filter': {},
'sort': [('_id', 1)],
'limit': 5,
}
# gets the first page
cursor1 = get_keyset_cursor(**search_condictions)
print('page1:', list(cursor1)) # [{'_id': 0}, {'_id': 1}, {'_id': 2}, {'_id': 3}, {'_id': 4}]
# gets the second page
cursor2 = get_keyset_cursor(**search_condictions, position=cursor1.paging.next_position)
print('page2:', list(cursor2)) # [{'_id': 5}, {'_id': 6}]
collection.insert({'_id': -1})
# the first page again, backwards from the previous page
cursor1 = get_keyset_cursor(**search_condictions, position=cursor2.paging.previous_position)
print('page1:', list(cursor1)) # [{'_id': 0}, {'_id': 1}, {'_id': 2}, {'_id': 3}, {'_id': 4}]
# what if new items were added at the start?
if cursor1.paging.has_previous:
cursor0 = get_keyset_cursor(**search_condictions, position=cursor1.paging.previous_position)
print('page0:', list(cursor0)) # [{'_id': -1}]
def analyze(userid):
# save the recent 10 posts into ./userid/
scraper.get_rec10(userid)
# load the saved vocabulary file
tag_vocab = {}
for tag in TAGS:
d = {}
f = open(tag + '.csv')
for line in f.readlines():
if len(line.split(',')) == 2:
newline = line.replace('\n', '')
word, freq = newline.split(',')
d[word] = float(freq)
tag_vocab[tag] = d
# save 10 classifying results in one list, then return it
results = []
# process the posts saved, generate hot words list
for root, dirs, files in os.walk(userid):
for f in files:
if f.split('.')[-1] != 'txt':
continue
# get 30 most used words
hot_words = prepare.prepare(userid + '/' + f)
# core: calculate likelyhood for every tag
probability = {}
for tag in TAGS:
probability[tag] = 1.0
for word in hot_words:
try:
probability[tag] *= tag_vocab[tag][word]
except KeyError:
probability[tag] *= MINIMAL_PROB[tag]
results.append(max(probability, key=probability.get))
return results
def update(dry_run):
if dry_run:
print "This is a dry run. Nothing will be sent to blogger.com"
print "Use command line argument --write to disable dry run"
else:
print "This is not a dry run. Updates will happen"
info = util.Info()
bloggerfeed = get_blogger_feed(info)
autolinks = generate_automatic_links(bloggerfeed)
diskfeed = get_disk_feed()
unending_bloggerfeed = itertools.chain(reversed(bloggerfeed.entry),
itertools.repeat(None))
for d, b in itertools.izip(diskfeed, unending_bloggerfeed):
name = os.path.join(root, d)
title, doc = prepare.prepare(name, autolinks)
if b:
print "Considering", d
should_update = False
if title != b.title.text:
print "\tUpdating title '%s' != '%s'" % (title, b.title.text)
should_update = True
if doc != b.content.text:
print "\tUpdating content"
should_update = True
if should_update and not dry_run:
publish.update(info, b, title, doc)
else:
print "Adding", d
if not dry_run:
publish.add(info, title, doc)
def graph(sourcedir,regex,config,dictionary,proto,testratio,n,maxk,outfile,mfcdir,outdir,tempdir):
wdnet, htk_dict, monophones, words_mlf, scp = prepare(sourcedir, mfcdir, outdir, regex, config, dictionary, tempdir)
with open(scp) as f:
full_set = set(f.readlines())
test_n = round(len(full_set)*testratio)
test_set = set(random.sample(full_set,int(test_n)))
train_set = full_set - test_set
scp_test = os.path.join(tempdir,'scp_test')
with open(scp_test,'w') as f:
f.writelines(test_set)
if maxk == -1:
maxk = len(train_set)
def k_result(k):
train_k = random.sample(train_set,k)
scp_k = os.path.join(tempdir,'scp_k')
with open(scp_k,'w') as f:
f.writelines(train_k)
final_dir = train(outdir, config, scp_k, proto, htk_dict, words_mlf, monophones, tempdir)
return test(outdir, final_dir, wdnet, htk_dict, monophones, scp_test, words_mlf, tempdir)
with open(outfile,'w') as f:
for i in range(n):
k = int(round(float(i+1)/n*maxk))
r = k_result(k)
f.write('{} {}\n'.format(k,r))
print('i k r =',i,k,r)
def predi_():
new_img = request.get_json()
img_name = new_img['imageName']
path = 'image/{}'.format(img_name)
storage.child(path).download('image.jpg')
img = prepare('image.jpg')
Class = prediction(model, img)
return jsonify({'data': Class})
def prepare_data(paragraphs):
sentences = []
for paragraph in paragraphs:
sentences = sentences + prepare.prepare(cleanup.clean(paragraph))
model = {}
for sentence in sentences:
model = make_pairs(tokenize.tokenize(sentence), model)
return model
def main():
from prepare import prepare
from decouple import config
from time import sleep
prepare()
print("Collection weather data ...")
collect_time = config("COLLECT_TIME_MIN", 60, cast=int)
while True:
try:
collect()
if collect_time > 0:
print("Waiting another {0} minutes...".format(collect_time))
sleep(60 * collect_time)
else:
break
except KeyboardInterrupt:
print("Manual break by user")
def newDataset():
dataset = l.loadDataset(DATASET_FILE)
dataset = p.prepare(dataset)
s.saveDataset(dataset)
X_train, X_test, y_train, y_test, y = p.splitSets(dataset)
s.saveSets(X_train, X_test, y_train, y_test, y)
clf = c.createClf()
s.saveClassifier(clf)
c.trainClassifier(clf, X_train, y_train)
m.printScoring(clf, X_test, y, y_test)
m.printPercentage(clf, X_test, y, y_test)
def main(_):
config = flags.FLAGS
if config.mode == "get_vocab":
get_vocab(config)
elif config.mode == "prepare":
prepare(config)
elif config.mode == "train":
train(config)
elif config.mode == "train_rl":
train_rl(config)
elif config.mode == "train_qpp":
train_qpp(config)
elif config.mode == "train_qap":
train_qap(config)
elif config.mode == "train_qqp_qap":
train_qqp_qap(config)
elif config.mode == "test":
test(config)
else:
print("Unknown mode")
exit(0)
def get_value(self, features, use_ECR):
ECR_value = None
IS_value = None
key = ",".join([str(i) for i in features])
if key in self.hist:
ECR_value = self.hist[key][0]
IS_value = self.hist[key][1]
else:
filename = "temp.csv"
prepare(features, "binned_{}_reorder.csv".format(self.num_bin),
filename)
ECR_value, IS_value = MDP_policy.induce_policy_MDP(filename)
data = [ECR_value, IS_value]
data.extend(features)
exportCSV(
data, "bin_{}_history/{}.csv".format(self.num_bin,
len(features)))
self.hist[key] = [float(ECR_value), float(IS_value)]
curr_value = ECR_value
if not use_ECR:
curr_value = IS_value
return curr_value
def main(args):
"""
This trains the PedalNet model to match the output data from the input data.
When you resume training from an existing model, you can override hparams such as
max_epochs, batch_size, or learning_rate. Note that changing num_channels,
dilation_depth, num_repeat, or kernel_size will change the shape of the WaveNet
model and is not advised.
"""
prepare(args)
model = PedalNet(vars(args))
trainer = pl.Trainer(
resume_from_checkpoint=args.model if args.resume else None,
gpus=None if args.cpu or args.tpu_cores else args.gpus,
tpu_cores=args.tpu_cores,
log_every_n_steps=100,
max_epochs=args.max_epochs,
)
trainer.fit(model)
trainer.save_checkpoint(args.model)
def infer(model_path):
# read the test data
df = pd.read_csv(config.TEST_FILE)
# perform cleaning, feature engineering,
# categorical variables encoding & scaling
df = prepare(df)
# fetch the pretrained model
clf = joblib.load(model_path)
# predict on test dataset
predictions = clf.predict(df)
df["predictions"] = predictions
# dump dataset with predictions
df.to_csv("../submission.csv", index=False)
# -*- coding: utf-8 -*-
from flask import Flask, render_template, redirect
from flask_flatpages import FlatPages
from flask_frozen import Freezer
from prepare import prepare
# -----------------------------------------------------------------------------
app = Flask(__name__)
app.config.from_pyfile('settings.py')
pages = FlatPages(app)
freezer = Freezer(app)
family_book, parent_map = prepare()
# -----------------------------------------------------------------------------
def get_spec_posts(_type, lang, num=5):
posts = [page for page in pages if page.path.startswith(lang) \
and 'date' in page.meta \
and 'type' in page.meta and page.meta['type'] == _type]
sorted_posts = sorted(posts,
reverse=True,
key=lambda page: page.meta['date'])[:num]
return sorted_posts
@app.route('/')
def home():
return redirect('/cn/')
if hp.jsonl is None:
if not (hp.train and hp.val):
print('Pass the train.csv and val.csv path')
exit()
train_dataset = dataset(hp.train)
train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset, **params)
valid_dataset = dataset(hp.val)
valid_dataloader = torch.utils.data.DataLoader(dataset=train_dataset, **params)
else:
prepare(hp.jsonl).run(hp.training_method)
train_dataset = dataset(
os.path.join(self.target_path,'train%d.csv'%(hp.training_method)))
train_dataloader = torch.utils.data.DataLoader(dataset=train_dataset, **params)
valid_dataset = dataset(
os.path.join(self.target_path,'val%d.csv'%(hp.training_method)))
valid_dataloader = torch.utils.data.DataLoader(dataset=train_dataset, **params)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print("Using device:", device)
soln, agg_soln = optimize(mu=(mu[0], mu_p2),
sigma=(cov[0], cov_p2),
alpha=(0.05, 0.10),
return_target=(target_returns, target_returns),
costs=cost,
prices=prices,
gamma=risk_tolerance[2])
return soln, agg_soln
## *********************************************************************************************************************
# INPUTS
## *********************************************************************************************************************
mu, cov, cost, prices = prepare()
# base portfolio ... comes as an input
portfolio = {'SPY': 0.25, 'MSFT': 0.10, 'JPM': 0.25, 'NTIOF': 0.40}
# our tracked assets
tickers = list(pd.read_csv(os.getcwd() + r'/data/tickers.csv')['Tickers'])
# the number of assets
N = len(tickers)
# user choose which assets (from the 18 we follow) should be included.
cardinality = [1] * 7 + [0] * (N - 7)
risk_tolerance = [((1, 10), (0, 0.10), cardinality, 'SHARPE'),
((5, 5), (0, 0.20), cardinality, 'SHARPE'),
((10, 1), (-0.05, 0.50), cardinality, 'SHARPE')]
def do_prepare(envdir, srcdir, source):
prepare.prepare(envdir, srcdir, source.prepare_arguments)
def __init__(self):
"""
Takes command line variables and does 1 of the following: uploads,prepares,upgrades,backout
"""
parser = OptionParser("usage: ftosupgrade <options>")
parser.add_option("-d", "--devices", dest="devices",
help="List of devices to upgrade separated by a ','", default=None)
parser.add_option("-r", "--region", dest="region",
help="Any region e.g us-east (for uploads only!)", default=None)
parser.add_option("-t", "--type",dest="type",
help="This can be prepare,upgrade,backout, or upload",
choices=['upload','prepare','upgrade','backout'],
default='prepare')
parser.add_option("-b","--binfile",dest="binfile",
help="The name of the binary file you are using for the upgrade e.g. FTOS-SK-9.14.1.0.bin")
parser.add_option("-n","--numforks",dest="numforks",
help="The number of scp sessions you want to run at once, default is 20 (only for uploads!)",default=20)
parser.add_option("-f", "--force", dest="noforce",
action="store_false",
help="use -f to force scripts to run (only works with prepare at the moment)", default=True)
parser.add_option("--test", dest="notest",
action="store_false",
help="use --test to run the upgrade command without reloading the switch", default=True)
parser.add_option("-p","--binfilepath",dest="binfilepath",
default=BINFILEPATH,
help="The path where all your binary files are stored")
(options, args) = parser.parse_args()
dl = os.getcwd().split('/')
self.options=options
if options.type=='upload' and options.binfile is not None and (options.devices is not None or options.region is not None):
#upload bin files to multiple devices
self.devlist=list()
self.sqllist=list()
if options.devices:
self.devlist=options.devices.split(',')
self.makeforks()
else:
self.region=options.region
self.gethosts()
i=1
for hn in self.sqllist:
if i<=int(options.numforks):
self.devlist.append(hn)
i=i+1
else:
i=0
self.makeforks()
self.devlist=[hn]
self.makeforks()
elif options.devices is not None and options.binfile is not None:
# prepare and upgrade devices
self.devlist=options.devices.split(",")
for d in self.devlist:
m=utils(hostname=d,options=options)
m.setupworkspace()
if options.type=='prepare':
prepare(hostname=d,options=options)
elif options.type=='backout':
backout(hostname=d,options=options)
elif options.type=='upgrade':
p=prepare(hostname=d,options=options)
if len(p.errors[d]['critical'])<1:
u=upgrade(hostname=d,options=options)
if len(u.errors[d]['critical'])>0:
m.warning('Found Errors with upgrade...exiting!')
sys.exit()
else:
m.warning('Found Errors with prepare... exiting!')
sys.exit()
else:
print("Please specify at least 1 device and a binary file name")
parser.print_help()
import tkinter
from config import config as configuration, Config
from prepare import prepare
__author__ = 'oglandx'
tk_root = tkinter.Tk()
imgs = prepare(configuration)
print(imgs)
canvas = tkinter.Canvas(tk_root, width=1300, height=700)
canvas.pack()
for k in imgs.keys():
print(k)
for i, cls in enumerate(imgs.values()):
for j, img in enumerate(cls):
canvas.create_image(
(Config.size[0] * (0.5 + 1.2 * i), Config.size[1] * (j + 1)),
image=img)
tk_root.mainloop()
(r'/waiter-receive', WaiterReceiveHandler),
(r'/waiter-query', WaiterQueryHandler),
(r'/waiter-done', WaiterDoneHandler),
(r'/waiter-left-update', WaiterLeftUpdateHandler),
(r'/waiter-done-update', WaiterDoneUpdateHandler),
(r'/waiter-queue', WaiterQueueHandler),
(r'/waiter-desk-update', WaiterDeskUpdateHandler),
(r'/waiter-queue-update', WaiterQueueUpdateHandler),
(r'/pictures/(.+)', PictureHandler)]
settings = dict(
cookie_secret="__TODO:_GENERATE_YOUR_OWN_RANDOM_VALUE_HERE__",
# login_url="/",
template_path=os.path.join(os.getcwd(), "templates"),
static_path=os.path.join(os.getcwd(), "static"),
xsrf_cookies=False,
debug=options.debug,
)
def main():
tornado.options.parse_command_line()
application = tornado.web.Application(myhandlers, **settings)
http_server = tornado.httpserver.HTTPServer(application)
http_server.listen(options.port)
tornado.ioloop.IOLoop.instance().start()
if __name__ == "__main__":
prepare.prepare()
main()
def main():
prepare()
n_args = count_args()
for i in tqdm(range(n_args)):
run(i)
"""
norm_factor = np.linalg.norm(vector)
vector = [_ / norm_factor for _ in norm_factor]
return vector
if TestFlag == True:
if __name__ == "__main__":
folder_dir = './Edge_Lists/AUCS/'
"""
=======================
prepare 数据
=======================
"""
DirectFlag = False
NodesSet, EdgesList_layers = prepare(folder_dir, DirectFlag)
"""
=======================
设置超参数
=======================
"""
dimension = 10
margin = 1
Learning_rate = 0.001
nbatch = 1
nepoch = 1000
error = 0.0000001
"""
=======================
Embedding 每一个网络
=======================
from time import sleep import recorder import player import prepare recording = [] samples = 0 (recording, samples) = recorder.record(2) recording = prepare.prepare(recording) player.replay(b''.join(recording))
# -*- coding: utf-8 -*-
from flask import Flask, render_template, redirect
from flask_flatpages import FlatPages
from flask_frozen import Freezer
from prepare import prepare
# -----------------------------------------------------------------------------
app = Flask(__name__)
app.config.from_pyfile('settings.py')
pages = FlatPages(app)
freezer = Freezer(app)
family_book, parent_map = prepare()
# -----------------------------------------------------------------------------
def get_spec_posts(_type, lang, num = 5):
posts = [page for page in pages if page.path.startswith(lang) \
and 'date' in page.meta \
and 'type' in page.meta and page.meta['type'] == _type]
sorted_posts = sorted(posts, reverse=True,
key=lambda page: page.meta['date'])[:num]
return sorted_posts
@app.route('/')
def home():
return redirect('/cn/')
@app.route('/<lang>/')
def home_lang(lang):
from report import report
usage = """
======================================================================
használat:
python checker.py sol=fájl lang=nyelv problem=feladat mode=mód
a paraméterek:
sol: a megoldás elérési útja
lang: a nyelv
problem: a tesztelendő feladat rövid neve
mode:
prog --> klasszikus program
func --> csak egy függvény, ez a DEFAULT.
A sol mindenképpen kell. A többit megpróbálja a fájlnévből kitalálni.
Például:
python checker.py sol=bday.py
megfelel a hosszabb:
python checker.py sol=bday.py lang=python problem=bday mode=func
hívásnak.
======================================================================
"""
res = prepare(dict())
res = execute(res)
res = evaluate(res)
report(res)
print()
if res["prep"]["msg"] != "OK":
print(usage)
def do_prepare(envdir, srcdir, source):
prepare.prepare(envdir, srcdir, source.prepare_arguments)
import sys
import numpy as np
from keras.models import Sequential
from keras.layers import LSTM
from keras.layers import Input
from keras.layers import Dense
from keras.layers import Dropout
import matplotlib.pyplot as plt
from prepare import prepare
import color
data, target = prepare('./data/XRP_usdt_xrp_1.csv',
'./data/XRP_usdt_btc_1.csv',
'./data/XRP_btc_xrp_1.csv')
data = np.array(data, dtype=float)
print(color.red(data.shape))
target = np.array(target, dtype=float)
print(color.red(target.shape))
# model = Sequential()
# model.add(LSTM(60, return_sequences=True, batch_input_shape=(None, len(data[0]), 6)))
# model.add(Dropout(0.35))
# model.add(LSTM(100, return_sequences=False))
# model.add(Dropout(0.35))
# model.add(Dense(1))
from prepare import prepare, update, kernel
from report import create_report
from watch import watch, flush
from estimate import Estimate
from tt import train, test
from pysvm.svm import SVM
from index import Index
from args import *
from db import *
try:
cnx = connect(**base)
lid = insert_launch(cnx)
obj, sen = Index(), Index()
stats, top, dl = prepare(cnx, lid, cargs["ngrams"], cargs["test"], obj,
sen)
k = kernel(cargs["kernel"], cargs["sigma"])
estimate = Estimate()
estimate.read()
for mode, (trset, teset) in zip(["objective", "sentiment"], dl):
svm = SVM(k,
c=cargs["c"],
tol=cargs["tol"],
lpass=cargs["lpass"],
liter=cargs["liter"])
svm = watch(svm, mode, len(trset[0]), estimate, cnx, lid, cargs)
tr = train(svm, mode, trset[0], trset[1], cnx, lid)
te = test(svm, mode, teset[0], teset[1])
svm, ts = flush(svm, mode)
stats = update(stats, tr, te, ts)
INFILE = argv[i+1]
if arg in ["-o", "--out"]:
OUTFILE = argv[i+1]
if arg == ["-m", "--meter"]:
METER = argv[i+1]
if arg == ["-l", "-L", "--mlength"]:
BEATS_PER_MEASURE = argv[i+1]
if arg == ["-k", "--key"]:
KEY = argv[i+1]
my_file = open(INFILE, "r")
lines = my_file.readlines()
my_file.close()
# convert lines of our file into a list of pieces
pieces = prepare.prepare(lines)
pieces = [piece for piece in pieces if piece[0][0] != "###"]
to_delete = []
for i in range(len(pieces)):
try:
pieces[i][1]["M"]
except KeyError:
# print("piece has no meter:", piece)
# print("piece without meter:",piece[0])
# piece[1]["M"] = "6/8"
to_delete.append(i)
# del pieces[i]
for i in range(len(pieces)):
try:
pieces[i][1]["K"]
import os
from config import workspace_path
from train import train
from config import Model_Config
from prepare import prepare
from predict import predict
from evaluate import evaluate
print(os.getcwd())
os.chdir(workspace_path)
os.mkdir('log')
os.mkdir('hdf')
print(os.getcwd())
print(os.listdir('./'))
if __name__ == '__main__':
# prepare
X_train_processed, X_val_processed, Y_train_list, Y_val_list, vocabulary_size, label_distribute_dict_list = prepare(
)
# train
model, history = train(X_train_processed, X_val_processed, Y_train_list,
Y_val_list, vocabulary_size,
label_distribute_dict_list)
# predict
preds = predict(X_val_processed, Model_Config.model_saved_filepath)
# evaluate
validate_df, df_pcf = evaluate(preds)
# print precision、recall、f1 值
print(df_pcf)
from flask_frozen import Freezer
from prepare import prepare
# -----------------------------------------------------------------------------
app = Flask(__name__)
app.config.from_pyfile('settings.py')
pages = FlatPages(app)
freezer = Freezer(app)
# -----------------------------------------------------------------------------
@app.route('/')
def home():
posts = [page for page in pages if 'date' in page.meta]
sorted_posts = sorted(posts, reverse=True,
key=lambda page: page.meta['date'])
return render_template('index.html', pages=sorted_posts)
@app.route('/<path:path>/')
def page(path):
page = pages.get_or_404(path)
return render_template('page.html', page=page)
# -----------------------------------------------------------------------------
if __name__ == "__main__":
prepare()
app.run()
# -----------------------------------------------------------------------------
from time import time
start = time()
print 'Importing...',
import prepare
import learn
print 'done'
aAList = ['ALA', 'ARG', 'ASN', 'ASP', 'CYS', 'GLU', 'GLN', 'GLY', 'HIS', 'ILE', 'LEU',
'LYS', 'MET', 'PHE', 'PRO', 'SER', 'THR', 'TRP', 'TYR', 'VAL']
working_directory = 'C:/university/biology'
prepare.prepare(working_directory)
learn.learn(working_directory, True)
print 'Total time taken: {} seconds'.format(time()-start)
###
i = open( input_file )
reader = csv.reader( i )
t = open( test_file )
headers = reader.next()
mapping = {}
for line in reader:
query = line[3]
sku = line[1]
# print "%s -> %s" % ( query, sku )
query = prepare( query )
try:
mapping[query][sku] += 1
except KeyError:
try:
mapping[query][sku] = 1
except KeyError:
mapping[query] = {}
mapping[query][sku] = 1
queries = mapping.keys()
nqueries = {}
for n in queries:
nqueries[n] = 1
# This line tells tabarray, that all columns contain string values
# not a numbers. Remove it after loading file
last_line = re.sub('[\t]','fake\t',raw_input_file[0])
out.write(last_line)
out.close()
# reading file into array
raw = tb.tabarray(SVfile = "cleaned_output.tmp",delimiter = '\t')
raw = raw[:-1] # remove hack-line
raw = utils.columnwider(raw)
tmp_tab = raw # create temporal array
os.remove("cleaned_output.tmp") # remove temporal file
#}}}
# create common data base for later processing
bd = prepare.prepare(raw)
# build component list PE3
pe3_array = pe3.pe3(bd)
# save table to file
savelatex(args.pe3, pe3_array)
