def first_run(self):
if db.num_users_defined() != 0:
turbogears.flash('Not the first run. User already defined.')
redirect(URL('/'))
db.initialize_db()
db.sync_songs()
db.sync_songbooks()
return dict(songbooks=[])
def make_app():
"""Neatly creates the webapp"""
app = web.Application()
config.read("config.cfg")
fernet_key = fernet.Fernet.generate_key()
secret_key = base64.urlsafe_b64decode(fernet_key)
setup(app, EncryptedCookieStorage(secret_key, cookie_name="session"))
routes.static("/", "static")
app.add_routes(routes)
db.initialize_db()
return app
def setUp(self):
# Initialize the database (will add any missing tables)
with db.connect_db() as conn:
db.initialize_db(conn)
c = conn.cursor()
# Clear out data from previous test
c.execute("DELETE FROM owners;")
c.execute("DELETE FROM projects;")
c.execute("DELETE FROM comments;")
conn.commit()
def initialize_db():
db.initialize_db(default_params)
return ''
import db, random
db.initialize_db()
data = db.sql_statement("SELECT * FROM students;")
def contact_tracing(data_input, infected_student):
infected_lst = []
def compare_schedules(Sch1, Sch2):
xsch = Sch1.split()
ysch = Sch2.split()
y = 0
for clss in xsch:
if clss == ysch[y]:
return True
y = y + 1
return False
for student in data_input:
if compare_schedules(infected_student[3], student[3]):
print(student)
infected_lst.append(student)
return infected_lst
# contact_tracing(data, random.choice(data))
from flask import Flask, request, jsonify
from flask_socketio import SocketIO, join_room, emit, rooms
from models import Session, User, Song
from db import initialize_db
from dotenv import load_dotenv, find_dotenv
import os
load_dotenv(find_dotenv())
app = Flask(__name__)
app.config['MONGODB_SETTINGS'] = {
'host': os.getenv('MONGODB_URL') # this should be in you .env-File
}
initialize_db(app)
socketio = SocketIO(app, cors_allowed_origins="*")
@socketio.on('connect')
def connect():
# send back connected signal
print('Client connected: ' + request.sid[:-10])
return
@socketio.on('disconnect')
def disconnect():
# send back connected signal
print('Client disconnected: ' + request.sid[:-10])
return
# some_file.py
import sys
# insert at 1, 0 is the script path (or '' in REPL)
sys.path.insert(1, '/home/thelyolya/source/insecure/src/py')
import db
db.initialize_db("/home/thelyolya/source/insecure/test/test.db")
fields = db.get_available_fields_list()
signums = db.get_all_signums_list()
for user in signums:
for field in fields:
print(db.get_info(user, field))
print(db.get_info("demo", """ * FROM employee -- """))
from jobs.hackernews import HackerNewsAPI
# Models bases
from jobs.model import JobBase
# Load environment variables
load_dotenv()
# Initialize Twitter API
print("Initializing Twitter API...")
twitter_api = TwitterAPI()
# # Initialize Database
print("Initializing DB...")
db_uri = os.getenv("DB_URI")
model_bases = [JobBase]
session = initialize_db(db_uri, model_bases)
# Initialize Services
print("Initializing Services...")
tweet_service = TweetService(session, twitter_api)
job_service = JobService(session, twitter_api)
if __name__ == "__main__":
args = get_arguments()
start_time = datetime.now()
if args.tweet:
print("Tweeting...")
tweet_service.tweet_job()
elif args.scrap_job:
print("Scrapping jobs....")
"""
This module contains example code for Flask usage.
Feel free to modify this file in any way.
"""
import json
import uuid
from flask import Flask, request, Response
from db import initialize_db, get_num_projects, add_project
from db import get_project_by_id, add_comment, get_comments_for_project
from db import delete_owners_project
from auth import get_user_info
app = Flask(__name__)
initialize_db()
@app.route("/", methods=["GET"])
def example():
"""
Basic example of GET to / using Flask
Does not handle missing or invalid Access Tokens
"""
if request.method == "GET":
# get bearer token from auth header
auth_header = request.headers.get("authorization")
access_token = auth_header[len("Bearer "):]
# get username and num_projects to respond with
user_info = get_user_info(access_token)
username = user_info["username"]
import json
import datetime
from dotenv import dotenv_values
import db
from sqlalchemy.orm import sessionmaker
data = []
config = dotenv_values(".env")
data_base = db.initialize_db(config["CONNECTION_STRING"])
Session = sessionmaker(bind=data_base)
session = Session()
with open("gavle_apartments.json") as f:
data = json.load(f)
db.Property.__table__.create(bind=data_base, checkfirst=True)
for entity in data:
property = db.Property()
if entity.get("url") is not None:
property.url = entity["url"]
if entity.get("img-url") is not None:
property.img_url = entity["img-url"]
if entity.get("street") is not None:
property.street = entity["street"]
if entity.get("address") is not None:
property.address = entity["address"]
if entity.get("price") is not None:
property.price = entity["price"]
if entity.get("Bostadstyp") is not None:
property.type = entity["Bostadstyp"]
if entity.get("Uppl\u00e5telseform") is not None:
property.contract_type = entity["Uppl\u00e5telseform"]
from config import DB_USER, DB_PASS, DB_HOST, DB_NAME
from db import initialize_db, models
from flask import Flask
from rest import initialize_app
from flask_migrate import Migrate
app = Flask(__name__)
app.config[
'SQLALCHEMY_DATABASE_URI'] = 'postgresql://{DB_USER}:{DB_PASS}@{DB_HOST}:5432/{DB_NAME}'.format(
DB_USER=DB_USER, DB_PASS=DB_PASS, DB_HOST=DB_HOST, DB_NAME=DB_NAME)
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
db = initialize_db(app)
migrate = Migrate(app, db)
initialize_app(app=app)
if __name__ == '__main__':
app.run(debug=True)
import sys
sys.path.insert(1, '/home/thelyolya/source/insecure/src/py')
import db
db.initialize_db("/home/admin/employee.db")
from tkinter import *
from tkinter import simpledialog
import db
#Sign in to task-diary
if __name__ == '__main__':
password_root = Tk()
password_root.withdraw()
password = simpledialog.askstring("Password",
"Enter your PostgreSQL password:"******"*")
password_root.destroy()
if password is None:
sys.exit()
db.initialize_db(password)
db.create_table5()
import auth
if (auth.signin == 1):
global username
username = auth.f_username
import task_diary_main
import redis
from flask import Flask, request, abort
from settings import vote_key, hashset_name, default_value, cfg_keys
from db import vote_for, initialize_db
from typing import List
redis_instance = redis.Redis(db=1)
app = Flask(__name__)
@app.route('/votes', methods=['POST'])
def votes():
request_body = request.json
if not request_body or not vote_key in request_body:
abort(400, 'This key does not exist')
voted_letter = request_body[vote_key]
return vote_for(voted_letter, redis_instance, hashset_name)
if __name__ == '__main__':
initialize_db(redis_instance, cfg_keys, default_value, hashset_name)
app.run()
