kover 2.6.2__tar.gz → 2.7.2__tar.gz

{kover-2.6.2 → kover-2.7.2}/.gitignore

@@ -1,6 +1,7 @@
+uv.lock
 __pycache__
 .vscode
-main.py
+test.py
 .git
 out
 badges.txt
@@ -8,6 +9,4 @@ badges.txt
 dist
 .ruff_cache
 .python-version
-.token
-uv.lock
-kover/bulk
+.token

{kover-2.6.2 → kover-2.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kover
-Version: 2.6.2
+Version: 2.7.2
 Summary: Fully async mongodb driver for mongod and replica sets.
 Project-URL: Repository, https://github.com/megawattka/kover
 Project-URL: Documentation, https://github.com/megawattka/kover
@@ -62,11 +62,11 @@ if __name__ == "__main__":
 ```
 
 The main reason why i created this project is that Motor - official async wrapper for mongodb, uses ThreadPool executor and it's just a wrapper around pymongo. In general thats slower than clear asyncio and looks more dirty.
-- 02.12.24 UPDATE: pymongo added async support but its kinda messed up and not clear. pymongo's code looks dirty and have lots of unnecessary things. kover almost 1.5-2 times faster than pymongo.
+- 02.12.24 UPDATE: pymongo added async support but its kinda messed up. pymongo's code looks complicated, dirty and unclean.
 
 # Status
 it still missing features. <br>
-e.g: **bulk write API** and **Encryption**
+e.g: **Encryption** and **AWS auth**
 but its already very cool! <br>
 
 # Dependencies

{kover-2.6.2 → kover-2.7.2}/README.md

@@ -32,11 +32,11 @@ if __name__ == "__main__":
 ```
 
 The main reason why i created this project is that Motor - official async wrapper for mongodb, uses ThreadPool executor and it's just a wrapper around pymongo. In general thats slower than clear asyncio and looks more dirty.
-- 02.12.24 UPDATE: pymongo added async support but its kinda messed up and not clear. pymongo's code looks dirty and have lots of unnecessary things. kover almost 1.5-2 times faster than pymongo.
+- 02.12.24 UPDATE: pymongo added async support but its kinda messed up. pymongo's code looks complicated, dirty and unclean.
 
 # Status
 it still missing features. <br>
-e.g: **bulk write API** and **Encryption**
+e.g: **Encryption** and **AWS auth**
 but its already very cool! <br>
 
 # Dependencies

{kover-2.6.2 → kover-2.7.2}/kover/__init__.py

@@ -20,11 +20,12 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-__version__ = "2.6.2"
+__version__ = "2.7.2"
 __author__ = "megawattka"
 __license__ = "MIT"
 __copyright__ = "Copyright (C) 2024-present megawattka"
 
+from .bulk_write_builder import BulkWriteBuilder
 from .client import Kover
 from .collection import Collection
 from .cursor import Cursor
@@ -65,6 +66,7 @@ from .typings import xJsonT
 __all__ = (
     "AuthCredentials",
     "BuildInfo",
+    "BulkWriteBuilder",
     "Collation",
     "CollationStrength",
     "Collection",

{kover-2.6.2 → kover-2.7.2}/kover/_internals/_mixins.py

@@ -28,7 +28,11 @@ class ModelMixin(BaseModel):
     )
 
     def to_dict(self) -> xJsonT:
-        """Convert the model to a dictionary with camel case keys."""
+        """Convert the model to a dictionary with camel case keys.
+
+        Returns:
+            A dictionary representation of the model with camel case keys.
+        """
         return self.model_dump(by_alias=True, exclude_none=True)
 
     def __str__(self) -> str:

{kover-2.6.2 → kover-2.7.2}/kover/_internals/_serializers.py

@@ -52,11 +52,11 @@ def _serialize_literal(
     *,
     is_optional: bool = False,
 ) -> xJsonT:
-    args = [
+    args: list[Any] = [
         x.value if issubclass(x.__class__, Enum)
         else x for x in attr_t.__args__
     ]
-    dtypes = chain([_lookup_type(type(val)) for val in args])  # type: ignore
+    dtypes = chain([_lookup_type(type(val)) for val in args])  # pyright: ignore[reportUnknownArgumentType]
     return {
         "enum": args + ([None] if is_optional else []),
         "bsonType": sorted(set(dtypes)),
@@ -93,7 +93,7 @@ def _serialize_enum(
     is_optional: bool = False,
 ) -> xJsonT:
     values = [z.value for z in attr_t]
-    dtypes = chain([_lookup_type(type(val)) for val in values])  # type: ignore
+    dtypes = chain([_lookup_type(type(val)) for val in values])  # pyright: ignore[reportUnknownArgumentType]
     return {
         "enum": values + ([None] if is_optional else []),
         "bsonType": sorted(set(dtypes)) + (
@@ -130,14 +130,14 @@ def value_to_json_schema(
         dict: _serialize_dict,
     }
     if origin in origin_map:
-        func = origin_map[origin]  # type: ignore
+        func = origin_map[origin]
 
-    elif isinstance(attr_t, type) and issubclass(attr_t, Enum):  # type: ignore
+    elif isinstance(attr_t, type) and issubclass(attr_t, Enum):  # pyright: ignore[reportUnnecessaryIsInstance]
         func = _serialize_enum
 
     elif attr_t in _TYPE_MAP:
         func = _serialize_simple_type
     if func is not None:
-        return func(attr_t, is_optional=is_optional)  # type: ignore
+        return func(attr_t, is_optional=is_optional)  # pyright: ignore[reportArgumentType]
 
     return None  # ruff requires this to be explicit

kover-2.7.2/kover/bulk_write_builder.py

@@ -0,0 +1,104 @@
+"""Builder for kover BulkWrite operations."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .helpers import filter_non_null
+
+if TYPE_CHECKING:
+    from .models import Delete, Update
+    from .typings import xJsonT
+
+
+# https://www.mongodb.com/docs/manual/reference/command/bulkWrite
+class BulkWriteBuilder:
+    """Builder for bulk write operations."""
+
+    def __init__(
+        self,
+        *,
+        ordered: bool = True,
+        bypass_document_validation: bool = False,
+        comment: str | None = None,
+        let: xJsonT | None = None,
+        errors_only: bool = False,
+        cursor_batch_size: int | None = None,
+        write_concern: str = "majority",
+    ) -> None:
+        self.ordered = ordered
+        self.bypass_document_validation = bypass_document_validation
+        self.comment = comment
+        self.let = let
+        self.errors_only = errors_only
+        self.cursor = {"batchSize": cursor_batch_size or 101}
+        self.write_concern = write_concern
+        self._operations: list[xJsonT] = []
+        self._namespaces: list[str] = []
+
+    def _prepair_additional_params(self) -> xJsonT:
+        return filter_non_null({
+            "ordered": self.ordered,
+            "bypassDocumentValidation": self.bypass_document_validation,
+            "comment": self.comment,
+            "let": self.let,
+            "errorsOnly": self.errors_only,
+            "cursor": self.cursor,
+            "writeConcern": {"w": self.write_concern},
+        })
+
+    def _get_ns_idx(self, namespace: str) -> int:
+        if namespace not in self._namespaces:
+            self._namespaces.append(namespace)
+        return self._namespaces.index(namespace)
+
+    def add_insert(
+        self,
+        documents: list[xJsonT],
+        /,
+        *,
+        ns: str,
+    ) -> None:
+        """Adds an Insert operations into the builder."""
+        idx = self._get_ns_idx(ns)
+        for document in documents:
+            self._operations.append({"insert": idx, "document": document})
+
+    def add_update(
+        self,
+        *updates: Update,
+        ns: str,
+    ) -> None:
+        """Adds an Update operations into the builder."""
+        idx = self._get_ns_idx(ns)
+        for update in updates:
+            self._operations.append({
+                "update": idx,
+                **update.as_bulk_write_op(),
+            })
+
+    def add_delete(
+        self,
+        *deletes: Delete,
+        ns: str,
+    ) -> None:
+        """Adds an Delete operations into the builder."""
+        idx = self._get_ns_idx(ns)
+        for delete in deletes:
+            self._operations.append({
+                "delete": idx,
+                **delete.as_bulk_write_op(),
+            })
+
+    def build(self) -> xJsonT:
+        """Build the command.
+
+        Returns:
+            The command that was built for Kover.bulk_write method.
+        """
+        return {
+            "bulkWrite": 1,
+            "ops": self._operations,
+            "nsInfo": [{"ns": ns} for ns in self._namespaces],
+            **self._prepair_additional_params(),
+        }

{kover-2.6.2 → kover-2.7.2}/kover/client.py

@@ -1,72 +1,89 @@
+"""Kover Client Module."""
+
 from __future__ import annotations
 
+import asyncio
 import json
 from typing import TYPE_CHECKING, Literal
 
 from typing_extensions import Self
 
 from .database import Database
-from .helpers import classrepr, filter_non_null, maybe_to_dict
+from .helpers import (
+    classrepr,
+    filter_non_null,
+    maybe_to_dict,
+)
 from .models import BuildInfo, WriteConcern
 from .network import MongoTransport, SrvResolver
 from .session import Session
+from .typings import DEFAULT_MONGODB_PORT
 from .uri_parser import parse_uri
 
 if TYPE_CHECKING:
-    import asyncio
-
     from .models import ReplicaSetConfig
     from .network import AuthCredentials
-    from .typings import COMPRESSION_T, xJsonT
+    from .transaction import Transaction
+    from .typings import COMPRESSION_T, DocumentT, xJsonT
+
+
+def create_connection_pool(
+    host: str,
+    port: int,
+    size: int,
+    *,
+    tls: bool,
+    loop: asyncio.AbstractEventLoop | None = None,
+) -> asyncio.Queue[MongoTransport]:
+    """Gives us a filled connection pool.
+
+    Returns:
+        Pool, filled with non connected connections.
+    """
+    pool: asyncio.Queue[MongoTransport] = asyncio.Queue()
+    for _ in range(size):
+        pool.put_nowait(MongoTransport(host, port, loop=loop, tls=tls))
+    return pool
 
 
-@classrepr("signature", "transport", "is_primary")
+@classrepr("_write_concern", "_compression", "_application")
 class Kover:
-    """Kover client for interacting with a MongoDB server.
-
-    Attributes:
-        transport : The underlying transport to the MongoDB server.
-        signature : The authentication signature, if authenticated.
-        default_database : The name of the default database.
-        is_primary : The flag that tells us whether that
-            this is primary or secondary instance
-    """
+    """Kover client for interacting with a MongoDB server."""
 
     def __init__(
         self,
-        transport: MongoTransport,
-        signature: bytes | None,
         *,
-        is_primary: bool = False,
         w: str | int = "majority",
+        pool: asyncio.Queue[MongoTransport],
+        credentials: AuthCredentials | None = None,
+        compression: COMPRESSION_T | None = None,
+        application: xJsonT | None = None,
     ) -> None:
-        self.transport = transport
-        self.signature = signature
-        self._is_primary = is_primary
         self._write_concern = WriteConcern(w=w)
+        self._pool = pool
+        self._credentials = credentials
+        self._compression = compression
+        self._application = application
 
     async def __aenter__(self) -> Self:
         return self
 
     async def __aexit__(self, *exc: object) -> bool:
-        if self.signature is not None:
-            await self.logout()
         await self.close()
         return True
 
-    @property
-    def is_primary(self) -> bool:
-        """Whether this instance is a primary or not."""
-        return self._is_primary
-
     async def close(self) -> None:
-        """Close the underlying transport connection.
+        """Close the underlying transport connections.
 
         This method closes the transport writer
         and waits until the connection is fully closed.
         """
-        self.transport.writer.close()
-        await self.transport.writer.wait_closed()
+        if self._pool.empty():
+            return
+
+        while not self._pool.empty():
+            conn = await self._pool.get()
+            await conn.close()
 
     def get_database(self, name: str) -> Database:
         """Get a Database instance for the specified database name.
@@ -90,7 +107,11 @@ class Kover:
         j: bool | None = None,
         wtimeout: int = 0,
     ) -> Self:
-        """This sets a WriteConcern for all requests."""
+        """This sets a WriteConcern for all requests.
+
+        Returns:
+            The Kover client instance with the updated write concern.
+        """
         self._write_concern = WriteConcern(w=w, j=j, wtimeout=wtimeout)
         return self
 
@@ -100,49 +121,54 @@ class Kover:
         uri: str,
         loop: asyncio.AbstractEventLoop | None = None,
     ) -> Kover:
-        """Create an instance of Kover client by passing a uri."""
+        """Create an instance of Kover client by passing a uri.
+
+        Parameters:
+            uri : The uri itself.
+            loop : Optional asyncio loop
+
+        Returns:
+            An instance of newly created Kover client.
+        """
         parsed = parse_uri(uri)
 
-        resolver = SrvResolver()
-        nodes = await resolver.get_nodes(parsed.hostname)
-        assert nodes, "Node resolution failed."
+        if parsed.scheme == "mongodb+srv":
+            resolver = SrvResolver()
+            nodes = await resolver.get_nodes(parsed.hostname)
+            assert nodes, "Node resolution failed."
+        else:
+            nodes = [parsed.hostname]
 
-        transport = await MongoTransport.make(
-            nodes[0], port=parsed.port, tls=parsed.tls, loop=loop)
+        transport = MongoTransport(
+            nodes[0], parsed.port, loop=loop, tls=parsed.tls)
 
+        await transport.connect()
         hello = await transport.hello(
             parsed.compressors, parsed.credentials, parsed.application)
+        await transport.close()
 
         if not hello.is_primary:
             assert hello.primary_node, "Primary node resolution failed."
 
             host, _ = hello.primary_node.split(":")
-            return await cls.make_client(
-                host=host,
-                port=parsed.port,
-                credentials=parsed.credentials,
-                loop=loop,
-                compression=parsed.compressors,
-                tls=parsed.tls,
-                application=parsed.application,
-                write_concern=parsed.write_concern,
-            )
+            nodes = [host]
 
-        mechanism = hello.get_auth_mechanism()
-        signature = await transport.authorize(mechanism, parsed.credentials)
+        args = (nodes[0], parsed.port, parsed.max_pool_size)
+        pool = create_connection_pool(*args, tls=parsed.tls, loop=loop)
 
         return cls(
-            transport=transport,
-            signature=signature,
-            is_primary=hello.is_primary,
             w=parsed.write_concern,
+            pool=pool,
+            credentials=parsed.credentials,
+            compression=parsed.compressors,
+            application=parsed.application,
         )
 
     @classmethod
     async def make_client(
         cls,
         host: str = "127.0.0.1",
-        port: int = 27017,
+        port: int = DEFAULT_MONGODB_PORT,
         *,
         credentials: AuthCredentials | None = None,
         loop: asyncio.AbstractEventLoop | None = None,
@@ -150,6 +176,7 @@ class Kover:
         tls: bool = False,
         application: xJsonT | None = None,
         write_concern: str | int = "majority",
+        max_pool_size: int = 100,
     ) -> Kover:
         """Create and return a new Kover client instance.
 
@@ -169,23 +196,60 @@ class Kover:
         Returns:
             An instance of the Kover client.
         """
-        transport = await MongoTransport.make(
-            host=host, port=port, loop=loop, tls=tls)
+        pool = create_connection_pool(
+            host, port, max_pool_size, tls=tls, loop=loop)
 
-        hello = await transport.hello(
+        return cls(
+            w=write_concern,
+            pool=pool,
             credentials=credentials,
             compression=compression,
             application=application,
         )
-        mechanism = hello.get_auth_mechanism()
-        signature = await transport.authorize(mechanism, credentials)
 
-        return cls(
-            transport,
-            signature,
-            is_primary=hello.is_primary,
-            w=write_concern,
-        )
+    async def request(
+        self,
+        doc: DocumentT,
+        *,
+        db_name: str = "admin",
+        transaction: Transaction | None = None,
+        wait_response: bool = True,
+    ) -> xJsonT:
+        """Send a request to MongoDB Server.
+
+        Returns:
+            Document, containing response from the server.
+        """
+        conn = await self._pool.get()
+        if not conn.is_connected:
+            await conn.connect()
+            hello = await conn.hello(
+                self._compression, self._credentials, self._application)
+
+            if hello.requires_auth:
+                mechanism = hello.get_auth_mechanism()
+                await conn.authorize(mechanism, credentials=self._credentials)
+        try:
+            return await conn.request(
+                doc,
+                db_name=db_name,
+                transaction=transaction,
+                wait_response=wait_response,
+            )
+        finally:
+            await self._pool.put(conn)
+
+    async def bulk_write(
+        self,
+        document: xJsonT,
+        transaction: Transaction | None = None,
+    ) -> xJsonT:
+        """Execute a bulkWrite operation and return info about it.
+
+        Returns:
+            Document, containing info about this operation.
+        """
+        return await self.request(document, transaction=transaction)
 
     async def refresh_sessions(self, sessions: list[Session]) -> None:
         """Refresh the provided list of sessions.
@@ -194,7 +258,7 @@ class Kover:
             sessions : A list of Session objects to be refreshed.
         """
         documents: list[xJsonT] = [x.document for x in sessions]
-        await self.transport.request({"refreshSessions": documents})
+        await self.request({"refreshSessions": documents})
 
     async def end_sessions(self, sessions: list[Session]) -> None:
         """End the provided list of sessions.
@@ -203,7 +267,7 @@ class Kover:
             sessions : A list of Session objects to be ended.
         """
         documents: list[xJsonT] = [x.document for x in sessions]
-        await self.transport.request({"endSessions": documents})
+        await self.request({"endSessions": documents})
 
     async def start_session(self) -> Session:
         """Start a new session.
@@ -211,8 +275,8 @@ class Kover:
         Returns:
             An instance of the Session class representing the started session.
         """
-        req = await self.transport.request({"startSession": 1.0})
-        return Session(document=req["id"], transport=self.transport)
+        req = await self.request({"startSession": 1.0})
+        return Session(document=req["id"], client=self)
 
     async def build_info(self) -> BuildInfo:
         """Retrieve build information from the MongoDB server.
@@ -220,7 +284,7 @@ class Kover:
         Returns:
             An instance of BuildInfo containing server build details.
         """
-        request = await self.transport.request({"buildInfo": 1.0})
+        request = await self.request({"buildInfo": 1.0})
         return BuildInfo.model_validate(request)
 
     async def logout(self) -> None:
@@ -229,7 +293,7 @@ class Kover:
         This method sends a logout request to the server
         to terminate the current authenticated session.
         """
-        await self.transport.request({"logout": 1.0})
+        await self.request({"logout": 1.0})
 
     async def list_database_names(self) -> list[str]:
         """Retrieve the names of all databases on the MongoDB server.
@@ -241,7 +305,7 @@ class Kover:
             "listDatabases": 1.0,
             "nameOnly": True  # noqa: COM812
         }
-        request = await self.transport.request(command)
+        request = await self.request(command)
         return [x["name"] for x in request["databases"]]
 
     async def drop_database(self, name: str) -> None:
@@ -250,7 +314,7 @@ class Kover:
         Parameters:
             name : The name of the database to drop.
         """
-        await self.transport.request({"dropDatabase": 1.0}, db_name=name)
+        await self.request({"dropDatabase": 1.0}, db_name=name)
 
     # https://www.mongodb.com/docs/manual/reference/command/replSetInitiate/
     async def replica_set_initiate(
@@ -264,7 +328,7 @@ class Kover:
                 default configuration is used.
         """
         document = maybe_to_dict(config) or {}
-        await self.transport.request({"replSetInitiate": document})
+        await self.request({"replSetInitiate": document})
 
     # https://www.mongodb.com/docs/manual/reference/command/replSetReconfig/
     async def replica_set_reconfig(
@@ -284,7 +348,7 @@ class Kover:
             "force": force,
             "maxTimeMS": max_time_ms,
         })
-        await self.transport.request(document)
+        await self.request(document)
 
     # https://www.mongodb.com/docs/manual/reference/command/replSetGetStatus/
     async def get_replica_set_status(self) -> xJsonT:
@@ -293,7 +357,7 @@ class Kover:
         Returns:
             A JSON document containing the replica set status information.
         """
-        return await self.transport.request({"replSetGetStatus": 1.0})
+        return await self.request({"replSetGetStatus": 1.0})
 
     # https://www.mongodb.com/docs/manual/reference/command/shutdown/
     async def shutdown(
@@ -316,7 +380,7 @@ class Kover:
             "timeoutSecs": timeout,
             "comment": comment,
         })
-        await self.transport.request(command, wait_response=False)
+        await self.request(command, wait_response=False)
 
     # https://www.mongodb.com/docs/manual/reference/command/getCmdLineOpts/
     async def get_commandline(self) -> list[str]:
@@ -325,7 +389,7 @@ class Kover:
         Returns:
             A list of command line arguments.
         """
-        r = await self.transport.request({"getCmdLineOpts": 1.0})
+        r = await self.request({"getCmdLineOpts": 1.0})
         return r["argv"]
 
     # https://www.mongodb.com/docs/manual/reference/command/getLog/#getlog
@@ -342,7 +406,7 @@ class Kover:
         Returns:
             A list of log entries as JSON objects.
         """
-        r = await self.transport.request({"getLog": parameter})
+        r = await self.request({"getLog": parameter})
         return [
             json.loads(info) for info in r["log"]
         ]
@@ -371,7 +435,7 @@ class Kover:
             "dropTarget": drop_target,
             "comment": comment,
         })
-        await self.transport.request(command)
+        await self.request(command)
 
     # https://www.mongodb.com/docs/manual/reference/command/setUserWriteBlockMode/
     async def set_user_write_block_mode(self, *, param: bool) -> None:
@@ -381,7 +445,7 @@ class Kover:
             param : Blocks writes on a cluster when set to true.
                 To enable writes on a cluster, set global: false.
         """
-        await self.transport.request({
+        await self.request({
             "setUserWriteBlockMode": 1.0,
             "global": param,
         })
@@ -409,7 +473,7 @@ class Kover:
             "lock": lock,
             "comment": comment,
         })
-        await self.transport.request(command)
+        await self.request(command)
 
     # https://www.mongodb.com/docs/manual/reference/command/fsyncUnlock/
     async def fsync_unlock(self, comment: str | None = None) -> None:
@@ -422,4 +486,4 @@ class Kover:
             "fsyncUnlock": 1.0,
             "comment": comment,
         })
-        await self.transport.request(command)
+        await self.request(command)