implement case insensitive dictionary

pymongo/common.py

@@ -711,37 +711,6 @@ def get_validated_options(options, warn=True):
     return validated_options
 
 
-def _handle_option_deprecations(options):
-    """Issue appropriate warnings when deprecated options are present in the
-    options dictionary. Removes deprecated option key, value pairs if the
-    options dictionary is found to also have the renamed option."""
-    undeprecated_options = {}
-    lc_optnames = [n.lower() for n in options]
-    for key, value in iteritems(options):
-        optname = str(key).lower()
-        if optname in URI_OPTIONS_DEPRECATION_MAP:
-            renamed_key = URI_OPTIONS_DEPRECATION_MAP[optname]
-            if renamed_key.lower() in lc_optnames:
-                warnings.warn("Deprecated option '%s' ignored in favor of "
-                              "'%s'." % (str(key), renamed_key))
-                continue
-            warnings.warn("Option '%s' is deprecated, use '%s' instead." % (
-                          str(key), renamed_key))
-        undeprecated_options[str(key)] = value
-    return undeprecated_options
-
-
-def _normalize_options(options):
-    """Renames keys in the options dictionary to their internally-used
-    names."""
-    normalized_options = {}
-    for key, value in iteritems(options):
-        optname = str(key).lower()
-        intname = INTERNAL_URI_OPTION_NAME_MAP.get(optname, key)
-        normalized_options[intname] = options[key]
-    return normalized_options
-
-
 # List of write-concern-related options.
 WRITE_CONCERN_OPTIONS = frozenset([
     'w',

pymongo/mongo_client.py

@@ -71,6 +71,9 @@
 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,
+                                _normalize_options)
 from pymongo.write_concern import DEFAULT_WRITE_CONCERN
 
 
@@ -565,12 +568,12 @@ def __init__(
         keyword_opts['connect'] = connect
 
         # Validate kwargs options.
-        keyword_opts = dict(common.validate(k, v)
-                            for k, v in keyword_opts.items())
+        keyword_opts = CaseInsensitiveDictionary(
+            dict(common.validate(k, v) for k, v in keyword_opts.items()))
         # Handle deprecated options in kwarg list.
-        keyword_opts = common._handle_option_deprecations(keyword_opts)
+        keyword_opts = _handle_option_deprecations(keyword_opts)
         # Change kwarg option names to those used internally.
-        keyword_opts = common._normalize_options(keyword_opts)
+        keyword_opts = _normalize_options(keyword_opts)
         # Augment URI options with kwarg options, overriding the former.
         opts.update(keyword_opts)
         # Username and password passed as kwargs override user info in URI.

pymongo/uri_parser.py

@@ -23,15 +23,15 @@
 except ImportError:
     _HAVE_DNSPYTHON = False
 
-from bson.py3compat import PY3, string_type
+from bson.py3compat import abc, iteritems, string_type, PY3
 
 if PY3:
     from urllib.parse import unquote_plus
 else:
     from urllib import unquote_plus
 
 from pymongo.common import (
-    get_validated_options, _handle_option_deprecations, _normalize_options)
+    get_validated_options, URI_OPTIONS_DEPRECATION_MAP, INTERNAL_URI_OPTION_NAME_MAP)
 from pymongo.errors import ConfigurationError, InvalidURI
 
 
@@ -42,6 +42,80 @@
 DEFAULT_PORT = 27017
 
 
+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 (self.__casedkeys[key] for key in self.__casedkeys)
+
+    def __repr__(self):
+        return str(self.__data)
+
+    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 get(self, key, default=None):
+        lc_key = key.lower()
+        if lc_key in self:
+            return self.__data[lc_key]
+        return 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):
+        for key in other:
+            self[key] = other[key]
+
+    def cased_key(self, key):
+        return self.__casedkeys[key.lower()]
+
+    def as_dict(self):
+        lc_data = {}
+        for lc_key in self.__data:
+            lc_data[lc_key] = self.__data[lc_key]
+        return lc_data
+
+
 def parse_userinfo(userinfo):
     """Validates the format of user information in a MongoDB URI.
     Reserved characters like ':', '/', '+' and '@' must be escaped
@@ -130,26 +204,76 @@ def parse_host(entity, default_port=DEFAULT_PORT):
     return host.lower(), port
 
 
+_IMPLICIT_TLSINSECURE_OPTS = {"tlsallowinvalidcertificates",
+                              "tlsallowinvalidhostnames"}
+
+
 def _parse_options(opts, delim):
     """Helper method for split_options which creates the options dict.
     Also handles the creation of a list for the URI tag_sets/
     readpreferencetags portion and the use of the tlsInsecure option."""
-    options = {}
+    options = CaseInsensitiveDictionary()
     for opt in opts.split(delim):
-        key, value = opt.split("=")
-        optname = str(key).lower()
-        if optname == 'readpreferencetags':
-            options.setdefault(optname, []).append(value)
+        cased_key, value = opt.split("=")
+        cased_key = str(cased_key)
+        lc_key = cased_key.lower()
+        if lc_key == 'readpreferencetags':
+            options.setdefault(cased_key, []).append(value)
         else:
-            if optname == 'tlsinsecure':
-                options['tlsAllowInvalidCertificates'] = value
-                options['tlsAllowInvalidHostnames'] = value
-            if key in options:
-                warnings.warn("Duplicate URI option '%s'." % (str(key),))
-            options[str(key)] = unquote_plus(value)
+            if cased_key in options:
+                warnings.warn("Duplicate URI option '%s'." % (cased_key,))
+            options[cased_key] = unquote_plus(value)
+            if (lc_key in _IMPLICIT_TLSINSECURE_OPTS and
+                    'tlsinsecure' in options):
+                warn_msg = "URI option '%s' overrides value implied by '%s'."
+                warnings.warn(warn_msg % (
+                    cased_key, options.cased_key('tlsinsecure')))
+            if lc_key == 'tlsinsecure':
+                for implicit_option in _IMPLICIT_TLSINSECURE_OPTS:
+                    if implicit_option in options:
+                        warn_msg = "URI option '%s' implicitly overrides '%s'."
+                        warnings.warn(warn_msg % (
+                            cased_key, options.cased_key(implicit_option)))
+                        options.pop(implicit_option)
+
+    tls_insecure = options.get('tlsinsecure')
+    if tls_insecure is not None:
+        for implicit_option in _IMPLICIT_TLSINSECURE_OPTS:
+            options.setdefault(implicit_option, tls_insecure)
+
     return options
 
 
+def _handle_option_deprecations(options):
+    """Issue appropriate warnings when deprecated options are present in the
+    options dictionary. Removes deprecated option key, value pairs if the
+    options dictionary is found to also have the renamed option."""
+    undeprecated_options = CaseInsensitiveDictionary()
+    for key, value in iteritems(options):
+        optname = str(key).lower()
+        if optname in URI_OPTIONS_DEPRECATION_MAP:
+            renamed_key = URI_OPTIONS_DEPRECATION_MAP[optname]
+            if renamed_key.lower() in options:
+                warnings.warn("Deprecated option '%s' ignored in favor of "
+                              "'%s'." % (str(key), renamed_key))
+                continue
+            warnings.warn("Option '%s' is deprecated, use '%s' instead." % (
+                          str(key), renamed_key))
+        undeprecated_options[str(key)] = value
+    return undeprecated_options
+
+
+def _normalize_options(options):
+    """Renames keys in the options dictionary to their internally-used
+    names."""
+    normalized_options = {}
+    for key, value in iteritems(options):
+        optname = str(key).lower()
+        intname = INTERNAL_URI_OPTION_NAME_MAP.get(optname, key)
+        normalized_options[intname] = options[key]
+    return normalized_options
+
+
 def validate_options(opts, warn=False):
     """Validates and normalizes options passed in a MongoDB URI.
 
@@ -430,4 +554,4 @@ def parse_uri(uri, default_port=DEFAULT_PORT, validate=True, warn=False):
         pprint.pprint(parse_uri(sys.argv[1]))
     except InvalidURI as exc:
         print(exc)
-    sys.exit(0)
+    sys.exit(0)