sensu-plugins-mongodb-mrtrotl 1.4.0

data/lib/bson/max_key.py

@@ -0,0 +1,55 @@
+# Copyright 2010-present MongoDB, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Representation for the MongoDB internal MaxKey type.
+"""
+from typing import Any
+
+
+class MaxKey(object):
+    """MongoDB internal MaxKey type."""
+
+    __slots__ = ()
+
+    _type_marker = 127
+
+    def __getstate__(self) -> Any:
+        return {}
+
+    def __setstate__(self, state: Any) -> None:
+        pass
+
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, MaxKey)
+
+    def __hash__(self) -> int:
+        return hash(self._type_marker)
+
+    def __ne__(self, other: Any) -> bool:
+        return not self == other
+
+    def __le__(self, other: Any) -> bool:
+        return isinstance(other, MaxKey)
+
+    def __lt__(self, dummy: Any) -> bool:
+        return False
+
+    def __ge__(self, dummy: Any) -> bool:
+        return True
+
+    def __gt__(self, other: Any) -> bool:
+        return not isinstance(other, MaxKey)
+
+    def __repr__(self):
+        return "MaxKey()"

data/lib/bson/min_key.py

@@ -0,0 +1,55 @@
+# Copyright 2010-present MongoDB, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Representation for the MongoDB internal MinKey type.
+"""
+from typing import Any
+
+
+class MinKey(object):
+    """MongoDB internal MinKey type."""
+
+    __slots__ = ()
+
+    _type_marker = 255
+
+    def __getstate__(self) -> Any:
+        return {}
+
+    def __setstate__(self, state: Any) -> None:
+        pass
+
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, MinKey)
+
+    def __hash__(self) -> int:
+        return hash(self._type_marker)
+
+    def __ne__(self, other: Any) -> bool:
+        return not self == other
+
+    def __le__(self, dummy: Any) -> bool:
+        return True
+
+    def __lt__(self, other: Any) -> bool:
+        return not isinstance(other, MinKey)
+
+    def __ge__(self, other: Any) -> bool:
+        return isinstance(other, MinKey)
+
+    def __gt__(self, dummy: Any) -> bool:
+        return False
+
+    def __repr__(self):
+        return "MinKey()"

data/lib/bson/objectid.py

@@ -0,0 +1,286 @@
+# Copyright 2009-2015 MongoDB, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Tools for working with MongoDB ObjectIds.
+"""
+
+import binascii
+import calendar
+import datetime
+import os
+import struct
+import threading
+import time
+from random import SystemRandom
+from typing import Any, NoReturn, Optional, Type, Union
+
+from bson.errors import InvalidId
+from bson.tz_util import utc
+
+_MAX_COUNTER_VALUE = 0xFFFFFF
+
+
+def _raise_invalid_id(oid: str) -> NoReturn:
+    raise InvalidId(
+        "%r is not a valid ObjectId, it must be a 12-byte input"
+        " or a 24-character hex string" % oid
+    )
+
+
+def _random_bytes() -> bytes:
+    """Get the 5-byte random field of an ObjectId."""
+    return os.urandom(5)
+
+
+class ObjectId(object):
+    """A MongoDB ObjectId."""
+
+    _pid = os.getpid()
+
+    _inc = SystemRandom().randint(0, _MAX_COUNTER_VALUE)
+    _inc_lock = threading.Lock()
+
+    __random = _random_bytes()
+
+    __slots__ = ("__id",)
+
+    _type_marker = 7
+
+    def __init__(self, oid: Optional[Union[str, "ObjectId", bytes]] = None) -> None:
+        """Initialize a new ObjectId.
+
+        An ObjectId is a 12-byte unique identifier consisting of:
+
+          - a 4-byte value representing the seconds since the Unix epoch,
+          - a 5-byte random value,
+          - a 3-byte counter, starting with a random value.
+
+        By default, ``ObjectId()`` creates a new unique identifier. The
+        optional parameter `oid` can be an :class:`ObjectId`, or any 12
+        :class:`bytes`.
+
+        For example, the 12 bytes b'foo-bar-quux' do not follow the ObjectId
+        specification but they are acceptable input::
+
+          >>> ObjectId(b'foo-bar-quux')
+          ObjectId('666f6f2d6261722d71757578')
+
+        `oid` can also be a :class:`str` of 24 hex digits::
+
+          >>> ObjectId('0123456789ab0123456789ab')
+          ObjectId('0123456789ab0123456789ab')
+
+        Raises :class:`~bson.errors.InvalidId` if `oid` is not 12 bytes nor
+        24 hex digits, or :class:`TypeError` if `oid` is not an accepted type.
+
+        :Parameters:
+          - `oid` (optional): a valid ObjectId.
+
+        .. seealso:: The MongoDB documentation on  `ObjectIds <http://dochub.mongodb.org/core/objectids>`_.
+
+        .. versionchanged:: 3.8
+           :class:`~bson.objectid.ObjectId` now implements the `ObjectID
+           specification version 0.2
+           <https://github.com/mongodb/specifications/blob/master/source/
+           objectid.rst>`_.
+        """
+        if oid is None:
+            self.__generate()
+        elif isinstance(oid, bytes) and len(oid) == 12:
+            self.__id = oid
+        else:
+            self.__validate(oid)
+
+    @classmethod
+    def from_datetime(cls: Type["ObjectId"], generation_time: datetime.datetime) -> "ObjectId":
+        """Create a dummy ObjectId instance with a specific generation time.
+
+        This method is useful for doing range queries on a field
+        containing :class:`ObjectId` instances.
+
+        .. warning::
+           It is not safe to insert a document containing an ObjectId
+           generated using this method. This method deliberately
+           eliminates the uniqueness guarantee that ObjectIds
+           generally provide. ObjectIds generated with this method
+           should be used exclusively in queries.
+
+        `generation_time` will be converted to UTC. Naive datetime
+        instances will be treated as though they already contain UTC.
+
+        An example using this helper to get documents where ``"_id"``
+        was generated before January 1, 2010 would be:
+
+        >>> gen_time = datetime.datetime(2010, 1, 1)
+        >>> dummy_id = ObjectId.from_datetime(gen_time)
+        >>> result = collection.find({"_id": {"$lt": dummy_id}})
+
+        :Parameters:
+          - `generation_time`: :class:`~datetime.datetime` to be used
+            as the generation time for the resulting ObjectId.
+        """
+        offset = generation_time.utcoffset()
+        if offset is not None:
+            generation_time = generation_time - offset
+        timestamp = calendar.timegm(generation_time.timetuple())
+        oid = struct.pack(">I", int(timestamp)) + b"\x00\x00\x00\x00\x00\x00\x00\x00"
+        return cls(oid)
+
+    @classmethod
+    def is_valid(cls: Type["ObjectId"], oid: Any) -> bool:
+        """Checks if a `oid` string is valid or not.
+
+        :Parameters:
+          - `oid`: the object id to validate
+
+        .. versionadded:: 2.3
+        """
+        if not oid:
+            return False
+
+        try:
+            ObjectId(oid)
+            return True
+        except (InvalidId, TypeError):
+            return False
+
+    @classmethod
+    def _random(cls) -> bytes:
+        """Generate a 5-byte random number once per process."""
+        pid = os.getpid()
+        if pid != cls._pid:
+            cls._pid = pid
+            cls.__random = _random_bytes()
+        return cls.__random
+
+    def __generate(self) -> None:
+        """Generate a new value for this ObjectId."""
+
+        # 4 bytes current time
+        oid = struct.pack(">I", int(time.time()))
+
+        # 5 bytes random
+        oid += ObjectId._random()
+
+        # 3 bytes inc
+        with ObjectId._inc_lock:
+            oid += struct.pack(">I", ObjectId._inc)[1:4]
+            ObjectId._inc = (ObjectId._inc + 1) % (_MAX_COUNTER_VALUE + 1)
+
+        self.__id = oid
+
+    def __validate(self, oid: Any) -> None:
+        """Validate and use the given id for this ObjectId.
+
+        Raises TypeError if id is not an instance of
+        (:class:`basestring` (:class:`str` or :class:`bytes`
+        in python 3), ObjectId) and InvalidId if it is not a
+        valid ObjectId.
+
+        :Parameters:
+          - `oid`: a valid ObjectId
+        """
+        if isinstance(oid, ObjectId):
+            self.__id = oid.binary
+        elif isinstance(oid, str):
+            if len(oid) == 24:
+                try:
+                    self.__id = bytes.fromhex(oid)
+                except (TypeError, ValueError):
+                    _raise_invalid_id(oid)
+            else:
+                _raise_invalid_id(oid)
+        else:
+            raise TypeError(
+                "id must be an instance of (bytes, str, ObjectId), not %s" % (type(oid),)
+            )
+
+    @property
+    def binary(self) -> bytes:
+        """12-byte binary representation of this ObjectId."""
+        return self.__id
+
+    @property
+    def generation_time(self) -> datetime.datetime:
+        """A :class:`datetime.datetime` instance representing the time of
+        generation for this :class:`ObjectId`.
+
+        The :class:`datetime.datetime` is timezone aware, and
+        represents the generation time in UTC. It is precise to the
+        second.
+        """
+        timestamp = struct.unpack(">I", self.__id[0:4])[0]
+        return datetime.datetime.fromtimestamp(timestamp, utc)
+
+    def __getstate__(self) -> bytes:
+        """return value of object for pickling.
+        needed explicitly because __slots__() defined.
+        """
+        return self.__id
+
+    def __setstate__(self, value: Any) -> None:
+        """explicit state set from pickling"""
+        # Provide backwards compatability with OIDs
+        # pickled with pymongo-1.9 or older.
+        if isinstance(value, dict):
+            oid = value["_ObjectId__id"]
+        else:
+            oid = value
+        # ObjectIds pickled in python 2.x used `str` for __id.
+        # In python 3.x this has to be converted to `bytes`
+        # by encoding latin-1.
+        if isinstance(oid, str):
+            self.__id = oid.encode("latin-1")
+        else:
+            self.__id = oid
+
+    def __str__(self) -> str:
+        return binascii.hexlify(self.__id).decode()
+
+    def __repr__(self):
+        return "ObjectId('%s')" % (str(self),)
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, ObjectId):
+            return self.__id == other.binary
+        return NotImplemented
+
+    def __ne__(self, other: Any) -> bool:
+        if isinstance(other, ObjectId):
+            return self.__id != other.binary
+        return NotImplemented
+
+    def __lt__(self, other: Any) -> bool:
+        if isinstance(other, ObjectId):
+            return self.__id < other.binary
+        return NotImplemented
+
+    def __le__(self, other: Any) -> bool:
+        if isinstance(other, ObjectId):
+            return self.__id <= other.binary
+        return NotImplemented
+
+    def __gt__(self, other: Any) -> bool:
+        if isinstance(other, ObjectId):
+            return self.__id > other.binary
+        return NotImplemented
+
+    def __ge__(self, other: Any) -> bool:
+        if isinstance(other, ObjectId):
+            return self.__id >= other.binary
+        return NotImplemented
+
+    def __hash__(self) -> int:
+        """Get a hash value for this :class:`ObjectId`."""
+        return hash(self.__id)

data/lib/bson/py.typed

@@ -0,0 +1,2 @@
+# PEP-561 Support File.
+# "Package maintainers who wish to support type checking of their code MUST add a marker file named py.typed to their package supporting typing".

data/lib/bson/raw_bson.py

@@ -0,0 +1,175 @@
+# Copyright 2015-present MongoDB, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Tools for representing raw BSON documents.
+
+Inserting and Retrieving RawBSONDocuments
+=========================================
+
+Example: Moving a document between different databases/collections
+
+.. doctest::
+
+  >>> import bson
+  >>> from pymongo import MongoClient
+  >>> from bson.raw_bson import RawBSONDocument
+  >>> client = MongoClient(document_class=RawBSONDocument)
+  >>> client.drop_database('db')
+  >>> client.drop_database('replica_db')
+  >>> db = client.db
+  >>> result = db.test.insert_many([{'_id': 1, 'a': 1},
+  ...                               {'_id': 2, 'b': 1},
+  ...                               {'_id': 3, 'c': 1},
+  ...                               {'_id': 4, 'd': 1}])
+  >>> replica_db = client.replica_db
+  >>> for doc in db.test.find():
+  ...    print(f"raw document: {doc.raw}")
+  ...    print(f"decoded document: {bson.decode(doc.raw)}")
+  ...    result = replica_db.test.insert_one(doc)
+  raw document: b'...'
+  decoded document: {'_id': 1, 'a': 1}
+  raw document: b'...'
+  decoded document: {'_id': 2, 'b': 1}
+  raw document: b'...'
+  decoded document: {'_id': 3, 'c': 1}
+  raw document: b'...'
+  decoded document: {'_id': 4, 'd': 1}
+
+For use cases like moving documents across different databases or writing binary
+blobs to disk, using raw BSON documents provides better speed and avoids the
+overhead of decoding or encoding BSON.
+"""
+
+from typing import Any, ItemsView, Iterator, Mapping, Optional
+
+from bson import _get_object_size, _raw_to_dict
+from bson.codec_options import _RAW_BSON_DOCUMENT_MARKER
+from bson.codec_options import DEFAULT_CODEC_OPTIONS as DEFAULT
+from bson.codec_options import CodecOptions
+from bson.son import SON
+
+
+class RawBSONDocument(Mapping[str, Any]):
+    """Representation for a MongoDB document that provides access to the raw
+    BSON bytes that compose it.
+
+    Only when a field is accessed or modified within the document does
+    RawBSONDocument decode its bytes.
+    """
+
+    __slots__ = ("__raw", "__inflated_doc", "__codec_options")
+    _type_marker = _RAW_BSON_DOCUMENT_MARKER
+
+    def __init__(self, bson_bytes: bytes, codec_options: Optional[CodecOptions] = None) -> None:
+        """Create a new :class:`RawBSONDocument`
+
+        :class:`RawBSONDocument` is a representation of a BSON document that
+        provides access to the underlying raw BSON bytes. Only when a field is
+        accessed or modified within the document does RawBSONDocument decode
+        its bytes.
+
+        :class:`RawBSONDocument` implements the ``Mapping`` abstract base
+        class from the standard library so it can be used like a read-only
+        ``dict``::
+
+            >>> from bson import encode
+            >>> raw_doc = RawBSONDocument(encode({'_id': 'my_doc'}))
+            >>> raw_doc.raw
+            b'...'
+            >>> raw_doc['_id']
+            'my_doc'
+
+        :Parameters:
+          - `bson_bytes`: the BSON bytes that compose this document
+          - `codec_options` (optional): An instance of
+            :class:`~bson.codec_options.CodecOptions` whose ``document_class``
+            must be :class:`RawBSONDocument`. The default is
+            :attr:`DEFAULT_RAW_BSON_OPTIONS`.
+
+        .. versionchanged:: 3.8
+          :class:`RawBSONDocument` now validates that the ``bson_bytes``
+          passed in represent a single bson document.
+
+        .. versionchanged:: 3.5
+          If a :class:`~bson.codec_options.CodecOptions` is passed in, its
+          `document_class` must be :class:`RawBSONDocument`.
+        """
+        self.__raw = bson_bytes
+        self.__inflated_doc: Optional[Mapping[str, Any]] = None
+        # Can't default codec_options to DEFAULT_RAW_BSON_OPTIONS in signature,
+        # it refers to this class RawBSONDocument.
+        if codec_options is None:
+            codec_options = DEFAULT_RAW_BSON_OPTIONS
+        elif codec_options.document_class is not RawBSONDocument:
+            raise TypeError(
+                "RawBSONDocument cannot use CodecOptions with document "
+                "class %s" % (codec_options.document_class,)
+            )
+        self.__codec_options = codec_options
+        # Validate the bson object size.
+        _get_object_size(bson_bytes, 0, len(bson_bytes))
+
+    @property
+    def raw(self) -> bytes:
+        """The raw BSON bytes composing this document."""
+        return self.__raw
+
+    def items(self) -> ItemsView[str, Any]:
+        """Lazily decode and iterate elements in this document."""
+        return self.__inflated.items()
+
+    @property
+    def __inflated(self) -> Mapping[str, Any]:
+        if self.__inflated_doc is None:
+            # We already validated the object's size when this document was
+            # created, so no need to do that again.
+            # Use SON to preserve ordering of elements.
+            self.__inflated_doc = _inflate_bson(self.__raw, self.__codec_options)
+        return self.__inflated_doc
+
+    def __getitem__(self, item: str) -> Any:
+        return self.__inflated[item]
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self.__inflated)
+
+    def __len__(self) -> int:
+        return len(self.__inflated)
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, RawBSONDocument):
+            return self.__raw == other.raw
+        return NotImplemented
+
+    def __repr__(self):
+        return "RawBSONDocument(%r, codec_options=%r)" % (self.raw, self.__codec_options)
+
+
+def _inflate_bson(bson_bytes: bytes, codec_options: CodecOptions) -> Mapping[Any, Any]:
+    """Inflates the top level fields of a BSON document.
+
+    :Parameters:
+      - `bson_bytes`: the BSON bytes that compose this document
+      - `codec_options`: An instance of
+        :class:`~bson.codec_options.CodecOptions` whose ``document_class``
+        must be :class:`RawBSONDocument`.
+    """
+    # Use SON to preserve ordering of elements.
+    return _raw_to_dict(bson_bytes, 4, len(bson_bytes) - 1, codec_options, SON())
+
+
+DEFAULT_RAW_BSON_OPTIONS: CodecOptions = DEFAULT.with_options(document_class=RawBSONDocument)
+"""The default :class:`~bson.codec_options.CodecOptions` for
+:class:`RawBSONDocument`.
+"""