PYTHON-1827 Follow-on work for unifying URI options

Author: prashantmital

pymongo/common.py

@@ -700,25 +700,33 @@ def get_validated_options(options, warn=True):
     Returns a copy of options with invalid entries removed.
 
     :Parameters:
-        - `opts`: A dict of MongoDB URI options.
+        - `opts`: A dict containing MongoDB URI options.
         - `warn` (optional): If ``True`` then warnings will be logged and
           invalid options will be ignored. Otherwise, invalid options will
           cause errors.
     """
-    validated_options = {}
+    if isinstance(options, _CaseInsensitiveDictionary):
+        validated_options = _CaseInsensitiveDictionary()
+        get_normed_key = lambda x: x
+        get_setter_key = lambda x: options.cased_key(x)
+    else:
+        validated_options = {}
+        get_normed_key = lambda x: x.lower()
+        get_setter_key = lambda x: x
+
     for opt, value in iteritems(options):
-        lower = opt.lower()
+        normed_key = get_normed_key(opt)
         try:
             validator = URI_OPTIONS_VALIDATOR_MAP.get(
-                lower, raise_config_error)
+                normed_key, raise_config_error)
             value = validator(opt, value)
         except (ValueError, TypeError, ConfigurationError) as exc:
             if warn:
                 warnings.warn(str(exc))
             else:
                 raise
         else:
-            validated_options[lower] = value
+            validated_options[get_setter_key(normed_key)] = value
     return validated_options
 
 
@@ -814,3 +822,83 @@ def read_concern(self):
         .. versionadded:: 3.2
         """
         return self.__read_concern
+
+
+class _CaseInsensitiveDictionary(abc.MutableMapping):
+    def __init__(self, *args, **kwargs):
+        self.__casedkeys = {}
+        self.__data = {}
+        self.update(dict(*args, **kwargs))
+
+    def __contains__(self, key):
+        return key.lower() in self.__data
+
+    def __len__(self):
+        return len(self.__data)
+
+    def __iter__(self):
+        return (key for key in self.__casedkeys)
+
+    def __repr__(self):
+        return str({self.__casedkeys[k]: self.__data[k] for k in self})
+
+    def __setitem__(self, key, value):
+        lc_key = key.lower()
+        self.__casedkeys[lc_key] = key
+        self.__data[lc_key] = value
+
+    def __getitem__(self, key):
+        return self.__data[key.lower()]
+
+    def __delitem__(self, key):
+        lc_key = key.lower()
+        del self.__casedkeys[lc_key]
+        del self.__data[lc_key]
+
+    def __eq__(self, other):
+        if not isinstance(other, abc.Mapping):
+            return NotImplemented
+        if len(self) != len(other):
+            return False
+        for key in other:
+            if self[key] != other[key]:
+                return False
+
+        return True
+
+    def get(self, key, default=None):
+        return self.__data.get(key.lower(), default)
+
+    def pop(self, key, *args, **kwargs):
+        lc_key = key.lower()
+        self.__casedkeys.pop(lc_key, None)
+        return self.__data.pop(lc_key, *args, **kwargs)
+
+    def popitem(self):
+        lc_key, cased_key = self.__casedkeys.popitem()
+        value = self.__data.pop(lc_key)
+        return cased_key, value
+
+    def clear(self):
+        self.__casedkeys.clear()
+        self.__data.clear()
+
+    def setdefault(self, key, default=None):
+        lc_key = key.lower()
+        if key in self:
+            return self.__data[lc_key]
+        else:
+            self.__casedkeys[lc_key] = key
+            self.__data[lc_key] = default
+            return default
+
+    def update(self, other):
+        if isinstance(other, _CaseInsensitiveDictionary):
+            for key in other:
+                self[other.cased_key(key)] = other[key]
+        else:
+            for key in other:
+                self[key] = other[key]
+
+    def cased_key(self, key):
+        return self.__casedkeys[key.lower()]

pymongo/mongo_client.py

@@ -39,7 +39,7 @@
 
 from collections import defaultdict
 
-from bson.codec_options import DEFAULT_CODEC_OPTIONS, TypeRegistry
+from bson.codec_options import DEFAULT_CODEC_OPTIONS
 from bson.py3compat import (integer_types,
                             string_type)
 from bson.son import SON
@@ -71,8 +71,8 @@
 from pymongo.topology import Topology
 from pymongo.topology_description import TOPOLOGY_TYPE
 from pymongo.settings import TopologySettings
-from pymongo.uri_parser import (_CaseInsensitiveDictionary,
-                                _handle_option_deprecations,
+from pymongo.uri_parser import (_handle_option_deprecations,
+                                _handle_security_options,
                                 _normalize_options)
 from pymongo.write_concern import DEFAULT_WRITE_CONCERN
 
@@ -588,7 +588,7 @@ def __init__(
         for entity in host:
             if "://" in entity:
                 res = uri_parser.parse_uri(
-                    entity, port, validate=True, warn=True)
+                    entity, port, validate=True, warn=True, normalize=False)
                 seeds.update(res["nodelist"])
                 username = res["username"] or username
                 password = res["password"] or password
@@ -605,7 +605,7 @@ def __init__(
         monitor_class = kwargs.pop('_monitor_class', None)
         condition_class = kwargs.pop('_condition_class', None)
 
-        keyword_opts = kwargs
+        keyword_opts = common._CaseInsensitiveDictionary(kwargs)
         keyword_opts['document_class'] = document_class
         if type_registry is not None:
             keyword_opts['type_registry'] = type_registry
@@ -616,15 +616,19 @@ def __init__(
         keyword_opts['tz_aware'] = tz_aware
         keyword_opts['connect'] = connect
 
-        # Validate kwargs options.
-        keyword_opts = _CaseInsensitiveDictionary(
-            dict(common.validate(k, v) for k, v in keyword_opts.items()))
-        # Handle deprecated options in kwarg list.
+        # Handle deprecated options in kwarg options.
         keyword_opts = _handle_option_deprecations(keyword_opts)
-        # Change kwarg option names to those used internally.
-        keyword_opts = _normalize_options(keyword_opts)
-        # Augment URI options with kwarg options, overriding the former.
+        # Validate kwarg options.
+        keyword_opts = common._CaseInsensitiveDictionary(
+            dict(common.validate(k, v) for k, v in keyword_opts.items()))
+
+        # Override connection string options with kwarg options.
         opts.update(keyword_opts)
+        # Handle security-option conflicts in combined options.
+        opts = _handle_security_options(opts)
+        # Normalize combined options.
+        opts = _normalize_options(opts)
+
         # Username and password passed as kwargs override user info in URI.
         username = opts.get("username", username)
         password = opts.get("password", password)