@app.after_request
def after_request(response):
response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
response.headers["Expires"] = 0
response.headers["Pragma"] = "no-cache"
return response
# # Configure session to use filesystem (instead of signed cookies)
app.config["SESSION_FILE_DIR"] = mkdtemp()
app.config["SESSION_PERMANENT"] = False
app.config["SESSION_TYPE"] = "filesystem"
Session(app)
# Configure CS50 Library to use SQLite database
db = SQL("sqlite:///deepwork.db")
@app.route("/", methods=["GET", "POST"])
@login_required
def index():
"""
Home Page where user can log timed tasks.
"""
# If user logged time
if request.method == "POST":
# JSON data format[hours, minutes, seconds, startTime, startDate, stopTime, stopDate, taskDescription, deepworkBool]
data = request.get_json()
# Ensure user has recorded time
if not data['startTime']:
response.headers["Expires"] = 0
response.headers["Pragma"] = "no-cache"
return response
# custom filter
app.jinja_env.filters["usd"] = usd
# configure session to use filesystem (instead of signed cookies)
app.config["SESSION_FILE_DIR"] = mkdtemp()
app.config["SESSION_PERMANENT"] = False
app.config["SESSION_TYPE"] = "filesystem"
Session(app)
# configure CS50 Library to use SQLite database
db = SQL("sqlite:///finance.db")
@app.route("/")
@login_required
def index():
# Sometimes the alphavantage API has issues, if it is unable to provide the neccessary
# data to present the portfolio, route the user to the "quote" template
# https://www.alphavantage.co/documentation/
try:
user = db.execute("SELECT username FROM users WHERE id=:id",
id=session['user_id'])
logging.info(user)
# Retrieve the stock symbol(s) and the corresponding number of shares from the portfoilo table
class Stock(object):
'''
Stock database handeling
'''
def __init__(self, source="sqlite:///finance.db"):
self.db = SQL(source)
def __str__(self):
'''
Returns the total amount of stocks in a string
'''
rows = self.db.execute("SELECT * FROM stocks")
total = 0
for row in rows:
total += row["amount"]
return f'Stock database contains {total} stocks'
def get_stocks(self, user_id):
'''
Returns a list of stocks corresponding to an ID number
'''
all_stocks = self.db.execute(
"SELECT stock FROM stocks WHERE id = :username", username=user_id)
list_stocks = []
for stock in all_stocks:
list_stocks.append(stock['stock'])
return list_stocks
def get_portfolio(self, user_id):
'''
Returns the row in JSON of a user
'''
all_stocks = self.db.execute(
"SELECT * FROM stocks WHERE id = :username", username=user_id)
return all_stocks
def get_amount(self, user_id, stock):
'''
Returns amount of stocks corresponding to an ID, if NONE returns 0.
'''
stock = stock.upper()
amount = self.db.execute(
"SELECT amount FROM stocks WHERE id = :username AND stock = :stock",
username=user_id,
stock=stock)
if amount:
return amount[0]['amount']
else:
return 0
def stock_zero(self, user_id, stock):
'''
Checks if Stock is None/empty
'''
stock_info = self.db.execute(
"SELECT amount FROM stocks WHERE id = :username AND stock = :stock",
username=user_id,
stock=stock)
if len(stock_info) > 0:
return False
else:
return True
def delete_stock(self, user_id, stock):
'''
Deletes stock of user.
'''
self.db.execute(
"Delete FROM stocks WHERE id = :username and stock = :stock",
username=user_id,
stock=stock)
return True
def add_stock(self, user_id, stock, amount):
'''
Adds stock of user
'''
self.db.execute(
"INSERT INTO stocks (id, stock, amount)"
"VALUES (:username, :stock ,:amount)",
username=user_id,
stock=stock,
amount=amount)
return True
def set_stock(self, user_id, stock, amount):
'''
Updates stock of user
'''
old_amount = self.db.execute(
"SELECT amount FROM stocks "
"WHERE id = :username AND stock = :stock",
username=user_id,
stock=stock)
amount = old_amount[0]["amount"] + amount
self.db.execute(
"UPDATE stocks SET amount = :amount "
"WHERE id = :username AND stock = :stock",
amount=amount,
username=user_id,
stock=stock)
return True
# TODO
from sys import argv
import csv
from cs50 import SQL
db = SQL("sqlite:///students.db")
#function for reading with all condition
def enter(csv_read_var):
fist_exception = 0
for i in csv_read_var:
if fist_exception == 0:
fist_exception += 1
continue
if len(i[0].split()) < 3:
name = i[0].split()
#print("if name " , name)
db.execute(
"INSERT INTO students (first , middle , last , house , birth) VALUES(? , ? , ? , ? , ?)",
name[0], "NONE", name[1], i[1], i[2])
else:
name = i[0].split()
#print("else name" , name)
db.execute(
"INSERT INTO students (first , middle , last , house , birth) VALUES(? , ? , ? , ? , ?)",
name[0], name[1], name[2], i[1], i[2])
#reading from csv using function
with open(argv[1], 'r') as csv_file:
import time
import datetime
import flask
import sqlite3
from cs50 import SQL
from flask import Flask, flash, jsonify, redirect, render_template, request, session
from flask_session import Session
from tempfile import mkdtemp
from werkzeug.exceptions import default_exceptions, HTTPException, InternalServerError
from werkzeug.security import check_password_hash, generate_password_hash
from helper import login_required, usd, timeformater
from engine import orderbook_sync
from app import app
db = SQL('sqlite:///DB.db')
@app.route('/', methods=['GET'])
def home():
return render_template("home.html")
@app.route("/trade")
@login_required
def trade():
"""Trading Interface"""
return render_template("trade.html")
@app.route("/funding")
import os
import requests
import urllib.parse
from cs50 import SQL
from flask import flash, redirect, render_template, request, session
from functools import wraps
# Finds SQLite3 database
db = SQL("sqlite:///jpthephonesurgeon.db")
def apology(message, code=400):
"""Render message as an apology to user."""
def escape(s):
"""
Escape special characters.
https://github.com/jacebrowning/memegen#special-characters
"""
for old, new in [("-", "--"), (" ", "-"), ("_", "__"), ("?", "~q"),
("%", "~p"), ("#", "~h"), ("/", "~s"), ("\"", "''")]:
s = s.replace(old, new)
return s
return render_template("auth/apology.html",
top=code,
bottom=escape(message)), code
def login_required(f):
import tensorflow
import logging
import sys
# Configure application
app = Flask(__name__)
# Ensure templates are auto-reloaded
app.config["TEMPLATES_AUTO_RELOAD"] = True
# Configure session to use filesystem (instead of signed cookies)
app.config["SESSION_FILE_DIR"] = mkdtemp()
app.config["SESSION_PERMANENT"] = False
app.config["SESSION_TYPE"] = "filesystem"
Session(app)
db = SQL("sqlite:///heart.db")
@app.route("/", methods=["GET", "POST"])
def main():
return render_template("main.html")
@app.route("/more", methods=["GET", "POST"])
@login_required
def more():
# Directs the user to the more html when they try to open it
if request.method == "GET":
return render_template("more.html")
# Takes care of the code as the user is trying to fill out the form
import sys
sys.path.insert(0, "../src")
from cs50 import SQL
db = SQL("mysql://root@localhost/test")
db.execute("SELECT 1")
import os
from cs50 import SQL
from flask import Flask, flash, jsonify, redirect, render_template, request, session
from flask_session import Session
from tempfile import mkdtemp
from werkzeug.exceptions import default_exceptions, HTTPException, InternalServerError
from werkzeug.security import check_password_hash, generate_password_hash
db = SQL("sqlite:///subrecipe.db")
print(subsubrecipes)
import csv
import urllib.request
from flask import redirect, render_template, request, session
from functools import wraps
import requests
import random
from cs50 import SQL
import ast
from passlib.apps import custom_app_context as pwd_context
db = SQL("sqlite:///trivia.db")
def create_game(player1_id, player2_id):
"""Create a game between two players."""
# haal vragen op
vragen = requests.get("https://opentdb.com/api.php?amount=50&category=22&type=multiple")
# zet vragen in json
json = vragen.json()
# shuffle de vragen
random.shuffle(json["results"])
# insert de benodigde gegevens in de database
player1_name = db.execute("SELECT username FROM users WHERE id = :player1_id", player1_id=player1_id)[0]["username"]
player2_name = db.execute("SELECT username FROM users WHERE id = :player2_id", player2_id=player2_id)[0]["username"]
db.execute("INSERT INTO games (player1_id, player2_id, questions, player1_name, player2_name) VALUES (:player1_id, :player2_id, :questions, :player1_name, :player2_name)",
player1_id=player1_id, player2_id=player2_id, questions=str(json), player1_name=player1_name, player2_name=player2_name)
return db.execute("SELECT max(game_id) FROM games WHERE player1_id = :player1_id AND player2_id = :player2_id",
player1_id=player1_id, player2_id=player2_id)[0]["max(game_id)"]
import csv
import sqlite3
from cs50 import SQL
from sys import argv, exit
if len(argv) == 2:
db = SQL("sqlite:///students.db")
lsts = db.execute(
"SELECT * FROM students WHERE house = (?) ORDER BY last, first",
argv[1])
for lst in lsts:
if lst['middle'] == None:
print(f"{lst['first']} {lst['last']}, born {lst['birth']}")
else:
print(
f"{lst['first']} {lst['middle']} {lst['last']}, born {lst['birth']}"
)
else:
print(f"Error there should be 2 argv, you have {argv}")
exit(1)
@app.after_request
def after_request(response):
response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
response.headers["Expires"] = 0
response.headers["Pragma"] = "no-cache"
return response
# Configure session to use filesystem (instead of signed cookies)
app.config["SESSION_FILE_DIR"] = mkdtemp()
app.config["SESSION_PERMANENT"] = False
app.config["SESSION_TYPE"] = "filesystem"
Session(app)
# Configure CS50 Library to use SQLite database
db = SQL("sqlite:///finalproject.db")
@app.route("/")
@login_required
def index():
"""Show all of the qualities of the website(Main page)"""
name = db.execute(
"SELECT username FROM users WHERE id=:id",
id=session["user_id"]) #name of user queried from database using SQL
time = datetime.now() # time is now containing date and time
return render_template("index.html",
username=name[0]["username"],
current_time=time.strftime("%d/%m/%Y %H:%M:%S"))
def after_request(response):
response.headers[
"Cache-Control"] = "no-cache, no-store, must-revalidate"
response.headers["Expires"] = 0
response.headers["Pragma"] = "no-cache"
return response
# logger = logging.getLogger('cs50')
# logger.propagate = False
logger = logging.getLogger('cs50')
logger.disabled = True
# configure CS50 Library to use SQLite database
db = SQL("sqlite:///csv.db")
# On IBM Cloud Cloud Foundry, get the port number from the environment variable PORT
# When running this app on the local machine, default the port to 8000
port = int(os.getenv('PORT', 8000))
# Main Index page
@app.route("/")
def index():
# Extracting the entire SQlite table and then displaying it.
rows = db.execute("SELECT * FROM earthquakes WHERE 1")
return render_template("index.html", rows=rows)
response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
response.headers["Expires"] = 0
response.headers["Pragma"] = "no-cache"
return response
# Configure session to use filesystem (instead of signed cookies)
#app.config["SESSION_FILE_DIR"] = mkdtemp()
app.config["SESSION_PERMANENT"] = False
app.config["SESSION_TYPE"] = "filesystem"
Session(app)
# Configure CS50 Library to use Postgres database
db = SQL(
"postgres://*****:*****@ec2-54-228-250-82.eu-west-1.compute.amazonaws.com:5432/da5k6k2pjfrag7"
)
@app.route("/")
def landingpage():
return render_template("landingpage.html")
@app.route("/login", methods=["GET", "POST"])
def login():
"""Log user in"""
# Forget any user_id
session.clear()
@app.after_request
def after_request(response):
response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
response.headers["Expires"] = 0
response.headers["Pragma"] = "no-cache"
return response
# Configure session to use filesystem (instead of signed cookies)
app.config["SESSION_FILE_DIR"] = mkdtemp()
app.config["SESSION_PERMANENT"] = False
app.config["SESSION_TYPE"] = "filesystem"
Session(app)
# Configure CS50 Library to use SQLite database
db = SQL("sqlite:///gcapp.db")
@app.route("/")
@login_required
def index():
return render_template("index.html")
@app.route("/check", methods=["GET"])
def check():
username = request.args.get("username")
usernames = db.execute(
"SELECT username FROM users WHERE username = :username",
response.headers["Expires"] = 0
response.headers["Pragma"] = "no-cache"
return response
# Custom filter
app.jinja_env.filters["usd"] = usd
# Configure session to use filesystem (instead of signed cookies)
app.config["SESSION_FILE_DIR"] = mkdtemp()
app.config["SESSION_PERMANENT"] = False
app.config["SESSION_TYPE"] = "filesystem"
Session(app)
# Configure CS50 Library to use SQLite database
db = SQL("sqlite:///fitness.db")
@app.route("/")
@login_required
def index():
"""Show list of workouts"""
user = session["user_id"]
data = db.execute("SELECT * FROM users WHERE id=:current", current=user)
for line in data:
# line["name"] = name
# Render portfolio
# Configure session to use filesystem (instead of signed cookies)
# The directory where session files are stored. Default to use flask_session directory under current working directory.
app.config["SESSION_FILE_DIR"] = mkdtemp()
# Whether use permanent session or not, default to be True
# By default, all non-null sessions in Flask-Session are permanent.
# Therefore, we must set it to False so Session will expire when logging out
app.config["SESSION_PERMANENT"] = False
# Specifies which type of session interface to use. Builtin: null, redis, memcached, filesystem, mongodb, sqlalchemy
app.config["SESSION_TYPE"] = "filesystem"
# This class is used to add Server-side Session to one or more Flask applications.
# initialize the instance with a very specific Flask application
# Configure CS50 Library to use SQLite database
# #default from CS50 codebase
# db = SQL("sqlite:///finance.db")
# #When hosting with Heroku using Postgresql
db = SQL(os.getenv("DATABASE_URL"))
Session(app)
# Make sure API key is set
if not os.environ.get("API_KEY"):
raise RuntimeError("API_KEY not set")
@app.route("/")
@login_required
def index():
"""Show portfolio of stocks"""
empty_porfolio = True
# Return an array of object
porfolio = db.execute("SELECT * FROM porfolio WHERE user_id = :user_id",
@app.after_request
def after_request(response):
response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
response.headers["Expires"] = 0
response.headers["Pragma"] = "no-cache"
return response
# Configure session to use filesystem (instead of signed cookies)
app.config["SESSION_FILE_DIR"] = mkdtemp()
app.config["SESSION_PERMANENT"] = False
app.config["SESSION_TYPE"] = "filesystem"
Session(app)
# Configure CS50 Library to use mysql database
db = SQL('mysql://*****:*****@localhost/book')
@app.route("/")
def getbooks():
file = open("books.csv", "r")
reader = csv.reader(file)
for row in reader:
data = db.execute(
"INSERT INTO books (isbn,title,author,year) VALUES (:isbn,:title,:author,:year)",
isbn=row[0],
title=row[1],
author=row[2],
year=row[3])
return True
from cs50 import SQL
from sys import argv, exit
if len(argv) != 2:
print("Usage: python roster.py HouseName")
exit(1)
HouseName = argv[1]
house = []
frist = []
middle = []
last = []
birth = []
num = 0
db = SQL("sqlite:///students.db")
for row in db.execute("SELECT house FROM students GROUP BY house"):
house.append(row["house"])
def search(Tuple, n):
flag = 0
for i in range(len(Tuple)):
if Tuple[i] == n:
flag = 1
if flag == 0:
print("House Name is wrong it check it again")
exit(1)
search(house, HouseName)
response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
response.headers["Expires"] = 0
response.headers["Pragma"] = "no-cache"
return response
# custom filter
app.jinja_env.filters["usd"] = usd
# configure session to use filesystem (instead of signed cookies)
app.config["SESSION_FILE_DIR"] = gettempdir()
app.config["SESSION_PERMANENT"] = False
app.config["SESSION_TYPE"] = "filesystem"
Session(app)
# configure CS50 Library to use SQLite database
db = SQL("sqlite:///projectv2.db")
@app.route("/", methods=["GET", "POST"])
@login_required
def index():
"""Home page."""
# get todos for user
rows = db.execute("SELECT todo, category FROM todos WHERE user_id = :id ", id = session["user_id"])
# initialize index table
list1, list2, list3, list4 = [], [], [], []
#store table values
for i in range(len(rows)):
if rows[i]["category"] == 1:
list1.append(rows[i]["todo"])
import csv
from cs50 import SQL
from flask import Flask
db = SQL("sqlite:///busigence.db")
def main():
db.execute("CREATE TABLE customers ('customerid' varchar(255),'companyname' varchar(255),'contactname' varchar(255),'contacttitle' varchar(255))")
if __name__ == "__main__":
main()
@app.after_request
def after_request(response):
response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
response.headers["Expires"] = 0
response.headers["Pragma"] = "no-cache"
return response
# Configure session to use filesystem (instead of signed cookies)
app.config["SESSION_FILE_DIR"] = mkdtemp()
app.config["SESSION_PERMANENT"] = False
app.config["SESSION_TYPE"] = "filesystem"
Session(app)
# Configure website to use database
db = SQL("sqlite:///cirqitous.db")
# set up redirect for index page to go to main website page
@app.route("/")
@login_required
def index():
return render_template("distance.html")
# set up distance tab on website to create a distance variable from the user's inputted desired distance and measurement type
@app.route("/distance", methods=["GET", "POST"])
@login_required
def distance():
"""Enable user to look up a distance."""
app.config["SESSION_PERMANENT"] = False
app.config["SESSION_TYPE"] = "filesystem"
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
mail=Mail(app)
app.config['MAIL_SERVER']='smtp.gmail.com'
app.config['MAIL_PORT'] = 465
app.config['MAIL_USERNAME'] = '******'
app.config['MAIL_PASSWORD'] = '******'
app.config['MAIL_USE_TLS'] = False
app.config['MAIL_USE_SSL'] = True
mail = Mail(app)
Session(app)
db = SQL("sqlite:///user.db")
@app.route("/")
def index():
items=db.execute("SELECT * FROM item")
return render_template("index.html", items=items)
@app.route("/register", methods=["GET", "POST"])
def register():
if request.method == "POST":
result = db.execute("SELECT * FROM user WHERE username = :username",
username=request.form.get("username"))
print("check")
if result:
flash("Username is already taken! Please try again.")
response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
response.headers["Expires"] = 0
response.headers["Pragma"] = "no-cache"
return response
# Custom filter
app.jinja_env.filters["usd"] = usd
# Configure session to use filesystem (instead of signed cookies)
app.config["SESSION_FILE_DIR"] = mkdtemp()
app.config["SESSION_PERMANENT"] = False
app.config["SESSION_TYPE"] = "filesystem"
Session(app)
# Configure CS50 Library to use SQLite database
db = SQL("sqlite:///finance.db")
# Make sure API key is set
if not os.environ.get("API_KEY"):
raise RuntimeError("API_KEY not set")
@app.route("/")
@login_required
def index():
"""Show portfolio of stocks"""
# get the info from the database
stock = db.execute("SELECT * FROM stocks WHERE user_id = :user", user=session['user_id'])
cash = db.execute("SELECT cash FROM users WHERE id = :user", user=session['user_id'])[0]['cash']
# pass the info to the templates and shown on the homepage
JSGlue(app)
# ensure responses aren't cached
if app.config["DEBUG"]:
@app.after_request
def after_request(response):
response.headers[
"Cache-Control"] = "no-cache, no-store, must-revalidate"
response.headers["Expires"] = 0
response.headers["Pragma"] = "no-cache"
return response
# configure CS50 Library to use SQLite database
db = SQL("sqlite:///mashup.db")
@app.route("/")
def index():
"""Render map."""
if not os.environ.get("API_KEY"):
raise RuntimeError("API_KEY not set")
return render_template("index.html", key=os.environ.get("API_KEY"))
@app.route("/articles")
def articles():
"""Look up articles for geo."""
# ensure parameters are present
from cs50 import SQL
from sys import argv, exit
from csv import DictReader
# chaking command line arguments along with file type(.csv)
if len(argv) != 2 or not (argv[1].endswith('.csv')):
print("Usage: Invalid argument(s) number or file type")
exit(1)
#set up a database connection
db = SQL("sqlite:///students.db")
# to update student id
count = 1
# to open csv file
with open(argv[1], newline='') as csv_file:
studentDic = DictReader(csv_file)
for row in studentDic:
# to store splited list of name
namelist = str.split(row["name"])
#inserting into student.db
if len(namelist) == 2:
#to perform insert query
db.execute(
"INSERT INTO students(id, first, middle, last, house, birth) VALUES (?, ?, ?, ?, ?, ?)",
count, namelist[0], None, namelist[1], row["house"],
row["birth"])
elif len(namelist) == 3:
from cs50 import SQL
db = SQL("sqlite:///immuns.db")
def idArange(user):
countries = db.execute("SELECT * FROM :user", user=user)
x = 1
for country in countries:
db.execute("UPDATE :user SET id=:idx WHERE id=:firstID", user=user, idx=x, firstID=country["id"])
x = x + 1
#idArange("msen")
#idArange("mssp")
#idArange("hsen")
#idArange("hssp")
#idArange("generalList")
#idArange("Marissa Aguilar_ASFM")
def after_request(response):
response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
response.headers["Expires"] = 0
response.headers["Pragma"] = "no-cache"
return response
# Configure session to use filesystem (instead of signed cookies)
#app.config["SESSION_FILE_DIR"] = mkdtemp() # Only use when running locally
app.config["SESSION_PERMANENT"] = False
app.config["SESSION_TYPE"] = "filesystem"
Session(app)
# Configure CS50 Library to use SQLite database
db = SQL(
"postgres://*****:*****@ec2-52-86-116-94.compute-1.amazonaws.com:5432/d5t0i8j478i083"
)
# sqlite:///fallguys.db
@app.route("/", methods=["GET", "POST"])
@login_required
def index():
"""Enter new wins/losses"""
if request.method == "GET":
# Get list of games
finals = db.execute(
"SELECT * FROM fallguystracker.games WHERE mode='final'")
nonfinals = db.execute(
def __init__(self, source="sqlite:///finance.db"):
self.db = SQL(source)
import csv
import sys
from cs50 import SQL
db = SQL("sqlite:///students.db")
strCharacters = str(sys.argv[1])
NULL = None
my_Sql_push = ''
if strCharacters != NULL:
with open(strCharacters, 'r', encoding='ISO-8859-1') as csvB:
#csvBase = csv.reader(csvB)
csvBase = csv.DictReader(csvB)
for row in csvBase:
### Creating new keys inside Dictionary
row['middle'] = ''
row['last'] = ''
### Part fullname
split = row['name'].split()
row['name'] = split[0]
if len(split) == 3:
row['middle'] = split[1]
row['last'] = split[2]
else:
row['middle'] = None
row['last'] = split[1]
