sensu-plugins-mongodb-mrtrotl 1.4.0

data/lib/bson/regex.py

@@ -0,0 +1,135 @@
+# Copyright 2013-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 MongoDB regular expressions.
+"""
+
+import re
+from typing import Any, Generic, Pattern, Type, TypeVar, Union
+
+from bson._helpers import _getstate_slots, _setstate_slots
+from bson.son import RE_TYPE
+
+
+def str_flags_to_int(str_flags: str) -> int:
+    flags = 0
+    if "i" in str_flags:
+        flags |= re.IGNORECASE
+    if "l" in str_flags:
+        flags |= re.LOCALE
+    if "m" in str_flags:
+        flags |= re.MULTILINE
+    if "s" in str_flags:
+        flags |= re.DOTALL
+    if "u" in str_flags:
+        flags |= re.UNICODE
+    if "x" in str_flags:
+        flags |= re.VERBOSE
+
+    return flags
+
+
+_T = TypeVar("_T", str, bytes)
+
+
+class Regex(Generic[_T]):
+    """BSON regular expression data."""
+
+    __slots__ = ("pattern", "flags")
+
+    __getstate__ = _getstate_slots
+    __setstate__ = _setstate_slots
+
+    _type_marker = 11
+
+    @classmethod
+    def from_native(cls: Type["Regex"], regex: "Pattern[_T]") -> "Regex[_T]":
+        """Convert a Python regular expression into a ``Regex`` instance.
+
+        Note that in Python 3, a regular expression compiled from a
+        :class:`str` has the ``re.UNICODE`` flag set. If it is undesirable
+        to store this flag in a BSON regular expression, unset it first::
+
+          >>> pattern = re.compile('.*')
+          >>> regex = Regex.from_native(pattern)
+          >>> regex.flags ^= re.UNICODE
+          >>> db.collection.insert_one({'pattern': regex})
+
+        :Parameters:
+          - `regex`: A regular expression object from ``re.compile()``.
+
+        .. warning::
+           Python regular expressions use a different syntax and different
+           set of flags than MongoDB, which uses `PCRE`_. A regular
+           expression retrieved from the server may not compile in
+           Python, or may match a different set of strings in Python than
+           when used in a MongoDB query.
+
+        .. _PCRE: http://www.pcre.org/
+        """
+        if not isinstance(regex, RE_TYPE):
+            raise TypeError("regex must be a compiled regular expression, not %s" % type(regex))
+
+        return Regex(regex.pattern, regex.flags)
+
+    def __init__(self, pattern: _T, flags: Union[str, int] = 0) -> None:
+        """BSON regular expression data.
+
+        This class is useful to store and retrieve regular expressions that are
+        incompatible with Python's regular expression dialect.
+
+        :Parameters:
+          - `pattern`: string
+          - `flags`: (optional) an integer bitmask, or a string of flag
+            characters like "im" for IGNORECASE and MULTILINE
+        """
+        if not isinstance(pattern, (str, bytes)):
+            raise TypeError("pattern must be a string, not %s" % type(pattern))
+        self.pattern: _T = pattern
+
+        if isinstance(flags, str):
+            self.flags = str_flags_to_int(flags)
+        elif isinstance(flags, int):
+            self.flags = flags
+        else:
+            raise TypeError("flags must be a string or int, not %s" % type(flags))
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, Regex):
+            return self.pattern == other.pattern and self.flags == other.flags
+        else:
+            return NotImplemented
+
+    __hash__ = None  # type: ignore
+
+    def __ne__(self, other: Any) -> bool:
+        return not self == other
+
+    def __repr__(self):
+        return "Regex(%r, %r)" % (self.pattern, self.flags)
+
+    def try_compile(self) -> "Pattern[_T]":
+        """Compile this :class:`Regex` as a Python regular expression.
+
+        .. warning::
+           Python regular expressions use a different syntax and different
+           set of flags than MongoDB, which uses `PCRE`_. A regular
+           expression retrieved from the server may not compile in
+           Python, or may match a different set of strings in Python than
+           when used in a MongoDB query. :meth:`try_compile()` may raise
+           :exc:`re.error`.
+
+        .. _PCRE: http://www.pcre.org/
+        """
+        return re.compile(self.pattern, self.flags)

data/lib/bson/son.py

@@ -0,0 +1,208 @@
+# Copyright 2009-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 creating and manipulating SON, the Serialized Ocument Notation.
+
+Regular dictionaries can be used instead of SON objects, but not when the order
+of keys is important. A SON object can be used just like a normal Python
+dictionary."""
+
+import copy
+import re
+from collections.abc import Mapping as _Mapping
+from typing import (
+    Any,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Mapping,
+    Optional,
+    Pattern,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+)
+
+# This sort of sucks, but seems to be as good as it gets...
+# This is essentially the same as re._pattern_type
+RE_TYPE: Type[Pattern[Any]] = type(re.compile(""))
+
+_Key = TypeVar("_Key")
+_Value = TypeVar("_Value")
+_T = TypeVar("_T")
+
+
+class SON(Dict[_Key, _Value]):
+    """SON data.
+
+    A subclass of dict that maintains ordering of keys and provides a
+    few extra niceties for dealing with SON. SON provides an API
+    similar to collections.OrderedDict.
+    """
+
+    __keys: List[Any]
+
+    def __init__(
+        self,
+        data: Optional[Union[Mapping[_Key, _Value], Iterable[Tuple[_Key, _Value]]]] = None,
+        **kwargs: Any
+    ) -> None:
+        self.__keys = []
+        dict.__init__(self)
+        self.update(data)
+        self.update(kwargs)
+
+    def __new__(cls: Type["SON[_Key, _Value]"], *args: Any, **kwargs: Any) -> "SON[_Key, _Value]":
+        instance = super(SON, cls).__new__(cls, *args, **kwargs)
+        instance.__keys = []
+        return instance
+
+    def __repr__(self):
+        result = []
+        for key in self.__keys:
+            result.append("(%r, %r)" % (key, self[key]))
+        return "SON([%s])" % ", ".join(result)
+
+    def __setitem__(self, key: _Key, value: _Value) -> None:
+        if key not in self.__keys:
+            self.__keys.append(key)
+        dict.__setitem__(self, key, value)
+
+    def __delitem__(self, key: _Key) -> None:
+        self.__keys.remove(key)
+        dict.__delitem__(self, key)
+
+    def copy(self) -> "SON[_Key, _Value]":
+        other: SON[_Key, _Value] = SON()
+        other.update(self)
+        return other
+
+    # TODO this is all from UserDict.DictMixin. it could probably be made more
+    # efficient.
+    # second level definitions support higher levels
+    def __iter__(self) -> Iterator[_Key]:
+        for k in self.__keys:
+            yield k
+
+    def has_key(self, key: _Key) -> bool:
+        return key in self.__keys
+
+    def iterkeys(self) -> Iterator[_Key]:
+        return self.__iter__()
+
+    # fourth level uses definitions from lower levels
+    def itervalues(self) -> Iterator[_Value]:
+        for _, v in self.items():
+            yield v
+
+    def values(self) -> List[_Value]:  # type: ignore[override]
+        return [v for _, v in self.items()]
+
+    def clear(self) -> None:
+        self.__keys = []
+        super(SON, self).clear()
+
+    def setdefault(self, key: _Key, default: _Value) -> _Value:  # type: ignore[override]
+        try:
+            return self[key]
+        except KeyError:
+            self[key] = default
+        return default
+
+    def pop(self, key: _Key, *args: Union[_Value, _T]) -> Union[_Value, _T]:
+        if len(args) > 1:
+            raise TypeError("pop expected at most 2 arguments, got " + repr(1 + len(args)))
+        try:
+            value = self[key]
+        except KeyError:
+            if args:
+                return args[0]
+            raise
+        del self[key]
+        return value
+
+    def popitem(self) -> Tuple[_Key, _Value]:
+        try:
+            k, v = next(iter(self.items()))
+        except StopIteration:
+            raise KeyError("container is empty")
+        del self[k]
+        return (k, v)
+
+    def update(self, other: Optional[Any] = None, **kwargs: _Value) -> None:  # type: ignore[override]
+        # Make progressively weaker assumptions about "other"
+        if other is None:
+            pass
+        elif hasattr(other, "items"):
+            for k, v in other.items():
+                self[k] = v
+        elif hasattr(other, "keys"):
+            for k in other.keys():
+                self[k] = other[k]
+        else:
+            for k, v in other:
+                self[k] = v
+        if kwargs:
+            self.update(kwargs)
+
+    def get(self, key: _Key, default: Optional[Union[_Value, _T]] = None) -> Union[_Value, _T, None]:  # type: ignore[override]
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def __eq__(self, other: Any) -> bool:
+        """Comparison to another SON is order-sensitive while comparison to a
+        regular dictionary is order-insensitive.
+        """
+        if isinstance(other, SON):
+            return len(self) == len(other) and list(self.items()) == list(other.items())
+        return self.to_dict() == other
+
+    def __ne__(self, other: Any) -> bool:
+        return not self == other
+
+    def __len__(self) -> int:
+        return len(self.__keys)
+
+    def to_dict(self) -> Dict[_Key, _Value]:
+        """Convert a SON document to a normal Python dictionary instance.
+
+        This is trickier than just *dict(...)* because it needs to be
+        recursive.
+        """
+
+        def transform_value(value: Any) -> Any:
+            if isinstance(value, list):
+                return [transform_value(v) for v in value]
+            elif isinstance(value, _Mapping):
+                return dict([(k, transform_value(v)) for k, v in value.items()])
+            else:
+                return value
+
+        return transform_value(dict(self))
+
+    def __deepcopy__(self, memo: Dict[int, "SON[_Key, _Value]"]) -> "SON[_Key, _Value]":
+        out: SON[_Key, _Value] = SON()
+        val_id = id(self)
+        if val_id in memo:
+            return memo[val_id]
+        memo[val_id] = out
+        for k, v in self.items():
+            if not isinstance(v, RE_TYPE):
+                v = copy.deepcopy(v, memo)
+            out[k] = v
+        return out

data/lib/bson/timestamp.py

@@ -0,0 +1,124 @@
+# Copyright 2010-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 representing MongoDB internal Timestamps.
+"""
+
+import calendar
+import datetime
+from typing import Any, Union
+
+from bson._helpers import _getstate_slots, _setstate_slots
+from bson.tz_util import utc
+
+UPPERBOUND = 4294967296
+
+
+class Timestamp(object):
+    """MongoDB internal timestamps used in the opLog."""
+
+    __slots__ = ("__time", "__inc")
+
+    __getstate__ = _getstate_slots
+    __setstate__ = _setstate_slots
+
+    _type_marker = 17
+
+    def __init__(self, time: Union[datetime.datetime, int], inc: int) -> None:
+        """Create a new :class:`Timestamp`.
+
+        This class is only for use with the MongoDB opLog. If you need
+        to store a regular timestamp, please use a
+        :class:`~datetime.datetime`.
+
+        Raises :class:`TypeError` if `time` is not an instance of
+        :class: `int` or :class:`~datetime.datetime`, or `inc` is not
+        an instance of :class:`int`. Raises :class:`ValueError` if
+        `time` or `inc` is not in [0, 2**32).
+
+        :Parameters:
+          - `time`: time in seconds since epoch UTC, or a naive UTC
+            :class:`~datetime.datetime`, or an aware
+            :class:`~datetime.datetime`
+          - `inc`: the incrementing counter
+        """
+        if isinstance(time, datetime.datetime):
+            offset = time.utcoffset()
+            if offset is not None:
+                time = time - offset
+            time = int(calendar.timegm(time.timetuple()))
+        if not isinstance(time, int):
+            raise TypeError("time must be an instance of int")
+        if not isinstance(inc, int):
+            raise TypeError("inc must be an instance of int")
+        if not 0 <= time < UPPERBOUND:
+            raise ValueError("time must be contained in [0, 2**32)")
+        if not 0 <= inc < UPPERBOUND:
+            raise ValueError("inc must be contained in [0, 2**32)")
+
+        self.__time = time
+        self.__inc = inc
+
+    @property
+    def time(self) -> int:
+        """Get the time portion of this :class:`Timestamp`."""
+        return self.__time
+
+    @property
+    def inc(self) -> int:
+        """Get the inc portion of this :class:`Timestamp`."""
+        return self.__inc
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, Timestamp):
+            return self.__time == other.time and self.__inc == other.inc
+        else:
+            return NotImplemented
+
+    def __hash__(self) -> int:
+        return hash(self.time) ^ hash(self.inc)
+
+    def __ne__(self, other: Any) -> bool:
+        return not self == other
+
+    def __lt__(self, other: Any) -> bool:
+        if isinstance(other, Timestamp):
+            return (self.time, self.inc) < (other.time, other.inc)
+        return NotImplemented
+
+    def __le__(self, other: Any) -> bool:
+        if isinstance(other, Timestamp):
+            return (self.time, self.inc) <= (other.time, other.inc)
+        return NotImplemented
+
+    def __gt__(self, other: Any) -> bool:
+        if isinstance(other, Timestamp):
+            return (self.time, self.inc) > (other.time, other.inc)
+        return NotImplemented
+
+    def __ge__(self, other: Any) -> bool:
+        if isinstance(other, Timestamp):
+            return (self.time, self.inc) >= (other.time, other.inc)
+        return NotImplemented
+
+    def __repr__(self):
+        return "Timestamp(%s, %s)" % (self.__time, self.__inc)
+
+    def as_datetime(self) -> datetime.datetime:
+        """Return a :class:`~datetime.datetime` instance corresponding
+        to the time portion of this :class:`Timestamp`.
+
+        The returned datetime's timezone is UTC.
+        """
+        return datetime.datetime.fromtimestamp(self.__time, utc)

data/lib/bson/tz_util.py

@@ -0,0 +1,52 @@
+# Copyright 2010-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.
+
+"""Timezone related utilities for BSON."""
+
+from datetime import datetime, timedelta, tzinfo
+from typing import Optional, Tuple, Union
+
+ZERO: timedelta = timedelta(0)
+
+
+class FixedOffset(tzinfo):
+    """Fixed offset timezone, in minutes east from UTC.
+
+    Implementation based from the Python `standard library documentation
+    <http://docs.python.org/library/datetime.html#tzinfo-objects>`_.
+    Defining __getinitargs__ enables pickling / copying.
+    """
+
+    def __init__(self, offset: Union[float, timedelta], name: str) -> None:
+        if isinstance(offset, timedelta):
+            self.__offset = offset
+        else:
+            self.__offset = timedelta(minutes=offset)
+        self.__name = name
+
+    def __getinitargs__(self) -> Tuple[timedelta, str]:
+        return self.__offset, self.__name
+
+    def utcoffset(self, dt: Optional[datetime]) -> timedelta:
+        return self.__offset
+
+    def tzname(self, dt: Optional[datetime]) -> str:
+        return self.__name
+
+    def dst(self, dt: Optional[datetime]) -> timedelta:
+        return ZERO
+
+
+utc: FixedOffset = FixedOffset(0, "UTC")
+"""Fixed offset timezone representing UTC."""