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)
