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)