def store_bookmark(url, description):
try:
bm = models.Bookmark(user=logged_in_user(),
url=url,
description=description)
db.session.add(bm)
db.session.commit()
except OperationalError:
models.create_db()
def save_state(self, db_name):
if os.path.exists(db_name):
os.remove(db_name)
create_db(db_name)
try:
room.Room.commit_rooms(db_name)
person.Person.commit_people(db_name)
except Exception as e:
print e
return "Data Has been Saved to Database!"
def liked(id):
jdict = request.json
db = create_db()
db.begin()
ret = ActressOp(db).tag_like(id, jdict['liked'])
assert ret
db.commit()
return ujson.dumps({"test": True})
def create_app():
"""
Creates and configures the flask app
"""
# This must be imported here to avoid the chicken and the egg problem
import file_manager
import auth
db_uri = f"sqlite:///{db_path}"
app = CustomFlask(__name__, instance_relative_config=True)
app.config["UPLOAD_FOLDER"] = UPLOAD_DIR
app.config.from_mapping(SECRET_KEY=os.urandom(16),
SQLALCHEMY_DATABASE_URI=db_uri)
app.register_blueprint(file_manager.bp)
app.register_blueprint(auth.bp)
# Initialize login manager
login_manager = LoginManager()
login_manager.init_app(app)
# Initialize database
db.init_app(app)
from models import DBUser, create_db
create_db(app)
# Add admin
with app.app_context():
user = DBUser.query.filter_by(email=os.getenv("ADMIN_EMAIL")).first()
if not user:
user = DBUser(email=os.getenv("ADMIN_EMAIL"),
password=generate_password_hash(
os.getenv("ADMIN_PASS")),
username=os.getenv("ADMIN_NAME"))
db.session.add(user)
db.session.commit()
@login_manager.user_loader
def user_loader(user_id):
return DBUser.query.get(int(user_id))
return app
def save_to_db():
create_db()
print("movies fetching")
get_movies()
print("db creating")
engine = create_engine('sqlite:///myblog.db', echo=False,
connect_args={'check_same_thread': False})
Session = sessionmaker(bind=engine)
session = Session()
df = pd.read_csv("movies.csv")
for i in range(len(df)):
m = session.query(Movie).filter_by(
title=df.iloc[i]['title'], year=int(df.iloc[i]['year']))
if m:
pass
movie = Movie(title=df.iloc[i]['title'], year=int(df.iloc[i]['year']), poster=df.iloc[i]['poster'], duration=int(
df.iloc[i]['duration']), imdb_rating=df.iloc[i]['imdb_rating'], metascore_rating=df.iloc[i]['metascore_rating'])
session.add(movie)
director = session.query(Director).filter_by(
name=df.iloc[i]['director']).first()
if not director:
director = Director(name=df.iloc[i]['director'])
session.add(director)
director.movies.append(movie)
genres = df.iloc[i]["genre"].split(",")
for genre in genres:
g = session.query(Genre).filter_by(name=genre).first()
if not g:
g = Genre(name=genre)
session.add(g)
movie.genres.append(g)
actors = df.iloc[i]['cast'].split(",")
for actor in actors:
a = session.query(Actor).filter_by(name=actor).first()
if not a:
a = Actor(name=actor)
session.add(a)
movie.actors.append(a)
session.commit()
def test_db():
app.config.update(
# In-memory sqlite DB
SQLALCHEMY_DATABASE_URI='sqlite:///:memory:',
# Propagate exceptions (don't show 500 error page).
TESTING=True,
# Disable CSRF token in Flask-Wtf.
WTF_CSRF_ENABLED=False,
# Enable @register_required while app.testing=True.
LOGIN_DISABLED=False,
# Suppress the sending of emails.
MAIL_SUPPRESS_SEND=True,
# Enable url_for() without request context.
SERVER_NAME='localhost',
# Use test keys, not live keys.
STRIPE_PRIVATE_KEY='sk_test_IrRibQTodX0xq299PzRJdnW8',
STRIPE_PUBLIC_KEY='pk_test_JvFCdXUEdhIuKsCFCbcL0jvH',
)
test_client = app.test_client()
with app.app_context():
create_db()
yield test_client
def create_app() -> Flask:
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.sqlite3'
flask_bcrypt.init_app(app)
create_db(app)
init_resources(app)
return app
def index():
create_db()
users = User.query.all()
return render_template('index.html', users=users)
file_handling(file_name, tw_srv[-1])
session.commit()
print('База залита файлом', file_name)
logger.info('База залита файлом ' + file_name)
os.remove(file_name)
print('Done!')
logger.info('Done!')
if __name__ == "__main__":
logger.info('--- Start ----------------------------------------------------------------')
try:
drop_old_tables()
create_db()
main_run()
except KeyboardInterrupt:
print('Exit')
except AuthenticationException:
print('Authentication error! Check login/password')
logger.critical('Authentication error! Check login/password')
except SQLAlchemyError as e:
session.rollback()
print('[write_to_db_SQLAlchemyError]', e)
logger.error(e)
except Exception as e:
print('[Main_Error]', e)
logger.exception(e)
def index():
create_db() # TODO REMOVE ME once model is set in stone
users = User.query.all()
return render_template('index.html', users=users)
def createdb():
start = time()
models.create_db()
return render_template('createdb.html', time_taken=(str(time() - start) + " s."))
# =======================
# Flask-user depends on flask-login. Instructions for integrating flask-login with flask-admin are at https://flask-admin.readthedocs.io/en/latest/introduction/#rolling-your-own. The following code follows those instructions.
class ModelView(sqla.ModelView):
def is_accessible(self):
return (
current_user.is_authenticated
and current_user.type_ == UserType.admin
)
def inaccessible_callback(self, name, **kwargs):
# redirect to login page if user doesn't have access
return app.login_manager.unauthorized()
# Create view of the database. The default URL is ``/admin``.
admin = Admin(app, name=app.config['USER_APP_NAME'], template_mode='bootstrap3')
for model in (Book, Page, Question, Answer, Feedback, Annotations, Annotation, Class_, Instructor, Author, User, Payment):
admin.add_view(ModelView(model, db.session))
#
# Main
# ====
# Start development web server
if __name__ == '__main__':
create_db()
sphinxImport()
# Make the server `externally visible <http://flask.pocoo.org/docs/0.11/quickstart/#public-server>`_. Notes:
#
# - To `enable debug <http://flask.pocoo.org/docs/0.11/quickstart/#public-server>`_, ``set FLASK_DEBUG=1``.
# - Use port 80 for a public webserver.
app.run(host='0.0.0.0', port=5000)
from forms import RegistrationForm, LoginForm
app = Flask(__name__)
app.config.from_object(os.environ['APP_SETTINGS'])
DEBUG = app.config['DEBUG']
FLASH_ERROR = 'error'
FLASH_INFO = 'info'
models.db = PostgresqlDatabase(database=app.config['DATABASE'],
user=app.config['USER'])
app.register_blueprint(table_page)
models.create_db()
@app.before_request
def before_request():
g.db = models.db
g.db.connect()
@app.after_request
def after_request(response):
g.db.close()
return response
def login_required(f):
def initdb():
models.create_db()
#Database loader to take in initial dummy data
import csv
import datetime
import models
from models import session
models.create_db()
s = models.session
def load_food(session):
with open ('food.csv', 'rU') as f:
filename_food = csv.reader(f, delimiter=",")
for food_row in filename_food:
new_food_row = models.Food(name=food_row[0], brand=food_row[1], measurement=food_row[2],
price=food_row[3], store_name=food_row[4], location=food_row[5], transit=food_row[6])
session.add(new_food_row)
session.commit()
session.refresh(new_food_row)
def load_basket_entries(session):
with open ('baskets.csv', 'rU') as f:
filename_stores = csv.reader(f, delimiter=",")
for basketname_row in filename_stores:
new_basketname_row = models.Basket_Entry(food_id=basketname_row[1], basket_id=basketname_row[2])
session.add(new_basketname_row)
session.commit()
session.refresh(new_basketname_row)
def admin_create_db():
print 'Creating database...'
create_db()
resp = json.dumps({'status': 'ok'})
return resp
def setup_db():
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/results.sqlite3'
from models import create_db
create_db()
subject: str
class Config:
schema_extra = {
'example': {
'id': 'JHJ454',
'datetime_start': '2021-05-16 00:18:31.568334',
'datetime_end': '2021-05-16 00:20:31.568334',
'location': 'Spain',
'subject': 'math',
}
}
settings = Settings()
create_db('sqlite:///db.sqlite')
bind_engine('sqlite:///db.sqlite')
pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
app = FastAPI()
origins = [
settings.app_origin,
]
app.add_middleware(
CORSMiddleware,
allow_origins=origins,
allow_credentials=True,
allow_methods=['*'],
[print(item) for item in new_id['pu']]
t.write(
f"Вот, например, {new_id['u']}") # вывод результатов в чат
[t.write(item) for item in new_id['pu']]
dump_it(session_maker, new_id['u'],
new_id['pu']) # запись в базу, если доступно
dump_list += [new_id['u'].mk_dict()]
t.write(f"Выберите 'q' для выхода или 'n' для продолжения")
q = t.read()
if q == 'q':
t.write(f"Пока, {u['first_name']} {u['last_name']}!")
break
if not session_maker: # если база недоступна - дамп в файл
with open("dump_file.json", "a", encoding='utf-8') as f:
json.dump(dump_list, f)
if __name__ == '__main__':
try:
Session = create_db(DSN)
except sqlalchemy.exc.OperationalError as error_msg:
print(error_msg)
Session = False
kinder = Kinder(token=my_token, c_token=comm_token)
go_go(kinder, Session)
#!/usr/bin/python
import models
import sys
sys.path.append('../') # noqa: E402
import config # noqa: E402
test_uuid = 'f3159e3b-7ca6-4243-83dd-376755ab4721'
ss = models.create_db(config.DB_URL, config.DB_DEBUG)
# Test adding an architecture
foo = models.get_one_or_create(ss,
models.LU_Architecture,
short_name='unknown',
long_name='unknown',
description='unknown')
print foo
bar = ss.query(models.LU_Architecture).all()
print bar
foo = models.get_one_or_create(ss,
models.LU_Architecture,
short_name='x86_64',
long_name='AMD 64 reference',
description='64 bit architecture')
print foo
bar = models.get_only_one(ss,
models.LU_Architecture,
short_name='x86_64',
long_name='AMD 64 reference',
from flask_moment import Moment
import logging
from logging import Formatter, FileHandler
from forms import (ArtistForm, VenueForm, ShowForm)
import os
from flask_migrate import Migrate
from typing import List
from psycopg2.errors import UniqueViolation
from models import create_db
# App config
app = Flask(__name__)
moment = Moment(app)
app.config.from_object('config.DevelopmentConfig')
app.config.from_envvar("APP_SETTINGS")
db, Venue, Artist, Show = create_db(app)
# DB migrations
migrate = Migrate(app, db)
# Filters.
def format_datetime(value, format='medium'):
date = dateutil.parser.parse(value)
if format == 'full':
format = "EEEE MMMM, d, y 'at' h:mma"
elif format == 'medium':
format = "EE MM, dd, y h:mma"
return babel.dates.format_datetime(date, format)
def index():
create_db()
return render_template('index.html')
def __init__(self, token):
self.token = token
self.bot = telegram.Bot(token=token)
updates = self.bot.getUpdates()
self.update_id = updates[-1].update_id + 1 if updates else None
create_db()
def createdb():
start = time()
models.create_db()
return render_template('createdb.html',
time_taken=(str(time() - start) + " s."))
def init_stuff():
create_db()
return 'Database created!'
if emote is None:
await send_error(ctx, f'Emote {e} not found')
return
if emote.animated:
emote_string += f'<a:{emote.name}:{emote.id}>'
else:
emote_string += f'<:{emote.name}:{emote.id}>'
emote_string += '\n'
ce = await models.CustomEmote.insert(name=name, emote_string=emote_string, server_id=server.id)
await ctx.send(emote_string)
@bot.command(aliases=['c', 'ce'])
async def custom_emote(ctx, *, content):
ce = await models.CustomEmote.select(name=content, server_id=ctx.message.guild.id)
await ctx.send(ce.emote_string)
await ctx.message.delete()
async def send_error(ctx, error):
help_message = 'Type `+help` for further assistance'
embed = discord.Embed(colour=discord.Colour.red())
embed.add_field(name=f'Error: {error}', value=help_message)
await ctx.send(embed=embed)
bot.loop.run_until_complete(models.create_db())
bot.run(token)
def get_one():
db = create_db()
actress = ActressOp(db).get_one()
if actress is None:
return "completed"
return engine.render('app/actress.html', actress)
