def encode_play():
# None of this works because all encode uses await, and you cannot call
# any await method unless every def is async def
# So we do have to split our database query build + ORM into both sync
# and async
from uvicore import db
import sqlalchemy as sa
from databases import Database
connection = 'wiki'
database = Database('mysql://*****:*****@127.0.0.1:3306/uvicore_wiki')
database.connect()
table = sa.Table("users", db.metadata.get(connection),
sa.Column("id", sa.Integer, primary_key=True),
sa.Column("name", sa.String(length=50)))
#engine = db.engine('wiki')
#con = db.connect()
query = table.select()
users = database.fetch_all(query)
# for user in users:
# table = User.Db.table
# query = table.select()
# users = con.execute(query)
dd('DONE encode_play()')
class ShowsDB(object):
def __init__(self):
self.database = Database(url=DATABASE_URL,
ssl='require',
min_size=1,
max_size=2)
self.metadata = MetaData()
self.shows = Table('shows', self.metadata,
Column('show_id', Integer, primary_key=True),
Column('type', String, nullable=True),
Column('title', String, nullable=True),
Column('director', String, nullable=True),
Column('cast', String, nullable=True),
Column('country', String, nullable=True),
Column('date_added', Date, nullable=True),
Column('release_year', Integer, nullable=True),
Column('rating', String, nullable=True),
Column('duration', String, nullable=True),
Column('listed_in', String, nullable=True),
Column('description', String, nullable=True))
def initialize(self):
engine = create_engine(DATABASE_URL)
self.metadata.create_all(engine)
return self
def connect(self):
return self.database.connect()
def disconnect(self):
return self.database.disconnect()
def execute(self, query, get='all'):
if get != 'all':
return self.database.fetch_one(query)
return self.database.fetch_all(query)
def fetch_all(self, query):
return self.database.fetch_all(query)
class SoundBert(commands.Bot):
def __init__(self, config: Config):
self._ensure_event_loop()
super().__init__(command_prefix=SoundBert._get_guild_prefix)
self.config = config
self.db = Database(config.database_url)
self.loop.run_until_complete(self.db.connect())
base_extensions = [
'soundbert.cogs.soundboard', 'soundbert.cogs.info',
'soundbert.cogs.settings', 'soundbert.cogs.admin'
]
log.info('Loading base extensions.')
for ext in base_extensions:
self.load_extension(ext)
log.debug(f'Loaded {ext}')
log.info('Loading extra extensions.')
for ext in self.config.extra_extensions.split(','):
ext = ext.strip()
try:
self.load_extension(ext)
except commands.ExtensionNotFound:
log.exception(f'Failed to load {ext}.')
else:
log.debug(f'Loaded {ext}.')
def run(self):
super(SoundBert, self).run(self.config.token)
@staticmethod
def _ensure_event_loop():
"""
Allows for subprocessing using asyncio on Windows, and tries to use uvloop on Unix-like systems.
"""
if platform.system() == 'Windows':
loop = asyncio.ProactorEventLoop()
asyncio.set_event_loop(loop)
else:
try:
import uvloop
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
except ImportError:
pass
async def _get_guild_prefix(self, msg: Message):
"""
Implementation for command_prefix.
:param msg: The message that might have a command.
:return: The prefix
"""
await self._ensure_guild(msg.guild.id)
prefix = await self.db.fetch_val(
select([guilds.c.prefix]).where(guilds.c.id == msg.guild.id))
return commands.when_mentioned_or(prefix)(self, msg)
@alru_cache(maxsize=2048)
async def _ensure_guild(self, guild_id: int):
"""
Ensures that the guild is in the database. Uses an LRU cache to try to not ping the database too much.
:param guild_id: The guild id
"""
log.debug(f'Ensuring guild {guild_id} is in database.')
query = guilds.insert().values(id=guild_id,
prefix=self.config.default_prefix)
try:
await self.db.execute(query)
except UniqueViolationError:
pass
async def on_command_error(self, ctx: commands.Context,
exception: commands.CommandError):
"""
Error handling.
:param ctx: Command context
:param exception: What went wrong
"""
log_msg = (
f'In guild {ctx.guild.name}, channel {ctx.channel.name}, '
f'{ctx.author.name} executed {ctx.message.content}, but encountered exception: {exception}'
)
if isinstance(exception,
(commands.UserInputError, commands.CheckFailure,
commands.CommandOnCooldown)):
log.debug(log_msg)
await warn(ctx)
else:
log.exception(log_msg, exc_info=exception)
await err(ctx)
if len(exception.args) > 0:
try:
delay = int(exception.args[1])
except (IndexError, ValueError):
delay = 60
await ctx.send(exception.args[0], delete_after=delay)
async def on_command(self, ctx: commands.Context):
"""
Log command execution.
:param ctx: Command context
"""
log.info(f'In guild {ctx.guild.name}, channel {ctx.channel.name}, '
f'{ctx.author.name} executed {ctx.message.content}')
# timing different calls
timer = 0
def timer_start():
global timer
timer = time.time()
def timer_end():
return time.time() - timer
timer_start()
asyncio.run(database.connect())
gprint("Database init took %3.2f" % (timer_end()))
d = []
timer_start()
for submission in reddit.subreddit(config['subreddit']).top(limit=25):
d.append(submission)
gprint("Feed fetch took %3.2f" % (timer_end()))
wait_cache = []
async def get_waits():
global wait_cache
global query_count
from settings import DATABASE_URL from databases import Database import sqlalchemy metadata = sqlalchemy.MetaData() db_url = str(DATABASE_URL) database = Database(db_url) database.connect()
