def initialize(self):
conf = ConfigParser.RawConfigParser(allow_no_value=True)
conf.read('db.conf')
db_usr = conf.get('mysql', 'user')
db_pwd = conf.get('mysql', 'passwd')
db.bind('mysql', host='localhost', user=db_usr, passwd=db_pwd, db='DOB')
db.generate_mapping(check_tables=True, create_tables=True)
def global_setup():
print("Global SetUp: Bind database and generate mapping")
db_name = "test_db.db"
db.bind(provider="sqlite", filename=db_name, create_db=True)
db.generate_mapping(create_tables=True)
yield
print("Global TearDown: drop tables")
db.drop_all_tables(with_all_data=True)
db.disconnect()
from flask import Flask
from flask_graphql import GraphQLView
from pony.flask import Pony
from models import db
from schema import schema
app = Flask(__name__)
Pony(app)
app.add_url_rule('/graphql',
view_func=GraphQLView.as_view('graphql',
schema=schema,
graphiql=True))
if __name__ == '__main__':
db.bind(provider='postgres',
user='******',
port=5432,
password='******',
host='postgres',
database='postgres')
db.generate_mapping(create_tables=False)
app.run(host="0.0.0.0", port=5000, debug=True)
secret_key = 'taU>5&(Z*+r2d5ULR|i2z$bt@+ 9|i,;u!N_2);v@i/@y;gUf/&0WXC?}g6<aK$H'
app = Flask(__name__, static_folder='pub', static_url_path='/static')
app.secret_key = secret_key
app.register_blueprint(api_bp, url_prefix='/api')
# Ref: http://stackoverflow.com/questions/34484066/create-a-postgres-database-using-python
# Create the required database if it doesn't exist.
con = psql.connect(dbname='postgres')
con.autocommit = True
cur = con.cursor()
try:
# cur.execute('DROP DATABASE catalog;')
cur.execute('CREATE DATABASE catalog;')
except:
pass
db.bind('postgres', database='catalog')
db.generate_mapping(create_tables=True)
# Only one catchall route required because this is a single page React app.
@app.route('/')
@app.route('/<path:path>')
def root(cat=None, id=None, path=None):
return render_template('index.html')
if __name__ == '__main__':
app.run(debug=True, host='0.0.0.0')
from dotenv import load_dotenv
from telegram import Bot
from telegram.ext import Updater
from models import db
import os
load_dotenv()
if os.getenv("DB_PROVIDER") == "sqlite":
db.bind(
provider="sqlite",
filename=os.getenv("DB_FILENAME"),
create_db=True,
)
else:
db.bind(
provider=os.getenv("DB_PROVIDER"),
user=os.getenv("DB_USER"),
password=os.getenv("DB_PASSWORD"),
host=os.getenv("DB_HOST"),
database=os.getenv("DB_DATABASE"),
)
db.generate_mapping(create_tables=True)
bot = Bot(os.getenv("TELEGRAM_TOKEN"))
# Create the Updater and pass it your bot's token.
# Make sure to set use_context=True to use the new context based callbacks
# Post version 12 this will no longer be necessary
est_num.append(int(est["estimate"]))
all_identical = est_num[1:] == est_num[:-1]
ranked = Counter(est_num).most_common(1)
if ranked:
result = str(ranked[0][0])
if not all_identical:
result += " (!)"
else:
result = '-'
return result
if __name__ == '__main__':
db.bind(provider=app.config['PONY']['provider'],
user=app.config['PONY']['user'],
password=app.config['PONY']['password'],
host=os.environ.get('DATABASE_URL') or app.config['PONY']['host'],
database=app.config['PONY']['database'],
port=app.config['PONY']['port'])
db.generate_mapping(create_tables=app.config['PONY']['create_tables'])
app.run(host='0.0.0.0')
if __name__ == 'app':
db.bind(provider=app.config['PONY']['provider'],
user=app.config['PONY']['user'],
password=app.config['PONY']['password'],
host=app.config['PONY']['host'],
database=app.config['PONY']['database'],
port=app.config['PONY']['port'])
db.generate_mapping(create_tables=app.config['PONY']['create_tables'])
app.run(host='0.0.0.0')
import database
import start
import help
import settings
import voteban
import admin_utils
import utils
config = configparser.ConfigParser()
config.read('/home/wanku/itc_moderator_bot/settings.ini')
bot = telebot.TeleBot(config['DEFAULT']['token'], threaded=False)
db.bind(
provider='mysql',
host=config['DEFAULT']['db_host'],
user=config['DEFAULT']['db_username'],
passwd=config['DEFAULT']['db_password'],
db=config['DEFAULT']['db_database'],
)
db.generate_mapping(create_tables=True)
@bot.message_handler(commands=['start'])
def handle_start(message):
start.handle_start(bot, message)
@bot.message_handler(commands=['help'])
def handle_help(message):
help.handle_help(bot, message)
import logging
from pony.orm import *
from models import db
from models.vxuser import VXUser
from models.vxmessage import VXMessage
# from models.vxsystem_parameter import VXSystemParameter
logger = logging.getLogger("VLIM Bot")
db_provider = 'postgres'
db_user = '******'
db_password = '******'
db_host = '127.0.0.1'
db_database = 'vlim_bot'
db.bind(provider=db_provider,
user=db_user,
password=db_password,
host=db_host,
database=db_database)
db.generate_mapping(create_tables=True)
# тут типа берется список файлов из modules/, а там фунции run и они запускаются
import os
from hashlib import md5
from importlib import import_module
from pony.orm import db_session
from models import db, News
from settings import DATABASE
db.bind(**DATABASE)
db.generate_mapping(create_tables=True)
modules = os.listdir('app/news_modules')
modules = [(module.replace('.py', ''),
import_module('news_modules.{}'.format(module.replace('.py', ''))))
for module in modules if not module.startswith('__')]
if __name__ == '__main__':
for name, module in modules:
news = module.run()
for n in news:
hash = md5(n['caption'].encode()).hexdigest()
with db_session:
if len(
News.select(
lambda n: n.hash == hash and n.source == name)):
continue
News(source=name, hash=hash, hide=False, **n)
db.Organisator(inn=3143, name='Showcompany')
db.Organisator(inn=1787, name='Promofabrika')
db.Organisator(inn=7589, name='Grand Premier')
if db.Place.select().first() is None:
place_a2 = db.Place(name='A2 Concert Hall')
place_air = db.Place(name='Club AIR')
place_ph = db.Place(name='BC Phoenix')
place_morskaya = db.Place(name='BC Morskaya')
if db.Auditory.select().first() is None:
db.Auditory(number=1, capacity=100, place=place_a2)
db.Auditory(number=2, capacity=20, place=place_a2)
db.Auditory(number=3, capacity=5, place=place_a2)
db.Auditory(number=1, capacity=120, place=place_air)
db.Auditory(number=2, capacity=10, place=place_air)
db.Auditory(number=3, capacity=10, place=place_air)
db.Auditory(number=7, capacity=24, place=place_ph)
db.Auditory(number=15, capacity=48, place=place_ph)
db.Auditory(number=33, capacity=96, place=place_ph)
db.Auditory(number=101, capacity=64, place=place_morskaya)
db.Auditory(number=1001, capacity=128, place=place_morskaya)
db.Auditory(number=11, capacity=256, place=place_morskaya)
db.bind(provider='sqlite', filename='database.sqlite', create_db=True)
db.generate_mapping(create_tables=True)
generate_db_data()
def run(*args, **kwargs):
if not os.path.exists(DEPLOY_DIR):
os.makedirs(DEPLOY_DIR)
db.bind(DB_PROVIDER, **DB_CONFIG)
db.generate_mapping(create_tables=True)
return app.run(*args, **kwargs)
from configparser import ConfigParser
from telegram import Bot
from telegram.ext import Updater
from models import db
# Load config.ini
config = ConfigParser()
config.read("config.ini")
db.bind(provider="sqlite", filename="database.sqlite", create_db=True)
db.generate_mapping(create_tables=True)
bot = Bot(config["telegram"]["token"])
# Create the Updater and pass it your bot's token.
# Make sure to set use_context=True to use the new context based callbacks
# Post version 12 this will no longer be necessary
updater = Updater(config["telegram"]["token"], use_context=True)
bot_description = """
This bot works in all your chats and groups, there's no need to add it anywhere.
Simply type in any chat @spnpbot, then a whitespace.
This will open a panel with a preview of the song you are currently playing on Spotify. Tap on it to send the song right away.
"""
# add the handler to the root logger
logger.addHandler(console)
# Named tuple for RollNo
RollNo = namedtuple("RollNo", ['roll_no', "idx", "search"])
# Database Setup
DBNAME = "{}-{}-{}-data-{:0>6}-{:0>6}-{year}.sqlite".format(options.level,
options.part,
options.type,
options.start,
options.end,
year=2018)
DIRNAME = "data"
db.bind('sqlite', path.join(DIRNAME, DBNAME), create_db=True)
db.generate_mapping(create_tables=True)
def output_ranges(level, part, type):
if type == "A":
if level == "SSC":
if part == "I":
return 900001, 999999, "https://www.fbise.edu.pk/res-ssc-I.php"
if part == "II":
return 100001, 199999, "https://www.fbise.edu.pk/res-ssc-II.php"
elif level == "HSSC":
if part == "I":
return 300001, 399999, "https://www.fbise.edu.pk/res-hssc-I.php"
if part == "II":
# Setting up the option parser
parser = OptionParser()
parser.add_option("-l", "--level", dest="level", type="str")
parser.add_option("-p", "--part", dest="part", type="str")
parser.add_option("-t", "--type", dest="type", type="str")
(options, args) = parser.parse_args()
DBDIR = "data"
INPUT_DB_NAME = "{}-{}-{}-complete.sqlite".format(options.level, options.part, options.type)
OUTPUT_DB_NAME = "{}-{}-{}-clean.sqlite".format(options.level, options.part, options.type)
INVALID_RECORD_MESSAGE = "Record Not Found Check Roll Number"
db.bind('sqlite', os.path.join(DBDIR, INPUT_DB_NAME))
db.generate_mapping()
cleandb.bind('sqlite', os.path.join(DBDIR, OUTPUT_DB_NAME), create_db=True)
cleandb.generate_mapping(create_tables=True)
with orm.db_session:
pool = orm.select(c for c in Record if c.error == 0)[:]
test = random.sample(pool, 90) + pool[-10:]
def split_tables(soup):
info, results = soup.find_all('table')[-2:]
return info, results
from flaskr import create_app
from models import db as mysql_db
from models import populate_db
from rabbitmq import rabbitmq
import env
app = create_app()
mysql_db.bind(**env.mysql_db_settings)
mysql_db.generate_mapping(create_tables=True)
if __name__ == "__main__":
rabbitmq.connect()
populate_db()
app.run(debug=True, host='0.0.0.0', use_reloader=False)
# Script to read from database and output recipient of participant into .txt file
from models import db, Participant
from pony.orm import *
db.bind('sqlite', 'participants.db', create_db=False)
db.generate_mapping(create_tables=True)
@db_session
def recipient_to_txt():
query = Participant.get(name=input('Who do you need the recipient for? ex: Justin: '))
with open(query.name + '.txt', 'w') as file:
file.write(query.name + ', you are giving to ' + query.giving_to + "!")
recipient_to_txt()
'provider': 'sqlite',
'filename': 'db.db3',
'create_db': True
}))
Pony(app)
login_manager = LoginManager(app)
login_manager.login_view = 'login'
@login_manager.user_loader
def load_user(user_id):
return db.User.get(id=user_id)
db.bind(**app.config['PONY'])
db.generate_mapping(create_tables=True)
@app.route('/')
def index():
users = db.User.select()
return render_template('home.html', user=current_user, users=users)
@app.route('/about')
def about():
return render_template('about.html')
@app.route('/login', methods=['GET', 'POST'])
from pony import orm
from datetime import datetime, timedelta
from models import db
# HACK: We should use a real unit testing library with real unit tests
# instead of rolling our own like I did here.
if __name__ == '__main__':
print('--- Testing the Database ---')
print('\n> Enabling SQL debugging...')
orm.set_sql_debug(True)
print('\n> Binding DB to SQLite instance in memory.')
db.bind(provider='sqlite', filename=':memory:')
print('\n> Generating DB mapping...')
db.generate_mapping(create_tables=True)
db.commit()
with orm.db_session:
# User IDs in the DB correspond to their Discord IDs
print('\n> Generating Users...')
u1 = db.User(id=143123353249513472)
u2 = db.User(id=444183067678998540)
u3 = db.User(id=293900315089174529)
# Issue explicit commits otherwise the DB will batch commits and the
# print() statements get out of sync.
db.commit()
print('\n> Generating Servers...')
s1 = db.Server(id=142851181843185664)
app.static("/favicon.ico", "static/favicon.ico")
app.blueprint(api)
env = Environment(loader=FileSystemLoader("templates"),
autoescape=select_autoescape(["html"]))
env.globals["url_for"] = app.url_for
env.globals["app"] = app
env.globals["config"] = config
app.env = env
# https://stackoverflow.com/a/51671065/11363384
db.bind(provider='postgres',
user=config.POSTGRES_USERNAME,
password=config.POSTGRES_PASSWORD,
host=config.POSTGRES_HOST,
database=config.DB_NAME)
db.generate_mapping(create_tables=True)
@app.route("/")
@is_user_logged_in
async def landing_page(request, is_logged_in):
if is_logged_in:
return redirect(app.url_for("watchlist.root"))
else:
trending = await get_trending(4)
template = env.get_template("landing-page.html")
return html(template.render(trending=trending))
