Check in a simple pure-python based Markdown previewer.

third_party/Python-Markdown/markdown/odict.py

-# markdown is released under the BSD license
-# Copyright 2007, 2008 The Python Markdown Project (v. 1.7 and later)
-# Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
-# Copyright 2004 Manfred Stienstra (the original version)
-# 
-# All rights reserved.
-# 
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-# 
-# *   Redistributions of source code must retain the above copyright
-#     notice, this list of conditions and the following disclaimer.
-# *   Redistributions in binary form must reproduce the above copyright
-#     notice, this list of conditions and the following disclaimer in the
-#     documentation and/or other materials provided with the distribution.
-# *   Neither the name of the <organization> nor the
-#     names of its contributors may be used to endorse or promote products
-#     derived from this software without specific prior written permission.
-# 
-# THIS SOFTWARE IS PROVIDED BY THE PYTHON MARKDOWN PROJECT ''AS IS'' AND ANY
-# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL ANY CONTRIBUTORS TO THE PYTHON MARKDOWN PROJECT
-# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-# POSSIBILITY OF SUCH DAMAGE.
-
-
 from __future__ import unicode_literals
 from __future__ import absolute_import
 from . import util
-
 from copy import deepcopy
 
-def iteritems_compat(d):
-    """Return an iterator over the (key, value) pairs of a dictionary.
-    Copied from `six` module."""
-    return iter(getattr(d, _iteritems)())
 
 class OrderedDict(dict):
     """
     A dictionary that keeps its keys in the order in which they're inserted.
-    
+
     Copied from Django's SortedDict with some modifications.
 
     """
     def __new__(cls, *args, **kwargs):
         instance = super(OrderedDict, cls).__new__(cls, *args, **kwargs)
         instance.keyOrder = []
         return instance
 
     def __init__(self, data=None):
         if data is None or isinstance(data, dict):
@@ skipping 54 matching lines @@
             yield key, self[key]
 
     def _iterkeys(self):
         for key in self.keyOrder:
             yield key
 
     def _itervalues(self):
         for key in self.keyOrder:
             yield self[key]
 
-    if util.PY3:
+    if util.PY3:  # pragma: no cover
         items = _iteritems
         keys = _iterkeys
         values = _itervalues
-    else:
+    else:  # pragma: no cover
         iteritems = _iteritems
         iterkeys = _iterkeys
         itervalues = _itervalues
 
         def items(self):
             return [(k, self[k]) for k in self.keyOrder]
 
         def keys(self):
             return self.keyOrder[:]
 
         def values(self):
             return [self[k] for k in self.keyOrder]
 
     def update(self, dict_):
-        for k, v in iteritems_compat(dict_):
-            self[k] = v
+        for k in dict_:
+            self[k] = dict_[k]
 
     def setdefault(self, key, default):
         if key not in self:
             self.keyOrder.append(key)
         return super(OrderedDict, self).setdefault(key, default)
 
     def value_for_index(self, index):
         """Returns the value of the item at the given zero-based index."""
         return self[self.keyOrder[index]]
 
@@ skipping 10 matching lines @@
     def copy(self):
         """Returns a copy of this object."""
         # This way of initializing the copy means it works for subclasses, too.
         return self.__class__(self)
 
     def __repr__(self):
         """
         Replaces the normal dict.__repr__ with a version that returns the keys
         in their Ordered order.
         """
-        return '{%s}' % ', '.join(['%r: %r' % (k, v) for k, v in iteritems_compat(self)])
+        return '{%s}' % ', '.join(
+            ['%r: %r' % (k, v) for k, v in self._iteritems()]
+        )
 
     def clear(self):
         super(OrderedDict, self).clear()
         self.keyOrder = []
 
     def index(self, key):
         """ Return the index of a given key. """
         try:
             return self.keyOrder.index(key)
         except ValueError:
@@ skipping 33 matching lines @@
         try:
             i = self.index_for_location(location)
             if i is not None:
                 self.keyOrder.insert(i, key)
             else:
                 self.keyOrder.append(key)
         except Exception as e:
             # restore to prevent data loss and reraise
             self.keyOrder.insert(n, key)
             raise e