def on_abrir_menu_item_activate(self, widget):
self.file_chooser.set_action(Gtk.FileChooserAction.OPEN)
response = self.file_chooser.run()
if response == Gtk.ResponseType.OK:
self.filename = self.file_chooser.get_filename()
models.init(self.filename)
models.open()
self.file_chooser.hide()
def on_novo_menu_item_activate(self, widget):
self.file_chooser.set_action(Gtk.FileChooserAction.SAVE)
response = self.file_chooser.run()
if response == Gtk.ResponseType.OK:
self.filename = self.file_chooser.get_filename()
models.init(self.filename)
models.open()
models.create_tables()
self.file_chooser.hide()
def feed(args):
"""
Scan last two days worth of data from KernelCI website/storage
and send it to an ES instance, respecting its limitations
"""
logger.info('Feeding ES')
if not _is_es_ok():
return -1
if not _is_data_dir_ok():
return -1
models.init()
kci = KernelCI()
# If builds or lavas are exclusively passed on command line, ignore the other one
# otherwise it'd retrieve the regular feed_es data size (past 2 days)
if args.builds or args.lavas or args.boots:
builds = args.builds or {}
lavas = args.lavas or {}
boots = args.boots or {}
else:
builds = _download('build', kci.get_builds(args.how_many))
lavas = _download('lava', kci.get_lavas(args.how_many))
# During download, some lava files might've been switched to boot files
# so let's just separate them and filter them out of lavas dictonary
boots = {
_id: lavas[_id]
for _id in lavas.keys() if 'boot' in lavas[_id]
}
for _id in boots.keys():
del lavas[_id]
# Delete old objects that are no longer needed
models.delete_old()
logger.info(
'Working on %i lavas, %i builds and %i boots from KernelCI/command line'
% (len(lavas), len(builds), len(boots)))
saved_lavas, failed_lavas = _send_to_es('lava', lavas)
saved_builds, failed_builds = _send_to_es('build', builds)
saved_boots, failed_boots = _send_to_es('boot', boots)
models.end()
logger.info('Lavas: sent %i to ES, %i failed' %
(len(saved_lavas), len(failed_lavas.keys())))
logger.info('Builds: sent %i to ES, %i failed' %
(len(saved_builds), len(failed_builds.keys())))
logger.info('Boots: sent %i to ES, %i failed' %
(len(saved_boots), len(failed_boots.keys())))
def main():
tracer.instance(routes.app)
sess = cql.session()
models.init(sess)
view = graphql.GraphQLView.as_view('graphql',
schema=schema.schema,
middleware=[tracer.middleware],
graphiql=True,
graphiql_template=schema.HTML)
routes.app.add_url_rule("/graphql", view_func=view)
routes.app.run(use_reloader=True, threaded=True)
def vote_add(request):
if request.method != "POST":
return HttpResponseBadRequest()
if not models.Team.objects.count():
models.init()
choice = request.POST.get("choice", None)
models.UserProfile.of(request.user).vote(choice)
return HttpResponseRedirect("/thanks")
def run(self, args):
models.init()
meta.Base.metadata.create_all(bind=meta.session.bind.engine)
# create user if needed
query = meta.session.query(users.OdontuxUser)
query = query.all()
if not query:
# create an admin user
print('creating first user "admin"')
print("password : please_change_password")
print("Would be a great idea to change the admin password")
admin_user = {
"username": "******",
"password": b64encode(scrypt.encrypt(os.urandom(64), "please_change_password", maxtime=0.5)),
"role": constants.ROLE_ADMIN,
"lastname": "admin",
"firstname": "admin",
"title": "M",
}
new_admin = users.OdontuxUser(**admin_user)
meta.session.add(new_admin)
meta.session.commit()
# create gnucash payments types
query = meta.session.query(compta.PaymentType)
if not query.all():
print("creating base for payments' types")
payments_types = [
("Cash", "Cash"),
("CreditCard", "Credit card"),
("DebitCard", "Debit card"),
("Transfer", "Transfer"),
("Check", "Check"),
("Paypal", "Paypal"),
("Boleto", "Boleto"),
("Other", "Other"),
]
for payment_type in payments_types:
values = {"gnucash_name": payment_type[0], "odontux_name": payment_type[1]}
new_payment_type = compta.PaymentType(**values)
meta.session.add(new_payment_type)
meta.session.commit()
# create setting for sticker
query = meta.session.query(users.Settings)
query = query.all()
if not query:
print("creating key-value for sticker_position")
values = {"key": "sticker_position", "value": "0"}
new_setting = users.Settings(**values)
meta.session.add(new_setting)
meta.session.commit()
def add_user():
print(
"For better security it is recommended that you add users using a"
" client on a different machine from the server, this utility is only"
" designed for adding a user to an otherwise empty system.\n")
init(config["connection_string"])
u = User()
while not u.username:
u.username = input("Enter username: "******"Enter full name: ")
while not u.email:
u.email = input("Enter email: ")
password = None
while not password:
password = getpass("Enter password: "******"y", "n"]:
admin_response = input("Is user an admin? [y/n]: ")
u.admin = admin_response == "y"
print("Generating keys...", end="")
sys.stdout.flush()
private = RSA.generate(config["key_length"])
public = private.publickey()
salt = os.urandom(8)
key = PBKDF2(password, salt).read(32)
iv = os.urandom(16)
cypher = AES.new(key, AES.MODE_CFB, iv)
encrypted_private_key = cypher.encrypt(private.exportKey("DER"))
u.public_key = base64.b64encode(public.exportKey("DER")).decode("UTF-8")
u.encrypted_private_key = base64.b64encode(encrypted_private_key).decode(
"UTF-8")
u.pbkdf2_salt = base64.b64encode(salt).decode("UTF-8")
u.aes_iv = base64.b64encode(iv).decode("UTF-8")
auth_key = base64.b64encode(
hashlib.pbkdf2_hmac("sha512", password.encode("UTF-8"),
u.username.encode("UTF-8"), 100000))
u.auth_hash = bcrypt.hashpw(auth_key, bcrypt.gensalt()).decode("UTF-8")
print("Done!")
print("Adding user...", end="")
sys.stdout.flush()
db_session.add(u)
db_session.commit()
print("Done!")
def add_user():
print("For better security it is recommended that you add users using a"
" client on a different machine from the server, this utility is only"
" designed for adding a user to an otherwise empty system.\n")
init(config["connection_string"])
u = User()
while not u.username:
u.username = input("Enter username: "******"Enter full name: ")
while not u.email:
u.email = input("Enter email: ")
password = None
while not password:
password = getpass("Enter password: "******"y", "n"]:
admin_response = input("Is user an admin? [y/n]: ")
u.admin = admin_response == "y"
print("Generating keys...", end="")
sys.stdout.flush()
private = RSA.generate(config["key_length"])
public = private.publickey()
salt = os.urandom(8)
key = PBKDF2(password, salt).read(32)
iv = os.urandom(16)
cypher = AES.new(key, AES.MODE_CFB, iv)
encrypted_private_key = cypher.encrypt(private.exportKey("DER"))
u.public_key = base64.b64encode(public.exportKey("DER")).decode("UTF-8")
u.encrypted_private_key = base64.b64encode(encrypted_private_key).decode(
"UTF-8")
u.pbkdf2_salt = base64.b64encode(salt).decode("UTF-8")
u.aes_iv = base64.b64encode(iv).decode("UTF-8")
auth_key = base64.b64encode(hashlib.pbkdf2_hmac("sha512",
password.encode("UTF-8"), u.username.encode("UTF-8"), 100000))
u.auth_hash = bcrypt.hashpw(auth_key, bcrypt.gensalt()).decode("UTF-8")
print("Done!")
print("Adding user...", end="")
sys.stdout.flush()
db_session.add(u)
db_session.commit()
print("Done!")
def main():
# Init database
models.init()
print('')
# Fill with Test Data
models.test_data()
print('')
# Search
search('sweater')
print('')
# List John's Products
list_user_products(2)
print('')
# List all products tagged with 'knitted'
list_products_per_tag(1)
print('')
# John now starts selling olive oil!
product = models.Product(name='Olive Oil',
description='Fresh olive oil from the farm',
price=6.50,
quantity=10)
add_product_to_catalog(2, product)
print('')
# List John's Products again
list_user_products(2)
print('')
# Now there's only 5 steaks left in the webshop
update_stock(5, 5)
print('')
# Let's make a transaction
purchase_product(1, 2, 2)
print('')
# And remove a product
remove_product(6)
print('')
# Search for something old fashioned
search('grandma')
print('')
def hubs_view(hub_name):
session = models.init('sqlite:////var/tmp/hubs.db')
hub = session.query(models.Hub)\
.filter(models.Hub.name==hub_name)\
.first()
return flask.render_template('hubs.html', hub=hub, session=session)
def main():
parser = argparse.ArgumentParser()
group = parser.add_mutually_exclusive_group()
group.add_argument("--run-server", action="store_true")
group.add_argument("--initialise-db", action="store_true")
group.add_argument("--add-user", action="store_true")
args = parser.parse_args()
if args.run_server:
init(config["connection_string"])
server.run(host="0.0.0.0", debug=True)
elif args.initialise_db:
initialise_db()
elif args.add_user:
add_user()
else:
parser.print_help()
def main():
parser = argparse.ArgumentParser()
group = parser.add_mutually_exclusive_group()
group.add_argument("--run-server", action="store_true")
group.add_argument("--initialise-db", action="store_true")
group.add_argument("--add-user", action="store_true")
args = parser.parse_args()
if args.run_server:
init(config["connection_string"])
server.run(host="0.0.0.0", debug=True)
elif args.initialise_db:
initialise_db()
elif args.add_user:
add_user()
else:
parser.print_help()
def static_web_generation(config):
""" Generate the whole static web pages """
engine = models.init(config)
session = models.get_session(engine)
# Latest first
passes = session().query(models.Passes).order_by(models.Passes.aos_time.asc())
print passes
def session(hosts=["127.0.0.1"]):
"""
session returns the Cassandra connection.
"""
global sess, film_by_episode_stmt, films_stmt, people_stmt, planets_stmt, species_stmt, starships_stmt, vehicles_stmt
if sess is None:
# TODO (NF 2018-02-13): Use connection pool.
lbp = policies.RoundRobinPolicy()
sess = cluster.Cluster(hosts, load_balancing_policy=lbp).connect()
models.init(sess)
film_by_episode_stmt = sess.prepare(SELECT_FILM_BY_EPISODE)
films_stmt = sess.prepare(SELECT_FILMS)
people_stmt = sess.prepare(SELECT_PEOPLE)
planets_stmt = sess.prepare(SELECT_PLANETS)
species_stmt = sess.prepare(SELECT_SPECIES)
starships_stmt = sess.prepare(SELECT_STARSHIPS)
vehicles_stmt = sess.prepare(SELECT_VEHICLES)
return sess
def tower_loss(scope, images, labels, model_name, num_labels):
# Build inference Graph.
logits = models.init(model_name, images, num_labels, is_training=True)
# Build the portion of the Graph calculating the losses. Note that we will
# assemble the total_loss using a custom function below.
_ = models.get_mse_loss(logits, labels)
# Assemble all of the losses for the current tower only.
losses = tf.get_collection(tf.GraphKeys.LOSSES, scope)
# Calculate the total loss for the current tower.
total_loss = tf.add_n(losses, name='total_loss')
return total_loss
def parse():
conn, cursor = models.init()
global mydata
req = request.args
if "company" in req:
company_code = req["company"]
mydata = models.execute(conn, cursor, ("company", company_code))
elif "person" in req:
name = req["person"]
mydata = models.execute(conn, cursor, ("person", name))
return render_template('test.html')
def setup(config_file):
global CONFIG_FILE
CONFIG_FILE = config_file
models.init(get_setting('databasefile', os.path.join(THIS_DIR, 'transfers.db')))
# Configure logging
default_logfile = os.path.join(THIS_DIR, 'automate-transfer.log')
CONFIG = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'default': {
'format': '%(levelname)-8s %(asctime)s %(filename)s:%(lineno)-4s %(message)s',
'datefmt': '%Y-%m-%d %H:%M:%S',
},
},
'handlers': {
'console': {
'class': 'logging.StreamHandler',
'formatter': 'default',
},
'file': {
'class': 'logging.handlers.RotatingFileHandler',
'formatter': 'default',
'filename': get_setting('logfile', default_logfile),
'backupCount': 2,
'maxBytes': 10 * 1024,
},
},
'loggers': {
'transfer': {
'level': 'INFO', # One of INFO, DEBUG, WARNING, ERROR, CRITICAL
'handlers': ['console', 'file'],
},
},
}
logging.config.dictConfig(CONFIG)
def main():
if 'test' not in settings.KCING_DB:
logger.error(
'Database for testing should contain the word "test" in it')
logger.error(
'Please specify a testing database passing KCING_DB env var when running tests'
)
return -1
# Deletes current db to make sure we're working with a fresh one
try:
os.unlink(settings.KCING_DB)
except OSError:
pass
os.mknod(settings.KCING_DB)
init()
create_tables()
rc = unittest.main()
end()
return rc
def add_db_record(config, sat_name, automate_started, aos_time, los_time, max_elev, record_time):
""" Add record of the pass to database """
engine = models.init(config)
session_maker = models.get_session(engine)
session = session_maker()
sat_pass = models.Passes()
sat_pass.sat_name = sat_name
sat_pass.automate_started = datetime.datetime.utcfromtimestamp(automate_started)
sat_pass.aos_time = datetime.datetime.utcfromtimestamp(aos_time)
sat_pass.los_time = datetime.datetime.utcfromtimestamp(los_time)
sat_pass.max_elev = max_elev
sat_pass.record_time = record_time
sat_pass.sat_type = sat_type(sat_name)
session.add(sat_pass)
session.commit()
def __init_model(self):
with tf.Graph().as_default():
self.placeholder = tf.placeholder(dtype=tf.float32,
shape=[
None,
self._arg_dict['img_size'],
self._arg_dict['img_size'], 3
])
self.logits = models.init(self._arg_dict['model'],
self.placeholder,
self._arg_dict['landmark_type'] * 2,
is_training=False)
saver = tf.train.Saver()
with tf.device('/gpu:0'):
self.sess = tf.Session(config=tf.ConfigProto(
gpu_options=tf.GPUOptions(allow_growth=True)))
ckpt_path = self._arg_dict['model_path']
if tf.train.checkpoint_exists(ckpt_path):
saver.restore(self.sess, ckpt_path)
else:
raise Exception("model_path inexistence")
train_layouts, train_objects, train_rewards, train_terminal, \
train_instructions, train_indices, train_values, train_goals = data.to_tensor(train_data, text_vocab)
test_layouts, test_objects, test_rewards, test_terminal, \
test_instructions, test_indices, test_values, test_goals = data.to_tensor(test_data, text_vocab)
print '<Main> Training: (', train_layouts.size(), 'x', train_objects.size(), 'x', train_indices.size(), ') -->', train_values.size()
print '<Main> test : (', test_layouts.size(), 'x', test_objects.size(), 'x', test_indices.size(), ') -->', test_values.size()
#################################
############ Training ###########
#################################
print '\n<Main> Initializing model: {}'.format(args.model)
model = models.init(args, layout_vocab_size, object_vocab_size, text_vocab_size)
train_inputs = (train_layouts, train_objects, train_indices)
test_inputs = (test_layouts, test_objects, test_indices)
print '<Main> Training model'
trainer = pipeline.Trainer(model, args.lr, args.batch_size)
trainer.train(train_inputs, train_values, test_inputs, test_values, iters=args.iters)
#################################
######## Save predictions #######
#################################
## make logging directories
pickle_path = os.path.join(args.save_path, 'pickle')
from models import *
from nxsim import NetworkSimulation
import numpy
from matplotlib import pyplot as plt
import networkx as nx
import settings
import models
import math
import json
settings.init() # Loads all the data from settings
models.init() # Loads the models and network variables
####################
# Network creation #
####################
if settings.network_type == 0:
G = nx.complete_graph(settings.number_of_nodes)
if settings.network_type == 1:
G = nx.barabasi_albert_graph(settings.number_of_nodes, 10)
if settings.network_type == 2:
G = nx.margulis_gabber_galil_graph(settings.number_of_nodes, None)
# More types of networks can be added here
##############
# Simulation #
##############
sim = NetworkSimulation(topology=G,
states=init_states,
from google.appengine.ext import webapp
from google.appengine.ext.webapp.util import run_wsgi_app
import settings
import rest
import models
import views
import paypal
from rest.views import PageHandler
import test_streetcode
import demo
models.init()
paths = [
('/', views.RootHandler),
]
paths.extend(rest.get_paths())
paths.extend([
('/(\w+)', PageHandler.using('mobile_profile.html')),
('/client/(\w+)/(\d+)', views.ClientHandler),
('/donations/(\w+)', PageHandler.using('mobile_donation.html')),
('/paypal/ipn', paypal.IPNHandler), # paypal ipn handler
('/paypal/pdt', paypal.PDTHandler), # paypal pdt handler
])
def main():
opts = parse_args()
models.init(opts.dburi, echo=opts.debug)
db = Session()
dbx = dropbox.client.DropboxClient(utils.dropbox_session(db))
for owner in db.query(Identity):
blogs = {}
cursor = owner.dropbox_cursor
print 'Found cursor:', cursor
dbx.session.set_token(owner.dropbox_key, owner.dropbox_secret)
account_info = dbx.account_info()
print 'Processing blogs for %s.' % account_info['display_name']
for blog in owner.blogs:
blogs[blog.name] = blog
delta = dbx.delta(cursor)
if delta['reset']:
print 'RESET'
for post in db.query(Post).join(Post.blog).filter(Blog.owner_id ==
owner.id):
db.delete(post)
db.commit()
for entry in delta['entries']:
if entry[1] and entry[1]['is_dir']:
continue
mo = re.match('/sites/(?P<blog>[^/]*)/posts/(?P<post>[^/]*\.md$)', entry[0])
if not mo or mo.group('blog') not in blogs:
continue
print '->', entry[0]
if entry[1] is None:
db.query(Post).filter(Post.id == entry[0]).delete()
else:
doc = mailbox.Message(dbx.get_file(entry[0]))
p = db.query(Post).get(entry[0])
if not p:
p = Post(id=entry[0],
date=time.strftime('%Y-%m-%d',
time.localtime()))
db.add(p)
blogs[mo.group('blog')].posts.append(p)
p.title = doc.get('title',
os.path.splitext(os.path.basename(entry[0]))[0]).encode('utf-8')
p.slug = slugify(p.title)
p.published = doc.get('published', 'True') == 'True'
p.date = doc.get('date', p.date)
html = utils.filter_markdown(doc.get_payload())
if not p.content:
p.content = Content()
p.content.html = html
owner.dropbox_cursor = delta['cursor']
db.commit()
def train(prefix, **arg_dict):
img_size = arg_dict['img_size']
gpu_num = len(arg_dict["gpu_device"].split(','))
batch_size = arg_dict["batch_size"]
common_dict = {"global_step": 1}
print ("batch_size = %d for gpu_num = %d" % (batch_size, gpu_num))
if arg_dict["parallel_mode"] == "ModelParallel":
print ("Working on model parallel.")
if gpu_num <= 1:
raise Exception("Model parallel only support more than 2 gpu number")
elif arg_dict["parallel_mode"] == "DataParallel":
print ("Working on data parallel")
else:
raise Exception("Unsupport parallel mode. see --help")
# Creat tf_summary writer.
try:
from tensorboardX import SummaryWriter
summary_dir = os.path.join(prefix, "tf_summary")
if os.path.exists(summary_dir):
print ("Delete old summary in first.")
os.system("rm -rf {}".format(summary_dir))
common_dict["tensorboard_writer"] = SummaryWriter(summary_dir)
print ("Enable tensorboard summary.")
print ("Please using 'python -m tensorboard.main --logdir={}'".format(summary_dir))
except Exception as ex:
common_dict["tensorboard_writer"] = None
print ("Disable tensorboard summary. please install tensorboardX in first.")
print ("Easy to install by 'pip install tensorboardX --user'")
# batch generator
_batch_reader = BatchReader(**arg_dict)
_batch_generator = _batch_reader.batch_generator()
# net
model_params = json.loads(arg_dict["model_params"])
model_params["image_size"] = arg_dict["img_size"]
model_params["feature_dim"] = arg_dict["feature_dim"]
model_params["class_num"] = arg_dict["label_num"]
net = models.init(arg_dict["model"], gpu_num=gpu_num, model_params=model_params,
parallel_mode=arg_dict["parallel_mode"], common_dict=common_dict)
if arg_dict["parallel_mode"] == "DataParallel":
net = nn.DataParallel(net)
net.cuda()
# print (net)
if arg_dict["restore_ckpt"]:
print ("Resotre ckpt from {}".format(arg_dict["restore_ckpt"]))
net.load_state_dict(torch.load(arg_dict["restore_ckpt"]))
# optimizer
optimizer = optim.SGD(net.parameters(), lr=arg_dict['learning_rate'],
momentum=0.9, weight_decay=5e-4)
lr_scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=20000, gamma=0.95)
# start loop
print ("Start to training...")
start_time = time.time()
display = 100
loss_list = []
while not _batch_reader.should_stop():
# prepare data
batch_st = time.time()
batch = _batch_generator.next()
datas = batch[0].cuda()
labels = batch[1].cuda()
batch_et = time.time()
# forward and backward
loss = net(datas, labels)
loss = loss.mean()
optimizer.zero_grad()
loss.backward()
optimizer.step()
lossd = loss.data[0]
# display
loss_list.append(lossd)
if common_dict["global_step"] % display == 0:
end_time = time.time()
cost_time, start_time = end_time - start_time, end_time
sample_per_sec = int(display * batch_size / cost_time)
sec_per_step = cost_time / float(display)
loss_display = np.mean(loss_list)
lr = optimizer.param_groups[0]['lr']
print ('[%s] epochs: %d, step: %d, lr: %.5f, loss: %.5f, '\
'sample/s: %d, sec/step: %.3f, batch time: %.3fs' % (
datetime.datetime.now().strftime("%Y%m%d_%H%M%S"),
_batch_reader.get_epoch(), common_dict["global_step"], lr, loss_display,
sample_per_sec, sec_per_step, batch_et - batch_st))
loss_list = []
if common_dict["tensorboard_writer"] is not None:
common_dict["tensorboard_writer"].add_scalar("loss", loss_display,
common_dict["global_step"])
common_dict["tensorboard_writer"].add_scalar("sample_per_sec", sample_per_sec,
common_dict["global_step"])
common_dict["tensorboard_writer"].add_scalar("lr", lr,
common_dict["global_step"])
if common_dict["global_step"] % 10000 == 0:
# save checkpoint
checkpoint_path = os.path.join(prefix, 'model.ckpt')
torch.save(net.state_dict(), checkpoint_path)
print ("save checkpoint to %s" % checkpoint_path)
lr_scheduler.step()
common_dict["global_step"] += 1
def train(prefix, **arg_dict):
batch_size = arg_dict['batch_size']
num_labels = arg_dict['landmark_type'] * 2
img_size = arg_dict['img_size']
# batch generator
_batch_reader = BatchReader(**arg_dict)
_batch_generator = _batch_reader.batch_generator()
with tf.Graph().as_default():
images = tf.placeholder(tf.float32,
shape=[batch_size, img_size, img_size, 3])
point_labels = tf.placeholder(tf.float32,
shape=[batch_size, num_labels])
logits = models.init(arg_dict['model'],
images,
num_labels,
is_training=True)
loss = models.get_l2_loss(logits, point_labels, batch_size)
# Create a variable to track the global step.
global_step = tf.Variable(0, name='global_step', trainable=False)
learning_rate = tf.train.exponential_decay(arg_dict['learning_rate'],
global_step,
30000,
0.5,
staircase=True)
# Use the optimizer to apply the gradients that minimize the loss
# (and also increment the global step counter) as a single training step.
optimizer = tf.train.AdamOptimizer(learning_rate)
train_op = optimizer.minimize(loss, global_step=global_step)
sess = tf.Session(config=tf.ConfigProto(gpu_options=tf.GPUOptions(
allow_growth=True)))
init = tf.global_variables_initializer()
sess.run(init)
saver = tf.train.Saver(tf.global_variables())
if arg_dict['restore_ckpt']:
variables_to_restore = tf.get_collection(
tf.GraphKeys.TRAINABLE_VARIABLES)
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, arg_dict['restore_ckpt'])
print('Resume-trained model restored from: %s' %
arg_dict['restore_ckpt'])
tf.train.write_graph(sess.graph.as_graph_def(), '.',
os.path.join(prefix, 'graph_struct.txt'))
print("Start to training...")
start_time = time.time()
while not _batch_reader.should_stop():
with tf.device('/gpu:0'):
batch = _batch_generator.next()
_, ploss, step, lr = sess.run(
[train_op, loss, global_step, learning_rate],
feed_dict={
images: batch[0],
point_labels: batch[1]
})
if step % 10 == 0:
end_time = time.time()
cost_time, start_time = end_time - start_time, end_time
sample_per_sec = int(10 * batch_size / cost_time)
sec_per_step = cost_time / 10.0
print(
'[%s] epochs: %d, step: %d, lr: %f, landmark_loss: %.4f, sample/s: %d, sec/step: %.3f'
% (datetime.datetime.now().strftime("%Y%m%d_%H%M%S"),
_batch_reader.get_epoch(), step, lr, ploss,
sample_per_sec, sec_per_step))
if step % 1024 == 0:
checkpoint_path = os.path.join(prefix, 'model.ckpt')
saver.save(sess, checkpoint_path)
print('Saved checkpoint to %s' % checkpoint_path)
checkpoint_path = os.path.join(prefix, 'model.ckpt')
saver.save(sess, checkpoint_path)
print('\nReview training parameter:\n%s\n' % (str(arg_dict)))
print('Saved checkpoint to %s' % checkpoint_path)
print('Bye Bye!')
def generate_static_web(config, sat_name, automate_started,
aos_time, los_time, max_elev, record_time):
""" Generate static web pages """
if not config.getboolean("PROCESSING", "staticWeb"):
return
engine = models.init(config)
session_maker = models.get_session(engine)
session = session_maker()
cur_path = os.path.dirname(os.path.abspath(__file__))
template_env = Environment(
autoescape=False,
loader=FileSystemLoader(os.path.join(cur_path, 'templates')),
trim_blocks=False)
template_env.filters['datetime'] = format_datetime
def render_template(template, context):
""" Render the template """
return template_env.get_template(template).render(context)
emerge_time_utc = time.strftime('%Y-%m-%dT%H:%M:%S', time.gmtime(aos_time))
if not os.path.exists(config.get("DIRS", "staticWeb")):
print cfg.logLineStart + \
"PATH for static web doesn't exist, can't generate web pages" + \
cfg.logLineEnd
return
# Generate the web page of the pass itself
# time is UTC
dst_single_pass = os.path.join(
config.get("DIRS", "staticWeb"), "{}.html".format(emerge_time_utc.replace(":", "-")))
# timestamp - UTC
img_tstamp = datetime.datetime.utcfromtimestamp(aos_time).strftime('%Y%m%d-%H%M')
with open(dst_single_pass, 'w') as single_pass_file:
ctx = {
'sat_name': sat_name,
'aos_time': aos_time, # localtime
'los_time': los_time, # localtime
'automate_started': automate_started, # UTC (from time.time())
'max_el': max_elev,
'record_time': record_time,
'img_tstamp': img_tstamp,
'sat_type': sat_type(sat_name),
}
if config.getboolean('PROCESSING', 'wxEnhCreate'):
ctx['enhancements'] = []
for enhancement in config.getlist('PROCESSING', 'wxEnhList'):
filename = "{}-{}-map.jpg".format(img_tstamp, enhancement)
ctx['enhancements'].append({
'name': enhancement,
'img_path': filename,
'img_full_path': os.path.join("/img_noaa", sat_name, filename),
'log': "{}.txt".format(os.path.join("/img_noaa", sat_name, filename)),
})
if config.getboolean('PROCESSING', 'createSpectro'):
filename = "{}-{}.png".format(sat_name.replace(" ", ""), str(aos_time))
ctx['spectro'] = {
'filename': os.path.join("/spectro_noaa", filename)
}
html = render_template(config.get('STATIC_WEB', 'single_pass'), ctx)
single_pass_file.write(html)
print cfg.logLineStart + "Wrote web page for single NOAA pass" + cfg.logLineEnd
# Generate the home page of the passes
# The CSV is filled even if no static web generation is activated
# Cycle over the CSV, regenerating home plus every pages splitted on config.passes_per_page
# Latest first
passes = session.query(models.Passes).order_by(models.Passes.aos_time.desc())
# (re)generate the home page
passes_per_pages = config.getint('STATIC_WEB', 'passes_per_page')
page = 0
pages = int(math.ceil(float(passes.count()) / float(passes_per_pages)))
home_passes = passes[0:passes_per_pages]
index_page = os.path.join(
config.get("DIRS", "staticWeb"), "index.html")
with open(index_page, 'w') as index_page_file:
ctx = {
'passes': home_passes,
'passes_per_pages': passes_per_pages,
'start': 0,
'total': passes.count(),
'page': page,
'pages': pages,
'pages_list': range(0, pages),
}
html = render_template(config.get('STATIC_WEB', 'index_passes'), ctx)
index_page_file.write(html)
page = 1 # index created, increment page
#print cfg.logLineStart + \
# "Wrote web page for index passes, page 0 0-{}".format(passes_per_pages) + \
# cfg.logLineEnd
if passes.count() > passes_per_pages:
# We have more pages to show
for _ in range(1, pages):
start_passes = (page * passes_per_pages)
page_passes = passes[start_passes:start_passes + passes_per_pages]
passes_page = os.path.join(config.get("DIRS", "staticWeb"),
"index_{}.html".format(page))
with open(passes_page, 'w') as passes_page_file:
ctx = {
'passes': page_passes,
'passes_per_pages': passes_per_pages,
'start': start_passes,
'total': passes.count(),
'page': page,
'pages': pages,
'pages_list': range(0, pages),
}
html = render_template(config.get('STATIC_WEB', 'index_passes'), ctx)
passes_page_file.write(html)
#print cfg.logLineStart + "Wrote web page for index passes, page {} {}-{}".format(
# page, start_passes, start_passes + passes_per_pages
#) + cfg.logLineEnd
page = page + 1 # page created, increment
print cfg.logLineStart + "Finished web page processing" + cfg.logLineEnd
opt.env = opt.model
# visdom
vis = Visualizer(opt.env)
# vis log output
vis.log('user config:')
for k, v in opt.__dict__.items():
if not k.startswith('__'):
vis.log('{} {}'.format(k, getattr(opt, k)))
# load data
# use torchtext to load
train_iter, test_iter = load_data(opt)
model = models.init(opt)
print(type(model))
# cuda
if opt.use_cuda:
model.cuda()
# start trainning
model.train()
# set optimizer
optim = torch.optim.Adam(filter(lambda p: p.requires_grad, model.parameters()),
lr=opt.learning_rate)
optim.zero_grad()
# use cross_entropy loss for classification
criterion = F.cross_entropy
landmark_block = nn.HybridSequential()
with landmark_block.name_scope():
landmark_block.add(nn.Dense(512, flatten=True),
nn.Dense(self.num_label, activation="sigmoid"))
model.add(landmark_block)
# angle_block
if self.kwargs.get("train_angle", False):
angle_block = nn.HybridSequential()
with angle_block.name_scope():
angle_block.add(nn.Dense(512, flatten=True),
nn.Dense(3, activation="sigmoid"))
model.add(angle_block)
return model
# init
def init(model, num_label, **kwargs):
func = getattr(sys.modules["models"], model)
return func(num_label, **kwargs)
if __name__ == "__main__":
import models
net = models.init("fanet8ss_inference", num_label=72 * 2)
net.initialize()
print net
from mxnet import nd
test_data = nd.random.uniform(shape=(1, 3, 128, 128))
landmark, angle = net(test_data)
print landmark.shape, angle.shape
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# ..
import logging, argparse
# ...
import yask, config, urls, models
app = yask.App()
# ...
config.init(app)
app.init_logger()
urls.init(app)
models.init(app)
# ...
if __name__ == "__main__":
# ...
parser = argparse.ArgumentParser(description='Setup defaults')
# ..
parser.add_argument('--host',
dest='host',
default=app.config.HOST,
help='Default hostname')
# ...
parser.add_argument('--port',
dest='port',
type=int,
default=app.config.PORT,
help='Default port')
def train(prefix, **arg_dict):
num_labels = arg_dict['landmark_type'] * 2
img_size = arg_dict['img_size']
train_angle = arg_dict['train_angle']
gpu_num = len(arg_dict["gpu_device"].split(','))
batch_size = arg_dict['batch_size'] * gpu_num
arg_dict['batch_size'] = batch_size
print("real batch_size = %d for gpu_num = %d" % (batch_size, gpu_num))
# batch generator
_batch_reader = BatchReader(**arg_dict)
_batch_generator = _batch_reader.batch_generator()
# net
ctx = [mx.gpu(i) for i in range(gpu_num)]
net = models.init(num_label=num_labels, **arg_dict)
if arg_dict["restore_ckpt"]:
print "resotre checkpoint from %s" % (arg_dict["restore_ckpt"])
net.load_params(arg_dict['restore_ckpt'], ctx=ctx)
else:
net.initialize(init=mx.init.Xavier(), ctx=ctx)
print net
# loss
losses_func = []
if train_angle:
losses_func.append(gluon.loss.L2Loss(weight=0.5)) # landmark
losses_func.append(gluon.loss.L2Loss(weight=0.5)) # angle
else:
losses_func.append(gluon.loss.L2Loss()) # landmark
# trainer
trainer = gluon.Trainer(net.collect_params(), "adam",
{"learning_rate": arg_dict['learning_rate']})
# start loop
print("Start to training...")
start_time = time.time()
step = 0
display = 10
loss_list = []
while not _batch_reader.should_stop():
batch = _batch_generator.next()
image = nd.array(batch[0])
image = nd.transpose(image.astype('float32'),
(0, 3, 1, 2)) / 127.5 - 1.0
image_list = gluon.utils.split_and_load(image, ctx)
landmark = nd.array(batch[1])
landmark_list = gluon.utils.split_and_load(landmark, ctx)
if train_angle:
angle = nd.array(batch[2])
angle_list = gluon.utils.split_and_load(angle, ctx)
with autograd.record():
losses = []
if train_angle:
for _i, _l, _a in zip(image_list, landmark_list, angle_list):
predicts = net(_i)
landmark_loss = losses_func[0](predicts[0], _l)
angle_loss = losses_func[1](predicts[1], _a)
losses.append(landmark_loss + angle_loss)
else:
for _i, _l in zip(image_list, landmark_list):
predicts = net(_i)
landmark_loss = losses_func[0](predicts, _l)
losses.append(landmark_loss)
for loss in losses:
loss.backward()
trainer.step(batch_size)
loss_list.append(np.mean([nd.mean(l).asscalar() for l in losses]))
nd.waitall()
if step % display == 0:
end_time = time.time()
cost_time, start_time = end_time - start_time, end_time
sample_per_sec = int(display * batch_size / cost_time)
sec_per_step = cost_time / float(display)
loss_display = "[landmark: %.5f]" % (np.mean(loss_list))
print ('[%s] epochs: %d, step: %d, lr: %.5f, loss: %s,'\
'sample/s: %d, sec/step: %.3f' % (
datetime.datetime.now().strftime("%Y%m%d_%H%M%S"),
_batch_reader.get_epoch(), step, trainer.learning_rate, loss_display,
sample_per_sec, sec_per_step))
loss_list = []
if step % 1024 == 0:
# change lr
trainer.set_learning_rate(trainer.learning_rate * 0.95)
# save checkpoint
checkpoint_path = os.path.join(prefix, 'model.params')
net.save_params(checkpoint_path)
print("save checkpoint to %s" % checkpoint_path)
step += 1
from flask import Flask
import models
app = Flask('supportsomething')
app.config.from_object('supportsomething.settings')
app.config.from_envvar('SETTINGS', silent=True)
# Init models
models.init(app)
# Import modules
import views
def initialise_db():
print("Initialising database...", end="")
sys.stdout.flush()
init(config["connection_string"])
create_all()
print("Done!")
def setUp(self):
self.session = cql.session()
models.init(self.session)
import flask, json
from flask import Flask, g, render_template, request, session, redirect, url_for
import itertools
import re
import os
import models
app = Flask(__name__)
app.secret_key = 'A0Zr98j/3yX R~XHH!j4mNLWX/,?RT'
db = models.init(os.environ.get("DATABASE_URL", "sqlite:///development.sqlite3"))
@app.before_request
def before_request():
g.db = db()
@app.teardown_request
def teardown_request(exception=None):
if hasattr(g, 'db'):
g.db.close()
@app.route("/courses")
def courses():
match_with = request.args.get('term', None)
if not match_with:
return json.dumps([])
matches = models.Course.search_by_keywords(match_with.split(" "))
course_data = []
for match in matches:
course_data.append({"label": match.name, "value": match.id})
import json
import tornado.web
import tornado.gen
import tornado.auth
import tornado.websocket
import motor.motor_tornado
from tornado.web import HTTPError
from tornado.gen import coroutine
from models import init, User, Dialog
motor_client = motor.motor_tornado.MotorClient('localhost', 27017)
db = motor_client['chatdb']
init(db)
class BaseHandler(tornado.web.RequestHandler):
def get_current_user(self):
return self.get_cookie('name')
class MainHandler(BaseHandler):
def get(self):
# if not self.get_current_user():
# self.redirect('/loginpage')
f = open('static/chats/chats.html')
s = f.read()
f.close()
self.write(s)
from flask import Flask, jsonify, url_for, redirect
from flask_sqlalchemy import SQLAlchemy
from os import environ
import models
from tasks_api import tasks
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/test.db'
db = SQLAlchemy(app)
# For blueprint use
app.config['models'] = models.init(db)
try:
assert environ['FLASK_ENV'] == 'development'
db.create_all()
from werkzeug.debug import DebuggedApplication
app.config.from_object(__name__)
app.wsgi_app = DebuggedApplication(app.wsgi_app, evalex=True)
except KeyError:
pass
except AssertionError:
pass
app.register_blueprint(tasks, url_prefix='/tasks')
@app.route('/')
def hello_json():
import smtplib
# from flask_mail import Mail
try:
host = "smtp.gmail.com"
port = 587
username = "******"
password = "******"
to = email
# try:
email_conn = smtplib.SMTP(host, port)
email_conn.ehlo()
email_conn.starttls()
email_conn.login(username, password)
import random
message = """\
Subject: Reset Password OTP
This message is sent from ShelterApp Volunteer Portal for Resetting your password. Your Otp is """ + str(
otp) + """\n\nThanks,\nShelterApp Team\[email protected]"""
email_conn.sendmail(username, to, message)
return True
except:
return False
if __name__ == "__main__":
# mailstuff()
email = init()
app.secret_key = "12345678"
app.run(host='0.0.0.0', debug=True, port=80)
import flask, json
from flask import Flask, g, render_template, request, session, redirect, url_for
import itertools
import re
import os
import models
app = Flask(__name__)
app.secret_key = 'A0Zr98j/3yX R~XHH!j4mNLWX/,?RT'
db = models.init(
os.environ.get("DATABASE_URL", "sqlite:///development.sqlite3"))
@app.before_request
def before_request():
g.db = db()
@app.teardown_request
def teardown_request(exception=None):
if hasattr(g, 'db'):
g.db.close()
@app.route("/courses")
def courses():
match_with = request.args.get('term', None)
if not match_with:
return json.dumps([])
matches = models.Course.search_by_keywords(match_with.split(" "))
app = Flask(__name__)
app.config['SECRET_KEY'] = '123456790'
app.config['DATABASE_FILE'] = 's0inv.sqlite'
app.config[
'SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + app.config['DATABASE_FILE']
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
#app.config['SQLALCHEMY_ECHO'] = True
db = SQLAlchemy(app)
admin = Admin(app,
name='s0inv',
template_mode='bootstrap3',
url='/' + NAMESPACE)
security.init(app, db, admin)
models.init(app, db, admin)
def build_sample_db():
db.drop_all()
db.create_all()
app_dir = os.path.realpath(os.path.dirname(__file__))
database_path = os.path.join(app_dir, app.config['DATABASE_FILE'])
if not os.path.exists(database_path):
build_sample_db()
@app.route("/")
def app_index():
def get_session(self):
""" Return a database session according to config values
"""
return models.init(uri=self['dbname'], host=self['host'], user=self.user, passwd=self.passwd_hash, dbtype=self['dbtype'], path=self.args.dname)
app.register_blueprint(res.inf_sarana_api, url_prefix=url_prefix)
app.register_blueprint(res.inf_dusun_api, url_prefix=url_prefix)
app.register_blueprint(res.inf_administrasi_api, url_prefix=url_prefix)
app.register_blueprint(res.inf_penduduk_api, url_prefix=url_prefix)
app.register_blueprint(res.inf_perangkat_api, url_prefix=url_prefix)
app.register_blueprint(res.inf_umum_api, url_prefix=url_prefix)
app.register_blueprint(res.geo_api, url_prefix=url_prefix)
# Set blacklist token for loging out
jwt = JWTManager(app)
blacklist = set()
@jwt.token_in_blacklist_loader
def check_if_token_in_blacklist(decrypted_token):
jti = decrypted_token['jti']
return jti in blacklist
@app.route('{}/user/logout'.format(url_prefix))
@jwt_required
def logout():
jti = get_raw_jwt()['jti']
blacklist.add(jti)
return 'loged out'
if __name__ == '__main__':
md.init()
app.run()
)
botsettings = {
'presence': settings['initial_presence'],
}
settings.update(config.settings)
settings = XMPPSettings(settings)
if config.trace:
logging.info('enabling trace')
for logger in ('pyxmpp2.IN', 'pyxmpp2.OUT'):
logger = logging.getLogger(logger)
logger.setLevel(logging.DEBUG)
for logger in (
'pyxmpp2.mainloop.base', 'pyxmpp2.expdict',
'pyxmpp2.mainloop.poll', 'pyxmpp2.mainloop.events',
'pyxmpp2.transport', 'pyxmpp2.mainloop.events',
):
logger = logging.getLogger(logger)
logger.setLevel(max((logging.INFO, config.logging_level)))
if config.logging_level > logging.DEBUG:
restart_if_failed(runit, 3, args=(settings, botsettings))
else:
runit(settings, botsettings)
if __name__ == '__main__':
setup_logging()
models.init()
main()
from flask import Flask, jsonify, request
from models import User, init, session
import datetime
app = Flask(__name__)
init(app)
@app.route('/user/list', methods = ['GET'])
def user_list():
return jsonify({'users': [u.json() for u in User.get_all()]})
@app.route('/user/save', methods = ['POST'])
def user_save():
if 'account_value' in request.json:
request.json['account_value'] = float(request.json['account_value'] or 0)
if 'birthdate' in request.json:
request.json['birthdate'] = datetime.datetime.strptime(request.json['birthdate'], '%Y-%m-%d')
data = {}
fields = ['account_value', 'name', 'state', 'address', 'birthdate']
for field in fields:
if field in request.json:
data[field] = request.json[field]
user = None