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()
