def init():
trainingdataset = process_dataset("out.csv")
create_tables()
insert_training(trainingdataset)
#print "data %s" % Data.select().count()
testdataset = process_dataset("test.csv")
try:
os.unlink("graphoutput.tx")
except OSError:
pass
for data in testdataset:
cat = replace_category(data)
neighbors = get_neighbors(data, k=10)
with open("graphoutput.txt", "a") as f:
for i in neighbors:
d = i.distance
print i.data.pprint()
f.write("%s\n" % d)
result = get_response(neighbors)
print "%s %s >>>>>>>>>>>>> prediction: %s" % (cat,data[:-1], result)
yes_no = raw_input("Desea validar el valor (y/[n])? ")
if yes_no is 'y':
result = raw_input("nuevo valor 1 or 0: ")
data[-1] = result
insert_data(*data)
def main():
model.create_tables()
load_artists(session)
load_artwork(session)
loop_directories("./artists")
add_artist_details()
add_details()
def test_create_tables(self):
"""Test that create_tables makes the database tables"""
create_tables(self.db)
cur = self.db.cursor()
# these queries return nothing but should succeed if the table is correct
cur.execute("SELECT name, unit FROM enrolments")
self.assertEqual([], cur.fetchall())
def test_add_enrolment(self):
"""Test whether we can add data to the database"""
create_tables(self.db)
add_enrollment(self.db, 'Sue', 'COMP249')
add_enrollment(self.db, 'Sue', 'COMP225')
cur = self.db.cursor()
cur.execute("SELECT name FROM enrolments WHERE unit='COMP249'")
self.assertEqual([('Sue', )], cur.fetchall())
def test_list_enrolments(self):
"""Test that we can list enrolments in the database"""
create_tables(self.db)
add_enrollment(self.db, 'Trevor', 'COMP225')
add_enrollment(self.db, 'Sue', 'COMP249')
en = list_enrolments(self.db)
# should see the results in order
self.assertListEqual([('Sue', 'COMP249'), ('Trevor', 'COMP225')], en)
def serve():
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
address = os.getenv("HOST") + ":" + os.getenv("PORT")
server.add_insecure_port(address)
model.create_tables()
service.add_ProjectSvcServicer_to_server(api.API(), server)
server.start()
logging.info("Server started at: http://" + address)
server.wait_for_termination()
def __init__(self):
self.auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
self.auth.set_access_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
self.api = tweepy.API(self.auth)
try:
print('There are {} tweets in the database.'.format(
model.Tweet.select().count()))
except pw.OperationalError:
model.create_tables()
print(
'There are {} tweets in the newly created Tweet table.'.format(
model.Tweet.select().count()))
def adduser(_=None):
create_tables()
username = raw_input('Username:')
user = None
try:
user = User.get(name=username)
except User.DoesNotExist:
pass # ok
if user:
sys.exit("The username has been already used.")
password = getpass.getpass()
user = User(name=username, password=password)
user.save()
print("The user was created successfully.")
database.close()
def create_app():
app = Flask(__name__)
CORS(app)
basedir = os.path.abspath(__file__)
app.config.update(
dict(
SECRET_KEY="subscribe secretkey",
WTF_CSRF_SECRET_KEY="subscribe csrf secret key",
SQLALCHEMY_DATABASE_URI="sqlite:///" + 'aws-ssm-list.db',
SQLALCHEMY_TRACK_MODIFICATIONS=False,
JSON_SORT_KEYS=False
)
)
model.init_app(app)
model.create_tables(app)
return app
def main():
model.create_tables()
load_users()
load_levels()
load_user_levels()
model.session.commit()
def init_controller():
model.load_database()
model.create_tables()
def main():
model.create_tables()
load_users()
load_levels()
load_user_levels()
model.session.commit()
def main(session):
# objectUsers,objectRatings,objectMovies = open(sys.argv[3])
model.create_tables()
load_users(session)
load_movies(session)
load_ratings(session)
def reset():
database = CreateDB()
create_tables()
setup_db()
return redirect(url_for('index'))
# These two lines are needed to run on EL6
__requires__ = ['SQLAlchemy >= 0.7', 'jinja2 >= 2.4']
import pkg_resources
import default_config
import model
model.create_tables(
default_config.DB_URL,
None,
debug=True)
# for city in response['items']:
# print(city['id'], city['title'], city['area'], city['region'])
# return cities
# for region in regions:
# if response['count']>1000:
# pass
# response = vk.database.getCities(country_id=region['country_id'], region_id=region['id'], need_all=1,
# count=1000, offset=offset)
# print(response)
if __name__ == '__main__':
engine.connect().execute(
"""drop table search_result, search_params, vkinder_user, viewed_users;"""
)
create_tables()
user = VKinder(1)
user.write_user_info('vkinder_user')
user.get_search_params(1, 18, 20)
user.write_user_info('search_result')
# меняем критерии и выполняем повторный поиск:
user.get_search_params(1, 18, 25)
user.write_user_info('search_result')
# устанавливаем статус для найденных пользователей:
*_, id1 = user.get_user_from_db()
user.set_user_status(id1, 0)
*_, id2 = user.get_user_from_db()
user.set_user_status(id2, 1)
import utils
def init_leverages():
for symbol in model_service.get_current_futures():
binance_client.futures_coin_change_leverage(symbol=symbol, leverage=1)
try:
binance_client.futures_coin_change_margin_type(
symbol=symbol, marginType="ISOLATED")
except:
pass
if __name__ == '__main__':
model.create_tables()
model_view.create_views()
model_service.check_config()
init_leverages()
thread_account_update = Thread(name="task_account_update",
target=task_account_update)
thread_account_update.start()
task_current_futures = Thread(name="task_current_futures",
target=task_current_futures)
task_current_futures.start()
if snow_data['data'][0]['Change In Snow Depth (in)'] != None:
depth_change = int(snow_data['data'][0]['Change In Snow Depth (in)'])
if snow_data['data'][0]['Snow Water Equivalent (in)'] != None:
water_equiv = float(snow_data['data'][0]['Snow Water Equivalent (in)'])
if snow_data['data'][0]['Change In Snow Water Equivalent (in)'] !=None:
water_equiv_change = float(snow_data['data'][0]['Change In Snow Water Equivalent (in)'])
telemetry_data = model.Snow_Data(\
sta_given_id = triplet,\
station_id = station_id.id,\
source = source,\
units = units,\
date = date,\
depth = depth)
if depth_change != None:
telemetry_data.depth_change = depth_change
if water_equiv != None:
telemetry_data.water_equiv = water_equiv
if water_equiv_change != None:
telemetry_data.water_equiv_change = water_equiv_change
session.add(telemetry_data)
session.commit()
def main(session):
# load_stations(session)
load_snow_data_csv(session)
# load_snow_data_API(session)
if __name__ == "__main__":
s= model.create_tables()
main(s)
def setup_db():
print('Setting DB')
sys.stdout.flush()
create_tables()
def initdb():
create_tables()
click.echo('Initialisation de la Base de données')
def initdb():
"""Create database"""
create_tables()
click.echo('Initialized the database')
def before_request():
if not model.network.table_exists():
model.create_tables()
def before_request():
if not model.network.table_exists():
model.create_tables()
def make_app(global_conf={}):
app.debug = False
app.secret_key = os.urandom(24)
create_tables()
return app
