def test_authenticate(self): if not test.env.auth: raise SkipTest('Authentication is not enabled on server') # self.db is logged in as root. yield from self.db.add_user("jesse", "password") db = AsyncIOMotorClient(host, port, io_loop=self.loop).motor_test try: # Authenticate many times at once to test concurrency. yield from asyncio.wait( [db.authenticate("jesse", "password") for _ in range(10)], loop=self.loop) # Just make sure there are no exceptions here. yield from db.remove_user("jesse") yield from db.logout() if (yield from at_least(self.cx, (2, 5, 4))): info = yield from self.db.command("usersInfo", "jesse") users = info.get('users', []) else: users = yield from self.db.system.users.find().to_list(10) self.assertFalse("jesse" in [u['user'] for u in users]) finally: yield from remove_all_users(self.db) test.env.sync_cx.disconnect()
def test_authenticate(self): if not test.env.auth: raise SkipTest('Authentication is not enabled on server') # self.db is logged in as root. yield from self.db.add_user("jesse", "password") db = AsyncIOMotorClient(env.host, env.port, **self.get_client_kwargs()).motor_test try: # Authenticate many times at once to test concurrency. yield from asyncio.wait( [db.authenticate("jesse", "password") for _ in range(10)], loop=self.loop) # Just make sure there are no exceptions here. yield from db.remove_user("jesse") yield from db.logout() info = yield from self.db.command("usersInfo", "jesse") users = info.get('users', []) self.assertFalse("jesse" in [u['user'] for u in users]) finally: yield from remove_all_users(self.db) test.env.sync_cx.close()
class Storage: db = None mongo_client = None def __init__(self, mongo_uri): self.mongo_client = AsyncIOMotorClient(mongo_uri) self.db = self.mongo_client.get_default_database() def find(self, collection): pass async def update(self, collection, query, update, options): return await self.db[collection].update(query, update, **options) def insert(self, collection, document): pass def remove(self, collection): pass
def init_clients(): mongo_uri = environ.get("MONGO_URI") if mongo_uri: global mdb mdb = AsyncIOMotorClient(mongo_uri)
def get_db(): from motor.motor_asyncio import AsyncIOMotorClient mongo_uri = "mongodb://localhost:27017/WebApi" client = AsyncIOMotorClient(mongo_uri) return client['WebApi']
self.result = list() def ensure_future(self): asyncio.ensure_future(self.crawl(), loop=self.loop) asyncio.ensure_future(self.save()) def handle_async_exception(_loop, ctx): print('Exception happened: ', ctx) if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('mongo', metavar='mongo', type=str, nargs='*', help='mongo db uri', default=['mongodb://localhost:27017/rss']) args = parser.parse_args() mongo_uri = args.mongo[0] print('Ready to crawling ... ') urls = prepare_urls() db = AsyncIOMotorClient(mongo_uri)['rss'] loop = asyncio.get_event_loop() loop.set_exception_handler(handle_async_exception) t = CrawlingTask(loop, urls, 3600, db) t.ensure_future() loop.run_forever() loop.close()
async def init_mongo(app: web.Application, mongodb_uri: str): loop = asyncio.get_event_loop() conn = AsyncIOMotorClient(mongodb_uri, io_loop=loop) return conn.get_database()
# -*- coding: utf-8 -*- # Author: kai.zhang01 # Date: 2018/8/24 # Desc: import arrow from datetime import datetime from motor.motor_asyncio import AsyncIOMotorClient # mongodb 的异步实现 MONGO_URI = 'mongodb://*****:*****@140.143.58.134:1234/admin' client = AsyncIOMotorClient(MONGO_URI) rank_db = client.rank_data # 数据库 async def fetch_huobi_price(start, end=None, db=rank_db): # # 从mongodb取数 coll = db.huobi_spot_otc_price # 表 query = { "created": { "$gte": start }, "coin_name": { "$in": ['BTC', 'ETH', 'USDT'] } } if end: assert isinstance(end, datetime), 'end must be instance of datetime' query['created']['$lte'] = end async for item in coll.find(query).sort('created', 1): yield item
async def setup_connection(app, loop): global db client = AsyncIOMotorClient(Config.MONGO_URL, io_loop=loop) db = client.microservices_db
def init_cache(): mongo_uri = environ.get('MONGO_URI') if mongo_uri: global cache_db cache_db = AsyncIOMotorClient(mongo_uri).report_cache
from motor.motor_asyncio import AsyncIOMotorClient from data.config import DB_NAME, DB_USER, DB_PASS srv = "mongodb+srv://{}:{}@cluster0.vrvwe.azure.mongodb.net/{}?retryWrites=true&w=majority" db = AsyncIOMotorClient(srv.format(DB_PASS, DB_USER, DB_NAME))[DB_NAME] users = db.users groups = db.groups
''' # here put the import lib from motor.motor_asyncio import AsyncIOMotorClient MONGOCONFIG = {"host": "127.0.0.1", "port": 27017, "aotodb": "NLAutoTest"} MONGOCOLLETIONS = { "batch_report": "batch_report", "case_execute_deatail": "case_execute_deatail", "db_config": "db_config", "interface_tmp": "interface_tmp", "stakeholders_list": "stakeholders_list", "test_case": "test_case", "version_demand_list": "version_demand_list", "interface_cfg": "InterFaceCfg" } REDISCONFIG = { "host": 'localhost', "port": 6379, "minsize": 5, "maxsize": 10, "retry_num": 3, "retry_delay": 5 } Connection = AsyncIOMotorClient(MONGOCONFIG["host"], MONGOCONFIG["port"]) AUTO_MODB = Connection[MONGOCONFIG["aotodb"]]
async def startup_mongo_client(): app.mongodb_client = AsyncIOMotorClient(settings.DB_URL) app.mongodb = app.mongodb_client[settings.DB_NAME]
def db(): return AsyncIOMotorClient()[TEST_DB]
from motor.motor_asyncio import AsyncIOMotorClient logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s: %(message)s') INDEX_URL = 'https://dynamic5.scrape.cuiqingcai.com/api/book/?limit=18&offset={offset}' DETAIL_URL = 'https://dynamic5.scrape.cuiqingcai.com/api/book/{id}' PAGE_SIZE = 18 PAGE_NUMBER = 1 CONCURRENCY = 5 MONGO_CONNECTION_STRING = 'mongodb://localhost:27017' MONGO_DB_NAME = 'books' MONGO_COLLECTION_NAME = 'books' client = AsyncIOMotorClient(MONGO_CONNECTION_STRING) db = client[MONGO_DB_NAME] collection = db[MONGO_CONNECTION_STRING] loop = asyncio.get_event_loop() class Spider(object): def __init__(self): self.semaphore = asyncio.Semaphore(CONCURRENCY) async def scrape_api(self, url): async with self.semaphore: try: logging.info('scraping %s', url) async with self.session.get(url) as response:
def client(): global CLIENT if CLIENT is None: CLIENT = AsyncIOMotorClient(MONGODB_URI) return CLIENT
HERE = Path(__file__).resolve().parent.parent # Path app MONGO_TEMPLATE = "mongodb+srv://admin:{}@quppeq0-qnmoc.mongodb.net/test?retryWrites=true&w=majority" MONGO_PASSWORD = getenv("MONGO_PASS", "B24v2PLoWJSRcHsc") MONGO_CONNECT = MONGO_TEMPLATE.format(MONGO_PASSWORD) policy = SessionIdentityPolicy() exceptions_html = {401: "exceptions/error_401.html"} exceptions = error_factory(exceptions_html) app = web.Application(middlewares=[db_handler, exceptions]) logger.info("Connect to db") app.client = AsyncIOMotorClient(MONGO_CONNECT) app.db = app.client["zrada"] aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader(str(HERE)+"/front/templates")) redis_pool = loop.run_until_complete(make_redis_pool()) setup_session(app, RedisStorage(redis_pool)) setup_security(app, policy, SimpleJack_AuthorizationPolicy(app.db)) if DEBUG: logger.info("Setup aiohttp static") app.add_routes([web.static('/static', str(HERE) + "/front/static", show_index=True),
def getClient(mongo_uri): return AsyncIOMotorClient(mongo_uri)
#!/usr/bin/env python3 import os import sys _project_dir = os.path.join(os.path.dirname(__file__), os.pardir) sys.path.insert(0, _project_dir) from app import Server, RequestHandler, config sys.path.pop(0) from motor.motor_asyncio import AsyncIOMotorClient if __name__ == '__main__': db_client = AsyncIOMotorClient(config['DB_HOST'], config['DB_PORT']) handler = RequestHandler(db_client) server = Server(handler) server.serve()
"""Initialize the MongoDB database.""" from os import getenv from typing import TYPE_CHECKING from motor.motor_asyncio import AsyncIOMotorClient from optimade_gateway.common.config import CONFIG from optimade_gateway.common.logger import LOGGER if TYPE_CHECKING or bool(getenv("MKDOCS_BUILD", "")): # pragma: no cover # pylint: disable=unused-import from pymongo.database import Database from pymongo.mongo_client import MongoClient MONGO_CLIENT: "MongoClient" = AsyncIOMotorClient( CONFIG.mongo_uri, appname="optimade-gateway", readConcernLevel="majority", readPreference="primary", w="majority", ) """The MongoDB motor client.""" MONGO_DB: "Database" = MONGO_CLIENT[CONFIG.mongo_database] """The MongoDB motor database. This is a representation of the database used for the gateway service.""" LOGGER.info("Using: Real MongoDB (motor) at %s", CONFIG.mongo_uri) LOGGER.info("Database: %s", CONFIG.mongo_database)
import asyncio import os from motor.motor_asyncio import AsyncIOMotorClient db = AsyncIOMotorClient( "mongodb+srv://enchanted:[email protected]/") async def main(): coll = db["enchanted-main"]['users'] async for d in coll.find({}): titles = [{ 'type': 'color', 'name': 'Basic color', 'value': "0xdb58dd" }, { 'type': 'emote', 'value': "Wow!" }, { 'type': 'emote', 'value': "Good Game!" }, { 'type': 'emote', 'value': '<:smi:729075126532046868>' }] for title in d["titles"]: if "Aged" or "aged" not in title: titles.append({'type': 'title', 'value': title}) try:
import motor import asyncio from motor import motor_asyncio from motor.motor_asyncio import (AsyncIOMotorCollection, AsyncIOMotorClient, AsyncIOMotorDatabase, AsyncIOMotorCommandCursor) import pymongo import datetime import tushare as ts code_list = ts.get_zz500s().code.tolist() time1 = datetime.datetime.now() client = AsyncIOMotorClient('127.0.0.1', 27017).quantaxis.stock_day print(client) data = [] print('async-mongo') async def get_data(code, func, data, *args, **kwargs): #data=[] async for message in client.find({'code': code}): data.append(message) #print(message) return func(data, *args, **kwargs) def callback(data): pass
def get_db(url: str, db_name: str = "flowsaber", **kwargs): client = AsyncIOMotorClient(url, **kwargs) db = client[db_name] return db
async def connect_to_mongo(): logging.info("Connecting to Mongodb...") db.client = AsyncIOMotorClient(str(MONGODB_URL)) # maxPoolSize=MAX_CONNECTIONS_COUNT, # minPoolSize=MIN_CONNECTIONS_COUNT) logging.info("Connected to Mongodb...")
async def getEvalData(qq_account: str): conn = AsyncIOMotorClient(config.MONGO_DB_URL) users = conn.cxautosign.users user = await users.find_one({'qq': qq_account}) return user['eval_times']
import discord from discord.ext import commands import time import os import inspect import json from contextlib import redirect_stdout import io import textwrap import traceback import aiohttp from motor.motor_asyncio import AsyncIOMotorClient client = AsyncIOMotorClient(os.environ.get("MONGOURL")) db = client.discordbot2001 async def guildpre(bot, message): '''Get the prefix for required guild''' f = await bot.db.config.find_one({"gid" : message.guild.id}) if f is None: return "e." else: f = f['prefix'] return f bot = commands.Bot(command_prefix=guildpre, description="An easy to use discord bot") bot.load_extension("cogs.fun") bot.load_extension("cogs.utility") bot.load_extension("cogs.mod")
sqlalchemy.Column("completed", sqlalchemy.Boolean), ) engine = sqlalchemy.create_engine("mysql+mysqldb://root:[email protected]:3306") metadata.create_all(engine) class MongoResponse(Response): def __init__(self, content, *args, **kwargs): super().__init__( content=dumps(content), media_type="application/json", *args, **kwargs, ) mongo = AsyncIOMotorClient('mongodb://*****:*****@localhost:27017/?authSource=admin') memcache = aiomcache.Client("127.0.0.1", 11211) app = FastAPI() docDB = mongo.sampleDB @app.on_event("startup") async def startup(): await mysql.connect() @app.on_event("shutdown") async def shutdown(): memcache.close() mongo.close() await mysql.disconnect()
import requests import datetime head = { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 \ (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36 Edge/16.16299' } url_dic = { 'day_all': 'https://www.bilibili.com/ranking/all/0/0/1', 'day_origin': 'https://www.bilibili.com/ranking/origin/0/0/1', 'day_cinema': 'https://www.bilibili.com/ranking/cinema/177/0/1', 'day_rookie': 'https://www.bilibili.com/ranking/rookie/0/0/1', } client = AsyncIOMotorClient('mongodb://localhost:27017') dbs = client['video'] collection = dbs['avnum_rank'] def get_rank(name, url): data = requests.get(url, headers=head) data.encoding = "utf-8" data = data.text soup = BeautifulSoup(data, 'lxml') a = soup.find_all("a", class_='title', target="_blank", href=True) avnum_list = [] for pat in a: href = pat['href'] avnum_list.append(href[href.index('av') + 2:]) avnum_list = {
def client(self, db): self.motor_uri = f"mongodb://localhost:27017/{db}" return AsyncIOMotorClient(self.motor_uri, io_loop=self.loop)
#!/usr/bin/env python3 # -*- coding:utf-8 -*- import attr from motor.motor_asyncio import AsyncIOMotorClient motor_client = AsyncIOMotorClient() proxy_db = motor_client.proxy proxy_coll = proxy_db.proxy_pool @attr.s class ProxyItem(object): ip = attr.ib() port = attr.ib(convert=int) position = attr.ib(default='') weight = attr.ib(default=1, convert=int) # 权重,默认初始插入数据库时为0 def __str__(self): return "{}:{}".format(self.ip, self.port) def pass_verify(self): self.weight += 1 def fail_verify(self): self.weight -= 1 async def bulk_upsert_proxy(proxy_list): bulk = proxy_coll.initialize_ordered_bulk_op() for proxy_item in proxy_list:
def fallback_data_source(event_loop): auth = os.environ.get('MONGO_AUTH', 'mongo:mongo') client = AsyncIOMotorClient(f'mongodb://{auth}@localhost:27017', io_loop=event_loop) return MongoDataSource(database_name='dbdaora', client=client)
async def get_db(): return AsyncIOMotorClient(DB_SERVER, 27017)[DB_NAME]
source: str research_areas: List[str] date: str summary: str MONGO_HOST = os.environ.get('MONGO_HOST', 'database') MONGO_PORT = os.environ.get('MONGO_PORT', 27017) MONGO_PASSWORD = os.environ.get('MONGO_PASSWORD', 'secret') MONGO_USER = os.environ.get('MONGO_USER', 'mongo') app = FastAPI() client = AsyncIOMotorClient(f"mongodb://{MONGO_HOST}:{MONGO_PORT}", username=MONGO_USER, password=MONGO_PASSWORD, authSource='mlDatabase', authMechanism='SCRAM-SHA-256') app.db = client.mlDatabase origins = [ "http://localhost", "http://localhost:8000", "http://localhost:4200", "http://localhost:4201", "http://127.0.0.1:4201", "http://127.0.0.1:4200" ] app.add_middleware( CORSMiddleware, allow_origins=origins, allow_credentials=True, allow_methods=["*"],
def __init__(self, mongo_uri): self.mongo_client = AsyncIOMotorClient(mongo_uri) self.db = self.mongo_client.get_default_database()