xtquant.xtbson.bson36.son

  1# Copyright 2009-present MongoDB, Inc.
  2#
  3# Licensed under the Apache License, Version 2.0 (the "License");
  4# you may not use this file except in compliance with the License.
  5# You may obtain a copy of the License at
  6#
  7# http://www.apache.org/licenses/LICENSE-2.0
  8#
  9# Unless required by applicable law or agreed to in writing, software
 10# distributed under the License is distributed on an "AS IS" BASIS,
 11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12# See the License for the specific language governing permissions and
 13# limitations under the License.
 14
 15"""Tools for creating and manipulating SON, the Serialized Ocument Notation.
 16
 17Regular dictionaries can be used instead of SON objects, but not when the order
 18of keys is important. A SON object can be used just like a normal Python
 19dictionary."""
 20
 21import copy
 22import re
 23from collections.abc import Mapping as _Mapping
 24
 25# This sort of sucks, but seems to be as good as it gets...
 26# This is essentially the same as re._pattern_type
 27RE_TYPE = type(re.compile(""))
 28
 29
 30class SON(dict):
 31    """SON data.
 32
 33    A subclass of dict that maintains ordering of keys and provides a
 34    few extra niceties for dealing with SON. SON provides an API
 35    similar to collections.OrderedDict.
 36    """
 37
 38    def __init__(self, data=None, **kwargs):
 39        self.__keys = []
 40        dict.__init__(self)
 41        self.update(data)
 42        self.update(kwargs)
 43
 44    def __new__(cls, *args, **kwargs):
 45        instance = super(SON, cls).__new__(cls, *args, **kwargs)
 46        instance.__keys = []
 47        return instance
 48
 49    def __repr__(self):
 50        result = []
 51        for key in self.__keys:
 52            result.append("(%r, %r)" % (key, self[key]))
 53        return "SON([%s])" % ", ".join(result)
 54
 55    def __setitem__(self, key, value):
 56        if key not in self.__keys:
 57            self.__keys.append(key)
 58        dict.__setitem__(self, key, value)
 59
 60    def __delitem__(self, key):
 61        self.__keys.remove(key)
 62        dict.__delitem__(self, key)
 63
 64    def copy(self):
 65        other = SON()
 66        other.update(self)
 67        return other
 68
 69    # TODO this is all from UserDict.DictMixin. it could probably be made more
 70    # efficient.
 71    # second level definitions support higher levels
 72    def __iter__(self):
 73        for k in self.__keys:
 74            yield k
 75
 76    def has_key(self, key):
 77        return key in self.__keys
 78
 79    def iterkeys(self):
 80        return self.__iter__()
 81
 82    # fourth level uses definitions from lower levels
 83    def itervalues(self):
 84        for _, v in self.items():
 85            yield v
 86
 87    def values(self):
 88        return [v for _, v in self.items()]
 89
 90    def clear(self):
 91        self.__keys = []
 92        super(SON, self).clear()
 93
 94    def setdefault(self, key, default=None):
 95        try:
 96            return self[key]
 97        except KeyError:
 98            self[key] = default
 99        return default
100
101    def pop(self, key, *args):
102        if len(args) > 1:
103            raise TypeError("pop expected at most 2 arguments, got " + repr(1 + len(args)))
104        try:
105            value = self[key]
106        except KeyError:
107            if args:
108                return args[0]
109            raise
110        del self[key]
111        return value
112
113    def popitem(self):
114        try:
115            k, v = next(iter(self.items()))
116        except StopIteration:
117            raise KeyError("container is empty")
118        del self[k]
119        return (k, v)
120
121    def update(self, other=None, **kwargs):
122        # Make progressively weaker assumptions about "other"
123        if other is None:
124            pass
125        elif hasattr(other, "items"):
126            for k, v in other.items():
127                self[k] = v
128        elif hasattr(other, "keys"):
129            for k in other.keys():
130                self[k] = other[k]
131        else:
132            for k, v in other:
133                self[k] = v
134        if kwargs:
135            self.update(kwargs)
136
137    def get(self, key, default=None):
138        try:
139            return self[key]
140        except KeyError:
141            return default
142
143    def __eq__(self, other):
144        """Comparison to another SON is order-sensitive while comparison to a
145        regular dictionary is order-insensitive.
146        """
147        if isinstance(other, SON):
148            return len(self) == len(other) and list(self.items()) == list(other.items())
149        return self.to_dict() == other
150
151    def __ne__(self, other):
152        return not self == other
153
154    def __len__(self):
155        return len(self.__keys)
156
157    def to_dict(self):
158        """Convert a SON document to a normal Python dictionary instance.
159
160        This is trickier than just *dict(...)* because it needs to be
161        recursive.
162        """
163
164        def transform_value(value):
165            if isinstance(value, list):
166                return [transform_value(v) for v in value]
167            elif isinstance(value, _Mapping):
168                return dict([(k, transform_value(v)) for k, v in value.items()])
169            else:
170                return value
171
172        return transform_value(dict(self))
173
174    def __deepcopy__(self, memo):
175        out = SON()
176        val_id = id(self)
177        if val_id in memo:
178            return memo.get(val_id)
179        memo[val_id] = out
180        for k, v in self.items():
181            if not isinstance(v, RE_TYPE):
182                v = copy.deepcopy(v, memo)
183            out[k] = v
184        return out