def test_auto_instance(self, db): instance = Instance(db) class Doc(Document): pass doc_impl_cls = instance.register(Doc) assert doc_impl_cls.collection == db['doc'] assert issubclass(doc_impl_cls, framework_pymongo.PyMongoDocument)
def connect(db_host, db_port, loop): logger.info("[DB] Establishing DB connection to: %s:%s ", db_host, db_port) global db db = AsyncIOMotorClient(db_host, db_port, io_loop=loop)['test_umongo'] global instance instance = Instance(db) return instance
def init(dburl, dbname): """Initialize a database instance.""" global instance client = AsyncIOMotorClient(dburl) instance = Instance(client[dbname])
def __init__(self, bot, host, dbname): self.db = AsyncIOMotorClient(host, io_loop=bot.loop)[dbname] instance = Instance(self.db) g = globals() for x in ( "PokemonBase", "Pokemon", "EmbeddedPokemon", "Member", "Listing", "Guild", "Channel", "Counter", "Sponsor", ): setattr(self, x, instance.register(g[x])) getattr(self, x).bot = bot
def patch_umongo_meta(odm_cls, **kargs): meta = getattr(odm_cls, META) if meta is None: return False connection = kargs.get(CONNECTION, None) database = kargs.get(DATABASE, None) collection = kargs.get(COLLECTION, None) instance = Instance(connection[database]) if connection is not None and \ isinstance(connection, MongoClient) and \ database is not None and \ collection is not None: col = connection[database][collection] setattr(odm_cls, META, col) if connection is not None and \ isinstance(connection, MongoClient) and \ database is not None: instance = instance.register(odm_cls) setattr(odm_cls, META, instance) return True
def setup_db(mongo_client=MongoClient, ): connection_string = os.environ.get('USER_MODULE_DB', '') db_name = os.environ.get('USER_MODULE_DB_NAME', '') mongo_client = mongo_client(connection_string, connect=True, maxPoolSize=200, connectTimeoutMS=120000, socketTimeoutMS=120000) db = mongo_client[db_name] db_umongo_instance = Instance(db) return db, db_umongo_instance
def __init__(self, *, db: MongoClient) -> None: self._instance = Instance(db) @self._instance.register class User(Document): name = fields.StringField(required=True, unique=True) password = fields.StringField(required=True) age = fields.IntegerField(required=True) email = fields.EmailField(required=False) class Meta: collection = db.user self.User = User
def __init__(self, bot: commands.Bot): self.bot = bot self.client = AsyncIOMotorClient(bot.config.DATABASE_URI, io_loop=bot.loop) self.db = self.client[bot.config.DATABASE_NAME] instance = Instance(self.db) g = globals() for x in ( "PokemonBase", "Pokemon", "EmbeddedPokemon", "Member", "Guild", "Channel", "Counter", "Blacklist", "Sponsor", "Auction", ): setattr(self, x, instance.register(g[x])) getattr(self, x).bot = bot
def __init__(self, bot, host, dbname): database_uri = os.getenv("DATABASE_URI") database_name = os.getenv("DATABASE_NAME") self.db = AsyncIOMotorClient(host, io_loop=bot.loop)[dbname] instance = Instance(self.db) self.Pokemon = instance.register(Pokemon) self.Pokemon.bot = bot self.Member = instance.register(Member) self.Member.bot = bot self.Listing = instance.register(Listing) self.Listing.bot = bot self.Guild = instance.register(Guild) self.Guild.bot = bot self.Counter = instance.register(Counter) self.Counter.bot = bot self.Blacklist = instance.register(Blacklist) self.Blacklist.bot = bot
from struct import pack from pyrogram.file_id import FileId from pymongo.errors import DuplicateKeyError from umongo import Instance, Document, fields from motor.motor_asyncio import AsyncIOMotorClient from marshmallow.exceptions import ValidationError from info import DATABASE_URI, DATABASE_NAME, COLLECTION_NAME, USE_CAPTION_FILTER logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) client = AsyncIOMotorClient(DATABASE_URI) db = client[DATABASE_NAME] instance = Instance.from_db(db) @instance.register class Media(Document): file_id = fields.StrField(attribute='_id') file_ref = fields.StrField(allow_none=True) file_name = fields.StrField(required=True) file_size = fields.IntField(required=True) file_type = fields.StrField(allow_none=True) mime_type = fields.StrField(allow_none=True) caption = fields.StrField(allow_none=True) class Meta: collection_name = COLLECTION_NAME
import logging from pymongo.errors import DuplicateKeyError from umongo import Instance, Document, fields from motor.motor_asyncio import AsyncIOMotorClient from marshmallow.exceptions import ValidationError from info import DATABASE_URI, DATABASE_NAME, COLLECTION_NAME, USE_CAPTION_FILTER from .helpers import unpack_new_file_id logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) client = AsyncIOMotorClient(DATABASE_URI) database = client[DATABASE_NAME] instance = Instance.from_db(database) @instance.register class Media(Document): file_id = fields.StrField(attribute='_id') file_ref = fields.StrField(allow_none=True) file_name = fields.StrField(required=True) file_size = fields.IntField(required=True) file_type = fields.StrField(allow_none=True) mime_type = fields.StrField(allow_none=True) caption = fields.StrField(allow_none=True) class Meta: indexes = ('$file_name', ) collection_name = COLLECTION_NAME
import asyncio from aiogram import Bot, Dispatcher, types from aiogram.contrib.fsm_storage.redis import RedisStorage2 from redis import Redis from pymongo import MongoClient from umongo import Instance import logging from modules.common import constants LOG_FORMAT = ( '%(levelname) -10s %(asctime)s %(name) -15s %(funcName) -20s: %(message)s') LOG_LEVEL = logging.DEBUG if constants.LOG_LEVEL == 'debug' else logging.INFO if constants.LOG_LEVEL == 'info' else logging.ERROR logging.basicConfig(level=LOG_LEVEL, format=LOG_FORMAT) # remove debug logs from aiohttp logger logging.getLogger('chardet.charsetprober').setLevel(logging.INFO) database = Redis(**constants.redis) storage = RedisStorage2(**constants.redis) mongo_client = MongoClient(**constants.mongo) mongo_instance = Instance(mongo_client.personalbot) bot = Bot(token=constants.BOT_TOKEN) dp = Dispatcher(bot, storage=storage) bot_id = bot.id event_loop = asyncio.get_event_loop()
from hashlib import sha256 from motor.motor_asyncio import AsyncIOMotorClient from umongo import Document, fields, Instance from umongo.validate import Length from app.config import MONGO_URI client = AsyncIOMotorClient(MONGO_URI) database = client.cafe_system instance = Instance(database) @instance.register class PaymentTypeDocument(Document): name = fields.StringField(required=True, unique=True) @instance.register class CafeDocument(Document): name = fields.StringField(required=True, unique=True) address = fields.StringField(required=True) info = fields.StringField(required=True) image_url = fields.StringField() payment_type = fields.ObjectIdField(allow_none=True) @instance.register class CafeEmployeeDocument(Document): username = fields.StringField(required=True,
from motor.motor_asyncio import AsyncIOMotorClient from umongo import Instance import config db = AsyncIOMotorClient()[config.mongo_collection] mongo = Instance(db)
from aiogram import Bot, Dispatcher, types from aiogram.contrib.fsm_storage.redis import RedisStorage2 from pymongo import MongoClient from umongo import Instance import logging from modules.common.config import constants LOG_FORMAT = ( '%(levelname) -10s %(asctime)s %(name) -15s %(funcName) -20s: %(message)s') LOG_LEVEL = logging.DEBUG if constants.LOG_LEVEL == 'debug' else logging.INFO if constants.LOG_LEVEL == 'info' else logging.ERROR logging.basicConfig(level=LOG_LEVEL, format=LOG_FORMAT) storage = RedisStorage2(**constants.redis) mongo_client = MongoClient(**constants.mongo) mongo_instance = Instance(mongo_client.surveys) bot = Bot(token=constants.BOT_TOKEN) dp = Dispatcher(bot, storage=storage)
from simple_settings import settings import motor.motor_asyncio from umongo import Instance, Document, fields client = motor.motor_asyncio.AsyncIOMotorClient(settings.DB_URL) db = client[settings.DB_NAME] odb = Instance(db) @odb.register class Feed(Document): type = fields.StringField(required=True) uri = fields.StringField() name = fields.StringField(required=True) last_ts = fields.NumberField(required=True, default=0) class Meta: collection_name = "feed" @odb.register class Article(Document): ts = fields.NumberField(required=True, default=0) text = fields.StringField() tags = fields.ListField(fields.StringField(), default=[]) source = fields.ReferenceField("Feed") address = fields.StringField(default="") # Location: { # type: "Point", # coordinates: [-73.856077, 40.848447] # }
from db.database import Database from db.chat import Chats from db.message import Messages from db.user import Users from umongo import Instance db_instance = Database() instance = Instance(db_instance.db) instance.register(Chats) instance.register(Messages) instance.register(Users) __all__ = ["Database", "Chats", "Messages", "Users"]
from motor.motor_asyncio import AsyncIOMotorClient from umongo import Document, EmbeddedDocument, Instance, fields from datetime import datetime import sys import os import json sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))) db = AsyncIOMotorClient(os.getenv("DB_URI")) collection = db[os.getenv("DB_NAME")] instance = Instance(collection) @instance.register class Member(Document): class Meta: strict = False id = fields.IntegerField(attribute="_id") coins = fields.IntegerField(default=0) last_collected = fields.DateTimeField(default=datetime.min) @instance.register class Guild(Document): class Meta: strict = False
QUEUE_PRIORITY = (QUEUE_PRIORITY_MAX, QUEUE_PRIORITY_DEFAULT, QUEUE_PRIORITY_MIN) EVENT_CODE_START_TASK = 200 EVENT_CODE_CANCEL_TASK = 201 EVENT_CODE_UPDATE_USER_SCRIPT = 202 EVENT_CODE_TASKQUEUE_START = 203 EVENT_CODE_TASKQUEUE_UPDATE = 204 EVENT_CODE_TASKQUEUE_DELETE = 205 EVENT_CODE_EXIT_EVENT_TASK = 206 EVENT_CODE_DELETE_ENDPOINT = 207 EVENT_CODE_GET_ENDPOINT_CONFIG = 208 LOCK_TIMEOUT = 20 instance = Instance(app.config.db) class IPAddressField(StringField): """A field that validates input as an IP address, may including port. """ def __init__(self, **kwargs): super().__init__(**kwargs) def validate(self, value): try: urlparse(value) except ValueError: self.error(u"Invalid IP address: {}".format(value))
import config pymongo_db = None MONGO_DB_HOST = os.getenv("MONGODB_URI") or "localhost" MONGO_DB_NAME = os.getenv("DB_NAME") or "imdbmovie" def get_pymongo_client(): global pymongo_db if pymongo_db is None: pymongo_client = MongoClient(MONGODB_SETTINGS["HOST"]) pymongo_db = pymongo_client[MONGODB_SETTINGS["DB"]] return pymongo_db instance = Instance(get_pymongo_client()) def create_app(): """Initialize the core application.""" app = Sanic(__name__) #loading configurations app.config.from_object(config) app.config["MONGODB_SETTINGS"] = { "db": MONGO_DB_NAME, "host": MONGO_DB_HOST, } # Register Blueprints from .api.v1.movies.handler import movie_views
def __init__(self, database_name: str, database_host: str, database_port: int, database_user: str, database_pwd: str, loop=None): if database_port >= 65535: raise Exception('Enviroment variable DBPORT is non valid port') self._db_name: str = database_name uri: str = 'mongodb://{DBUSER}:{DBPSWD}@{DBHOST}:{DBPORT}/{DBNAME}'.format( DBUSER=database_user, DBPSWD=database_pwd, DBHOST=database_host, DBPORT=database_port, DBNAME=database_name) self._connection = motor.motor_asyncio.AsyncIOMotorClient( uri, io_loop=loop) self._instance = Instance(self._connection[database_name]) for odm_model in [ types.User, types.Action, types.Rule, types.Topic, types.Params, types.Message, types.UserMessage, types.BotMessage, types.WozUserMessage, types.WozBotMessage, types.Context ]: self._instance.register(odm_model) user_meta = get_meta_fields(load=('username',), dump=('id', 'username')) message_meta = get_meta_fields( load=('text',), dump=('id', 'text', 'timestamp', 'bot')) um = self._instance.UserMessage uwm = self._instance.WozUserMessage class UserWebSchema(self._instance.User.schema.as_marshmallow_schema()): __mongoload__ = user_meta.load __mongodump__ = user_meta.dump class Meta: fields = user_meta.fields load_only = user_meta.load_only dump_only = user_meta.dump_only class MessageWebSchema( self._instance.Context.schema.as_marshmallow_schema()): __mongoload__ = message_meta.load __mongodump__ = ('id', 'message.text', 'message._cls', 'timestamp') text = marshmallow.fields.Method('_get_text') bot = marshmallow.fields.Method('_get_bot') def _get_text(self, obj): return obj.message.text def _get_bot(self, obj): return not isinstance(obj.message, (um, uwm)) class Meta: fields = message_meta.fields load_only = message_meta.load_only dump_only = message_meta.dump_only self.user_schema = UserWebSchema() self.message_schema = MessageWebSchema()
import umongo from umongo import Instance, Document, fields, validate import os # db = MongoClient().test try: if (os.environ['WorkflowEnvironment'] == "Docker"): db = MongoClient('host.docker.internal', 27017) else: db = MongoClient('localhost', 27017) except KeyError: db = MongoClient('localhost', 27017) instance = Instance(db.WorkflowDB) @instance.register class Project(Document): projectId = fields.StrField(required=True) name = fields.StrField(required=True) ownerName = fields.StrField(required=True) ownerORCID = fields.StrField(required=True) description = fields.StrField() createdDate = fields.DateTimeField(default=datetime.now) updatedDate = fields.DateTimeField(default=datetime.now) samples = fields.ListField(fields.ReferenceField("Sample")) isLocked = fields.BooleanField(default="false") class Meta:
host='localhost', port=6379, poolsize=10 ) return self._pool redis = Redis() # pass the getter method for the connection pool into the session # https://pythonhosted.org/sanic_session/using_the_interfaces.html session = RedisSessionInterface(redis.get_redis_pool) sanic_db = get_client().SANIC_TODO # sanic_db.test_coll.insert({'key':123}) >>> Wokrs instance = Instance(sanic_db) ''' MODELS ''' @instance.register class User(Document): name = StringField(required = True) username = StringField(required = True) password = StringField(required = True) email = EmailField(required = True , unique = True) joined_on = DateTimeField(default = datetime.utcnow() + timedelta(hours=5,minutes=30)) def set_password(self, password): self.password = pbkdf2_sha512.hash(password)
from motor import motor_asyncio as ma from umongo import Instance import settings from utils import utils host = utils.get_connection_string_for_alias(settings.DB_ALIAS) db = utils.get_db_name() print("URL:", host) client = ma.AsyncIOMotorClient(host) db = client[db] instance = Instance(db) INVITE_TYPE = [ 'personal', 'group', 'admin', ] SOCIAL_LINK_TYPES = [ 'personal_url', 'linkedin', 'instagram', 'twitter', ] LANGUAGE_LEVELS = [ 'beginner', 'intermediate', 'upper_intermediate', 'advanced', 'fluent',
from motor.motor_asyncio import AsyncIOMotorClient from marshmallow.exceptions import ValidationError import os import PTN import requests import json from info import DATABASE_URI, DATABASE_NAME, COLLECTION_NAME, USE_CAPTION_FILTER, AUTH_CHANNEL, API_KEY DATABASE_URI_2 = os.environ.get('DATABASE_URI_2', DATABASE_URI) DATABASE_NAME_2 = os.environ.get('DATABASE_NAME_2', DATABASE_NAME) COLLECTION_NAME_2 = "Posters" logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) client = AsyncIOMotorClient(DATABASE_URI) db = client[DATABASE_NAME] instance = Instance.from_db(db) IClient = AsyncIOMotorClient(DATABASE_URI_2) imdbdb = client[DATABASE_NAME_2] imdb = Instance.from_db(imdbdb) @instance.register class Media(Document): file_id = fields.StrField(attribute='_id') file_ref = fields.StrField(allow_none=True) file_name = fields.StrField(required=True) file_size = fields.IntField(required=True) file_type = fields.StrField(allow_none=True) mime_type = fields.StrField(allow_none=True) caption = fields.StrField(allow_none=True)
from umongo import Document, Instance, fields from datetime import datetime import pymongo import os from main import config mongo_uri = f"mongodb://{config['MONGO']['USER']}:{config['MONGO']['PASSWORD']}@{config['MONGO']['HOSTNAME']}:{config['MONGO']['PORT']}/tawep" print(f"Attempting to connect to : {mongo_uri}") db = pymongo.MongoClient(mongo_uri) instance = Instance(db.tawep) @instance.register class Card(Document): year = fields.IntegerField(required=True) img = fields.UrlField() name = fields.StringField(required=True, unique=True) desc = fields.StringField(required=True) class Meta: collection = db.tawep.card @instance.register class Deck(Document): name = fields.StringField(required=True, unique=True) cards = fields.ListField(fields.ReferenceField("Card"))
import os from flask import Flask # from flask_pymongo import PyMongo import json import datetime from bson.objectid import ObjectId from pymongo import MongoClient from umongo import Instance app = Flask(__name__) # add mongo url to flask config, so that flask_pymongo can use it to make connection # app.config['MONGO_URI'] = os.environ.get('DB') # mongo = PyMongo(app) dbClient = MongoClient(host=os.environ.get('MONGO_HOST'), port=int(os.environ.get('MONGO_PORT'))) mongo = Instance(dbClient.db) class JSONEncoder(json.JSONEncoder): ''' extend json-encoder class''' def default(self, o): return o.__dict__ # if isinstance(o, ObjectId): # return str(o) # if isinstance(o, datetime.datetime): # return str(o) # return json.JSONEncoder.default(self, o)