コード例 #1
0
 def __init__(self, app):
     global session
     session = Session()
     self.app = app
     self.db = Database()
     self.db.destroy()
     self.db.init()
コード例 #2
0
def state_univ(state_list):
    """Return A JSON Containing National University Data."""
    output = []
    db_operator = Database()
    db_operator.check_database()
    for state_abbr in state_list:
        result_list = db_operator.get_state_univ(state_abbr=state_abbr)
        result_list = [
            dict(ID=result[0],
                 Name=result[1],
                 Ranking=result[2],
                 State=result[3],
                 City=result[4],
                 Type=result[5],
                 FoundYear=result[6],
                 Endowment=result[7],
                 TuitionAndFeesInState=result[8],
                 TuitionAndFeesOutOfState=result[9],
                 Enrollment=result[10],
                 MedianStartingSalary=result[11],
                 StudentFacultyRatio=result[12],
                 FemalePercentage=round(result[13] * 100, 1)
                 if result[13] is not None else None) for result in result_list
        ]
        output += result_list
    return json.dumps(output)
コード例 #3
0
def bar_state_univ(limit=20):
    """Bar Plot - States with Most National Universities"""
    if limit not in list(range(1, 31)):
        print('Invalid Input')
        return

    with Database() as db_operator:
        db_operator.check_database()
        result_list = db_operator.get_university_count(limit)

    data = [Bar(x=[result[0] for result in result_list],
                y=[result[1] for result in result_list],
                marker=dict(line=dict(color='rgb(0,0,0)',
                                      width=1.5)))]
    layout = Layout(xaxis=dict(tickangle=-45,
                               tickfont=dict(size=10)),
                    yaxis=dict(tickfont=dict(size=15)),
                    title='Top {} States with Most National Universities'.format(limit))
    fig = Figure(data=data, layout=layout)

    try:
        div = offplot(fig, show_link=False, output_type="div", include_plotlyjs=False)
        return div
    except PlotlyRequestError:
        print('Account limit reached')
        return '<div></div>'
コード例 #4
0
def histogram_difference_tuition():
    """Plot Histogram Showing Difference between In-State and Out-of-State Tuition and Fees of Public Universities"""
    with Database() as db_operator:
        db_operator.check_database()
        result_list = db_operator.get_tuition_difference()

    data = [Bar(x=['0', '0 ~ 5,000', '5,000 ~ 10,000', '10,000 ~ 15,000', '15,000 ~ 20,000', '20,000 ~ 25,000',
                   '25,000 ~ 30,000', '> 30,000'],
                y=[len([result for result in result_list if result == 0]),
                   len([result for result in result_list if 0 < result <= 5000]),
                   len([result for result in result_list if 5000 < result <= 10000]),
                   len([result for result in result_list if 10000 < result <= 15000]),
                   len([result for result in result_list if 15000 < result <= 20000]),
                   len([result for result in result_list if 20000 < result <= 25000]),
                   len([result for result in result_list if 25000 < result <= 30000]),
                   len([result for result in result_list if result > 30000])],
                marker=dict(line=dict(color='rgb(0,0,0)',
                                      width=1.5)))]
    layout = Layout(xaxis=dict(tickfont=dict(size=15)),
                    yaxis=dict(tickfont=dict(size=15)),
                    title='Difference between In-State and Out-of-State Tuition and Fees of Public Universities')
    fig = Figure(data=data, layout=layout)

    try:
        div = offplot(fig, show_link=False, output_type="div", include_plotlyjs=False)
        return div
    except PlotlyRequestError:
        print('Account limit reached')
        return '<div></div>'
コード例 #5
0
def state_gdp(state_list):
    """Return A JSON Containing GDP Data."""
    output = []
    db_operator = Database()
    db_operator.check_database()
    for state_abbr in state_list:
        result = db_operator.get_state_gdp(state_abbr=state_abbr)
        result = dict(Name=result[0],
                      Y1997=result[1],
                      Y1998=result[2],
                      Y1999=result[3],
                      Y2000=result[4],
                      Y2001=result[5],
                      Y2002=result[6],
                      Y2003=result[7],
                      Y2004=result[8],
                      Y2005=result[9],
                      Y2006=result[10],
                      Y2007=result[11],
                      Y2008=result[12],
                      Y2009=result[13],
                      Y2010=result[14],
                      Y2011=result[15],
                      Y2012=result[16],
                      Y2013=result[17],
                      Y2014=result[18],
                      Y2015=result[19],
                      Y2016=result[20])
        output.append(result)
    return json.dumps(output)
コード例 #6
0
ファイル: server.py プロジェクト: sgorawski/InformatykaUWr
def run_server():
    with SimpleXMLRPCServer(("localhost", 9000), allow_none=True) as server:
        server.register_instance(Database("contacts.db"))
        print("Serving XML-RPC on localhost port 9000")
        try:
            server.serve_forever()
        except KeyboardInterrupt:
            print("Server interrupted, exiting")
コード例 #7
0
def getDatabase():
    if 'db' not in g:
        g.db = Database('bucket_list')

    if g.db is None:
        abort(400)

    return g.db
コード例 #8
0
def main():
    if request.method == 'POST':
        ttemail = request.form.get('email')
        tpassword = request.form.get('password')
        db = Database()
        if db.isUserValid(ttemail, tpassword):
            return redirect("/dashboard")
        render_template('Login.html')
    return render_template('Login.html')
コード例 #9
0
def login():
    db = Database()
    if request.method == 'POST':
        username = request.form.get("username")
        password = request.form.get("password")
        if db.isUserValid(username, password):
            print("im okay")
            return redirect("/page2")
        else:
            return redirect("/")

    if request.method == 'GET':
        return render_template('index.html')
コード例 #10
0
def scatter_public_private(x_axis='Enrollment', y_axis='MedianStartingSalary'):
    """Scatter Plot - Clustering of Private & Public University"""
    axis_range = ['FoundYear', 'Endowment(M)', 'TuitionAndFeesInState', 'TuitionAndFeesOutOfState', 'Enrollment',
                  'MedianStartingSalary', 'StudentFacultyRatio', 'FemalePercentage', 'Tuition Difference']
    if x_axis not in axis_range:
        x_axis = 'Enrollment'
    if y_axis not in axis_range:
        y_axis = 'MedianStartingSalary'

    with Database() as db_operator:
        db_operator.check_database()
        result_list = db_operator.get_public_private(x_axis=x_axis, y_axis=y_axis)

    trace1 = Scatter(x=[result[0] for result in result_list if result[2] == 'Private'],
                     y=[result[1] for result in result_list if result[2] == 'Private'],
                     text=[result[3] for result in result_list if result[2] == 'Private'],
                     marker=dict(size=12,
                                 color='#258039'),
                     mode='markers',
                     name='Private')

    trace2 = Scatter(x=[result[0] for result in result_list if result[2] == 'Public'],
                     y=[result[1] for result in result_list if result[2] == 'Public'],
                     text=[result[3] for result in result_list if result[2] == 'Public'],
                     marker=dict(size=12,
                                 color='#F5BE41'),
                     mode='markers',
                     name='Public')

    data = [trace1, trace2]
    layout = Layout(xaxis=dict(tickfont=dict(size=15),
                               title=x_axis,
                               titlefont=dict(size=20)),
                    yaxis=dict(tickfont=dict(size=15),
                               title=y_axis,
                               titlefont=dict(size=20),
                               showline=True),
                    title='Clustering of Private & Public University',
                    titlefont=dict(size=25),
                    legend=dict(font=dict(size=20),
                                x=0.88,
                                y=0.97))
    fig = Figure(data=data, layout=layout)

    try:
        div = offplot(fig, show_link=False, output_type="div", include_plotlyjs=False)
        return div
    except PlotlyRequestError:
        print('Account limit reached')
        return '<div></div>'
コード例 #11
0
def scatter_university_gdp(input_phrase='Total Endowment (Million)'):
    """Scatter Plot - Relationship between GDP & National University Amount"""
    input_range = ['Total Endowment (Million)', 'Average Endowment (Million)', 'Total Enrollment', 'Average Enrollment',
                   'Average Tuition in State', 'Average Tuition out of State', 'Average Median Starting Salary',
                   'Average Student Faculty Ratio', 'Average Female Percentage']
    if input_phrase not in input_range:
        input_phrase = 'Total Endowment (Million)'

    with Database() as db_operator:
        db_operator.check_database()
        result_list = db_operator.get_university_gdp(additional_variable=input_phrase)

    if input_phrase == 'Average Student Faculty Ratio':
        text_format = '{0} ({1})<br>{2}: {3}:1'
    elif input_phrase == 'Average Female Percentage':
        text_format = '{0} ({1})<br>{2}: {3: 3.0%}'
    else:
        text_format = '{0} ({1})<br>{2}: {3}'
    text = [text_format.format(result[1], result[0], input_phrase, result[3]) for result in result_list]

    data = [Scatter(x=[result[2] for result in result_list],
                    y=[result[3] for result in result_list],
                    text=text,
                    marker=dict(sizeref=2. * max([result[4] for result in result_list]) / (100 ** 2),
                                size=[result[4] for result in result_list],
                                color=[result[4] for result in result_list],
                                colorscale='Viridis',
                                sizemode='area',
                                showscale=True,
                                colorbar=dict(title=input_phrase.replace(' (', '</br>(').replace(' ', '</br></br>'),
                                              titlefont=dict(size=15),
                                              tickfont=dict(size=15))),
                    mode='markers')]
    layout = Layout(xaxis=dict(tickfont=dict(size=15),
                               title='National University',
                               titlefont=dict(size=20)),
                    yaxis=dict(tickfont=dict(size=15),
                               title='GDP of State (Million $)',
                               titlefont=dict(size=20)),
                    title='Relationship between GDP & National University',
                    titlefont=dict(size=25))
    fig = Figure(data=data, layout=layout)

    try:
        div = offplot(fig, show_link=False, output_type="div", include_plotlyjs=False)
        return div
    except PlotlyRequestError:
        print('Account limit reached')
        return '<div></div>'
コード例 #12
0
def register():
    db = Database()
    if request.method == 'POST':
        fullname = request.form.get('fulllname')
        email = request.form.get('the_email')
        phone_number = request.form.get('the_phone_number')
        password = request.form.get('password')
        confirmpass = request.form.get('confirm_pass')
        if password != "" and confirmpass != "" and password == confirmpass:
            db.insertUser(fullname, email, password)
            print("done")
            # return render_template('Register.html',errormessage="User added successfully")
            return redirect('/')
        return render_template('Register.html',
                               errormessage="Mismatch password")
    return render_template('Register.html')
コード例 #13
0
def register():
    db = Database()

    if request.method == 'GET':
        return render_template('reg.html')

    if request.method == 'POST':
        username = request.form.get("username")
        email = request.form.get("email")
        password = request.form.get("psw")
        password_repeat = request.form.get("psw-repeat")

        if password == password_repeat and password_repeat != "" and password != "":
            db.insertUser(username, email, password)
            return redirect("/login")
        return render_template('reg.html')
コード例 #14
0
def state_abbr_table():
    """Initialize State Abbreviation Table"""
    t_name = 'State_Abbr'

    data_dict = get_state_abbr_data()
    data_dict['DC'] = 'District of Columbia'

    table_dict = dict(name=t_name,
                      column=[('Id', 'INTEGER'), ('StateAbbr', 'TEXT'),
                              ('StateName', 'TEXT')],
                      key='Id')

    statement = 'INSERT INTO {} VALUES (NULL, ?, ?)'.format(t_name)

    with Database() as db_operator:
        db_operator.create_table(table_dict)
        db_operator.insert_data(list(data_dict.items()), statement)
コード例 #15
0
def gdp_state_table():
    """Initialize GDP State Table"""
    t_name = 'GDP_State'

    column_name, column_data = get_gdp_data()
    column_list = ['INT'] * (len(column_name) - 1)

    table_dict = dict(name=t_name,
                      column=[('StateId', 'INTEGER')] +
                      list(zip(column_name[1:], column_list)))

    statement = 'INSERT INTO {} VALUES ('.format(t_name)
    statement += '(SELECT Id FROM State_Abbr WHERE StateName = ?)'
    statement += ', ?' * (len(column_name) - 1)
    statement += ')'

    with Database() as db_operator:
        db_operator.create_table(table_dict)
        db_operator.insert_data([tuple(row) for row in column_data[1:]],
                                statement)
コード例 #16
0
def mapbox_univ(state_abbr):
    """Plot National Universities on Map through Mapbox"""
    with Database() as db_operator:
        db_operator.check_database()
        result_list = db_operator.get_gps_data(state_abbr=state_abbr)

    lat_list = []
    lon_list = []
    name_list = []
    for result in result_list:
        if (result[1] is not None) and (result[2] is not None):
            lat_list.append(result[1])
            lon_list.append(result[2])
            name_list.append(result[0])

    axis_dict = get_axis_info(lat_list, lon_list)

    data = Data([Scattermapbox(name="National Universities",
                               lat=lat_list,
                               lon=lon_list,
                               text=name_list,
                               mode="markers",
                               marker=Marker(size=10))])
    layout = Layout(title="National Universities in " + state_abbr,
                    autosize=True,
                    hovermode="closest",
                    mapbox=dict(
                        accesstoken=mapbox_access_token,
                        bearing=0,
                        center=dict(lat=axis_dict["center_lat"],
                                    lon=axis_dict["center_lon"]),
                        zoom=5,
                        pitch=0))
    fig = dict(data=data, layout=layout)

    try:
        div = offplot(fig, show_link=False, output_type="div", include_plotlyjs=False)
        return div
    except PlotlyRequestError:
        print('Account limit reached')
        return '<div></div>'
コード例 #17
0
def national_university_table():
    """Initialize National University Table"""
    t_name = 'National_University'
    db_operator = Database()

    table_dict = dict(name=t_name,
                      column=[('Id', 'INTEGER'),
                              ('Name', 'TEXT'),
                              ('Ranking', 'TEXT'),
                              ('StateId', 'INT'),
                              ('City', 'TEXT'),
                              ('Type', 'TEXT'),
                              ('FoundYear', 'TEXT'),
                              ('Endowment(M)', 'REAL'),
                              ('TuitionAndFeesInState', 'INT'),
                              ('TuitionAndFeesOutOfState', 'INT'),
                              ('Enrollment', 'INT'),
                              ('MedianStartingSalary', 'INT'),
                              ('StudentFacultyRatio', 'INT'),
                              ('FemalePercentage', 'REAL'),
                              ('Latitude', 'INT'),
                              ('Longitude', 'INT')],
                      key='Id')
    db_operator.create_table(table_dict)

    statement = 'INSERT INTO {} VALUES (NULL'.format(t_name)
    statement += ', ?' * 2
    statement += ', (SELECT Id FROM State_Abbr WHERE StateAbbr = ?)'
    statement += ', ?' * 12
    statement += ')'

    data_list = []
    for nu_obj in get_all_national_university():
        data_list.append((nu_obj.name, nu_obj.ranking, nu_obj.state, nu_obj.city,
                          nu_obj.type, nu_obj.found_year, nu_obj.endowment, nu_obj.tuition_in_state,
                          nu_obj.tuition_out_state, nu_obj.enrollment, nu_obj.median_salary,
                          nu_obj.student_faculty, nu_obj.female, nu_obj.lat, nu_obj.lng))
    db_operator.insert_data(data_list, statement)
コード例 #18
0
def line_gdp(abbr_list):
    """Scatter Plot - GDP"""
    # if len(abbr_list) > 10:
    #     print('Too Many States')
    #     return

    with Database() as db_operator:
        db_operator.check_database()

        data = []
        for state_abbr in abbr_list:
            result = db_operator.get_state_gdp(state_abbr=state_abbr)

            if result is None:
                print('No Result')
                continue

            data.append(Scatter(x=list(range(1996, 2017)),
                                y=result[1:],
                                mode='lines+markers',
                                name=state_abbr))

    layout = Layout(xaxis=dict(tickfont=dict(size=15),
                               title='Year',
                               titlefont=dict(size=20)),
                    yaxis=dict(tickfont=dict(size=15),
                               title='GDP',
                               titlefont=dict(size=20)),
                    title='GDP')
    fig = Figure(data=data, layout=layout)

    try:
        div = offplot(fig, show_link=False, output_type="div", include_plotlyjs=False)
        return div
    except PlotlyRequestError:
        print('Account limit reached')
        return '<div></div>'
コード例 #19
0
ファイル: main.py プロジェクト: DmitriiTitkov/app_aio
@web.middleware
async def user_middleware(request: web.Request,
                          handler: Callable) -> web.Response:
    session = await get_session(request)
    if not session.empty:
        session['last_visited'] = datetime.datetime.now().isoformat()
    if session.get('user', None):
        request["user"] = session['user']
        request['last_visited'] = session['last_visited']

    return await handler(request)


loop = asyncio.get_event_loop()
pg_pool = loop.run_until_complete(create_pool())
db = Database(pg_pool)
redis = loop.run_until_complete(get_redis_pool())

storage = RedisStorage(redis)
session_middleware = aiohttp_session.session_middleware(storage)

dir_path = os.path.dirname(os.path.realpath(__file__))
router = SwaggerRouter(search_dirs=[dir_path],
                       swagger_ui='/api/',
                       default_validate=True)

app = web.Application(router=router,
                      middlewares=[
                          session_middleware, error_middleware,
                          user_middleware, jsonify
                      ])
コード例 #20
0
 def setUp(self):
     """Generate Database Operator"""
     from model import Database
     self.db = Database()
コード例 #21
0
ファイル: execute.py プロジェクト: smackov/visualization
"""
Execute script
"""

from model import Database
# sys.path.append('/Users/admin/Developer/Python/Playground/Visual')

config = {
    'user': '******',
    'password': '******',
    'host': 'localhost',
    'database': 'MV'
}

db = Database(**config)

db.show_weeks_short_information()

print(db.show_week_full_information(28))

db.close()
コード例 #22
0
ファイル: DSN.py プロジェクト: girishramnani/rpi_projects
from flask import Flask, request, session, g, redirect, url_for
from model import Database
import os
from config import CONFIG

app = Flask(__name__)
app.config.from_object(CONFIG)

x = Database(app)
x.init_db()


@app.route('/')
def hello_world():
    return 'Hello World!'


@app.route("/api", methods=["POST", "GET"])
def api():
    pass


if __name__ == '__main__':
    app.run()
コード例 #23
0
ファイル: app.py プロジェクト: Mexamos/my-postgresql-admin
from flask import Flask, request
from flask_cors import CORS
from model import Database

app = Flask(__name__)
CORS(app, origins='*', supports_credentials=True)

db = Database()


@app.route("/databases")
def get_data_bases():
    database_list = db.select_rows('SELECT datname FROM pg_database;')
    print('database_list', database_list)
    return database_list


@app.route("/databases/<dbname>/tables")
def get_table_list(dbname):
    tables_list = db.select_rows(
        "SELECT table_schema, table_name, table_type FROM information_schema.tables WHERE table_catalog = '"
        + dbname + "' ORDER BY table_schema, table_name;",
        dbname=dbname)
    return tables_list


@app.route("/databases/<dbname>/schema/<schemaname>")
def get_schema(dbname, schemaname):
    schema_table_list = db.select_rows(
        "SELECT c.table_name, t.table_type, json_agg(json_build_object('column_name', c.column_name, 'data_type', c.data_type)) AS columns FROM information_schema.columns c JOIN information_schema.tables t ON c.table_name = t.table_name WHERE c.table_schema = '"
        + schemaname + "' GROUP BY c.table_name, t.table_type;",
コード例 #24
0
from view import View
from model import Database

#Open connection to database with the Database class from models
my_database = Database()

#Initialize View class from view
my_view = View()

running = True
#Run menu until the exit choice is selected
while running == True:
    #output menu and take user input
    user_input = my_view.menu()

    #Insert item into shoppinglist
    if user_input == "1":
        #Get item name
        list_item = my_view.takeInput("Enter the name of the item: ")

        #Get amount of item
        choosing = True
        amount_of_item = ""
        while choosing == True:
            amount_of_item = my_view.takeInput(
                "Enter how many of that item you want: ")

            #CHeck if input is integer and convert to interger
            if amount_of_item.isdigit() == True:
                amount_of_item = int(amount_of_item)
                choosing = False