import textwrap
import inspect
from contextlib import redirect_stdout
from discord.ext import commands
import json
import ezjson
import colorama
from motor.motor_asyncio import AsyncIOMotorClient
from ext.context import DatContext
from ext.logger import Logger as logger
colorama.init()
with open("data/apikeys.json") as f:
x = json.load(f)
db = AsyncIOMotorClient(x['mongodb'])
async def getprefix(bot, message):
if isinstance(message.channel, discord.DMChannel): return "*"
x = await db.datbananabot.prefix.find_one({"id": str(message.guild.id)})
pre = x['prefix'] if x is not None else '*'
match = re.match(f"<@!?{bot.user.id}> ", message.content)
return match.group() if match else pre
bot = commands.Bot(command_prefix=getprefix,description="The revamped dat banana bot made by dat banana boi#1982.\n\nHelp Commands",owner_id=277981712989028353)
bot._last_result = None
bot.session = aiohttp.ClientSession()
bot.starttime = time.time()
bot.commands_run = 0
import asyncio
from pymongo import MongoClient
from motor.motor_asyncio import AsyncIOMotorClient
from cluster_monitor.utils import common
host_port = common.CLUSTER_CONF.get('mongo_center')
host = host_port.split(':')[0]
port = int(host_port.split(':')[1])
db_name = 'tesra'
connection = MongoClient('mongodb://{}:{}'.format(host, port), connect=False)
db = connection[db_name]
motor_loop = asyncio.new_event_loop()
a_connection = AsyncIOMotorClient(host, int(port), io_loop=motor_loop)
a_db = a_connection[db_name]
from aiohttp.web import Application, RouteTableDef, Response
from aiohttp_graphql import GraphQLView
from graphql.execution.executors.asyncio import AsyncioExecutor
from motor.motor_asyncio import AsyncIOMotorClient
import os
from .graphql import graphql_schema
from .model import Model
routes = RouteTableDef()
@routes.get('/')
def index(request):
return Response(text='Hello World! This is polls_backend.\n')
application = Application()
application.add_routes(routes)
GraphQLView.attach(application, schema=graphql_schema, graphiql=True, executor=AsyncioExecutor())
# example how the full connection (MONGO_URI) string looks like:
# "mongodb+srv://user0:[email protected]/test?retryWrites=true&w=majority"
client = AsyncIOMotorClient(os.environ.get('MONGO_URI') or 'mongodb://127.0.0.1:27017')
db_name = os.environ.get('MONGO_DB_NAME') or 'poll_app'
db = client[db_name]
application['model'] = Model(db)
def __init__(self, middleware=None, loop=None, is_async_start=False):
super().__init__(middleware, loop, is_async_start)
self.client = AsyncIOMotorClient(MONGODB_URL, io_loop=loop)
self.db_name = DB_NAME
self.fund_collection = self.client[self.db_name]['fund']
# coding: utf-8
from contextlib import closing
import asyncio
import datetime
import time
from motor.motor_asyncio import AsyncIOMotorClient
client = AsyncIOMotorClient(host='localhost',
port=15461,
username='******',
password='******',
authSource='test',
authMechanism='SCRAM-SHA-1')
db = client['test']
places = db['User']
st = datetime.datetime(2018, 11, 6, 9, 30, 0)
async def update_time(data):
"""删除mongodb document中某字段"""
await places.update_one({'_id': data['_id']}, {'$unset': {'_class': ''}})
print(data['_id'])
async def main():
cur = places.find({'_class': {'$exists': True}}).sort('_id', 1).limit(1000)
results = []
async for c in cur:
async def main():
# This must be the same master key that was used to create
# the encryption key.
local_master_key = os.urandom(96)
kms_providers = {"local": {"key": local_master_key}}
# The MongoDB namespace (db.collection) used to store
# the encryption data keys.
key_vault_namespace = "encryption.__pymongoTestKeyVault"
key_vault_db_name, key_vault_coll_name = key_vault_namespace.split(".", 1)
# bypass_auto_encryption=True disable automatic encryption but keeps
# the automatic _decryption_ behavior. bypass_auto_encryption will
# also disable spawning mongocryptd.
auto_encryption_opts = AutoEncryptionOpts(
kms_providers, key_vault_namespace, bypass_auto_encryption=True
)
client = AsyncIOMotorClient(auto_encryption_opts=auto_encryption_opts)
coll = client.test.coll
# Clear old data
await coll.drop()
# Set up the key vault (key_vault_namespace) for this example.
key_vault = client[key_vault_db_name][key_vault_coll_name]
# Ensure that two data keys cannot share the same keyAltName.
await key_vault.drop()
await key_vault.create_index(
"keyAltNames", unique=True, partialFilterExpression={"keyAltNames": {"$exists": True}}
)
client_encryption = AsyncIOMotorClientEncryption(
kms_providers,
key_vault_namespace,
# The MotorClient to use for reading/writing to the key vault.
# This can be the same MotorClient used by the main application.
client,
# The CodecOptions class used for encrypting and decrypting.
# This should be the same CodecOptions instance you have configured
# on MotorClient, Database, or Collection.
coll.codec_options,
)
# Create a new data key for the encryptedField.
_ = await client_encryption.create_data_key(
"local", key_alt_names=["pymongo_encryption_example_4"]
)
# Explicitly encrypt a field:
encrypted_field = await client_encryption.encrypt(
"123456789",
Algorithm.AEAD_AES_256_CBC_HMAC_SHA_512_Deterministic,
key_alt_name="pymongo_encryption_example_4",
)
await coll.insert_one({"encryptedField": encrypted_field})
# Automatically decrypts any encrypted fields.
doc = await coll.find_one()
print("Decrypted document: %s" % (doc,))
unencrypted_coll = AsyncIOMotorClient().test.coll
print("Encrypted document: %s" % (await unencrypted_coll.find_one(),))
# Cleanup resources.
await client_encryption.close()
conf = CONF
if conf.get("databases",
{}).get("default", {}).get("USER", False) and conf.get(
"databases", {}).get("default", {}).get("PASSWORD", False):
client_conf = {
"host":
conf.get("databases", {}).get("default", {}).get("HOST"),
"port":
int(conf.get("databases", {}).get("default", {}).get("PORT")),
"username":
conf.get("databases", {}).get("default", {}).get("USER"),
"password":
conf.get("databases", {}).get("default", {}).get("PASSWORD"),
}
else:
client_conf = {
"host": conf.get("databases", {}).get("default", {}).get("HOST"),
"port":
int(conf.get("databases", {}).get("default", {}).get("PORT")),
}
return client_conf
DB_CLIENT = AsyncIOMotorClient(**_get_client_config())
DB = DB_CLIENT[CONF.get("databases", {}).get("default", {}).get("NAME")]
def close_db_client():
DB_CLIENT.close()
def init_clients():
mongo_uri = environ.get("MONGO_URI")
if mongo_uri:
global mdb
mdb = AsyncIOMotorClient(mongo_uri)
def init_mongo():
mongo_uri = f'mongodb://{MONGO_HOST}:{MONGO_PORT}'
client = AsyncIOMotorClient(mongo_uri)
db = client[MONGO_DATABASE]
return db
intents = discord.Intents(guilds=True, messages=True, reactions=True)
bot = commands.AutoShardedBot(
activity=discord.Activity(
name="the Sola bot arena", type=discord.ActivityType.competing
),
command_prefix=prefix,
intents=intents,
owner_ids=config["devs"],
status=discord.Status.idle,
)
bot.color = config["color"]
bot.success = config["success"]
bot.failure = config["failure"]
bot.db = AsyncIOMotorClient(config["mongo"])["hanalon"]
cogs_dir = pathlib.Path("./bot/cogs")
bot.owner_only = commands.check(lambda ctx: bot.is_owner(ctx.author))
bot.__version__ = "0a (unversioned)"
def include_cog(cog: commands.Cog):
"""Loads a cog."""
bot.add_cog(cog())
def load_cogs():
"""Loads all cogs."""
for root, _, files in os.walk(cogs_dir):
def init_slot(cls, conf:dict) -> 'Slot': mconf = conf['mongodb'] mcli = AsyncIOMotorClient(mconf['uri'], compressors='zstd,snappy,zlib') mdb = mcli[mconf['db']] #.mail_links Slot.slot = slot = Slot(conf, mdb) return slot
1000: 1100,
2000: 2400,
4000: 5600,
}
# Setup
stripe.api_key = config.STRIPE_KEY
stripe_secret = config.STRIPE_WEBHOOK_SECRET
github_secret = config.GITHUB_WEBHOOK_SECRET.encode("utf-8")
app = Quart(__name__)
web_ipc = Client(secret_key=config.SECRET_KEY)
loop = asyncio.get_event_loop()
db = AsyncIOMotorClient(config.DATABASE_URI,
io_loop=loop)[config.DATABASE_NAME]
# IPC Routes
async def req(idx, endpoint, **kwargs):
try:
resp = await asyncio.wait_for(web_ipc.request(endpoint, 8765 + idx,
**kwargs),
timeout=5.0)
return resp
except asyncio.TimeoutError:
return {"success": False, "error": "ipc_timeout"}
def login_required(func):
@wraps(func)
async def connect_to_mongo():
logging.info("Connecting to Mongo")
db.client = AsyncIOMotorClient(str(MONGODB_URL), document_class=dict,
maxPoolSize=MAX_CONNECTIONS_COUNT,
minPoolSize=MIN_CONNECTIONS_COUNT)
logging.info("Mongo Db Connected!")
def client(self, db):
# motor
self.motor_uri = f"mongodb://localhost:27017/{db}"
return AsyncIOMotorClient(self.motor_uri, io_loop=self.loop)
def QA_util_sql_async_mongo_setting(ip='127.0.0.1', port=27017):
client = AsyncIOMotorClient(ip, int(port))
QA_util_log_info('ip:{},port{}'.format(str(ip), str(port)))
return client
def connect():
global client
logging.info('Mongo connection opening...')
client = AsyncIOMotorClient(os.getenv('MONGODB_URL'))
def init_mongo(mongo_url: str):
motor_client: AsyncIOMotorClient = AsyncIOMotorClient(mongo_url)
return motor_client["data"]
async def init(app, loop):
app.ctx.db = AsyncIOMotorClient(MONGO_URI).modmail_bot
to_save.append(Article(content))
print('create new articles')
await asyncio.wait([
db['article'].find_one_and_update(article.exists_query,
{'$set': article.json},
upsert=True)
for article in to_save
])
print('removing parsed feeds ... ')
await db['feed'].remove(
{'_id': {
'$in': list(map(lambda x: x['_id'], sources))
}})
await asyncio.sleep(interval)
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]
db = AsyncIOMotorClient(mongo_uri)['rss']
loop = asyncio.get_event_loop()
asyncio.ensure_future(main(db, 3600))
loop.run_forever()
import time
import uuid
from motor.motor_asyncio import AsyncIOMotorClient
from settings import USH_MONGO_CON_STRING
client = AsyncIOMotorClient(USH_MONGO_CON_STRING)
class Link:
def __init__(self, link, lid=None, r_count=None, r_at=None):
"""
:param link: link that should be shorted.
:param lid: link id also it is use for create redirect link
:param r_count: redirect count
:param r_at: last time when link was used in timestamp format
"""
self.link = link
self.lid = lid or uuid.uuid4().hex[:10]
self.r_count = r_count or 0
self.r_at = r_at
def to_dict(self):
return vars(self)
class NotFoundException(Exception):
pass
import os
from typing import List
from motor.motor_asyncio import AsyncIOMotorClient
from .models import EmployeeSchema
client = AsyncIOMotorClient(os.environ["DB_PATH"])
db = client.test
async def get_employees_by_filter(
filters: str,
query: str,
comparison: str = None,
extra_for_compare: str = None) -> List[EmployeeSchema]:
if filters in ("age", "salary"):
if comparison is not None:
if extra_for_compare is not None:
query = {f"$gt": int(query), f"$lt": int(extra_for_compare)}
else:
query = {f"${comparison}": int(query)}
else:
query = int(query)
employees: List[EmployeeSchema] = []
rows = db["employees"].find({filters: query})
async for row in rows:
employees.append(EmployeeSchema(**row))
from fastapi import APIRouter, HTTPException
from app.data import models
from typing import List
from odmantic import AIOEngine, ObjectId
from motor.motor_asyncio import AsyncIOMotorClient
from app.config import config
router = APIRouter()
settings = config.Settings()
Hug = models.Hug
client = AsyncIOMotorClient(settings.uri)
engine = AIOEngine(motor_client=client)
@router.put("/hugs/", response_model=Hug, tags=["hugs"])
async def new_hug(hug: Hug):
'''
Add a hug to the Database.
Delete the objectID from the example if using
swaggerUI
Use to add or edit an item in the DB. Do not use Post
when using MongoDB.
'''
await engine.save(hug)
return hug
@router.get("/hugs/", response_model=List[Hug], tags=["hugs"])
async def get_hugs():
'''
async def init(app, loop):
app.db = AsyncIOMotorClient(os.getenv("MONGO_URI")).modmail_bot
app.session = aiohttp.ClientSession(loop=loop)
from typing import Optional, List
from datetimerange import DateTimeRange
import asyncio
from pytz import timezone
import binascii
from motor.motor_asyncio import AsyncIOMotorClient
from databases import DatabaseURL
MONGO_HOST = os.getenv("MONGO_HOST", "10.42.0.26")
MONGO_PORT = int(os.getenv("MONGO_PORT", 27017))
MONGO_USER = os.getenv("MONGO_USER", "admin")
MONGO_PASS = os.getenv("MONGO_PASSWORD", "admin")
MONGODB_URL = DatabaseURL(
f"mongodb://{MONGO_USER}:{MONGO_PASS}@{MONGO_HOST}:{MONGO_PORT}")
db = AsyncIOMotorClient(str(MONGODB_URL))
localtz = timezone('Europe/Moscow')
KKM_TOPIC = 'KKM'
VISIT_TOPIC = 'face_visits_01'
TRACKS_TOPIC = 'test_tracks_00'
KAFKA_BROKER = 'kafka://10.42.0.26:9092'
class KKMVISITS(faust.App):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.table_kkm = {}
self.table_visits = {}
self.persist_table_visits = {}
def mongo_conn(host, port, database, collection):
conn = AsyncIOMotorClient(host, port)
db = conn[database]
col = db[collection]
return col
from logging import getLogger, Formatter, FileHandler, StreamHandler, info, critical, INFO
from os import environ
from sys import stdout
from traceback import print_tb
from json import load
from discord import Color
from discord.ext.commands import errors
from discord.ext.commands.bot import Bot
from pymongo import MongoClient
from motor.motor_asyncio import AsyncIOMotorClient
from utils.embed import create_embed
BOT = Bot(command_prefix="$", pm_help=False) # Create the bot
BOT.mongo = AsyncIOMotorClient(host=environ["MONGO_HOST"], port=int(environ["MONGO_PORT"]),
connect=True)
# Extensions to load at start
LOGGER = getLogger("discord_against_humanity.bot")
EXTENSIONS = ["commands.discord_against_humanity"]
def init_logger():
"""Set the logger to the desired level
Keyword Arguments:
level {int} -- Level of logging (default: {INFO})
"""
with open("logging.json", "r") as config_file:
data = load(config_file)
dictConfig(data)
async def connect_to_mongo():
db.client = AsyncIOMotorClient(str(MONGO_URI))
async def connect_to_mongo():
logger.info("Connecting to the database...")
db.client = AsyncIOMotorClient(str(MONGODB_URL),
maxPoolSize=MAX_CONNECTIONS_COUNT,
minPoolSize=MIN_CONNECTIONS_COUNT)
logger.info("Successfully connected to the database!")
# 实例
import asyncio
import aiohttp
import logging
import json
from motor.motor_asyncio import AsyncIOMotorClient
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_COLLECTION_NAME]
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 = 100
CONCURRENCY = 5
# 爬取列表页
semaphore = asyncio.Semaphore(CONCURRENCY)
session = None
async def scrape_api(url):
async with semaphore:
try:
logging.info('scraping %s', url)
async with session.get(url) as response:
from motor.motor_asyncio import AsyncIOMotorClient
from app.settings import MongoSettings
settings = MongoSettings()
client = AsyncIOMotorClient(
settings.HOST,
settings.PORT,
uuidRepresentation='standard',
)
db = client[settings.DB]
