def __init__(self, url):
database_proxy = peewee.DatabaseProxy()
class BaseTable(peewee.Model):
class Meta:
database = database_proxy
class WeatherForecast(BaseTable):
weather = peewee.CharField()
day_temp = peewee.CharField()
night_temp = peewee.CharField()
date = peewee.DateField()
image = peewee.CharField()
class DatesRequests(BaseTable):
request_start_date = peewee.DateField()
request_end_date = peewee.DateField()
database = connect(url)
database_proxy.initialize(database)
if not database.table_exists(
'WeatherForecast'.lower()) or not database.table_exists(
'DatesRequests'.lower()):
database.create_tables([WeatherForecast, DatesRequests])
self.WeatherForecast = WeatherForecast
self.DatesRequests = DatesRequests
def db_init(self):
database_proxy = peewee.DatabaseProxy()
self.database = peewee.SqliteDatabase('weather')
database_proxy.initialize(self.database)
# Инициализировать её через DatabaseProxy()
# https://peewee.readthedocs.io/en/latest/peewee/database.html#dynamically-defining-a-database
import logging
import cv2
import bs4
import requests
import peewee
import re
from playhouse.db_url import connect
from datetime import datetime, timedelta
from pathlib import Path
from PIL import Image, ImageDraw, ImageFont, ImageColor
from models import Weather
RE_DATE = r"^([1-9]|0[1-9]|1[0-9]|2[0-9]|3[0-1])(\.)(0[1-9]|1[0-2])(\.)[0-9][0-9]$"
DATABASE_PROXY = peewee.DatabaseProxy()
CONDITIONS = {
"clear": "Ясно",
"partly cloudy": "Переменная облачность",
"overcast": "Пасмурная погода",
"mostly cloudy": "В основном облачно",
"rain": "Дождь",
"drizzle": "Моросит",
"light rain": "Легкий дождь",
"heavy rain": "Ливень",
"sleet": "Мокрый снег",
"light sleet": "Легкий мокрый снег",
"heavy sleet": "Сильный мокрый снег",
"snow": "Снег",
"flurries": "Очень легкий снег",
import logging
import datetime
from uuid import uuid4
import peewee as pw
from passlib.hash import argon2
logger = logging.getLogger(__name__)
database_proxy = pw.DatabaseProxy()
db = None
def generate_uuid():
return uuid4().hex
def utcnow():
return datetime.datetime.utcnow()
def database_init(database: str) -> pw.Database:
global db
_db = pw.SqliteDatabase(database, pragmas=(
('cache_size', -1024 * 64),
('journal_mode', 'wal'),
('foreign_keys', 1)))
db = _db
database_proxy.initialize(db)
db.connect()
"""Peewee database ORM."""
import enum
import functools
import typing as T
import peewee as pw
from flask_app.settings import needs_settings_init
from flask_app.settings import Settings
database_proxy = pw.DatabaseProxy() # Create a proxy for our db.
SubClass = T.TypeVar("SubClass", bound="BaseModel")
class BaseModel(pw.Model):
class Meta:
database = database_proxy
def refresh(self: SubClass) -> SubClass:
# https://stackoverflow.com/a/32156865/13664712
return type(self).get(self._pk_expr())
# From: https://github.com/coleifer/peewee/issues/630
class EnumField(pw.CharField):
"""An EnumField for Peewee."""
def __init__(self, enum_class: T.Type[enum.Enum], *args: T.Any,
**kwargs: T.Any) -> None:
"""init.
import peewee
_database_proxy = peewee.DatabaseProxy()
class Model(peewee.Model):
# This is currently necessary for aiohttp-apispec request data validation
def __iter__(self):
return ((k, v) for (k, v) in self.__data__.items())
def update_fields(self, fields):
for n, v in fields.items():
setattr(self, n, v)
class Meta:
database = _database_proxy
def set_database(database):
_database_proxy.initialize(database)
"""Local database used by our bot."""
import datetime
import peewee
from peewee import AutoField, IntegerField, BigIntegerField, TextField, DateTimeField
from playhouse.sqlite_ext import SqliteExtDatabase
from playhouse.sqlite_ext import JSONField
# We connect to our database dynamically.
_proxy: peewee.DatabaseProxy = peewee.DatabaseProxy()
class Model(peewee.Model):
class Meta:
database = _proxy
class Message(Model):
"""Archived message."""
class Meta:
# These are copies of our messages and so they are stored under a more descriptive table name.
table_name = 'history'
# Snowflake assigned by Discord.
id = BigIntegerField(primary_key=True)
# Link to jump to message.
link = TextField()
# Author of message.
from pathlib import Path
import peewee
from typing import Iterable, Type
database = peewee.DatabaseProxy()
def initialize_database(
db: peewee.Database,
db_path: Path,
models: Iterable[Type[peewee.Model]],
) -> None:
""" Initialize and bind the corresponding database instance
to the database proxy. Create tables for the given models """
db_path.parent.mkdir(parents=True, exist_ok=True)
db.init(str(db_path))
database.initialize(db)
database.create_tables(models, safe=True)
import atexit
from datetime import datetime
import logging
import os
import socket
import sys
import peewee as pw
from fluf import config
from fluf import helpers
lgr = logging.getLogger('FLUF.db')
DBPROXY = pw.DatabaseProxy()
DB = None
class Function(pw.Model):
class Meta:
database = DBPROXY
checksum = pw.CharField(unique=True)
name = pw.CharField()
code = pw.TextField()
@classmethod
def init(cls, func):
code, checksum = helpers.get_func_code_checksum(func)
func, created = Function.get_or_create(code=code,
checksum=checksum,
name=func.__name__)
"""models.py for DB Models"""
from datetime import datetime
import peewee as pw
from playhouse.db_url import connect
database = pw.DatabaseProxy()
class BaseModel(pw.Model):
class Meta:
database = database
class AdventureStore(BaseModel):
"""AdventureStore DB model for saving Adventure state save data"""
session_id = pw.CharField(unique=True)
create_ts = pw.DateTimeField(default=datetime.utcnow)
updated_ts = pw.DateTimeField(default=datetime.utcnow)
save_data = pw.CharField(default="")
def save(self, *args, **kwargs):
"""overriden save method to update updated_ts"""
self.updated_ts = datetime.utcnow()
super().save(*args, **kwargs)
def to_json(self):
return {
"session_id": self.session_id,
"create_ts": self.create_ts.isoformat(),
import datetime
import peewee
from playhouse.db_url import connect
connection = peewee.DatabaseProxy()
class DictionaryIndexMixin:
hash_field = "id"
def __init__(self, *args, **kwargs):
super(DictionaryIndexMixin, self).__init__(*args, **kwargs)
def __hash__(self):
return hash(self.get_hash_field())
def __eq__(self, other):
if hasattr(other, "get_hash_field"):
return self.get_hash_field() == other.get_hash_field()
if self.get_hash_field() == other:
return True
if other is None:
return False
raise NotImplementedError()
def get_hash_field(self):
from typing import Union, List, Any, Dict
from contextlib import contextmanager
import inspect
from abc import ABC
import peewee as pw
from playhouse import db_url
DATABASE: Union[pw.DatabaseProxy, pw.Database] = pw.DatabaseProxy()
class BaseModel(pw.Model):
class Meta:
database = DATABASE
class BaseController(ABC):
model = None
database = DATABASE
@contextmanager
def transaction(self):
yield self.database.atomic()
def create(self, row_data: Dict[str, Any]) -> BaseModel:
return self.model.create(**row_data)
def get_by_id(self, id: Any, primary_key: str = "id") -> BaseModel:
field = getattr(self.model, primary_key)
query = self.model.select().where(field == id)
return query.get()
class db_handler:
db = peewee.DatabaseProxy()
def __init__(self, file_name):
self.db.initialize(peewee.SqliteDatabase(file_name))
print(self.db)
