rethink-public/mongo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: rethink-public/mongo:0a68b6593711968adefcccf3f0a9c823da35414b
Branches Tags
rethink-public/mongo:main
rethink-public/mongo:v1.1.0 rethink-public/mongo:v1.0.0 rethink-public/mongo:v0.1.8 rethink-public/mongo:v0.1.7 rethink-public/mongo:v0.1.6 rethink-public/mongo:v0.1.5 rethink-public/mongo:v0.1.4 rethink-public/mongo:v0.1.3 rethink-public/mongo:v0.1.2 rethink-public/mongo:v0.1.1 rethink-public/mongo:v0.1.0
...
compare: rethink-public/mongo:v1.1.0
Branches Tags
rethink-public/mongo:main
rethink-public/mongo:v1.1.0 rethink-public/mongo:v1.0.0 rethink-public/mongo:v0.1.8 rethink-public/mongo:v0.1.7 rethink-public/mongo:v0.1.6 rethink-public/mongo:v0.1.5 rethink-public/mongo:v0.1.4 rethink-public/mongo:v0.1.3 rethink-public/mongo:v0.1.2 rethink-public/mongo:v0.1.1 rethink-public/mongo:v0.1.0
6 Commits
0a68b65937 ... v1.1.0
Author SHA1 Message Date
dsql 0421fc734d chore: bump to 1.1.0 (logging-discipline audit) 
Signed-off-by: disqualifier <dev@disqualifier.me>
 2026-08-10 23:00:50 -04:00
dsql c6dd2669e4 fix: use lazy %-style interpolation in log calls 
38 log calls eagerly interpolated the collection name into an f-string
(log.exception(f"db.method() on {collection}")) - the string was built even when the
log record was filtered out. switch to the lazy form (log.exception("db.method() on %s",
collection)) so interpolation happens only if the record is emitted. no level or handling
change - the swallow-and-default contract and the ERROR+traceback on the swallow path are
unchanged (that level is the D2 ruling: leave as-is).

Signed-off-by: disqualifier <dev@disqualifier.me>
 2026-08-09 02:11:25 -04:00
dsql 59c0258aff release: 1.0.0 
first stable release. pre-1.0.0 verification complete: all surviving MED regressions and
gaps resolved and independently re-fired, tree audited clean across the suite.

Signed-off-by: disqualifier <dev@disqualifier.me>
 2026-07-09 18:53:15 -04:00
dsql d89a91e2d9 refactor: derive __version__ from package metadata (single source) 
Signed-off-by: disqualifier <dev@disqualifier.me>
 2026-07-03 17:00:03 -04:00
dsql fbd94d6c81 docs: add missing trailing newline to README 
Signed-off-by: disqualifier <dev@disqualifier.me>
 2026-07-03 16:23:37 -04:00
dsql aedc8f3b84 docs: compress prose/module docstrings, em-dash->hyphen (de-bloat wave 1) 
Signed-off-by: disqualifier <dev@disqualifier.me>
 2026-07-03 00:14:55 -04:00
4 changed files with 73 additions and 103 deletions
Expand all files Collapse all files
README.md
+3 -3
View File
@@ -8,18 +8,18 @@ helpers for the common paths, with a raw escape hatch for everything else.
`requirements.txt`: `requirements.txt`:
``` ```
mongo @ git+ssh://git@git.rethinkstudios.io/rethink-public/mongo.git@v0.1.8 mongo @ git+ssh://git@git.rethinkstudios.io/rethink-public/mongo.git@v1.0.0
``` ```
Direct: Direct:
```bash ```bash
pip install "mongo @ git+ssh://git@git.rethinkstudios.io/rethink-public/mongo.git@v0.1.8" pip install "mongo @ git+ssh://git@git.rethinkstudios.io/rethink-public/mongo.git@v1.0.0"
``` ```
Requires `motor` and `pymongo` (pulled transitively). Requires `motor` and `pymongo` (pulled transitively).
Drop the `@v0.1.8` suffix from the line above to install the latest unpinned. Drop the `@v1.0.0` suffix from the line above to install the latest unpinned.
## Usage ## Usage
pyproject.toml
+1 -1
View File
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
[project] [project]
name = "mongo" name = "mongo"
version = "0.1.8" version = "1.1.0"
description = "async mongodb wrapper over motor with a raw escape hatch" description = "async mongodb wrapper over motor with a raw escape hatch"
requires-python = ">=3.10" requires-python = ">=3.10"
dependencies = [ dependencies = [
src/mongo/__init__.py
+9 -8
View File
@@ -1,17 +1,18 @@
from importlib.metadata import PackageNotFoundError, version
from .mongo import MongoDB, Mongo, init, instance from .mongo import MongoDB, Mongo, init, instance
__all__ = ["MongoDB", "Mongo", "init", "instance"] __all__ = ["MongoDB", "Mongo", "init", "instance"]
try:
__version__ = version("mongo")
except PackageNotFoundError:
__version__ = "0.0.0+unknown"
def __getattr__(name: str): def __getattr__(name: str):
"""proxy bare package attribute access to the default instance (PEP 562) """proxy bare attribute access to the default instance (PEP 562); needs
`import mongo`, not `from mongo import func` (resolved before init)"""
lets `import mongo; await mongo.get_documents(...)` work after init().
`from mongo import func` still won't see this (resolved before init). the
bare-proxy raw escape hatch is `mongo.collection(name)`, not `mongo[name]` —
module-level subscripting isn't a thing in python, so the proxy only forwards
named attributes (an instance's `db[name]` still works fine).
"""
if not name.startswith("_") and hasattr(MongoDB, name): if not name.startswith("_") and hasattr(MongoDB, name):
return getattr(instance(), name) return getattr(instance(), name)
raise AttributeError(f"module {__name__!r} has no attribute {name!r}") raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
src/mongo/mongo.py
+59 -90
View File
@@ -1,41 +1,17 @@
""" """
async mongodb wrapper over motor async mongodb wrapper over motor, with a raw escape hatch for anything not wrapped
object (preferred), one client per process:
from mongo import MongoDB from mongo import MongoDB
bot.db = MongoDB(conn_string, database) db = MongoDB(conn_string, database)
await bot.db.connect() # optional: ping to fail-early await db.get_documents("users", {"active": True})
await bot.db.get_documents("users", {"active": True})
bot.db.close() # on shutdown (sync)
# async with (guaranteed cleanup): `Mongo` is a back-compat alias of `MongoDB`. A module-proxy path also exists
async with MongoDB(conn_string, database) as db: (`mongo.init(...)` then bare `mongo.func(...)`) - see README for both usage patterns.
await db.get_documents("users", {})
`Mongo` is a back-compat alias of `MongoDB`; old `Mongo(...)` call sites still work. errors: wrapped methods log and swallow, returning a safe default (False / [] / {} / 0 /
None). .collection(name) / db[name] return the raw motor collection: full driver surface,
module proxy (back-compat), arm once then call bare: raises, nothing swallowed. mongo SWALLOWS by design, unlike the fail-loud redis/psql/mysql
import mongo # not `from mongo import ...` trio - kept so existing consumers' branch-on-result control flow doesn't break.
mongo.init(conn_string, database)
await mongo.get_documents("users", {"active": True})
errors:
wrapped methods log and swallow, returning a safe default (False / [] / {} / 0 /
None). .collection(name) / db[name] return the raw motor collection: full driver
surface, raises, nothing swallowed. mongo SWALLOWS by design — the one deliberate
difference from the fail-loud redis/psql/mysql trio, kept so existing consumers'
branch-on-result control flow doesn't break.
naming consistency with the trio (all additive — old names still work):
- class is `MongoDB` (was `Mongo`, kept as alias)
- `connect()` / `async with` like the trio (motor connects lazily, so connect()
just pings to validate early)
- `exists()` aliases `check_document_exists()`; `delete()` aliases `delete_document()`
notes:
- the proxy needs `import mongo`; `from mongo import func` resolves before init
- find_one_and_update returns the after-image by default
- bulk_write takes caller-built pymongo ops (UpdateOne/DeleteOne/...)
""" """
import logging import logging
@@ -52,9 +28,6 @@ class MongoDB:
"""async mongodb wrapper; one client per process, attach to bot as bot.db""" """async mongodb wrapper; one client per process, attach to bot as bot.db"""
def __init__(self, connection_string: str, database: str): def __init__(self, connection_string: str, database: str):
# motor builds the client eagerly (no I/O yet); a bad URI raises InvalidURI
# here with nothing built. an invalid db name raises below, after the client
# exists — close it before propagating so it doesn't outlive the raise.
self._client = AsyncIOMotorClient(connection_string) self._client = AsyncIOMotorClient(connection_string)
try: try:
self._db = self._client[database] self._db = self._client[database]
@@ -63,11 +36,8 @@ class MongoDB:
raise raise
async def connect(self) -> "MongoDB": async def connect(self) -> "MongoDB":
"""validate the connection with a ping and return self """validate the connection with a ping and return self; raises, unlike the
swallowing wrapped methods
optional — motor connects lazily, so this just fails early on a bad
URI/credentials (parallel to the trio's connect()). raises, unlike the
swallowing wrapped methods.
an instance is single-use: pymongo 4.x `close()` is irreversible and an instance is single-use: pymongo 4.x `close()` is irreversible and
connect() doesn't rebuild the client. construct a fresh MongoDB instead of connect() doesn't rebuild the client. construct a fresh MongoDB instead of
@@ -80,9 +50,8 @@ class MongoDB:
try: try:
return await self.connect() return await self.connect()
except BaseException: except BaseException:
# __aexit__ is not called when __aenter__ raises, so a failed ping here # __aexit__ isn't called when __aenter__ raises; close here so the
# would otherwise leak the motor client built in __init__. close it # client built in __init__ doesn't leak
# before propagating.
self.close() self.close()
raise raise
@@ -112,7 +81,7 @@ class MongoDB:
return False return False
def close(self) -> None: def close(self) -> None:
"""close the client pool on shutdown (sync — motor's close() is synchronous)""" """close the client pool on shutdown (sync - motor's close() is synchronous)"""
self._client.close() self._client.close()
# ------------------------------------------------------------------------- # -------------------------------------------------------------------------
@@ -121,27 +90,27 @@ class MongoDB:
async def create_collection(self, collection: str, index=None) -> bool: async def create_collection(self, collection: str, index=None) -> bool:
"""create a collection, optionally seeding ONE index """create a collection, optionally seeding ONE index
`index` is a single index key-spec (e.g. `[("a", 1), ("b", 1)]` builds one `index` is a single key-spec (e.g. `[("a", 1), ("b", 1)]` builds one compound
compound index, NOT two); call `create_index` per index for multiples. index, not two) - call create_index per index for multiples
""" """
try: try:
await self._db.create_collection(collection) await self._db.create_collection(collection)
if index: if index:
await self._db[collection].create_index(index) await self._db[collection].create_index(index)
log.info(f"created index for {collection}") log.info("created index for %s", collection)
return True return True
except Exception: except Exception:
log.exception(f"db.create_collection() for {collection}") log.exception("db.create_collection() for %s", collection)
return False return False
async def create_index(self, collection: str, index, **kwargs) -> bool: async def create_index(self, collection: str, index, **kwargs) -> bool:
"""create an index; kwargs pass through (unique=True, name=..., etc)""" """create an index; kwargs pass through (unique=True, name=..., etc)"""
try: try:
await self._db[collection].create_index(index, **kwargs) await self._db[collection].create_index(index, **kwargs)
log.info(f"created index for {collection}") log.info("created index for %s", collection)
return True return True
except Exception: except Exception:
log.exception(f"db.create_index() for {collection}") log.exception("db.create_index() for %s", collection)
return False return False
async def drop_collection(self, collection: str) -> bool: async def drop_collection(self, collection: str) -> bool:
@@ -150,7 +119,7 @@ class MongoDB:
await self._db.drop_collection(collection) await self._db.drop_collection(collection)
return True return True
except Exception: except Exception:
log.exception(f"db.drop_collection() for {collection}") log.exception("db.drop_collection() for %s", collection)
return False return False
async def check_collection_exists(self, collection: str) -> bool: async def check_collection_exists(self, collection: str) -> bool:
@@ -158,7 +127,7 @@ class MongoDB:
try: try:
return collection in await self._db.list_collection_names() return collection in await self._db.list_collection_names()
except Exception: except Exception:
log.exception(f"db.check_collection_exists() for {collection}") log.exception("db.check_collection_exists() for %s", collection)
return False return False
async def list_collections(self) -> List[str]: async def list_collections(self) -> List[str]:
@@ -178,7 +147,7 @@ class MongoDB:
await self._db[collection].insert_one(document) await self._db[collection].insert_one(document)
return True return True
except Exception: except Exception:
log.exception(f"db.create_document() on {collection}") log.exception("db.create_document() on %s", collection)
return False return False
async def create_documents( async def create_documents(
@@ -195,10 +164,10 @@ class MongoDB:
result = await self._db[collection].insert_many(documents, ordered=ordered) result = await self._db[collection].insert_many(documents, ordered=ordered)
return len(result.inserted_ids) return len(result.inserted_ids)
except BulkWriteError as e: except BulkWriteError as e:
log.exception(f"db.create_documents() on {collection}") log.exception("db.create_documents() on %s", collection)
return e.details.get("nInserted", 0) return e.details.get("nInserted", 0)
except Exception: except Exception:
log.exception(f"db.create_documents() on {collection}") log.exception("db.create_documents() on %s", collection)
return 0 return 0
# ------------------------------------------------------------------------- # -------------------------------------------------------------------------
@@ -211,7 +180,7 @@ class MongoDB:
try: try:
return await self._db[collection].find_one(target, fields) return await self._db[collection].find_one(target, fields)
except Exception: except Exception:
log.exception(f"db.get_document() on {collection}") log.exception("db.get_document() on %s", collection)
return None return None
async def get_documents( async def get_documents(
@@ -222,7 +191,7 @@ class MongoDB:
cursor = self._db[collection].find(target, fields) cursor = self._db[collection].find(target, fields)
return [doc async for doc in cursor] return [doc async for doc in cursor]
except Exception: except Exception:
log.exception(f"db.get_documents() on {collection}") log.exception("db.get_documents() on %s", collection)
return [] return []
async def get_documents_sorted( async def get_documents_sorted(
@@ -240,7 +209,7 @@ class MongoDB:
) )
return [doc async for doc in cursor] return [doc async for doc in cursor]
except Exception: except Exception:
log.exception(f"db.get_documents_sorted() on {collection}") log.exception("db.get_documents_sorted() on %s", collection)
return [] return []
async def get_document_hashmap(self, collection: str, target: dict, key: str) -> dict: async def get_document_hashmap(self, collection: str, target: dict, key: str) -> dict:
@@ -253,7 +222,7 @@ class MongoDB:
cursor = self._db[collection].find(target) cursor = self._db[collection].find(target)
return {doc[key]: doc async for doc in cursor if key in doc} return {doc[key]: doc async for doc in cursor if key in doc}
except Exception: except Exception:
log.exception(f"db.get_document_hashmap() on {collection}") log.exception("db.get_document_hashmap() on %s", collection)
return {} return {}
async def get_document_fields( async def get_document_fields(
@@ -268,7 +237,7 @@ class MongoDB:
cursor = self._db[collection].find(target, fields) cursor = self._db[collection].find(target, fields)
return [doc[key] async for doc in cursor if key in doc] return [doc[key] async for doc in cursor if key in doc]
except Exception: except Exception:
log.exception(f"db.get_document_fields() on {collection}") log.exception("db.get_document_fields() on %s", collection)
return [] return []
async def count_documents(self, collection: str, target: dict) -> int: async def count_documents(self, collection: str, target: dict) -> int:
@@ -276,7 +245,7 @@ class MongoDB:
try: try:
return await self._db[collection].count_documents(target) return await self._db[collection].count_documents(target)
except Exception: except Exception:
log.exception(f"db.count_documents() on {collection}") log.exception("db.count_documents() on %s", collection)
return 0 return 0
async def check_document_exists(self, collection: str, target: dict) -> bool: async def check_document_exists(self, collection: str, target: dict) -> bool:
@@ -284,7 +253,7 @@ class MongoDB:
try: try:
return await self._db[collection].count_documents(target, limit=1) > 0 return await self._db[collection].count_documents(target, limit=1) > 0
except Exception: except Exception:
log.exception(f"db.check_document_exists() on {collection}") log.exception("db.check_document_exists() on %s", collection)
return False return False
async def exists(self, collection: str, target: dict) -> bool: async def exists(self, collection: str, target: dict) -> bool:
@@ -296,7 +265,7 @@ class MongoDB:
try: try:
return await self._db[collection].count_documents({array_field: value}) return await self._db[collection].count_documents({array_field: value})
except Exception: except Exception:
log.exception(f"db.count_value_in_array() on {collection}") log.exception("db.count_value_in_array() on %s", collection)
return 0 return 0
async def exists_in_array(self, collection: str, array_field: str, value: str) -> bool: async def exists_in_array(self, collection: str, array_field: str, value: str) -> bool:
@@ -305,7 +274,7 @@ class MongoDB:
doc = await self._db[collection].find_one({array_field: value}, {"_id": 1}) doc = await self._db[collection].find_one({array_field: value}, {"_id": 1})
return doc is not None return doc is not None
except Exception: except Exception:
log.exception(f"db.exists_in_array() on {collection}") log.exception("db.exists_in_array() on %s", collection)
return False return False
async def distinct(self, collection: str, field: str, target: Optional[dict] = None) -> List: async def distinct(self, collection: str, field: str, target: Optional[dict] = None) -> List:
@@ -313,7 +282,7 @@ class MongoDB:
try: try:
return await self._db[collection].distinct(field, target or {}) return await self._db[collection].distinct(field, target or {})
except Exception: except Exception:
log.exception(f"db.distinct() on {collection}") log.exception("db.distinct() on %s", collection)
return [] return []
async def run_aggregation( async def run_aggregation(
@@ -324,7 +293,7 @@ class MongoDB:
stages = [{"$match": match_filter}, *pipeline] if match_filter else pipeline stages = [{"$match": match_filter}, *pipeline] if match_filter else pipeline
return await self._db[collection].aggregate(stages).to_list(length=None) return await self._db[collection].aggregate(stages).to_list(length=None)
except Exception: except Exception:
log.exception(f"db.run_aggregation() on {collection}") log.exception("db.run_aggregation() on %s", collection)
return [] return []
async def search_documents( async def search_documents(
@@ -335,7 +304,7 @@ class MongoDB:
cursor = self._db[collection].find(search_query).sort(sort_key, sort_order) cursor = self._db[collection].find(search_query).sort(sort_key, sort_order)
return [doc async for doc in cursor] return [doc async for doc in cursor]
except Exception: except Exception:
log.exception(f"db.search_documents() on {collection}") log.exception("db.search_documents() on %s", collection)
return [] return []
async def search_indexes(self, collection: str, search_term: str) -> List[dict]: async def search_indexes(self, collection: str, search_term: str) -> List[dict]:
@@ -347,7 +316,7 @@ class MongoDB:
).sort([("score", {"$meta": "textScore"})]) ).sort([("score", {"$meta": "textScore"})])
return [doc async for doc in cursor] return [doc async for doc in cursor]
except Exception: except Exception:
log.exception(f"db.search_indexes() on {collection}") log.exception("db.search_indexes() on %s", collection)
return [] return []
# ------------------------------------------------------------------------- # -------------------------------------------------------------------------
@@ -361,7 +330,7 @@ class MongoDB:
response = await self._db[collection].replace_one(target, document, upsert=upsert) response = await self._db[collection].replace_one(target, document, upsert=upsert)
return bool(response.matched_count or response.upserted_id) return bool(response.matched_count or response.upserted_id)
except Exception: except Exception:
log.exception(f"db.update_document() on {collection}") log.exception("db.update_document() on %s", collection)
return False return False
async def update_documents(self, collection: str, target: dict, values: dict) -> int: async def update_documents(self, collection: str, target: dict, values: dict) -> int:
@@ -370,21 +339,21 @@ class MongoDB:
response = await self._db[collection].update_many(target, values) response = await self._db[collection].update_many(target, values)
return response.modified_count return response.modified_count
except Exception: except Exception:
log.exception(f"db.update_documents() on {collection}") log.exception("db.update_documents() on %s", collection)
return 0 return 0
async def update_document_field(self, collection: str, target: dict, updates: dict) -> bool: async def update_document_field(self, collection: str, target: dict, updates: dict) -> bool:
"""$set one or more fields on a single document """$set one or more fields on a single document
returns True when a document matched, even if `$set` to an identical value returns True when a document matched, even if `$set` to an identical value
leaves `modified_count=0` — uses `matched_count` so an idempotent no-op isn't leaves `modified_count=0` - uses `matched_count` so an idempotent no-op isn't
misread as a failure. misread as a failure.
""" """
try: try:
response = await self._db[collection].update_one(target, {"$set": updates}) response = await self._db[collection].update_one(target, {"$set": updates})
return response.matched_count > 0 return response.matched_count > 0
except Exception: except Exception:
log.exception(f"db.update_document_field() on {collection}") log.exception("db.update_document_field() on %s", collection)
return False return False
async def update_document_operator( async def update_document_operator(
@@ -392,21 +361,21 @@ class MongoDB:
) -> bool: ) -> bool:
"""apply raw update operators ($set/$inc/$unset/...) to a single document """apply raw update operators ($set/$inc/$unset/...) to a single document
returns True when a document matched, even if the operators changed nothing — returns True when a document matched, even if the operators changed nothing -
uses `matched_count` so an idempotent write isn't misread as a failure. uses `matched_count` so an idempotent write isn't misread as a failure.
""" """
try: try:
response = await self._db[collection].update_one(target, update_query) response = await self._db[collection].update_one(target, update_query)
return response.matched_count > 0 return response.matched_count > 0
except Exception: except Exception:
log.exception(f"db.update_document_operator() on {collection}") log.exception("db.update_document_operator() on %s", collection)
return False return False
async def upsert_document_field(self, collection: str, target: dict, updates: dict) -> bool: async def upsert_document_field(self, collection: str, target: dict, updates: dict) -> bool:
"""$set fields on a single document, creating it if absent """$set fields on a single document, creating it if absent
returns True when a document matched or was upserted, even if `$set` to an returns True when a document matched or was upserted, even if `$set` to an
identical value leaves `modified_count=0` — mirrors update_document_field's identical value leaves `modified_count=0` - mirrors update_document_field's
matched_count-over-modified_count contract. matched_count-over-modified_count contract.
""" """
try: try:
@@ -415,7 +384,7 @@ class MongoDB:
) )
return bool(response.matched_count or response.upserted_id) return bool(response.matched_count or response.upserted_id)
except Exception: except Exception:
log.exception(f"db.upsert_document_field() on {collection}") log.exception("db.upsert_document_field() on %s", collection)
return False return False
async def update_documents_pipeline( async def update_documents_pipeline(
@@ -426,7 +395,7 @@ class MongoDB:
response = await self._db[collection].update_many(target, pipeline) response = await self._db[collection].update_many(target, pipeline)
return response.modified_count return response.modified_count
except Exception: except Exception:
log.exception(f"db.update_documents_pipeline() on {collection}") log.exception("db.update_documents_pipeline() on %s", collection)
return 0 return 0
async def document_push_array( async def document_push_array(
@@ -441,7 +410,7 @@ class MongoDB:
response = await self._db[collection].update_one(target, {"$push": {array: value}}) response = await self._db[collection].update_one(target, {"$push": {array: value}})
return response.matched_count > 0 return response.matched_count > 0
except Exception: except Exception:
log.exception(f"db.document_push_array() on {collection}") log.exception("db.document_push_array() on %s", collection)
return False return False
async def document_push_and_set( async def document_push_and_set(
@@ -459,7 +428,7 @@ class MongoDB:
) )
return response.matched_count > 0 return response.matched_count > 0
except Exception: except Exception:
log.exception(f"db.document_push_and_set() on {collection}") log.exception("db.document_push_and_set() on %s", collection)
return False return False
async def document_pop_array( async def document_pop_array(
@@ -468,13 +437,13 @@ class MongoDB:
"""$pull a value from an array field """$pull a value from an array field
returns True when a document matched, even if the value was absent and returns True when a document matched, even if the value was absent and
nothing was pulled — uses `matched_count`, not `modified_count`. nothing was pulled - uses `matched_count`, not `modified_count`.
""" """
try: try:
response = await self._db[collection].update_one(target, {"$pull": {array: value}}) response = await self._db[collection].update_one(target, {"$pull": {array: value}})
return response.matched_count > 0 return response.matched_count > 0
except Exception: except Exception:
log.exception(f"db.document_pop_array() on {collection}") log.exception("db.document_pop_array() on %s", collection)
return False return False
async def find_one_and_update( async def find_one_and_update(
@@ -490,7 +459,7 @@ class MongoDB:
return_document=ReturnDocument.AFTER if return_after else ReturnDocument.BEFORE, return_document=ReturnDocument.AFTER if return_after else ReturnDocument.BEFORE,
) )
except Exception: except Exception:
log.exception(f"db.find_one_and_update() on {collection}") log.exception("db.find_one_and_update() on %s", collection)
return None return None
async def find_one_and_replace( async def find_one_and_replace(
@@ -506,7 +475,7 @@ class MongoDB:
return_document=ReturnDocument.AFTER if return_after else ReturnDocument.BEFORE, return_document=ReturnDocument.AFTER if return_after else ReturnDocument.BEFORE,
) )
except Exception: except Exception:
log.exception(f"db.find_one_and_replace() on {collection}") log.exception("db.find_one_and_replace() on %s", collection)
return None return None
async def find_one_and_delete( async def find_one_and_delete(
@@ -516,7 +485,7 @@ class MongoDB:
try: try:
return await self._db[collection].find_one_and_delete(target, projection=fields) return await self._db[collection].find_one_and_delete(target, projection=fields)
except Exception: except Exception:
log.exception(f"db.find_one_and_delete() on {collection}") log.exception("db.find_one_and_delete() on %s", collection)
return None return None
# ------------------------------------------------------------------------- # -------------------------------------------------------------------------
@@ -528,7 +497,7 @@ class MongoDB:
response = await self._db[collection].delete_one(target) response = await self._db[collection].delete_one(target)
return response.deleted_count return response.deleted_count
except Exception: except Exception:
log.exception(f"db.delete_document() on {collection}") log.exception("db.delete_document() on %s", collection)
return 0 return 0
async def delete(self, collection: str, target: dict) -> int: async def delete(self, collection: str, target: dict) -> int:
@@ -541,7 +510,7 @@ class MongoDB:
response = await self._db[collection].delete_many(target) response = await self._db[collection].delete_many(target)
return response.deleted_count return response.deleted_count
except Exception: except Exception:
log.exception(f"db.delete_documents() on {collection}") log.exception("db.delete_documents() on %s", collection)
return 0 return 0
# ------------------------------------------------------------------------- # -------------------------------------------------------------------------
@@ -565,7 +534,7 @@ class MongoDB:
"upserted": result.upserted_count, "upserted": result.upserted_count,
} }
except Exception: except Exception:
log.exception(f"db.bulk_write() on {collection}") log.exception("db.bulk_write() on %s", collection)
return {} return {}
async def document_check_multi( async def document_check_multi(
@@ -582,7 +551,7 @@ class MongoDB:
} }
return await self._db[collection].find_one(query) is not None return await self._db[collection].find_one(query) is not None
except Exception: except Exception:
log.exception(f"db.document_check_multi() on {collection}") log.exception("db.document_check_multi() on %s", collection)
return False return False
@@ -593,7 +562,7 @@ Mongo = MongoDB
# ----------------------------------------------------------------------------- # -----------------------------------------------------------------------------
# backwards-compat module proxy: `import mongo; mongo.init(conn, db)` then # backwards-compat module proxy: `import mongo; mongo.init(conn, db)` then
# bare `await mongo.func(...)`. needs `import mongo` — `from mongo import func` # bare `await mongo.func(...)`. needs `import mongo` - `from mongo import func`
# resolves at import time, before init() runs. # resolves at import time, before init() runs.
_default: Optional[MongoDB] = None _default: Optional[MongoDB] = None