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 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)