mongojet 0.2.3__cp313-none-win32.whl

mongojet/__init__.py

@@ -0,0 +1,58 @@
+from ._client import create_client, Client
+from ._database import Database
+from ._collection import Collection
+from ._gridfs import GridfsBucket
+
+from .mongojet import (
+    PyMongoError,
+    OperationFailure,
+    WriteError,
+    WriteConcernError,
+    DuplicateKeyError,
+    BsonSerializationError,
+    BsonDeserializationError,
+    ConnectionFailure,
+    ServerSelectionError,
+    ConfigurationError,
+    GridFSError,
+    NoFile,
+    FileExists,
+)
+
+from ._types import (
+    DatabaseOptions,
+    CollectionOptions,
+    ReadConcern,
+    WriteConcern,
+    ReadPreference,
+    IndexModel,
+    IndexModelDef,
+)
+
+__all__ = (
+    'create_client',
+    'Client',
+    'Database',
+    'Collection',
+    'PyMongoError',
+    'OperationFailure',
+    'WriteError',
+    'WriteConcernError',
+    'DuplicateKeyError',
+    'BsonSerializationError',
+    'BsonDeserializationError',
+    'ConnectionFailure',
+    'ServerSelectionError',
+    'ConfigurationError',
+    'DatabaseOptions',
+    'CollectionOptions',
+    'ReadConcern',
+    'WriteConcern',
+    'ReadPreference',
+    'IndexModel',
+    'IndexModelDef',
+    'GridfsBucket',
+    'GridFSError',
+    'NoFile',
+    'FileExists',
+)

mongojet/_client.py

@@ -0,0 +1,99 @@
+from typing import Optional
+
+from bson import CodecOptions
+
+from .mongojet import core_create_client  # noqa
+
+try:
+    from typing import Unpack
+except ImportError:
+    from typing_extensions import Unpack
+
+from ._database import Database
+from ._types import DatabaseOptions, SessionOptions
+from ._codec import Codec
+from ._session import ClientSession
+
+
+async def create_client(url: str, tz_aware: bool = True) -> 'Client':
+    core_client = await core_create_client(url=url)
+    return Client(core_client, codec_options=CodecOptions(tz_aware=tz_aware))
+
+
+class Client:
+    def __init__(self, core_client, codec_options: CodecOptions) -> None:
+        self._codec_options = codec_options
+        self._codec = Codec(options=codec_options)
+        self._core_client = core_client
+
+    def get_default_database(
+        self,
+        codec_options: Optional[CodecOptions] = None,
+        **options: Unpack[DatabaseOptions],
+    ) -> Database:
+        default_database = self._core_client.default_database_name
+        if default_database is None:
+            raise ValueError('No default database name defined or provided.')
+
+        if options:
+            core_database = self._core_client.get_database_with_options(
+                default_database,
+                self._codec.encode(options),
+            )
+        else:
+            core_database = self._core_client.get_default_database()
+
+        return Database(
+            core_database,
+            codec_options=codec_options or self._codec_options,
+            client=self,
+        )
+
+    def get_database(
+        self,
+        name: Optional[str] = None,
+        codec_options: Optional[CodecOptions] = None,
+        **options: Unpack[DatabaseOptions],
+    ) -> Database:
+        if name is None:
+            return self.get_default_database(codec_options=codec_options, **options)
+
+        if options:
+            core_database = self._core_client.get_database_with_options(
+                name,
+                self._codec.encode(options),
+            )
+        else:
+            core_database = self._core_client.get_database(name)
+
+        return Database(
+            core_database,
+            codec_options=codec_options or self._codec_options,
+            client=self,
+        )
+
+    async def start_session(self, **options: Unpack[SessionOptions]) -> ClientSession:
+        core_session = await self._core_client.start_session(
+            self._codec.encode(options),
+        )
+        return ClientSession(
+            core_session,
+            codec_options=self._codec_options,
+        )
+
+    async def close(self, immediate=True):
+        if immediate:
+            await self._core_client.shutdown_immediate()
+        else:
+            await self._core_client.shutdown()
+
+    def __getitem__(self, name: str) -> Database:
+        return self.get_database(name)
+
+    def __getattr__(self, name: str) -> Database:
+        if name.startswith("_"):  # pragma: no cover
+            raise AttributeError(
+                f"Client has no attribute {name!r}. To access the {name}"
+                f" database, use client[{name!r}]."
+            )
+        return self.__getitem__(name)

mongojet/_codec.py

@@ -0,0 +1,104 @@
+import re
+from typing import Any, Dict, Optional, Mapping
+
+import bson
+from bson import CodecOptions
+
+DEFAULT_CODEC_OPTIONS = CodecOptions(tz_aware=True)
+
+
+class Codec:
+    def __init__(self, options: CodecOptions):
+        self._options = options
+
+    def encode(
+        self,
+        doc: Optional[Mapping[str, Any]],
+        optional=True,
+    ) -> Optional[bytes]:
+        if doc is None:
+            return None
+
+        # if optional and doc=={}
+        if optional and not doc:
+            return None
+
+        return bson.BSON.encode(doc, codec_options=self._options)
+
+    def decode(
+        self,
+        data: Optional[bytes],
+    ) -> Optional[Dict[str, Any]]:
+        if data is None:
+            return None
+
+        doc = bson.BSON(data).decode(codec_options=self._options)
+
+        return doc
+
+
+def encode(
+    doc: Optional[Mapping[str, Any]],
+    codec_options=None,
+    amend_keys=False,
+    optional=True,
+) -> Optional[bytes]:
+    """
+    DEPRECATED
+    """
+    # ???
+    # if not doc:
+    #     return None
+
+    if doc is None:
+        return None
+
+    # if optional and doc=={}
+    if optional and not doc:
+        return None
+
+    if amend_keys:
+        doc = dict_keys_to_camel_case(doc)
+
+    return bson.BSON.encode(
+        doc,
+        codec_options=codec_options or DEFAULT_CODEC_OPTIONS,
+    )
+
+
+def decode(
+    data: Optional[bytes],
+    codec_options=None,
+    amend_keys=False,
+) -> Optional[Dict[str, Any]]:
+    if data is None:
+        return None
+
+    doc = bson.BSON(data).decode(
+        codec_options=codec_options or DEFAULT_CODEC_OPTIONS,
+    )
+
+    if amend_keys:
+        doc = dict_keys_to_snake_case(doc)
+
+    return doc
+
+
+def to_camel_case(s: str) -> str:
+    s = ''.join(word.capitalize() for word in s.split('_'))
+    return s[:1].lower() + s[1:]
+
+
+re_caps = re.compile(r'(?<!^)(?=[A-Z])')
+
+
+def to_snake_case(s: str) -> str:
+    return re_caps.sub('_', s).lower()
+
+
+def dict_keys_to_camel_case(d: Mapping[str, Any]) -> dict:
+    return {to_camel_case(k): v for k, v in d.items()}
+
+
+def dict_keys_to_snake_case(d: Mapping[str, Any]) -> dict:
+    return {to_snake_case(k): v for k, v in d.items()}