class Postgres:
db_pg = Gino()
def __init__(self) -> None:
"""
:return:
"""
self.db_pg: Gino = Postgres.db_pg
self.bind: Gino.set_bind = None
async def connect(self, url: str) -> Gino:
"""
:param url:
:return:
"""
self.bind = await self.db_pg.set_bind(url)
return self.bind
async def make_migrate(self) -> Gino:
return await self.db_pg.gino.create_all()
def return_bind(self) -> Gino:
"""
:return:
"""
return self.bind
async def test_core():
from gino import Gino
db = Gino()
users = db.Table(
"users",
db,
db.Column("id", db.Integer, primary_key=True),
db.Column("name", db.String(255)),
db.Column("fullname", db.String(255)),
)
db.Table(
"addresses",
db,
db.Column("id", db.Integer, primary_key=True),
db.Column("user_id", None, db.ForeignKey("users.id")),
db.Column("email_address", db.String(255), nullable=False),
)
async with db.with_bind(MYSQL_URL):
await db.gino.create_all()
try:
await users.insert().values(
name="jack",
fullname="Jack Jones",
).gino.status()
res = await users.select().gino.all()
assert isinstance(res[0], RowProxy)
finally:
await db.gino.drop_all()
async def test_core():
from gino import Gino
db = Gino()
users = db.Table(
'users',
db,
db.Column('id', db.Integer, primary_key=True),
db.Column('name', db.String),
db.Column('fullname', db.String),
)
addresses = db.Table('addresses', db,
db.Column('id', db.Integer, primary_key=True),
db.Column('user_id', None, db.ForeignKey('users.id')),
db.Column('email_address', db.String, nullable=False))
async with db.with_bind(PG_URL):
await db.gino.create_all()
try:
await users.insert().values(
name='jack',
fullname='Jack Jones',
).gino.status()
res = await users.select().gino.all()
assert isinstance(res[0], RowProxy)
finally:
await db.gino.drop_all()
async def test_orm():
from gino import Gino
db = Gino()
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
fullname = db.Column(db.String)
class Address(db.Model):
__tablename__ = 'addresses'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(None, db.ForeignKey('users.id'))
email_address = db.Column(db.String, nullable=False)
async with db.with_bind(PG_URL):
await db.gino.create_all()
try:
await User.create(name='jack', fullname='Jack Jones')
res = await User.query.gino.all()
assert isinstance(res[0], User)
finally:
await db.gino.drop_all()
# External Libraries
from gino import Gino
# Used to provide predictable names for indexes and the like.
naming_convention = {
"ix": "ix_%(column_0_label)s",
"uq": "uq_%(table_name)s_%(column_0_name)s",
"ck": "ck_%(table_name)s_%(constraint_name)s",
"fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
"pk": "pk_%(table_name)s"
}
db = Gino(naming_convention=naming_convention)
from gino import Gino
from ..utils.config import BOT_CONFIG
DATABASE = Gino()
async def init_connection():
await DATABASE.set_bind(BOT_CONFIG.construct_database_url())
async def close_connection():
await DATABASE.pop_bind().close()
def get_db_instance():
if DBInstance.__instance is None:
DBInstance.__instance = Gino()
return DBInstance.__instance
import sqlalchemy
from datetime import datetime
from gino import Gino
from .hashes import generate_v1
db: sqlalchemy = Gino()
class Model(db.Model):
_created = db.Column(db.DateTime(timezone=False), default=datetime.utcnow)
_updated = db.Column(db.DateTime(timezone=False), default=datetime.utcnow)
_etag = db.Column(db.String(255), default=generate_v1)
__all__ = ("db", "Model")
from gino import Gino
from scraper import config
print(config.DB_DSN)
import asyncio
gino_db = Gino()
async def main():
await gino_db.set_bind(config.DB_DSN)
asyncio.get_event_loop().run_until_complete(main())
# Import your models here so Alembic will pick them up
from db.models import *
def __init__(self):
self._host = os.environ.get("POSTGRES_HOST")
self._user = os.environ.get("POSTGRES_USER")
self._password = os.environ.get("POSTGRES_PASSWORD")
self._db_name = os.environ.get("POSTGRES_DB")
self.db = Gino()
async def main():
db = Gino()
await db.set_bind("postgresql://*****:*****@postgres:5432/gino")
await db.pop_bind().close()
async def test_issue_79(task_local):
db = Gino()
pool = await db.create_pool('postgresql:///non_exist', min_size=0)
with pytest.raises(InvalidCatalogNameError):
await pool.acquire()
assert len(get_local().get('connection_stack', [])) == 0
def pg_databases(name):
if name not in _db_cache:
connection = Gino()
_db_cache[name] = connection
return _db_cache[name]
def create_postgres(*, url, **kwargs):
from sqlalchemy import create_engine
return Gino(bind=create_engine(url, **kwargs))
from aiocache import cached
from gino import Gino
from quart import Blueprint, websocket, redirect
from quart import request
from quart_cors import cors
from app import app
from models import Result
from utilities.count_words import count_ents
simple_app = Blueprint('simple_app', __name__)
simple_app = cors(simple_app)
app = app
db = Gino(app)
@simple_app.route('/index')
@simple_app.route('/', methods=['GET'])
async def index():
frontend = os.getenv('FRONTEND_URL')
return redirect(frontend)
@simple_app.route('/getcounts', methods=['POST'])
async def get_counts():
json_data = await request.get_json()
url = json_data["url"]
parsed_url = urlparse(url)
def get_gino_instance() -> Gino:
if conf.db.initialized:
return conf.db
database = Gino()
conf.db.__setup__(database)
return database
async def get_async_connection() -> Gino:
db = Gino(bind=config.DB_DSN)
return db.bind
return await connect(config.DB_DSN)
from gino import Gino db: Gino = Gino()
'sqlalchemy.url',
'postgresql://{}:{}@{}:{}/{}'.format(db_user,
db_password,
db_host,
db_port,
db_name))
# Interpret the config file for Python logging.
# This line sets up loggers basically.
fileConfig(config.config_file_name)
# add your model's MetaData object here
# for 'autogenerate' support
# from myapp import mymodel
# target_metadata = mymodel.Base.metadata
target_metadata = Gino()
# other values from the config, defined by the needs of env.py,
# can be acquired:
# my_important_option = config.get_main_option("my_important_option")
# ... etc.
def run_migrations_offline():
"""Run migrations in 'offline' mode.
This configures the context with just a URL
and not an Engine, though an Engine is acceptable
here as well. By skipping the Engine creation
we don't even need a DBAPI to be available.
Calls to context.execute() here emit the given string to the
script output.
from gino import Gino
db = Gino(
naming_convention={
"ix": "%(column_0_label)s_idx",
"uq": "%(table_name)s_%(column_0_name)s_key",
"ck": "%(table_name)s_%(constraint_name)s_check",
"fk": "%(table_name)s_%(column_0_name)s_%(referred_table_name)s_fkey",
"pk": "%(table_name)s_pkey",
})
from aiogram import Dispatcher, Bot from aiogram.contrib.fsm_storage.memory import MemoryStorage from aiogram.types import ParseMode from data.config import TOKEN_BOT from gino import Gino database = Gino() storage = MemoryStorage() bot = Bot(token=TOKEN_BOT, parse_mode=ParseMode.HTML) dp = Dispatcher(bot=bot, storage=storage) __all__ = ['dp', 'bot', 'storage', 'database']
from gino import Gino
from sqlalchemy import BigInteger
from sqlalchemy import Boolean
from sqlalchemy import CheckConstraint
from sqlalchemy import Column
from sqlalchemy import DateTime
from sqlalchemy import ForeignKey
from sqlalchemy import Integer
from sqlalchemy import String
from sqlalchemy import func
from sqlalchemy import Index
logger = getLogger('app.database.models')
db = Gino()
class GameItemCategory(db.Model):
__tablename__ = 'item_category'
__table_args__ = ({'schema': 'game'})
id = Column(String(16), primary_key=True, autoincrement=False)
class GameCurrency(db.Model):
__tablename__ = 'currency'
__table_args__ = ({'schema': 'game'})
id = Column(String(4), primary_key=True, autoincrement=False)
import asyncio
import traceback
from gino import Gino
from sqlalchemy import ForeignKey
dbo = Gino()
class Server(dbo.Model):
__tablename__ = 'server'
guildid = dbo.Column(dbo.Integer(), primary_key=True) # pylint: disable=no-member
class User(dbo.Model):
__tablename__ = 'users'
id = dbo.Column(dbo.Integer(), primary_key=True) # pylint: disable=no-member
guild = dbo.Column(dbo.Integer(), None, ForeignKey('Server.guildid')) # pylint: disable=no-member
funds = dbo.Column(dbo.Integer()) # pylint: disable=no-member
class dbc:
async def add_guild(self, id):
queryRes = Server.query.where(Server.guildid == id)
#print(queryRes) #THIS BREAKS INITIALIZATION SOMEHOW!
if (queryRes == None):
await Server.create(guildid=id)
return True
else:
return False
