Add files using upload-large-folder tool

.gitattributes

@@ -127,3 +127,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 670proj-master/app/songcleaned2.csv filter=lfs diff=lfs merge=lfs -text
 5dolar-website-meme-master/static/webfonts/fa-brands-400.eot filter=lfs diff=lfs merge=lfs -text
 5485-master/demos/node_modules/mongoose/node_modules/bson/node_modules/bson-ext/build/Release/obj.target/bson/ext/bson.o filter=lfs diff=lfs merge=lfs -text
+670proj-master/app/data/checkpoints/model-3200.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+8210_A1P3-master/Lib/site-packages/PIL/_imagingft.cp37-win32.pyd filter=lfs diff=lfs merge=lfs -text

670proj-master/app/data/checkpoints/model-3200.data-00000-of-00001

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8544ca5736536209b18a3d256ecf42945a69c87c7615c099d08cfe07f8182ee8
+size 1410120

8210_A1P3-master/Lib/site-packages/PIL/_imagingft.cp37-win32.pyd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:42bc69675a9d7a47f932a9eb034e22138d76dc81ee14107130b8ed6a54f5686b
+size 495616

8210_A1P3-master/Lib/site-packages/html5lib/treebuilders/etree.py

@@ -0,0 +1,340 @@
+from __future__ import absolute_import, division, unicode_literals
+# pylint:disable=protected-access
+
+from six import text_type
+
+import re
+
+from . import base
+from .. import _ihatexml
+from .. import constants
+from ..constants import namespaces
+from .._utils import moduleFactoryFactory
+
+tag_regexp = re.compile("{([^}]*)}(.*)")
+
+
+def getETreeBuilder(ElementTreeImplementation, fullTree=False):
+    ElementTree = ElementTreeImplementation
+    ElementTreeCommentType = ElementTree.Comment("asd").tag
+
+    class Element(base.Node):
+        def __init__(self, name, namespace=None):
+            self._name = name
+            self._namespace = namespace
+            self._element = ElementTree.Element(self._getETreeTag(name,
+                                                                  namespace))
+            if namespace is None:
+                self.nameTuple = namespaces["html"], self._name
+            else:
+                self.nameTuple = self._namespace, self._name
+            self.parent = None
+            self._childNodes = []
+            self._flags = []
+
+        def _getETreeTag(self, name, namespace):
+            if namespace is None:
+                etree_tag = name
+            else:
+                etree_tag = "{%s}%s" % (namespace, name)
+            return etree_tag
+
+        def _setName(self, name):
+            self._name = name
+            self._element.tag = self._getETreeTag(self._name, self._namespace)
+
+        def _getName(self):
+            return self._name
+
+        name = property(_getName, _setName)
+
+        def _setNamespace(self, namespace):
+            self._namespace = namespace
+            self._element.tag = self._getETreeTag(self._name, self._namespace)
+
+        def _getNamespace(self):
+            return self._namespace
+
+        namespace = property(_getNamespace, _setNamespace)
+
+        def _getAttributes(self):
+            return self._element.attrib
+
+        def _setAttributes(self, attributes):
+            # Delete existing attributes first
+            # XXX - there may be a better way to do this...
+            for key in list(self._element.attrib.keys()):
+                del self._element.attrib[key]
+            for key, value in attributes.items():
+                if isinstance(key, tuple):
+                    name = "{%s}%s" % (key[2], key[1])
+                else:
+                    name = key
+                self._element.set(name, value)
+
+        attributes = property(_getAttributes, _setAttributes)
+
+        def _getChildNodes(self):
+            return self._childNodes
+
+        def _setChildNodes(self, value):
+            del self._element[:]
+            self._childNodes = []
+            for element in value:
+                self.insertChild(element)
+
+        childNodes = property(_getChildNodes, _setChildNodes)
+
+        def hasContent(self):
+            """Return true if the node has children or text"""
+            return bool(self._element.text or len(self._element))
+
+        def appendChild(self, node):
+            self._childNodes.append(node)
+            self._element.append(node._element)
+            node.parent = self
+
+        def insertBefore(self, node, refNode):
+            index = list(self._element).index(refNode._element)
+            self._element.insert(index, node._element)
+            node.parent = self
+
+        def removeChild(self, node):
+            self._childNodes.remove(node)
+            self._element.remove(node._element)
+            node.parent = None
+
+        def insertText(self, data, insertBefore=None):
+            if not(len(self._element)):
+                if not self._element.text:
+                    self._element.text = ""
+                self._element.text += data
+            elif insertBefore is None:
+                # Insert the text as the tail of the last child element
+                if not self._element[-1].tail:
+                    self._element[-1].tail = ""
+                self._element[-1].tail += data
+            else:
+                # Insert the text before the specified node
+                children = list(self._element)
+                index = children.index(insertBefore._element)
+                if index > 0:
+                    if not self._element[index - 1].tail:
+                        self._element[index - 1].tail = ""
+                    self._element[index - 1].tail += data
+                else:
+                    if not self._element.text:
+                        self._element.text = ""
+                    self._element.text += data
+
+        def cloneNode(self):
+            element = type(self)(self.name, self.namespace)
+            for name, value in self.attributes.items():
+                element.attributes[name] = value
+            return element
+
+        def reparentChildren(self, newParent):
+            if newParent.childNodes:
+                newParent.childNodes[-1]._element.tail += self._element.text
+            else:
+                if not newParent._element.text:
+                    newParent._element.text = ""
+                if self._element.text is not None:
+                    newParent._element.text += self._element.text
+            self._element.text = ""
+            base.Node.reparentChildren(self, newParent)
+
+    class Comment(Element):
+        def __init__(self, data):
+            # Use the superclass constructor to set all properties on the
+            # wrapper element
+            self._element = ElementTree.Comment(data)
+            self.parent = None
+            self._childNodes = []
+            self._flags = []
+
+        def _getData(self):
+            return self._element.text
+
+        def _setData(self, value):
+            self._element.text = value
+
+        data = property(_getData, _setData)
+
+    class DocumentType(Element):
+        def __init__(self, name, publicId, systemId):
+            Element.__init__(self, "<!DOCTYPE>")
+            self._element.text = name
+            self.publicId = publicId
+            self.systemId = systemId
+
+        def _getPublicId(self):
+            return self._element.get("publicId", "")
+
+        def _setPublicId(self, value):
+            if value is not None:
+                self._element.set("publicId", value)
+
+        publicId = property(_getPublicId, _setPublicId)
+
+        def _getSystemId(self):
+            return self._element.get("systemId", "")
+
+        def _setSystemId(self, value):
+            if value is not None:
+                self._element.set("systemId", value)
+
+        systemId = property(_getSystemId, _setSystemId)
+
+    class Document(Element):
+        def __init__(self):
+            Element.__init__(self, "DOCUMENT_ROOT")
+
+    class DocumentFragment(Element):
+        def __init__(self):
+            Element.__init__(self, "DOCUMENT_FRAGMENT")
+
+    def testSerializer(element):
+        rv = []
+
+        def serializeElement(element, indent=0):
+            if not(hasattr(element, "tag")):
+                element = element.getroot()
+            if element.tag == "<!DOCTYPE>":
+                if element.get("publicId") or element.get("systemId"):
+                    publicId = element.get("publicId") or ""
+                    systemId = element.get("systemId") or ""
+                    rv.append("""<!DOCTYPE %s "%s" "%s">""" %
+                              (element.text, publicId, systemId))
+                else:
+                    rv.append("<!DOCTYPE %s>" % (element.text,))
+            elif element.tag == "DOCUMENT_ROOT":
+                rv.append("#document")
+                if element.text is not None:
+                    rv.append("|%s\"%s\"" % (' ' * (indent + 2), element.text))
+                if element.tail is not None:
+                    raise TypeError("Document node cannot have tail")
+                if hasattr(element, "attrib") and len(element.attrib):
+                    raise TypeError("Document node cannot have attributes")
+            elif element.tag == ElementTreeCommentType:
+                rv.append("|%s<!-- %s -->" % (' ' * indent, element.text))
+            else:
+                assert isinstance(element.tag, text_type), \
+                    "Expected unicode, got %s, %s" % (type(element.tag), element.tag)
+                nsmatch = tag_regexp.match(element.tag)
+
+                if nsmatch is None:
+                    name = element.tag
+                else:
+                    ns, name = nsmatch.groups()
+                    prefix = constants.prefixes[ns]
+                    name = "%s %s" % (prefix, name)
+                rv.append("|%s<%s>" % (' ' * indent, name))
+
+                if hasattr(element, "attrib"):
+                    attributes = []
+                    for name, value in element.attrib.items():
+                        nsmatch = tag_regexp.match(name)
+                        if nsmatch is not None:
+                            ns, name = nsmatch.groups()
+                            prefix = constants.prefixes[ns]
+                            attr_string = "%s %s" % (prefix, name)
+                        else:
+                            attr_string = name
+                        attributes.append((attr_string, value))
+
+                    for name, value in sorted(attributes):
+                        rv.append('|%s%s="%s"' % (' ' * (indent + 2), name, value))
+                if element.text:
+                    rv.append("|%s\"%s\"" % (' ' * (indent + 2), element.text))
+            indent += 2
+            for child in element:
+                serializeElement(child, indent)
+            if element.tail:
+                rv.append("|%s\"%s\"" % (' ' * (indent - 2), element.tail))
+        serializeElement(element, 0)
+
+        return "\n".join(rv)
+
+    def tostring(element):  # pylint:disable=unused-variable
+        """Serialize an element and its child nodes to a string"""
+        rv = []
+        filter = _ihatexml.InfosetFilter()
+
+        def serializeElement(element):
+            if isinstance(element, ElementTree.ElementTree):
+                element = element.getroot()
+
+            if element.tag == "<!DOCTYPE>":
+                if element.get("publicId") or element.get("systemId"):
+                    publicId = element.get("publicId") or ""
+                    systemId = element.get("systemId") or ""
+                    rv.append("""<!DOCTYPE %s PUBLIC "%s" "%s">""" %
+                              (element.text, publicId, systemId))
+                else:
+                    rv.append("<!DOCTYPE %s>" % (element.text,))
+            elif element.tag == "DOCUMENT_ROOT":
+                if element.text is not None:
+                    rv.append(element.text)
+                if element.tail is not None:
+                    raise TypeError("Document node cannot have tail")
+                if hasattr(element, "attrib") and len(element.attrib):
+                    raise TypeError("Document node cannot have attributes")
+
+                for child in element:
+                    serializeElement(child)
+
+            elif element.tag == ElementTreeCommentType:
+                rv.append("<!--%s-->" % (element.text,))
+            else:
+                # This is assumed to be an ordinary element
+                if not element.attrib:
+                    rv.append("<%s>" % (filter.fromXmlName(element.tag),))
+                else:
+                    attr = " ".join(["%s=\"%s\"" % (
+                        filter.fromXmlName(name), value)
+                        for name, value in element.attrib.items()])
+                    rv.append("<%s %s>" % (element.tag, attr))
+                if element.text:
+                    rv.append(element.text)
+
+                for child in element:
+                    serializeElement(child)
+
+                rv.append("</%s>" % (element.tag,))
+
+            if element.tail:
+                rv.append(element.tail)
+
+        serializeElement(element)
+
+        return "".join(rv)
+
+    class TreeBuilder(base.TreeBuilder):  # pylint:disable=unused-variable
+        documentClass = Document
+        doctypeClass = DocumentType
+        elementClass = Element
+        commentClass = Comment
+        fragmentClass = DocumentFragment
+        implementation = ElementTreeImplementation
+
+        def testSerializer(self, element):
+            return testSerializer(element)
+
+        def getDocument(self):
+            if fullTree:
+                return self.document._element
+            else:
+                if self.defaultNamespace is not None:
+                    return self.document._element.find(
+                        "{%s}html" % self.defaultNamespace)
+                else:
+                    return self.document._element.find("html")
+
+        def getFragment(self):
+            return base.TreeBuilder.getFragment(self)._element
+
+    return locals()
+
+
+getETreeModule = moduleFactoryFactory(getETreeBuilder)

8210_A1P3-master/Lib/site-packages/html5lib/treebuilders/etree_lxml.py

@@ -0,0 +1,366 @@
+"""Module for supporting the lxml.etree library. The idea here is to use as much
+of the native library as possible, without using fragile hacks like custom element
+names that break between releases. The downside of this is that we cannot represent
+all possible trees; specifically the following are known to cause problems:
+
+Text or comments as siblings of the root element
+Docypes with no name
+
+When any of these things occur, we emit a DataLossWarning
+"""
+
+from __future__ import absolute_import, division, unicode_literals
+# pylint:disable=protected-access
+
+import warnings
+import re
+import sys
+
+from . import base
+from ..constants import DataLossWarning
+from .. import constants
+from . import etree as etree_builders
+from .. import _ihatexml
+
+import lxml.etree as etree
+
+
+fullTree = True
+tag_regexp = re.compile("{([^}]*)}(.*)")
+
+comment_type = etree.Comment("asd").tag
+
+
+class DocumentType(object):
+    def __init__(self, name, publicId, systemId):
+        self.name = name
+        self.publicId = publicId
+        self.systemId = systemId
+
+
+class Document(object):
+    def __init__(self):
+        self._elementTree = None
+        self._childNodes = []
+
+    def appendChild(self, element):
+        self._elementTree.getroot().addnext(element._element)
+
+    def _getChildNodes(self):
+        return self._childNodes
+
+    childNodes = property(_getChildNodes)
+
+
+def testSerializer(element):
+    rv = []
+    infosetFilter = _ihatexml.InfosetFilter(preventDoubleDashComments=True)
+
+    def serializeElement(element, indent=0):
+        if not hasattr(element, "tag"):
+            if hasattr(element, "getroot"):
+                # Full tree case
+                rv.append("#document")
+                if element.docinfo.internalDTD:
+                    if not (element.docinfo.public_id or
+                            element.docinfo.system_url):
+                        dtd_str = "<!DOCTYPE %s>" % element.docinfo.root_name
+                    else:
+                        dtd_str = """<!DOCTYPE %s "%s" "%s">""" % (
+                            element.docinfo.root_name,
+                            element.docinfo.public_id,
+                            element.docinfo.system_url)
+                    rv.append("|%s%s" % (' ' * (indent + 2), dtd_str))
+                next_element = element.getroot()
+                while next_element.getprevious() is not None:
+                    next_element = next_element.getprevious()
+                while next_element is not None:
+                    serializeElement(next_element, indent + 2)
+                    next_element = next_element.getnext()
+            elif isinstance(element, str) or isinstance(element, bytes):
+                # Text in a fragment
+                assert isinstance(element, str) or sys.version_info[0] == 2
+                rv.append("|%s\"%s\"" % (' ' * indent, element))
+            else:
+                # Fragment case
+                rv.append("#document-fragment")
+                for next_element in element:
+                    serializeElement(next_element, indent + 2)
+        elif element.tag == comment_type:
+            rv.append("|%s<!-- %s -->" % (' ' * indent, element.text))
+            if hasattr(element, "tail") and element.tail:
+                rv.append("|%s\"%s\"" % (' ' * indent, element.tail))
+        else:
+            assert isinstance(element, etree._Element)
+            nsmatch = etree_builders.tag_regexp.match(element.tag)
+            if nsmatch is not None:
+                ns = nsmatch.group(1)
+                tag = nsmatch.group(2)
+                prefix = constants.prefixes[ns]
+                rv.append("|%s<%s %s>" % (' ' * indent, prefix,
+                                          infosetFilter.fromXmlName(tag)))
+            else:
+                rv.append("|%s<%s>" % (' ' * indent,
+                                       infosetFilter.fromXmlName(element.tag)))
+
+            if hasattr(element, "attrib"):
+                attributes = []
+                for name, value in element.attrib.items():
+                    nsmatch = tag_regexp.match(name)
+                    if nsmatch is not None:
+                        ns, name = nsmatch.groups()
+                        name = infosetFilter.fromXmlName(name)
+                        prefix = constants.prefixes[ns]
+                        attr_string = "%s %s" % (prefix, name)
+                    else:
+                        attr_string = infosetFilter.fromXmlName(name)
+                    attributes.append((attr_string, value))
+
+                for name, value in sorted(attributes):
+                    rv.append('|%s%s="%s"' % (' ' * (indent + 2), name, value))
+
+            if element.text:
+                rv.append("|%s\"%s\"" % (' ' * (indent + 2), element.text))
+            indent += 2
+            for child in element:
+                serializeElement(child, indent)
+            if hasattr(element, "tail") and element.tail:
+                rv.append("|%s\"%s\"" % (' ' * (indent - 2), element.tail))
+    serializeElement(element, 0)
+
+    return "\n".join(rv)
+
+
+def tostring(element):
+    """Serialize an element and its child nodes to a string"""
+    rv = []
+
+    def serializeElement(element):
+        if not hasattr(element, "tag"):
+            if element.docinfo.internalDTD:
+                if element.docinfo.doctype:
+                    dtd_str = element.docinfo.doctype
+                else:
+                    dtd_str = "<!DOCTYPE %s>" % element.docinfo.root_name
+                rv.append(dtd_str)
+            serializeElement(element.getroot())
+
+        elif element.tag == comment_type:
+            rv.append("<!--%s-->" % (element.text,))
+
+        else:
+            # This is assumed to be an ordinary element
+            if not element.attrib:
+                rv.append("<%s>" % (element.tag,))
+            else:
+                attr = " ".join(["%s=\"%s\"" % (name, value)
+                                 for name, value in element.attrib.items()])
+                rv.append("<%s %s>" % (element.tag, attr))
+            if element.text:
+                rv.append(element.text)
+
+            for child in element:
+                serializeElement(child)
+
+            rv.append("</%s>" % (element.tag,))
+
+        if hasattr(element, "tail") and element.tail:
+            rv.append(element.tail)
+
+    serializeElement(element)
+
+    return "".join(rv)
+
+
+class TreeBuilder(base.TreeBuilder):
+    documentClass = Document
+    doctypeClass = DocumentType
+    elementClass = None
+    commentClass = None
+    fragmentClass = Document
+    implementation = etree
+
+    def __init__(self, namespaceHTMLElements, fullTree=False):
+        builder = etree_builders.getETreeModule(etree, fullTree=fullTree)
+        infosetFilter = self.infosetFilter = _ihatexml.InfosetFilter(preventDoubleDashComments=True)
+        self.namespaceHTMLElements = namespaceHTMLElements
+
+        class Attributes(dict):
+            def __init__(self, element, value=None):
+                if value is None:
+                    value = {}
+                self._element = element
+                dict.__init__(self, value)  # pylint:disable=non-parent-init-called
+                for key, value in self.items():
+                    if isinstance(key, tuple):
+                        name = "{%s}%s" % (key[2], infosetFilter.coerceAttribute(key[1]))
+                    else:
+                        name = infosetFilter.coerceAttribute(key)
+                    self._element._element.attrib[name] = value
+
+            def __setitem__(self, key, value):
+                dict.__setitem__(self, key, value)
+                if isinstance(key, tuple):
+                    name = "{%s}%s" % (key[2], infosetFilter.coerceAttribute(key[1]))
+                else:
+                    name = infosetFilter.coerceAttribute(key)
+                self._element._element.attrib[name] = value
+
+        class Element(builder.Element):
+            def __init__(self, name, namespace):
+                name = infosetFilter.coerceElement(name)
+                builder.Element.__init__(self, name, namespace=namespace)
+                self._attributes = Attributes(self)
+
+            def _setName(self, name):
+                self._name = infosetFilter.coerceElement(name)
+                self._element.tag = self._getETreeTag(
+                    self._name, self._namespace)
+
+            def _getName(self):
+                return infosetFilter.fromXmlName(self._name)
+
+            name = property(_getName, _setName)
+
+            def _getAttributes(self):
+                return self._attributes
+
+            def _setAttributes(self, attributes):
+                self._attributes = Attributes(self, attributes)
+
+            attributes = property(_getAttributes, _setAttributes)
+
+            def insertText(self, data, insertBefore=None):
+                data = infosetFilter.coerceCharacters(data)
+                builder.Element.insertText(self, data, insertBefore)
+
+            def appendChild(self, child):
+                builder.Element.appendChild(self, child)
+
+        class Comment(builder.Comment):
+            def __init__(self, data):
+                data = infosetFilter.coerceComment(data)
+                builder.Comment.__init__(self, data)
+
+            def _setData(self, data):
+                data = infosetFilter.coerceComment(data)
+                self._element.text = data
+
+            def _getData(self):
+                return self._element.text
+
+            data = property(_getData, _setData)
+
+        self.elementClass = Element
+        self.commentClass = Comment
+        # self.fragmentClass = builder.DocumentFragment
+        base.TreeBuilder.__init__(self, namespaceHTMLElements)
+
+    def reset(self):
+        base.TreeBuilder.reset(self)
+        self.insertComment = self.insertCommentInitial
+        self.initial_comments = []
+        self.doctype = None
+
+    def testSerializer(self, element):
+        return testSerializer(element)
+
+    def getDocument(self):
+        if fullTree:
+            return self.document._elementTree
+        else:
+            return self.document._elementTree.getroot()
+
+    def getFragment(self):
+        fragment = []
+        element = self.openElements[0]._element
+        if element.text:
+            fragment.append(element.text)
+        fragment.extend(list(element))
+        if element.tail:
+            fragment.append(element.tail)
+        return fragment
+
+    def insertDoctype(self, token):
+        name = token["name"]
+        publicId = token["publicId"]
+        systemId = token["systemId"]
+
+        if not name:
+            warnings.warn("lxml cannot represent empty doctype", DataLossWarning)
+            self.doctype = None
+        else:
+            coercedName = self.infosetFilter.coerceElement(name)
+            if coercedName != name:
+                warnings.warn("lxml cannot represent non-xml doctype", DataLossWarning)
+
+            doctype = self.doctypeClass(coercedName, publicId, systemId)
+            self.doctype = doctype
+
+    def insertCommentInitial(self, data, parent=None):
+        assert parent is None or parent is self.document
+        assert self.document._elementTree is None
+        self.initial_comments.append(data)
+
+    def insertCommentMain(self, data, parent=None):
+        if (parent == self.document and
+                self.document._elementTree.getroot()[-1].tag == comment_type):
+            warnings.warn("lxml cannot represent adjacent comments beyond the root elements", DataLossWarning)
+        super(TreeBuilder, self).insertComment(data, parent)
+
+    def insertRoot(self, token):
+        # Because of the way libxml2 works, it doesn't seem to be possible to
+        # alter information like the doctype after the tree has been parsed.
+        # Therefore we need to use the built-in parser to create our initial
+        # tree, after which we can add elements like normal
+        docStr = ""
+        if self.doctype:
+            assert self.doctype.name
+            docStr += "<!DOCTYPE %s" % self.doctype.name
+            if (self.doctype.publicId is not None or
+                    self.doctype.systemId is not None):
+                docStr += (' PUBLIC "%s" ' %
+                           (self.infosetFilter.coercePubid(self.doctype.publicId or "")))
+                if self.doctype.systemId:
+                    sysid = self.doctype.systemId
+                    if sysid.find("'") >= 0 and sysid.find('"') >= 0:
+                        warnings.warn("DOCTYPE system cannot contain single and double quotes", DataLossWarning)
+                        sysid = sysid.replace("'", 'U00027')
+                    if sysid.find("'") >= 0:
+                        docStr += '"%s"' % sysid
+                    else:
+                        docStr += "'%s'" % sysid
+                else:
+                    docStr += "''"
+            docStr += ">"
+            if self.doctype.name != token["name"]:
+                warnings.warn("lxml cannot represent doctype with a different name to the root element", DataLossWarning)
+        docStr += "<THIS_SHOULD_NEVER_APPEAR_PUBLICLY/>"
+        root = etree.fromstring(docStr)
+
+        # Append the initial comments:
+        for comment_token in self.initial_comments:
+            comment = self.commentClass(comment_token["data"])
+            root.addprevious(comment._element)
+
+        # Create the root document and add the ElementTree to it
+        self.document = self.documentClass()
+        self.document._elementTree = root.getroottree()
+
+        # Give the root element the right name
+        name = token["name"]
+        namespace = token.get("namespace", self.defaultNamespace)
+        if namespace is None:
+            etree_tag = name
+        else:
+            etree_tag = "{%s}%s" % (namespace, name)
+        root.tag = etree_tag
+
+        # Add the root element to the internal child/open data structures
+        root_element = self.elementClass(name, namespace)
+        root_element._element = root
+        self.document._childNodes.append(root_element)
+        self.openElements.append(root_element)
+
+        # Reset to the default insert comment function
+        self.insertComment = self.insertCommentMain

8210_A1P3-master/Lib/site-packages/html5lib/treewalkers/__init__.py

@@ -0,0 +1,154 @@
+"""A collection of modules for iterating through different kinds of
+tree, generating tokens identical to those produced by the tokenizer
+module.
+
+To create a tree walker for a new type of tree, you need to do
+implement a tree walker object (called TreeWalker by convention) that
+implements a 'serialize' method taking a tree as sole argument and
+returning an iterator generating tokens.
+"""
+
+from __future__ import absolute_import, division, unicode_literals
+
+from .. import constants
+from .._utils import default_etree
+
+__all__ = ["getTreeWalker", "pprint"]
+
+treeWalkerCache = {}
+
+
+def getTreeWalker(treeType, implementation=None, **kwargs):
+    """Get a TreeWalker class for various types of tree with built-in support
+
+    :arg str treeType: the name of the tree type required (case-insensitive).
+        Supported values are:
+
+        * "dom": The xml.dom.minidom DOM implementation
+        * "etree": A generic walker for tree implementations exposing an
+          elementtree-like interface (known to work with ElementTree,
+          cElementTree and lxml.etree).
+        * "lxml": Optimized walker for lxml.etree
+        * "genshi": a Genshi stream
+
+    :arg implementation: A module implementing the tree type e.g.
+        xml.etree.ElementTree or cElementTree (Currently applies to the "etree"
+        tree type only).
+
+    :arg kwargs: keyword arguments passed to the etree walker--for other
+        walkers, this has no effect
+
+    :returns: a TreeWalker class
+
+    """
+
+    treeType = treeType.lower()
+    if treeType not in treeWalkerCache:
+        if treeType == "dom":
+            from . import dom
+            treeWalkerCache[treeType] = dom.TreeWalker
+        elif treeType == "genshi":
+            from . import genshi
+            treeWalkerCache[treeType] = genshi.TreeWalker
+        elif treeType == "lxml":
+            from . import etree_lxml
+            treeWalkerCache[treeType] = etree_lxml.TreeWalker
+        elif treeType == "etree":
+            from . import etree
+            if implementation is None:
+                implementation = default_etree
+            # XXX: NEVER cache here, caching is done in the etree submodule
+            return etree.getETreeModule(implementation, **kwargs).TreeWalker
+    return treeWalkerCache.get(treeType)
+
+
+def concatenateCharacterTokens(tokens):
+    pendingCharacters = []
+    for token in tokens:
+        type = token["type"]
+        if type in ("Characters", "SpaceCharacters"):
+            pendingCharacters.append(token["data"])
+        else:
+            if pendingCharacters:
+                yield {"type": "Characters", "data": "".join(pendingCharacters)}
+                pendingCharacters = []
+            yield token
+    if pendingCharacters:
+        yield {"type": "Characters", "data": "".join(pendingCharacters)}
+
+
+def pprint(walker):
+    """Pretty printer for tree walkers
+
+    Takes a TreeWalker instance and pretty prints the output of walking the tree.
+
+    :arg walker: a TreeWalker instance
+
+    """
+    output = []
+    indent = 0
+    for token in concatenateCharacterTokens(walker):
+        type = token["type"]
+        if type in ("StartTag", "EmptyTag"):
+            # tag name
+            if token["namespace"] and token["namespace"] != constants.namespaces["html"]:
+                if token["namespace"] in constants.prefixes:
+                    ns = constants.prefixes[token["namespace"]]
+                else:
+                    ns = token["namespace"]
+                name = "%s %s" % (ns, token["name"])
+            else:
+                name = token["name"]
+            output.append("%s<%s>" % (" " * indent, name))
+            indent += 2
+            # attributes (sorted for consistent ordering)
+            attrs = token["data"]
+            for (namespace, localname), value in sorted(attrs.items()):
+                if namespace:
+                    if namespace in constants.prefixes:
+                        ns = constants.prefixes[namespace]
+                    else:
+                        ns = namespace
+                    name = "%s %s" % (ns, localname)
+                else:
+                    name = localname
+                output.append("%s%s=\"%s\"" % (" " * indent, name, value))
+            # self-closing
+            if type == "EmptyTag":
+                indent -= 2
+
+        elif type == "EndTag":
+            indent -= 2
+
+        elif type == "Comment":
+            output.append("%s<!-- %s -->" % (" " * indent, token["data"]))
+
+        elif type == "Doctype":
+            if token["name"]:
+                if token["publicId"]:
+                    output.append("""%s<!DOCTYPE %s "%s" "%s">""" %
+                                  (" " * indent,
+                                   token["name"],
+                                   token["publicId"],
+                                   token["systemId"] if token["systemId"] else ""))
+                elif token["systemId"]:
+                    output.append("""%s<!DOCTYPE %s "" "%s">""" %
+                                  (" " * indent,
+                                   token["name"],
+                                   token["systemId"]))
+                else:
+                    output.append("%s<!DOCTYPE %s>" % (" " * indent,
+                                                       token["name"]))
+            else:
+                output.append("%s<!DOCTYPE >" % (" " * indent,))
+
+        elif type == "Characters":
+            output.append("%s\"%s\"" % (" " * indent, token["data"]))
+
+        elif type == "SpaceCharacters":
+            assert False, "concatenateCharacterTokens should have got rid of all Space tokens"
+
+        else:
+            raise ValueError("Unknown token type, %s" % type)
+
+    return "\n".join(output)

8210_A1P3-master/Lib/site-packages/html5lib/treewalkers/base.py

@@ -0,0 +1,252 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from xml.dom import Node
+from ..constants import namespaces, voidElements, spaceCharacters
+
+__all__ = ["DOCUMENT", "DOCTYPE", "TEXT", "ELEMENT", "COMMENT", "ENTITY", "UNKNOWN",
+           "TreeWalker", "NonRecursiveTreeWalker"]
+
+DOCUMENT = Node.DOCUMENT_NODE
+DOCTYPE = Node.DOCUMENT_TYPE_NODE
+TEXT = Node.TEXT_NODE
+ELEMENT = Node.ELEMENT_NODE
+COMMENT = Node.COMMENT_NODE
+ENTITY = Node.ENTITY_NODE
+UNKNOWN = "<#UNKNOWN#>"
+
+spaceCharacters = "".join(spaceCharacters)
+
+
+class TreeWalker(object):
+    """Walks a tree yielding tokens
+
+    Tokens are dicts that all have a ``type`` field specifying the type of the
+    token.
+
+    """
+    def __init__(self, tree):
+        """Creates a TreeWalker
+
+        :arg tree: the tree to walk
+
+        """
+        self.tree = tree
+
+    def __iter__(self):
+        raise NotImplementedError
+
+    def error(self, msg):
+        """Generates an error token with the given message
+
+        :arg msg: the error message
+
+        :returns: SerializeError token
+
+        """
+        return {"type": "SerializeError", "data": msg}
+
+    def emptyTag(self, namespace, name, attrs, hasChildren=False):
+        """Generates an EmptyTag token
+
+        :arg namespace: the namespace of the token--can be ``None``
+
+        :arg name: the name of the element
+
+        :arg attrs: the attributes of the element as a dict
+
+        :arg hasChildren: whether or not to yield a SerializationError because
+            this tag shouldn't have children
+
+        :returns: EmptyTag token
+
+        """
+        yield {"type": "EmptyTag", "name": name,
+               "namespace": namespace,
+               "data": attrs}
+        if hasChildren:
+            yield self.error("Void element has children")
+
+    def startTag(self, namespace, name, attrs):
+        """Generates a StartTag token
+
+        :arg namespace: the namespace of the token--can be ``None``
+
+        :arg name: the name of the element
+
+        :arg attrs: the attributes of the element as a dict
+
+        :returns: StartTag token
+
+        """
+        return {"type": "StartTag",
+                "name": name,
+                "namespace": namespace,
+                "data": attrs}
+
+    def endTag(self, namespace, name):
+        """Generates an EndTag token
+
+        :arg namespace: the namespace of the token--can be ``None``
+
+        :arg name: the name of the element
+
+        :returns: EndTag token
+
+        """
+        return {"type": "EndTag",
+                "name": name,
+                "namespace": namespace}
+
+    def text(self, data):
+        """Generates SpaceCharacters and Characters tokens
+
+        Depending on what's in the data, this generates one or more
+        ``SpaceCharacters`` and ``Characters`` tokens.
+
+        For example:
+
+            >>> from html5lib.treewalkers.base import TreeWalker
+            >>> # Give it an empty tree just so it instantiates
+            >>> walker = TreeWalker([])
+            >>> list(walker.text(''))
+            []
+            >>> list(walker.text('  '))
+            [{u'data': '  ', u'type': u'SpaceCharacters'}]
+            >>> list(walker.text(' abc '))  # doctest: +NORMALIZE_WHITESPACE
+            [{u'data': ' ', u'type': u'SpaceCharacters'},
+            {u'data': u'abc', u'type': u'Characters'},
+            {u'data': u' ', u'type': u'SpaceCharacters'}]
+
+        :arg data: the text data
+
+        :returns: one or more ``SpaceCharacters`` and ``Characters`` tokens
+
+        """
+        data = data
+        middle = data.lstrip(spaceCharacters)
+        left = data[:len(data) - len(middle)]
+        if left:
+            yield {"type": "SpaceCharacters", "data": left}
+        data = middle
+        middle = data.rstrip(spaceCharacters)
+        right = data[len(middle):]
+        if middle:
+            yield {"type": "Characters", "data": middle}
+        if right:
+            yield {"type": "SpaceCharacters", "data": right}
+
+    def comment(self, data):
+        """Generates a Comment token
+
+        :arg data: the comment
+
+        :returns: Comment token
+
+        """
+        return {"type": "Comment", "data": data}
+
+    def doctype(self, name, publicId=None, systemId=None):
+        """Generates a Doctype token
+
+        :arg name:
+
+        :arg publicId:
+
+        :arg systemId:
+
+        :returns: the Doctype token
+
+        """
+        return {"type": "Doctype",
+                "name": name,
+                "publicId": publicId,
+                "systemId": systemId}
+
+    def entity(self, name):
+        """Generates an Entity token
+
+        :arg name: the entity name
+
+        :returns: an Entity token
+
+        """
+        return {"type": "Entity", "name": name}
+
+    def unknown(self, nodeType):
+        """Handles unknown node types"""
+        return self.error("Unknown node type: " + nodeType)
+
+
+class NonRecursiveTreeWalker(TreeWalker):
+    def getNodeDetails(self, node):
+        raise NotImplementedError
+
+    def getFirstChild(self, node):
+        raise NotImplementedError
+
+    def getNextSibling(self, node):
+        raise NotImplementedError
+
+    def getParentNode(self, node):
+        raise NotImplementedError
+
+    def __iter__(self):
+        currentNode = self.tree
+        while currentNode is not None:
+            details = self.getNodeDetails(currentNode)
+            type, details = details[0], details[1:]
+            hasChildren = False
+
+            if type == DOCTYPE:
+                yield self.doctype(*details)
+
+            elif type == TEXT:
+                for token in self.text(*details):
+                    yield token
+
+            elif type == ELEMENT:
+                namespace, name, attributes, hasChildren = details
+                if (not namespace or namespace == namespaces["html"]) and name in voidElements:
+                    for token in self.emptyTag(namespace, name, attributes,
+                                               hasChildren):
+                        yield token
+                    hasChildren = False
+                else:
+                    yield self.startTag(namespace, name, attributes)
+
+            elif type == COMMENT:
+                yield self.comment(details[0])
+
+            elif type == ENTITY:
+                yield self.entity(details[0])
+
+            elif type == DOCUMENT:
+                hasChildren = True
+
+            else:
+                yield self.unknown(details[0])
+
+            if hasChildren:
+                firstChild = self.getFirstChild(currentNode)
+            else:
+                firstChild = None
+
+            if firstChild is not None:
+                currentNode = firstChild
+            else:
+                while currentNode is not None:
+                    details = self.getNodeDetails(currentNode)
+                    type, details = details[0], details[1:]
+                    if type == ELEMENT:
+                        namespace, name, attributes, hasChildren = details
+                        if (namespace and namespace != namespaces["html"]) or name not in voidElements:
+                            yield self.endTag(namespace, name)
+                    if self.tree is currentNode:
+                        currentNode = None
+                        break
+                    nextSibling = self.getNextSibling(currentNode)
+                    if nextSibling is not None:
+                        currentNode = nextSibling
+                        break
+                    else:
+                        currentNode = self.getParentNode(currentNode)

8210_A1P3-master/Lib/site-packages/html5lib/treewalkers/dom.py

@@ -0,0 +1,43 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from xml.dom import Node
+
+from . import base
+
+
+class TreeWalker(base.NonRecursiveTreeWalker):
+    def getNodeDetails(self, node):
+        if node.nodeType == Node.DOCUMENT_TYPE_NODE:
+            return base.DOCTYPE, node.name, node.publicId, node.systemId
+
+        elif node.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):
+            return base.TEXT, node.nodeValue
+
+        elif node.nodeType == Node.ELEMENT_NODE:
+            attrs = {}
+            for attr in list(node.attributes.keys()):
+                attr = node.getAttributeNode(attr)
+                if attr.namespaceURI:
+                    attrs[(attr.namespaceURI, attr.localName)] = attr.value
+                else:
+                    attrs[(None, attr.name)] = attr.value
+            return (base.ELEMENT, node.namespaceURI, node.nodeName,
+                    attrs, node.hasChildNodes())
+
+        elif node.nodeType == Node.COMMENT_NODE:
+            return base.COMMENT, node.nodeValue
+
+        elif node.nodeType in (Node.DOCUMENT_NODE, Node.DOCUMENT_FRAGMENT_NODE):
+            return (base.DOCUMENT,)
+
+        else:
+            return base.UNKNOWN, node.nodeType
+
+    def getFirstChild(self, node):
+        return node.firstChild
+
+    def getNextSibling(self, node):
+        return node.nextSibling
+
+    def getParentNode(self, node):
+        return node.parentNode

8210_A1P3-master/Lib/site-packages/html5lib/treewalkers/etree.py

@@ -0,0 +1,130 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from collections import OrderedDict
+import re
+
+from six import string_types
+
+from . import base
+from .._utils import moduleFactoryFactory
+
+tag_regexp = re.compile("{([^}]*)}(.*)")
+
+
+def getETreeBuilder(ElementTreeImplementation):
+    ElementTree = ElementTreeImplementation
+    ElementTreeCommentType = ElementTree.Comment("asd").tag
+
+    class TreeWalker(base.NonRecursiveTreeWalker):  # pylint:disable=unused-variable
+        """Given the particular ElementTree representation, this implementation,
+        to avoid using recursion, returns "nodes" as tuples with the following
+        content:
+
+        1. The current element
+
+        2. The index of the element relative to its parent
+
+        3. A stack of ancestor elements
+
+        4. A flag "text", "tail" or None to indicate if the current node is a
+           text node; either the text or tail of the current element (1)
+        """
+        def getNodeDetails(self, node):
+            if isinstance(node, tuple):  # It might be the root Element
+                elt, _, _, flag = node
+                if flag in ("text", "tail"):
+                    return base.TEXT, getattr(elt, flag)
+                else:
+                    node = elt
+
+            if not(hasattr(node, "tag")):
+                node = node.getroot()
+
+            if node.tag in ("DOCUMENT_ROOT", "DOCUMENT_FRAGMENT"):
+                return (base.DOCUMENT,)
+
+            elif node.tag == "<!DOCTYPE>":
+                return (base.DOCTYPE, node.text,
+                        node.get("publicId"), node.get("systemId"))
+
+            elif node.tag == ElementTreeCommentType:
+                return base.COMMENT, node.text
+
+            else:
+                assert isinstance(node.tag, string_types), type(node.tag)
+                # This is assumed to be an ordinary element
+                match = tag_regexp.match(node.tag)
+                if match:
+                    namespace, tag = match.groups()
+                else:
+                    namespace = None
+                    tag = node.tag
+                attrs = OrderedDict()
+                for name, value in list(node.attrib.items()):
+                    match = tag_regexp.match(name)
+                    if match:
+                        attrs[(match.group(1), match.group(2))] = value
+                    else:
+                        attrs[(None, name)] = value
+                return (base.ELEMENT, namespace, tag,
+                        attrs, len(node) or node.text)
+
+        def getFirstChild(self, node):
+            if isinstance(node, tuple):
+                element, key, parents, flag = node
+            else:
+                element, key, parents, flag = node, None, [], None
+
+            if flag in ("text", "tail"):
+                return None
+            else:
+                if element.text:
+                    return element, key, parents, "text"
+                elif len(element):
+                    parents.append(element)
+                    return element[0], 0, parents, None
+                else:
+                    return None
+
+        def getNextSibling(self, node):
+            if isinstance(node, tuple):
+                element, key, parents, flag = node
+            else:
+                return None
+
+            if flag == "text":
+                if len(element):
+                    parents.append(element)
+                    return element[0], 0, parents, None
+                else:
+                    return None
+            else:
+                if element.tail and flag != "tail":
+                    return element, key, parents, "tail"
+                elif key < len(parents[-1]) - 1:
+                    return parents[-1][key + 1], key + 1, parents, None
+                else:
+                    return None
+
+        def getParentNode(self, node):
+            if isinstance(node, tuple):
+                element, key, parents, flag = node
+            else:
+                return None
+
+            if flag == "text":
+                if not parents:
+                    return element
+                else:
+                    return element, key, parents, None
+            else:
+                parent = parents.pop()
+                if not parents:
+                    return parent
+                else:
+                    assert list(parents[-1]).count(parent) == 1
+                    return parent, list(parents[-1]).index(parent), parents, None
+
+    return locals()
+
+getETreeModule = moduleFactoryFactory(getETreeBuilder)

8210_A1P3-master/Lib/site-packages/html5lib/treewalkers/etree_lxml.py

@@ -0,0 +1,213 @@
+from __future__ import absolute_import, division, unicode_literals
+from six import text_type
+
+from lxml import etree
+from ..treebuilders.etree import tag_regexp
+
+from . import base
+
+from .. import _ihatexml
+
+
+def ensure_str(s):
+    if s is None:
+        return None
+    elif isinstance(s, text_type):
+        return s
+    else:
+        return s.decode("ascii", "strict")
+
+
+class Root(object):
+    def __init__(self, et):
+        self.elementtree = et
+        self.children = []
+
+        try:
+            if et.docinfo.internalDTD:
+                self.children.append(Doctype(self,
+                                             ensure_str(et.docinfo.root_name),
+                                             ensure_str(et.docinfo.public_id),
+                                             ensure_str(et.docinfo.system_url)))
+        except AttributeError:
+            pass
+
+        try:
+            node = et.getroot()
+        except AttributeError:
+            node = et
+
+        while node.getprevious() is not None:
+            node = node.getprevious()
+        while node is not None:
+            self.children.append(node)
+            node = node.getnext()
+
+        self.text = None
+        self.tail = None
+
+    def __getitem__(self, key):
+        return self.children[key]
+
+    def getnext(self):
+        return None
+
+    def __len__(self):
+        return 1
+
+
+class Doctype(object):
+    def __init__(self, root_node, name, public_id, system_id):
+        self.root_node = root_node
+        self.name = name
+        self.public_id = public_id
+        self.system_id = system_id
+
+        self.text = None
+        self.tail = None
+
+    def getnext(self):
+        return self.root_node.children[1]
+
+
+class FragmentRoot(Root):
+    def __init__(self, children):
+        self.children = [FragmentWrapper(self, child) for child in children]
+        self.text = self.tail = None
+
+    def getnext(self):
+        return None
+
+
+class FragmentWrapper(object):
+    def __init__(self, fragment_root, obj):
+        self.root_node = fragment_root
+        self.obj = obj
+        if hasattr(self.obj, 'text'):
+            self.text = ensure_str(self.obj.text)
+        else:
+            self.text = None
+        if hasattr(self.obj, 'tail'):
+            self.tail = ensure_str(self.obj.tail)
+        else:
+            self.tail = None
+
+    def __getattr__(self, name):
+        return getattr(self.obj, name)
+
+    def getnext(self):
+        siblings = self.root_node.children
+        idx = siblings.index(self)
+        if idx < len(siblings) - 1:
+            return siblings[idx + 1]
+        else:
+            return None
+
+    def __getitem__(self, key):
+        return self.obj[key]
+
+    def __bool__(self):
+        return bool(self.obj)
+
+    def getparent(self):
+        return None
+
+    def __str__(self):
+        return str(self.obj)
+
+    def __unicode__(self):
+        return str(self.obj)
+
+    def __len__(self):
+        return len(self.obj)
+
+
+class TreeWalker(base.NonRecursiveTreeWalker):
+    def __init__(self, tree):
+        # pylint:disable=redefined-variable-type
+        if isinstance(tree, list):
+            self.fragmentChildren = set(tree)
+            tree = FragmentRoot(tree)
+        else:
+            self.fragmentChildren = set()
+            tree = Root(tree)
+        base.NonRecursiveTreeWalker.__init__(self, tree)
+        self.filter = _ihatexml.InfosetFilter()
+
+    def getNodeDetails(self, node):
+        if isinstance(node, tuple):  # Text node
+            node, key = node
+            assert key in ("text", "tail"), "Text nodes are text or tail, found %s" % key
+            return base.TEXT, ensure_str(getattr(node, key))
+
+        elif isinstance(node, Root):
+            return (base.DOCUMENT,)
+
+        elif isinstance(node, Doctype):
+            return base.DOCTYPE, node.name, node.public_id, node.system_id
+
+        elif isinstance(node, FragmentWrapper) and not hasattr(node, "tag"):
+            return base.TEXT, ensure_str(node.obj)
+
+        elif node.tag == etree.Comment:
+            return base.COMMENT, ensure_str(node.text)
+
+        elif node.tag == etree.Entity:
+            return base.ENTITY, ensure_str(node.text)[1:-1]  # strip &;
+
+        else:
+            # This is assumed to be an ordinary element
+            match = tag_regexp.match(ensure_str(node.tag))
+            if match:
+                namespace, tag = match.groups()
+            else:
+                namespace = None
+                tag = ensure_str(node.tag)
+            attrs = {}
+            for name, value in list(node.attrib.items()):
+                name = ensure_str(name)
+                value = ensure_str(value)
+                match = tag_regexp.match(name)
+                if match:
+                    attrs[(match.group(1), match.group(2))] = value
+                else:
+                    attrs[(None, name)] = value
+            return (base.ELEMENT, namespace, self.filter.fromXmlName(tag),
+                    attrs, len(node) > 0 or node.text)
+
+    def getFirstChild(self, node):
+        assert not isinstance(node, tuple), "Text nodes have no children"
+
+        assert len(node) or node.text, "Node has no children"
+        if node.text:
+            return (node, "text")
+        else:
+            return node[0]
+
+    def getNextSibling(self, node):
+        if isinstance(node, tuple):  # Text node
+            node, key = node
+            assert key in ("text", "tail"), "Text nodes are text or tail, found %s" % key
+            if key == "text":
+                # XXX: we cannot use a "bool(node) and node[0] or None" construct here
+                # because node[0] might evaluate to False if it has no child element
+                if len(node):
+                    return node[0]
+                else:
+                    return None
+            else:  # tail
+                return node.getnext()
+
+        return (node, "tail") if node.tail else node.getnext()
+
+    def getParentNode(self, node):
+        if isinstance(node, tuple):  # Text node
+            node, key = node
+            assert key in ("text", "tail"), "Text nodes are text or tail, found %s" % key
+            if key == "text":
+                return node
+            # else: fallback to "normal" processing
+        elif node in self.fragmentChildren:
+            return None
+
+        return node.getparent()

8210_A1P3-master/Lib/site-packages/html5lib/treewalkers/genshi.py

@@ -0,0 +1,69 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from genshi.core import QName
+from genshi.core import START, END, XML_NAMESPACE, DOCTYPE, TEXT
+from genshi.core import START_NS, END_NS, START_CDATA, END_CDATA, PI, COMMENT
+
+from . import base
+
+from ..constants import voidElements, namespaces
+
+
+class TreeWalker(base.TreeWalker):
+    def __iter__(self):
+        # Buffer the events so we can pass in the following one
+        previous = None
+        for event in self.tree:
+            if previous is not None:
+                for token in self.tokens(previous, event):
+                    yield token
+            previous = event
+
+        # Don't forget the final event!
+        if previous is not None:
+            for token in self.tokens(previous, None):
+                yield token
+
+    def tokens(self, event, next):
+        kind, data, _ = event
+        if kind == START:
+            tag, attribs = data
+            name = tag.localname
+            namespace = tag.namespace
+            converted_attribs = {}
+            for k, v in attribs:
+                if isinstance(k, QName):
+                    converted_attribs[(k.namespace, k.localname)] = v
+                else:
+                    converted_attribs[(None, k)] = v
+
+            if namespace == namespaces["html"] and name in voidElements:
+                for token in self.emptyTag(namespace, name, converted_attribs,
+                                           not next or next[0] != END or
+                                           next[1] != tag):
+                    yield token
+            else:
+                yield self.startTag(namespace, name, converted_attribs)
+
+        elif kind == END:
+            name = data.localname
+            namespace = data.namespace
+            if namespace != namespaces["html"] or name not in voidElements:
+                yield self.endTag(namespace, name)
+
+        elif kind == COMMENT:
+            yield self.comment(data)
+
+        elif kind == TEXT:
+            for token in self.text(data):
+                yield token
+
+        elif kind == DOCTYPE:
+            yield self.doctype(*data)
+
+        elif kind in (XML_NAMESPACE, DOCTYPE, START_NS, END_NS,
+                      START_CDATA, END_CDATA, PI):
+            pass
+
+        else:
+            yield self.unknown(kind)

8210_A1P3-master/Lib/site-packages/mathfilters/templatetags/mathfilters.py

@@ -0,0 +1,136 @@
+# -*- coding: utf-8 -*-
+from __future__ import print_function, division, absolute_import, unicode_literals
+
+import logging
+try:
+    from cdecimal import Decimal
+except ImportError:
+    from decimal import Decimal
+
+from django.template import Library
+
+
+register = Library()
+logger = logging.getLogger(__name__)
+
+
+def valid_numeric(arg):
+    if isinstance(arg, (int, float, Decimal)):
+        return arg
+    try:
+        return int(arg)
+    except ValueError:
+        return float(arg)
+
+
+def handle_float_decimal_combinations(value, arg, operation):
+    if isinstance(value, float) and isinstance(arg, Decimal):
+        logger.warning('Unsafe operation: {0!r} {1} {2!r}.'.format(value, operation, arg))
+        value = Decimal(str(value))
+    if isinstance(value, Decimal) and isinstance(arg, float):
+        logger.warning('Unsafe operation: {0!r} {1} {2!r}.'.format(value, operation, arg))
+        arg = Decimal(str(arg))
+    return value, arg
+
+
+@register.filter
+def sub(value, arg):
+    """Subtract the arg from the value."""
+    try:
+        nvalue, narg = handle_float_decimal_combinations(
+            valid_numeric(value), valid_numeric(arg), '-')
+        return nvalue - narg
+    except (ValueError, TypeError):
+        try:
+            return value - arg
+        except Exception:
+            return ''
+sub.is_safe = False
+
+
+@register.filter
+def mul(value, arg):
+    """Multiply the arg with the value."""
+    try:
+        nvalue, narg = handle_float_decimal_combinations(
+            valid_numeric(value), valid_numeric(arg), '*')
+        return nvalue * narg
+    except (ValueError, TypeError):
+        try:
+            return value * arg
+        except Exception:
+            return ''
+mul.is_safe = False
+
+
+@register.filter
+def div(value, arg):
+    """Divide the arg by the value."""
+    try:
+        nvalue, narg = handle_float_decimal_combinations(
+            valid_numeric(value), valid_numeric(arg), '/')
+        return nvalue / narg
+    except (ValueError, TypeError):
+        try:
+            return value / arg
+        except Exception:
+            return ''
+div.is_safe = False
+
+
+@register.filter
+def intdiv(value, arg):
+    """Divide the arg by the value. Use integer (floor) division."""
+    try:
+        nvalue, narg = handle_float_decimal_combinations(
+            valid_numeric(value), valid_numeric(arg), '//')
+        return nvalue // narg
+    except (ValueError, TypeError):
+        try:
+            return value // arg
+        except Exception:
+            return ''
+intdiv.is_safe = False
+
+
+@register.filter(name='abs')
+def absolute(value):
+    """Return the absolute value."""
+    try:
+        return abs(valid_numeric(value))
+    except (ValueError, TypeError):
+        try:
+            return abs(value)
+        except Exception:
+            return ''
+absolute.is_safe = False
+
+
+@register.filter
+def mod(value, arg):
+    """Return the modulo value."""
+    try:
+        nvalue, narg = handle_float_decimal_combinations(
+            valid_numeric(value), valid_numeric(arg), '%')
+        return nvalue % narg
+    except (ValueError, TypeError):
+        try:
+            return value % arg
+        except Exception:
+            return ''
+mod.is_safe = False
+
+
+@register.filter(name='addition')
+def addition(value, arg):
+    """Float-friendly replacement for Django's built-in `add` filter."""
+    try:
+        nvalue, narg = handle_float_decimal_combinations(
+            valid_numeric(value), valid_numeric(arg), '+')
+        return nvalue + narg
+    except (ValueError, TypeError):
+        try:
+            return value + arg
+        except Exception:
+            return ''
+addition.is_safe = False

8210_A1P3-master/Lib/site-packages/mathfilters/tests.py

@@ -0,0 +1,306 @@
+# -*- coding: utf-8 -*-
+from __future__ import print_function, division, absolute_import, unicode_literals
+
+import unittest
+import logging
+try:
+    from cdecimal import Decimal
+except ImportError:
+    from decimal import Decimal
+
+from templatetags import mathfilters
+
+
+logging.basicConfig(level=logging.ERROR)
+
+
+class NumericConverterTest(unittest.TestCase):
+
+    def test_string(self):
+        self.assertEqual(13, mathfilters.valid_numeric('13'))
+        self.assertEqual(-13, mathfilters.valid_numeric('-13'))
+        self.assertEqual(13.3, mathfilters.valid_numeric('13.3'))
+        self.assertEqual(-13.3, mathfilters.valid_numeric('-13.3'))
+
+    def test_int(self):
+        self.assertEqual(13, mathfilters.valid_numeric(13))
+        self.assertEqual(-13, mathfilters.valid_numeric(-13))
+
+    def test_float(self):
+        self.assertEqual(13.3, mathfilters.valid_numeric(13.3))
+        self.assertEqual(-13.3, mathfilters.valid_numeric(-13.3))
+
+    def test_decimal(self):
+        self.assertEqual(Decimal('2.3'), mathfilters.valid_numeric(Decimal('2.3')))
+        self.assertEqual(Decimal('-2.3'), mathfilters.valid_numeric(Decimal('-2.3')))
+
+
+class DecimalFloatHandlerTest(unittest.TestCase):
+
+    def test_int_float(self):
+        a, b = mathfilters.handle_float_decimal_combinations(1, 2.0, '+')
+        self.assertTrue(isinstance(a, int), 'Type is {0}'.format(type(a)))
+        self.assertTrue(isinstance(b, float), 'Type is {0}'.format(type(b)))
+
+    def test_float_float(self):
+        a, b = mathfilters.handle_float_decimal_combinations(1.0, 2.0, '+')
+        self.assertTrue(isinstance(a, float), 'Type is {0}'.format(type(a)))
+        self.assertTrue(isinstance(b, float), 'Type is {0}'.format(type(b)))
+
+    def test_float_decimal(self):
+        a, b = mathfilters.handle_float_decimal_combinations(1.0, Decimal('2.0'), '+')
+        self.assertTrue(isinstance(a, Decimal), 'Type is {0}'.format(type(a)))
+        self.assertTrue(isinstance(b, Decimal), 'Type is {0}'.format(type(b)))
+
+    def test_decimal_float(self):
+        a, b = mathfilters.handle_float_decimal_combinations(Decimal('2.0'), 1.0, '+')
+        self.assertTrue(isinstance(a, Decimal), 'Type is {0}'.format(type(a)))
+        self.assertTrue(isinstance(b, Decimal), 'Type is {0}'.format(type(b)))
+
+    def test_decimal_int(self):
+        a, b = mathfilters.handle_float_decimal_combinations(Decimal('2.0'), 1, '+')
+        self.assertTrue(isinstance(a, Decimal), 'Type is {0}'.format(type(a)))
+        self.assertTrue(isinstance(b, int), 'Type is {0}'.format(type(b)))
+
+    def test_decimal_decimal(self):
+        a, b = mathfilters.handle_float_decimal_combinations(Decimal('2.0'), Decimal('1.0'), '+')
+        self.assertTrue(isinstance(a, Decimal), 'Type is {0}'.format(type(a)))
+        self.assertTrue(isinstance(b, Decimal), 'Type is {0}'.format(type(b)))
+
+
+class SubtractionTest(unittest.TestCase):
+
+    def test_positive(self):
+        self.assertEqual(3, mathfilters.sub('7', '4'))
+
+    def test_negative_result(self):
+        self.assertEqual(-20, mathfilters.sub('13', '33'))
+
+    def test_negative_minuend(self):
+        self.assertEqual(-42, mathfilters.sub('-23', '19'))
+
+    def test_negative_subtrahend(self):
+        self.assertEqual(6, mathfilters.sub('5', '-1'))
+
+    def test_float(self):
+        self.assertEqual(1.5, mathfilters.sub('-0.5', '-2'))
+
+    def test_decimal_decimal(self):
+        val1 = Decimal('9.9')
+        val2 = Decimal('6.6')
+        self.assertEqual(Decimal('3.3'), mathfilters.sub(val1, val2))
+
+    def test_decimal_int(self):
+        val1 = Decimal('9.999')
+        val2 = 9
+        self.assertEqual(Decimal('0.999'), mathfilters.sub(val1, val2))
+
+    def test_float_decimal(self):
+        """Regression test for issue #3."""
+        result = mathfilters.sub('201.7', Decimal('3.1'))
+        self.assertTrue(198 < result < 199, repr(result))
+
+    def test_decimal_float(self):
+        """Regression test for issue #3."""
+        result = mathfilters.sub(Decimal('201.7'), '3.1')
+        self.assertTrue(198 < result < 199, repr(result))
+
+
+class MultiplicationTest(unittest.TestCase):
+
+    def test_positive(self):
+        self.assertEqual(12, mathfilters.mul('3', '4'))
+
+    def test_negative1(self):
+        self.assertEqual(-10, mathfilters.mul('2', '-5'))
+
+    def test_negative2(self):
+        self.assertEqual(-10, mathfilters.mul('-2', '5'))
+
+    def test_negative3(self):
+        self.assertEqual(10, mathfilters.mul('-2', '-5'))
+
+    def test_float(self):
+        self.assertEqual(4.2, mathfilters.mul('2.1', '2'))
+
+    def test_decimal_decimal(self):
+        val1 = Decimal('3.3')
+        val2 = Decimal('3')
+        self.assertEqual(Decimal('9.9'), mathfilters.mul(val1, val2))
+
+    def test_decimal_int(self):
+        val1 = Decimal('3.3')
+        val2 = 3
+        self.assertEqual(Decimal('9.9'), mathfilters.mul(val1, val2))
+
+    def test_float_decimal(self):
+        """Regression test for issue #3."""
+        result = mathfilters.mul('2.2', Decimal('3.1'))
+        self.assertTrue(6 < result < 7, repr(result))
+
+    def test_decimal_float(self):
+        """Regression test for issue #3."""
+        result = mathfilters.mul(Decimal('2.2'), '3.1')
+        self.assertTrue(6 < result < 7, repr(result))
+
+
+class DivisionTest(unittest.TestCase):
+
+    def test_positive(self):
+        self.assertEqual(3, mathfilters.div('12', '4'))
+
+    def test_negative1(self):
+        self.assertEqual(-2, mathfilters.div('10', '-5'))
+
+    def test_negative2(self):
+        self.assertEqual(-2, mathfilters.div('-10', '5'))
+
+    def test_negative3(self):
+        self.assertEqual(2, mathfilters.div('-10', '-5'))
+
+    def test_float1(self):
+        self.assertEqual(8.5, mathfilters.div('27.2', '3.2'))
+
+    def test_decimal_decimal(self):
+        val1 = Decimal('9.9')
+        val2 = Decimal('3.3')
+        self.assertEqual(Decimal('3'), mathfilters.div(val1, val2))
+
+    def test_decimal_int(self):
+        val1 = Decimal('9.9')
+        val2 = 3
+        self.assertEqual(Decimal('3.3'), mathfilters.div(val1, val2))
+
+    def test_float_decimal(self):
+        """Regression test for issue #3."""
+        result = mathfilters.div('201.7', Decimal('3.1'))
+        self.assertTrue(65 < result < 66, repr(result))
+
+    def test_decimal_float(self):
+        """Regression test for issue #3."""
+        result = mathfilters.div(Decimal('201.7'), '3.1')
+        self.assertTrue(65 < result < 66, repr(result))
+
+
+class IntegerDivisionTest(unittest.TestCase):
+
+    def test_positive(self):
+        self.assertEqual(3, mathfilters.intdiv('12', '4'))
+
+    def test_negative1(self):
+        self.assertEqual(-2, mathfilters.intdiv('10', '-5'))
+
+    def test_negative2(self):
+        self.assertEqual(-2, mathfilters.intdiv('-10', '5'))
+
+    def test_negative3(self):
+        self.assertEqual(2, mathfilters.intdiv('-10', '-5'))
+
+    def test_float1(self):
+        result = mathfilters.intdiv('7', '2')
+        self.assertTrue(isinstance(result, int))
+        self.assertEqual(3, result)
+
+    def test_float2(self):
+        result = mathfilters.intdiv('27.2', '3.2')
+        self.assertTrue(isinstance(result, float))
+        self.assertEqual(8.0, result)
+
+    def test_decimal_decimal(self):
+        val1 = Decimal('7.0')
+        val2 = Decimal('2.0')
+        self.assertEqual(Decimal('3'), mathfilters.intdiv(val1, val2))
+
+    def test_decimal_int(self):
+        val1 = Decimal('9.9')
+        val2 = 3
+        self.assertEqual(Decimal('3'), mathfilters.intdiv(val1, val2))
+
+    def test_float_decimal(self):
+        """Regression test for issue #3."""
+        result = mathfilters.intdiv('201.7', Decimal('3.1'))
+        self.assertEqual(Decimal('65'), result)
+
+    def test_decimal_float(self):
+        """Regression test for issue #3."""
+        result = mathfilters.intdiv(Decimal('201.7'), '3.1')
+        self.assertEqual(Decimal('65'), result)
+
+
+class AbsoluteTest(unittest.TestCase):
+
+    def test_positive(self):
+        self.assertEqual(21, mathfilters.absolute('21'))
+
+    def test_negative(self):
+        self.assertEqual(21, mathfilters.absolute('-21'))
+
+    def test_positive_float(self):
+        self.assertEqual(2.3, mathfilters.absolute('2.3'))
+
+    def test_negative_float(self):
+        self.assertEqual(2.3, mathfilters.absolute('-2.3'))
+
+    def test_positive_decimal(self):
+        self.assertEqual(Decimal('9.99'), mathfilters.absolute(Decimal('9.99')))
+
+    def test_negative_decimal(self):
+        self.assertEqual(Decimal('9.99'), mathfilters.absolute(Decimal('-9.99')))
+
+
+class ModuloTest(unittest.TestCase):
+
+    def test_positive(self):
+        self.assertEqual(2, mathfilters.mod('12', '5'))
+
+    def test_negative(self):
+        self.assertEqual(-3, mathfilters.mod('12', '-5'))
+
+    def test_float(self):
+        self.assertEqual(3.0, mathfilters.mod('27.5', '3.5'))
+
+    def test_float_decimal(self):
+        """Regression test for issue #3."""
+        result = mathfilters.mod('7.8', Decimal('2.2'))
+        self.assertTrue(1 < result < 2, repr(result))
+
+    def test_decimal_float(self):
+        """Regression test for issue #3."""
+        result = mathfilters.mod(Decimal('7.8'), '2.2')
+        self.assertTrue(1 < result < 2, repr(result))
+
+
+class AdditionTest(unittest.TestCase):
+
+    def test_positive(self):
+        self.assertEqual(11, mathfilters.addition('7', '4'))
+
+    def test_negative_negative(self):
+        self.assertEqual(-4, mathfilters.addition('-1', '-3'))
+
+    def test_negative_positive(self):
+        self.assertEqual(6, mathfilters.addition('-3', '9'))
+
+    def test_positive_negative(self):
+        self.assertEqual(4, mathfilters.addition('5', '-1'))
+
+    def test_float_int(self):
+        self.assertEqual(2.5, mathfilters.addition('0.5', '2'))
+
+    def test_decimal_decimal(self):
+        val1 = Decimal('7.3')
+        val2 = Decimal('2.7')
+        self.assertEqual(Decimal('10'), mathfilters.addition(val1, val2))
+
+    def test_decimal_int(self):
+        val1 = Decimal('1.9')
+        val2 = 4
+        self.assertEqual(Decimal('5.9'), mathfilters.addition(val1, val2))
+
+    def test_float_decimal(self):
+        result = mathfilters.addition('3.7', Decimal('11.1'))
+        self.assertEqual(Decimal('14.8'), result)
+
+
+if __name__ == '__main__':
+    unittest.main()

8210_A1P3-master/Lib/site-packages/pdfrw-0.4.dist-info/DESCRIPTION.rst

@@ -0,0 +1,791 @@
+==================
+pdfrw 0.4
+==================
+
+:Author: Patrick Maupin
+
+.. contents::
+    :backlinks: none
+
+.. sectnum::
+
+Introduction
+============
+
+**pdfrw** is a Python library and utility that reads and writes PDF files:
+
+* Version 0.4 is tested and works on Python 2.6, 2.7, 3.3, 3.4, 3.5, and 3.6
+* Operations include subsetting, merging, rotating, modifying metadata, etc.
+* The fastest pure Python PDF parser available
+* Has been used for years by a printer in pre-press production
+* Can be used with rst2pdf to faithfully reproduce vector images
+* Can be used either standalone, or in conjunction with `reportlab`__
+  to reuse existing PDFs in new ones
+* Permissively licensed
+
+__ http://www.reportlab.org/
+
+
+pdfrw will faithfully reproduce vector formats without
+rasterization, so the rst2pdf package has used pdfrw
+for PDF and SVG images by default since March 2010.
+
+pdfrw can also be used in conjunction with reportlab, in order
+to re-use portions of existing PDFs in new PDFs created with
+reportlab.
+
+
+Examples
+=========
+
+The library comes with several examples that show operation both with
+and without reportlab.
+
+
+All examples
+------------------
+
+The examples directory has a few scripts which use the library.
+Note that if these examples do not work with your PDF, you should
+try to use pdftk to uncompress and/or unencrypt them first.
+
+* `4up.py`__ will shrink pages down and place 4 of them on
+  each output page.
+* `alter.py`__ shows an example of modifying metadata, without
+  altering the structure of the PDF.
+* `booklet.py`__ shows an example of creating a 2-up output
+  suitable for printing and folding (e.g on tabloid size paper).
+* `cat.py`__ shows an example of concatenating multiple PDFs together.
+* `extract.py`__ will extract images and Form XObjects (embedded pages)
+  from existing PDFs to make them easier to use and refer to from
+  new PDFs (e.g. with reportlab or rst2pdf).
+* `poster.py`__ increases the size of a PDF so it can be printed
+  as a poster.
+* `print_two.py`__ Allows creation of 8.5 X 5.5" booklets by slicing
+  8.5 X 11" paper apart after printing.
+* `rotate.py`__ Rotates all or selected pages in a PDF.
+* `subset.py`__ Creates a new PDF with only a subset of pages from the
+  original.
+* `unspread.py`__ Takes a 2-up PDF, and splits out pages.
+* `watermark.py`__ Adds a watermark PDF image over or under all the pages
+  of a PDF.
+* `rl1/4up.py`__ Another 4up example, using reportlab canvas for output.
+* `rl1/booklet.py`__ Another booklet example, using reportlab canvas for
+  output.
+* `rl1/subset.py`__ Another subsetting example, using reportlab canvas for
+  output.
+* `rl1/platypus_pdf_template.py`__ Another watermarking example, using
+  reportlab canvas and generated output for the document.  Contributed
+  by user asannes.
+* `rl2`__ Experimental code for parsing graphics.  Needs work.
+* `subset_booklets.py`__ shows an example of creating a full printable pdf
+  version in a more professional and pratical way ( take a look at
+  http://www.wikihow.com/Bind-a-Book )
+
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/4up.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/alter.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/booklet.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/cat.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/extract.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/poster.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/print_two.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/rotate.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/subset.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/unspread.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/watermark.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/rl1/4up.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/rl1/booklet.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/rl1/subset.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/rl1/platypus_pdf_template.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/rl2/
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/subset_booklets.py
+
+Notes on selected examples
+------------------------------------
+
+Reorganizing pages and placing them two-up
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+A printer with a fancy printer and/or a full-up copy of Acrobat can
+easily turn your small PDF into a little booklet (for example, print 4
+letter-sized pages on a single 11" x 17").
+
+But that assumes several things, including that the personnel know how
+to operate the hardware and software. `booklet.py`__ lets you turn your PDF
+into a preformatted booklet, to give them fewer chances to mess it up.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/booklet.py
+
+Adding or modifying metadata
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The `cat.py`__ example will accept multiple input files on the command
+line, concatenate them and output them to output.pdf, after adding some
+nonsensical metadata to the output PDF file.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/cat.py
+
+The `alter.py`__ example alters a single metadata item in a PDF,
+and writes the result to a new PDF.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/alter.py
+
+
+One difference is that, since **cat** is creating a new PDF structure,
+and **alter** is attempting to modify an existing PDF structure, the
+PDF produced by alter (and also by watermark.py) *should* be
+more faithful to the original (except for the desired changes).
+
+For example, the alter.py navigation should be left intact, whereas with
+cat.py it will be stripped.
+
+
+Rotating and doubling
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If you ever want to print something that is like a small booklet, but
+needs to be spiral bound, you either have to do some fancy rearranging,
+or just waste half your paper.
+
+The `print_two.py`__ example program will, for example, make two side-by-side
+copies each page of of your PDF on a each output sheet.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/print_two.py
+
+But, every other page is flipped, so that you can print double-sided and
+the pages will line up properly and be pre-collated.
+
+Graphics stream parsing proof of concept
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The `copy.py`__ script shows a simple example of reading in a PDF, and
+using the decodegraphics.py module to try to write the same information
+out to a new PDF through a reportlab canvas. (If you know about reportlab,
+you know that if you can faithfully render a PDF to a reportlab canvas, you
+can do pretty much anything else with that PDF you want.) This kind of
+low level manipulation should be done only if you really need to.
+decodegraphics is really more than a proof of concept than anything
+else. For most cases, just use the Form XObject capability, as shown in
+the examples/rl1/booklet.py demo.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/rl2/copy.py
+
+pdfrw philosophy
+==================
+
+Core library
+-------------
+
+The philosophy of the library portion of pdfrw is to provide intuitive
+functions to read, manipulate, and write PDF files.  There should be
+minimal leakage between abstraction layers, although getting useful
+work done makes "pure" functionality separation difficult.
+
+A key concept supported by the library is the use of Form XObjects,
+which allow easy embedding of pieces of one PDF into another.
+
+Addition of core support to the library is typically done carefully
+and thoughtfully, so as not to clutter it up with too many special
+cases.
+
+There are a lot of incorrectly formatted PDFs floating around; support
+for these is added in some cases.  The decision is often based on what
+acroread and okular do with the PDFs; if they can display them properly,
+then eventually pdfrw should, too, if it is not too difficult or costly.
+
+Contributions are welcome; one user has contributed some decompression
+filters and the ability to process PDF 1.5 stream objects.  Additional
+functionality that would obviously be useful includes additional
+decompression filters, the ability to process password-protected PDFs,
+and the ability to output linearized PDFs.
+
+Examples
+--------
+
+The philosophy of the examples is to provide small, easily-understood
+examples that showcase pdfrw functionality.
+
+
+PDF files and Python
+======================
+
+Introduction
+------------
+
+In general, PDF files conceptually map quite well to Python. The major
+objects to think about are:
+
+-  **strings**. Most things are strings. These also often decompose
+   naturally into
+-  **lists of tokens**. Tokens can be combined to create higher-level
+   objects like
+-  **arrays** and
+-  **dictionaries** and
+-  **Contents streams** (which can be more streams of tokens)
+
+Difficulties
+------------
+
+The apparent primary difficulty in mapping PDF files to Python is the
+PDF file concept of "indirect objects."  Indirect objects provide
+the efficiency of allowing a single piece of data to be referred to
+from more than one containing object, but probably more importantly,
+indirect objects provide a way to get around the chicken and egg
+problem of circular object references when mapping arbitrary data
+structures to files. To flatten out a circular reference, an indirect
+object is *referred to* instead of being *directly included* in another
+object. PDF files have a global mechanism for locating indirect objects,
+and they all have two reference numbers (a reference number and a
+"generation" number, in case you wanted to append to the PDF file
+rather than just rewriting the whole thing).
+
+pdfrw automatically handles indirect references on reading in a PDF
+file. When pdfrw encounters an indirect PDF file object, the
+corresponding Python object it creates will have an 'indirect' attribute
+with a value of True. When writing a PDF file, if you have created
+arbitrary data, you just need to make sure that circular references are
+broken up by putting an attribute named 'indirect' which evaluates to
+True on at least one object in every cycle.
+
+Another PDF file concept that doesn't quite map to regular Python is a
+"stream". Streams are dictionaries which each have an associated
+unformatted data block. pdfrw handles streams by placing a special
+attribute on a subclassed dictionary.
+
+Usage Model
+-----------
+
+The usage model for pdfrw treats most objects as strings (it takes their
+string representation when writing them to a file). The two main
+exceptions are the PdfArray object and the PdfDict object.
+
+PdfArray is a subclass of list with two special features.  First,
+an 'indirect' attribute allows a PdfArray to be written out as
+an indirect PDF object.  Second, pdfrw reads files lazily, so
+PdfArray knows about, and resolves references to other indirect
+objects on an as-needed basis.
+
+PdfDict is a subclass of dict that also has an indirect attribute
+and lazy reference resolution as well.  (And the subclassed
+IndirectPdfDict has indirect automatically set True).
+
+But PdfDict also has an optional associated stream. The stream object
+defaults to None, but if you assign a stream to the dict, it will
+automatically set the PDF /Length attribute for the dictionary.
+
+Finally, since PdfDict instances are indexed by PdfName objects (which
+always start with a /) and since most (all?) standard Adobe PdfName
+objects use names formatted like "/CamelCase", it makes sense to allow
+access to dictionary elements via object attribute accesses as well as
+object index accesses. So usage of PdfDict objects is normally via
+attribute access, although non-standard names (though still with a
+leading slash) can be accessed via dictionary index lookup.
+
+Reading PDFs
+~~~~~~~~~~~~~~~
+
+The PdfReader object is a subclass of PdfDict, which allows easy access
+to an entire document::
+
+    >>> from pdfrw import PdfReader
+    >>> x = PdfReader('source.pdf')
+    >>> x.keys()
+    ['/Info', '/Size', '/Root']
+    >>> x.Info
+    {'/Producer': '(cairo 1.8.6 (http://cairographics.org))',
+     '/Creator': '(cairo 1.8.6 (http://cairographics.org))'}
+    >>> x.Root.keys()
+    ['/Type', '/Pages']
+
+Info, Size, and Root are retrieved from the trailer of the PDF file.
+
+In addition to the tree structure, pdfrw creates a special attribute
+named *pages*, that is a list of all the pages in the document. pdfrw
+creates the *pages* attribute as a simplification for the user, because
+the PDF format allows arbitrarily complicated nested dictionaries to
+describe the page order. Each entry in the *pages* list is the PdfDict
+object for one of the pages in the file, in order.
+
+::
+
+    >>> len(x.pages)
+    1
+    >>> x.pages[0]
+    {'/Parent': {'/Kids': [{...}], '/Type': '/Pages', '/Count': '1'},
+     '/Contents': {'/Length': '11260', '/Filter': None},
+     '/Resources': ... (Lots more stuff snipped)
+    >>> x.pages[0].Contents
+    {'/Length': '11260', '/Filter': None}
+    >>> x.pages[0].Contents.stream
+    'q\n1 1 1 rg /a0 gs\n0 0 0 RG 0.657436
+      w\n0 J\n0 j\n[] 0.0 d\n4 M q' ... (Lots more stuff snipped)
+
+Writing PDFs
+~~~~~~~~~~~~~~~
+
+As you can see, it is quite easy to dig down into a PDF document. But
+what about when it's time to write it out?
+
+::
+
+    >>> from pdfrw import PdfWriter
+    >>> y = PdfWriter()
+    >>> y.addpage(x.pages[0])
+    >>> y.write('result.pdf')
+
+That's all it takes to create a new PDF. You may still need to read the
+`Adobe PDF reference manual`__ to figure out what needs to go *into*
+the PDF, but at least you don't have to sweat actually building it
+and getting the file offsets right.
+
+__ http://www.adobe.com/devnet/acrobat/pdfs/pdf_reference_1-7.pdf
+
+Manipulating PDFs in memory
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+For the most part, pdfrw tries to be agnostic about the contents of
+PDF files, and support them as containers, but to do useful work,
+something a little higher-level is required, so pdfrw works to
+understand a bit about the contents of the containers.  For example:
+
+-  PDF pages. pdfrw knows enough to find the pages in PDF files you read
+   in, and to write a set of pages back out to a new PDF file.
+-  Form XObjects. pdfrw can take any page or rectangle on a page, and
+   convert it to a Form XObject, suitable for use inside another PDF
+   file.  It knows enough about these to perform scaling, rotation,
+   and positioning.
+-  reportlab objects. pdfrw can recursively create a set of reportlab
+   objects from its internal object format. This allows, for example,
+   Form XObjects to be used inside reportlab, so that you can reuse
+   content from an existing PDF file when building a new PDF with
+   reportlab.
+
+There are several examples that demonstrate these features in
+the example code directory.
+
+Missing features
+~~~~~~~~~~~~~~~~~~~~~~~
+
+Even as a pure PDF container library, pdfrw comes up a bit short. It
+does not currently support:
+
+-  Most compression/decompression filters
+-  encryption
+
+`pdftk`__ is a wonderful command-line
+tool that can convert your PDFs to remove encryption and compression.
+However, in most cases, you can do a lot of useful work with PDFs
+without actually removing compression, because only certain elements
+inside PDFs are actually compressed.
+
+__ https://www.pdflabs.com/tools/pdftk-the-pdf-toolkit/
+
+Library internals
+==================
+
+Introduction
+------------
+
+**pdfrw** currently consists of 19 modules organized into a main
+package and one sub-package.
+
+The `__init.py__`__ module does the usual thing of importing a few
+major attributes from some of the submodules, and the `errors.py`__
+module supports logging and exception generation.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/__init__.py
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/errors.py
+
+
+PDF object model support
+--------------------------
+
+The `objects`__ sub-package contains one module for each of the
+internal representations of the kinds of basic objects that exist
+in a PDF file, with the `objects/__init__.py`__ module in that
+package simply gathering them up and making them available to the
+main pdfrw package.
+
+One feature that all the PDF object classes have in common is the
+inclusion of an 'indirect' attribute. If 'indirect' exists and evaluates
+to True, then when the object is written out, it is written out as an
+indirect object. That is to say, it is addressable in the PDF file, and
+could be referenced by any number (including zero) of container objects.
+This indirect object capability saves space in PDF files by allowing
+objects such as fonts to be referenced from multiple pages, and also
+allows PDF files to contain internal circular references.  This latter
+capability is used, for example, when each page object has a "parent"
+object in its dictionary.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/objects/
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/objects/__init__.py
+
+Ordinary objects
+~~~~~~~~~~~~~~~~
+
+The `objects/pdfobject.py`__ module contains the PdfObject class, which is
+a subclass of str, and is the catch-all object for any PDF file elements
+that are not explicitly represented by other objects, as described below.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/objects/pdfobject.py
+
+Name objects
+~~~~~~~~~~~~
+
+The `objects/pdfname.py`__ module contains the PdfName singleton object,
+which will convert a string into a PDF name by prepending a slash. It can
+be used either by calling it or getting an attribute, e.g.::
+
+    PdfName.Rotate == PdfName('Rotate') == PdfObject('/Rotate')
+
+In the example above, there is a slight difference between the objects
+returned from PdfName, and the object returned from PdfObject.  The
+PdfName objects are actually objects of class "BasePdfName".  This
+is important, because only these may be used as keys in PdfDict objects.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/objects/pdfname.py
+
+String objects
+~~~~~~~~~~~~~~
+
+The `objects/pdfstring.py`__
+module contains the PdfString class, which is a subclass of str that is
+used to represent encoded strings in a PDF file. The class has encode
+and decode methods for the strings.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/objects/pdfstring.py
+
+
+Array objects
+~~~~~~~~~~~~~
+
+The `objects/pdfarray.py`__
+module contains the PdfArray class, which is a subclass of list that is
+used to represent arrays in a PDF file. A regular list could be used
+instead, but use of the PdfArray class allows for an indirect attribute
+to be set, and also allows for proxying of unresolved indirect objects
+(that haven't been read in yet) in a manner that is transparent to pdfrw
+clients.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/objects/pdfarray.py
+
+Dict objects
+~~~~~~~~~~~~
+
+The `objects/pdfdict.py`__
+module contains the PdfDict class, which is a subclass of dict that is
+used to represent dictionaries in a PDF file. A regular dict could be
+used instead, but the PdfDict class matches the requirements of PDF
+files more closely:
+
+* Transparent (from the library client's viewpoint) proxying
+  of unresolved indirect objects
+* Return of None for non-existent keys (like dict.get)
+* Mapping of attribute accesses to the dict itself
+  (pdfdict.Foo == pdfdict[NameObject('Foo')])
+* Automatic management of following stream and /Length attributes
+  for content dictionaries
+* Indirect attribute
+* Other attributes may be set for private internal use of the
+  library and/or its clients.
+* Support for searching parent dictionaries for PDF "inheritable"
+  attributes.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/objects/pdfdict.py
+
+If a PdfDict has an associated data stream in the PDF file, the stream
+is accessed via the 'stream' (all lower-case) attribute.  Setting the
+stream attribute on the PdfDict will automatically set the /Length attribute
+as well.  If that is not what is desired (for example if the the stream
+is compressed), then _stream (same name with an underscore) may be used
+to associate the stream with the PdfDict without setting the length.
+
+To set private attributes (that will not be written out to a new PDF
+file) on a dictionary, use the 'private' attribute::
+
+    mydict.private.foo = 1
+
+Once the attribute is set, it may be accessed directly as an attribute
+of the dictionary::
+
+    foo = mydict.foo
+
+Some attributes of PDF pages are "inheritable."  That is, they may
+belong to a parent dictionary (or a parent of a parent dictionary, etc.)
+The "inheritable" attribute allows for easy discovery of these::
+
+    mediabox = mypage.inheritable.MediaBox
+
+
+Proxy objects
+~~~~~~~~~~~~~
+
+The `objects/pdfindirect.py`__
+module contains the PdfIndirect class, which is a non-transparent proxy
+object for PDF objects that have not yet been read in and resolved from
+a file. Although these are non-transparent inside the library, client code
+should never see one of these -- they exist inside the PdfArray and PdfDict
+container types, but are resolved before being returned to a client of
+those types.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/objects/pdfindirect.py
+
+
+File reading, tokenization and parsing
+--------------------------------------
+
+`pdfreader.py`__
+contains the PdfReader class, which can read a PDF file (or be passed a
+file object or already read string) and parse it. It uses the PdfTokens
+class in `tokens.py`__  for low-level tokenization.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/pdfreader.py
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/tokens.py
+
+
+The PdfReader class does not, in general, parse into containers (e.g.
+inside the content streams). There is a proof of concept for doing that
+inside the examples/rl2 subdirectory, but that is slow and not well-developed,
+and not useful for most applications.
+
+An instance of the PdfReader class is an instance of a PdfDict -- the
+trailer dictionary of the PDF file, to be exact.  It will have a private
+attribute set on it that is named 'pages' that is a list containing all
+the pages in the file.
+
+When instantiating a PdfReader object, there are options available
+for decompressing all the objects in the file.  pdfrw does not currently
+have very many options for decompression, so this is not all that useful,
+except in the specific case of compressed object streams.
+
+Also, there are no options for decryption yet.  If you have PDF files
+that are encrypted or heavily compressed, you may find that using another
+program like pdftk on them can make them readable by pdfrw.
+
+In general, the objects are read from the file lazily, but this is not
+currently true with compressed object streams -- all of these are decompressed
+and read in when the PdfReader is instantiated.
+
+
+File output
+-----------
+
+`pdfwriter.py`__
+contains the PdfWriter class, which can create and output a PDF file.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/pdfwriter.py
+
+There are a few options available when creating and using this class.
+
+In the simplest case, an instance of PdfWriter is instantiated, and
+then pages are added to it from one or more source files (or created
+programmatically), and then the write method is called to dump the
+results out to a file.
+
+If you have a source PDF and do not want to disturb the structure
+of it too badly, then you may pass its trailer directly to PdfWriter
+rather than letting PdfWriter construct one for you.  There is an
+example of this (alter.py) in the examples directory.
+
+
+Advanced features
+-----------------
+
+`buildxobj.py`__
+contains functions to build Form XObjects out of pages or rectangles on
+pages.  These may be reused in new PDFs essentially as if they were images.
+
+buildxobj is careful to cache any page used so that it only appears in
+the output once.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/buildxobj.py
+
+
+`toreportlab.py`__
+provides the makerl function, which will translate pdfrw objects into a
+format which can be used with `reportlab <http://www.reportlab.org/>`__.
+It is normally used in conjunction with buildxobj, to be able to reuse
+parts of existing PDFs when using reportlab.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/toreportlab.py
+
+
+`pagemerge.py`__ builds on the foundation laid by buildxobj.  It
+contains classes to create a new page (or overlay an existing page)
+using one or more rectangles from other pages.  There are examples
+showing its use for watermarking, scaling, 4-up output, splitting
+each page in 2, etc.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/pagemerge.py
+
+`findobjs.py`__ contains code that can find specific kinds of objects
+inside a PDF file.  The extract.py example uses this module to create
+a new PDF that places each image and Form XObject from a source PDF onto
+its own page, e.g. for easy reuse with some of the other examples or
+with reportlab.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/findobjs.py
+
+
+Miscellaneous
+----------------
+
+`compress.py`__ and `uncompress.py`__
+contains compression and decompression functions. Very few filters are
+currently supported, so an external tool like pdftk might be good if you
+require the ability to decompress (or, for that matter, decrypt) PDF
+files.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/compress.py
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/uncompress.py
+
+
+`py23_diffs.py`__ contains code to help manage the differences between
+Python 2 and Python 3.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/py23_diffs.py
+
+Testing
+===============
+
+The tests associated with pdfrw require a large number of PDFs,
+which are not distributed with the library.
+
+To run the tests:
+
+* Download or clone the full package from github.com/pmaupin/pdfrw
+* cd into the tests directory, and then clone the package
+  github.com/pmaupin/static_pdfs into a subdirectory (also named
+  static_pdfs).
+* Now the tests may be run from that directory using unittest, or
+  py.test, or nose.
+* travisci is used at github, and runs the tests with py.test
+
+Other libraries
+=====================
+
+Pure Python
+-----------
+
+-  `reportlab <http://www.reportlab.org/>`__
+
+    reportlab is must-have software if you want to programmatically
+    generate arbitrary PDFs.
+
+-  `pyPdf <https://github.com/mstamy2/PyPDF2>`__
+
+    pyPdf is, in some ways, very full-featured. It can do decompression
+    and decryption and seems to know a lot about items inside at least
+    some kinds of PDF files. In comparison, pdfrw knows less about
+    specific PDF file features (such as metadata), but focuses on trying
+    to have a more Pythonic API for mapping the PDF file container
+    syntax to Python, and (IMO) has a simpler and better PDF file
+    parser.  The Form XObject capability of pdfrw means that, in many
+    cases, it does not actually need to decompress objects -- they
+    can be left compressed.
+
+-  `pdftools <http://www.boddie.org.uk/david/Projects/Python/pdftools/index.html>`__
+
+    pdftools feels large and I fell asleep trying to figure out how it
+    all fit together, but many others have done useful things with it.
+
+-  `pagecatcher <http://www.reportlab.com/docs/pagecatcher-ds.pdf>`__
+
+    My understanding is that pagecatcher would have done exactly what I
+    wanted when I built pdfrw. But I was on a zero budget, so I've never
+    had the pleasure of experiencing pagecatcher. I do, however, use and
+    like `reportlab <http://www.reportlab.org/>`__ (open source, from
+    the people who make pagecatcher) so I'm sure pagecatcher is great,
+    better documented and much more full-featured than pdfrw.
+
+-  `pdfminer <http://www.unixuser.org/~euske/python/pdfminer/index.html>`__
+
+    This looks like a useful, actively-developed program. It is quite
+    large, but then, it is trying to actively comprehend a full PDF
+    document. From the website:
+
+    "PDFMiner is a suite of programs that help extracting and analyzing
+    text data of PDF documents. Unlike other PDF-related tools, it
+    allows to obtain the exact location of texts in a page, as well as
+    other extra information such as font information or ruled lines. It
+    includes a PDF converter that can transform PDF files into other
+    text formats (such as HTML). It has an extensible PDF parser that
+    can be used for other purposes instead of text analysis."
+
+non-pure-Python libraries
+-------------------------
+
+-  `pyPoppler <https://launchpad.net/poppler-python/>`__ can read PDF
+   files.
+-  `pycairo <http://www.cairographics.org/pycairo/>`__ can write PDF
+   files.
+-  `PyMuPDF <https://github.com/rk700/PyMuPDF>`_ high performance rendering
+   of PDF, (Open)XPS, CBZ and EPUB
+
+Other tools
+-----------
+
+-  `pdftk <https://www.pdflabs.com/tools/pdftk-the-pdf-toolkit/>`__ is a wonderful command
+   line tool for basic PDF manipulation. It complements pdfrw extremely
+   well, supporting many operations such as decryption and decompression
+   that pdfrw cannot do.
+-  `MuPDF <http://www.mupdf.com/>`_ is a free top performance PDF, (Open)XPS, CBZ and EPUB rendering library
+   that also comes with some command line tools. One of those, ``mutool``, has big overlaps with pdftk's - 
+   except it is up to 10 times faster.
+
+Release information
+=======================
+
+Revisions:
+
+0.4 -- Released 18 September, 2017
+
+    - Python 3.6 added to test matrix
+    - Proper unicode support for text strings in PDFs added
+    - buildxobj fixes allow better support creating form XObjects
+      out of compressed pages in some cases
+    - Compression fixes for Python 3+
+    - New subset_booklets.py example
+    - Bug with non-compressed indices into compressed object streams fixed
+    - Bug with distinguishing compressed object stream first objects fixed
+    - Better error reporting added for some invalid PDFs (e.g. when reading
+      past the end of file)
+    - Better scrubbing of old bookmark information when writing PDFs, to
+      remove dangling references
+    - Refactoring of pdfwriter, including updating API, to allow future
+      enhancements for things like incremental writing
+    - Minor tokenizer speedup
+    - Some flate decompressor bugs fixed
+    - Compression and decompression tests added
+    - Tests for new unicode handling added
+    - PdfReader.readpages() recursion error (issue #92) fixed.
+    - Initial crypt filter support added
+
+
+0.3 -- Released 19 October, 2016.
+
+    - Python 3.5 added to test matrix
+    - Better support under Python 3.x for in-memory PDF file-like objects
+    - Some pagemerge and Unicode patches added
+    - Changes to logging allow better coexistence with other packages
+    - Fix for "from pdfrw import \*"
+    - New fancy_watermark.py example shows off capabilities of pagemerge.py
+    - metadata.py example renamed to cat.py
+
+
+0.2 -- Released 21 June, 2015.  Supports Python 2.6, 2.7, 3.3, and 3.4.
+
+    - Several bugs have been fixed
+    - New regression test functionally tests core with dozens of
+      PDFs, and also tests examples.
+    - Core has been ported and tested on Python3 by round-tripping
+      several difficult files and observing binary matching results
+      across the different Python versions.
+    - Still only minimal support for compression and no support
+      for encryption or newer PDF features.  (pdftk is useful
+      to put PDFs in a form that pdfrw can use.)
+
+0.1 -- Released to PyPI in 2012.  Supports Python 2.5 - 2.7
+
+
+

8210_A1P3-master/Lib/site-packages/pdfrw-0.4.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

8210_A1P3-master/Lib/site-packages/pdfrw-0.4.dist-info/METADATA

@@ -0,0 +1,820 @@
+Metadata-Version: 2.0
+Name: pdfrw
+Version: 0.4
+Summary: PDF file reader/writer library
+Home-page: https://github.com/pmaupin/pdfrw
+Author: Patrick Maupin
+Author-email: pmaupin@gmail.com
+License: MIT
+Keywords: pdf vector graphics PDF nup watermark split join merge
+Platform: Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.6
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Topic :: Multimedia :: Graphics :: Graphics Conversion
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Printing
+Classifier: Topic :: Utilities
+
+==================
+pdfrw 0.4
+==================
+
+:Author: Patrick Maupin
+
+.. contents::
+    :backlinks: none
+
+.. sectnum::
+
+Introduction
+============
+
+**pdfrw** is a Python library and utility that reads and writes PDF files:
+
+* Version 0.4 is tested and works on Python 2.6, 2.7, 3.3, 3.4, 3.5, and 3.6
+* Operations include subsetting, merging, rotating, modifying metadata, etc.
+* The fastest pure Python PDF parser available
+* Has been used for years by a printer in pre-press production
+* Can be used with rst2pdf to faithfully reproduce vector images
+* Can be used either standalone, or in conjunction with `reportlab`__
+  to reuse existing PDFs in new ones
+* Permissively licensed
+
+__ http://www.reportlab.org/
+
+
+pdfrw will faithfully reproduce vector formats without
+rasterization, so the rst2pdf package has used pdfrw
+for PDF and SVG images by default since March 2010.
+
+pdfrw can also be used in conjunction with reportlab, in order
+to re-use portions of existing PDFs in new PDFs created with
+reportlab.
+
+
+Examples
+=========
+
+The library comes with several examples that show operation both with
+and without reportlab.
+
+
+All examples
+------------------
+
+The examples directory has a few scripts which use the library.
+Note that if these examples do not work with your PDF, you should
+try to use pdftk to uncompress and/or unencrypt them first.
+
+* `4up.py`__ will shrink pages down and place 4 of them on
+  each output page.
+* `alter.py`__ shows an example of modifying metadata, without
+  altering the structure of the PDF.
+* `booklet.py`__ shows an example of creating a 2-up output
+  suitable for printing and folding (e.g on tabloid size paper).
+* `cat.py`__ shows an example of concatenating multiple PDFs together.
+* `extract.py`__ will extract images and Form XObjects (embedded pages)
+  from existing PDFs to make them easier to use and refer to from
+  new PDFs (e.g. with reportlab or rst2pdf).
+* `poster.py`__ increases the size of a PDF so it can be printed
+  as a poster.
+* `print_two.py`__ Allows creation of 8.5 X 5.5" booklets by slicing
+  8.5 X 11" paper apart after printing.
+* `rotate.py`__ Rotates all or selected pages in a PDF.
+* `subset.py`__ Creates a new PDF with only a subset of pages from the
+  original.
+* `unspread.py`__ Takes a 2-up PDF, and splits out pages.
+* `watermark.py`__ Adds a watermark PDF image over or under all the pages
+  of a PDF.
+* `rl1/4up.py`__ Another 4up example, using reportlab canvas for output.
+* `rl1/booklet.py`__ Another booklet example, using reportlab canvas for
+  output.
+* `rl1/subset.py`__ Another subsetting example, using reportlab canvas for
+  output.
+* `rl1/platypus_pdf_template.py`__ Another watermarking example, using
+  reportlab canvas and generated output for the document.  Contributed
+  by user asannes.
+* `rl2`__ Experimental code for parsing graphics.  Needs work.
+* `subset_booklets.py`__ shows an example of creating a full printable pdf
+  version in a more professional and pratical way ( take a look at
+  http://www.wikihow.com/Bind-a-Book )
+
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/4up.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/alter.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/booklet.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/cat.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/extract.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/poster.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/print_two.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/rotate.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/subset.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/unspread.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/watermark.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/rl1/4up.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/rl1/booklet.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/rl1/subset.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/rl1/platypus_pdf_template.py
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/rl2/
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/subset_booklets.py
+
+Notes on selected examples
+------------------------------------
+
+Reorganizing pages and placing them two-up
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+A printer with a fancy printer and/or a full-up copy of Acrobat can
+easily turn your small PDF into a little booklet (for example, print 4
+letter-sized pages on a single 11" x 17").
+
+But that assumes several things, including that the personnel know how
+to operate the hardware and software. `booklet.py`__ lets you turn your PDF
+into a preformatted booklet, to give them fewer chances to mess it up.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/booklet.py
+
+Adding or modifying metadata
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The `cat.py`__ example will accept multiple input files on the command
+line, concatenate them and output them to output.pdf, after adding some
+nonsensical metadata to the output PDF file.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/cat.py
+
+The `alter.py`__ example alters a single metadata item in a PDF,
+and writes the result to a new PDF.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/alter.py
+
+
+One difference is that, since **cat** is creating a new PDF structure,
+and **alter** is attempting to modify an existing PDF structure, the
+PDF produced by alter (and also by watermark.py) *should* be
+more faithful to the original (except for the desired changes).
+
+For example, the alter.py navigation should be left intact, whereas with
+cat.py it will be stripped.
+
+
+Rotating and doubling
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If you ever want to print something that is like a small booklet, but
+needs to be spiral bound, you either have to do some fancy rearranging,
+or just waste half your paper.
+
+The `print_two.py`__ example program will, for example, make two side-by-side
+copies each page of of your PDF on a each output sheet.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/print_two.py
+
+But, every other page is flipped, so that you can print double-sided and
+the pages will line up properly and be pre-collated.
+
+Graphics stream parsing proof of concept
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The `copy.py`__ script shows a simple example of reading in a PDF, and
+using the decodegraphics.py module to try to write the same information
+out to a new PDF through a reportlab canvas. (If you know about reportlab,
+you know that if you can faithfully render a PDF to a reportlab canvas, you
+can do pretty much anything else with that PDF you want.) This kind of
+low level manipulation should be done only if you really need to.
+decodegraphics is really more than a proof of concept than anything
+else. For most cases, just use the Form XObject capability, as shown in
+the examples/rl1/booklet.py demo.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/examples/rl2/copy.py
+
+pdfrw philosophy
+==================
+
+Core library
+-------------
+
+The philosophy of the library portion of pdfrw is to provide intuitive
+functions to read, manipulate, and write PDF files.  There should be
+minimal leakage between abstraction layers, although getting useful
+work done makes "pure" functionality separation difficult.
+
+A key concept supported by the library is the use of Form XObjects,
+which allow easy embedding of pieces of one PDF into another.
+
+Addition of core support to the library is typically done carefully
+and thoughtfully, so as not to clutter it up with too many special
+cases.
+
+There are a lot of incorrectly formatted PDFs floating around; support
+for these is added in some cases.  The decision is often based on what
+acroread and okular do with the PDFs; if they can display them properly,
+then eventually pdfrw should, too, if it is not too difficult or costly.
+
+Contributions are welcome; one user has contributed some decompression
+filters and the ability to process PDF 1.5 stream objects.  Additional
+functionality that would obviously be useful includes additional
+decompression filters, the ability to process password-protected PDFs,
+and the ability to output linearized PDFs.
+
+Examples
+--------
+
+The philosophy of the examples is to provide small, easily-understood
+examples that showcase pdfrw functionality.
+
+
+PDF files and Python
+======================
+
+Introduction
+------------
+
+In general, PDF files conceptually map quite well to Python. The major
+objects to think about are:
+
+-  **strings**. Most things are strings. These also often decompose
+   naturally into
+-  **lists of tokens**. Tokens can be combined to create higher-level
+   objects like
+-  **arrays** and
+-  **dictionaries** and
+-  **Contents streams** (which can be more streams of tokens)
+
+Difficulties
+------------
+
+The apparent primary difficulty in mapping PDF files to Python is the
+PDF file concept of "indirect objects."  Indirect objects provide
+the efficiency of allowing a single piece of data to be referred to
+from more than one containing object, but probably more importantly,
+indirect objects provide a way to get around the chicken and egg
+problem of circular object references when mapping arbitrary data
+structures to files. To flatten out a circular reference, an indirect
+object is *referred to* instead of being *directly included* in another
+object. PDF files have a global mechanism for locating indirect objects,
+and they all have two reference numbers (a reference number and a
+"generation" number, in case you wanted to append to the PDF file
+rather than just rewriting the whole thing).
+
+pdfrw automatically handles indirect references on reading in a PDF
+file. When pdfrw encounters an indirect PDF file object, the
+corresponding Python object it creates will have an 'indirect' attribute
+with a value of True. When writing a PDF file, if you have created
+arbitrary data, you just need to make sure that circular references are
+broken up by putting an attribute named 'indirect' which evaluates to
+True on at least one object in every cycle.
+
+Another PDF file concept that doesn't quite map to regular Python is a
+"stream". Streams are dictionaries which each have an associated
+unformatted data block. pdfrw handles streams by placing a special
+attribute on a subclassed dictionary.
+
+Usage Model
+-----------
+
+The usage model for pdfrw treats most objects as strings (it takes their
+string representation when writing them to a file). The two main
+exceptions are the PdfArray object and the PdfDict object.
+
+PdfArray is a subclass of list with two special features.  First,
+an 'indirect' attribute allows a PdfArray to be written out as
+an indirect PDF object.  Second, pdfrw reads files lazily, so
+PdfArray knows about, and resolves references to other indirect
+objects on an as-needed basis.
+
+PdfDict is a subclass of dict that also has an indirect attribute
+and lazy reference resolution as well.  (And the subclassed
+IndirectPdfDict has indirect automatically set True).
+
+But PdfDict also has an optional associated stream. The stream object
+defaults to None, but if you assign a stream to the dict, it will
+automatically set the PDF /Length attribute for the dictionary.
+
+Finally, since PdfDict instances are indexed by PdfName objects (which
+always start with a /) and since most (all?) standard Adobe PdfName
+objects use names formatted like "/CamelCase", it makes sense to allow
+access to dictionary elements via object attribute accesses as well as
+object index accesses. So usage of PdfDict objects is normally via
+attribute access, although non-standard names (though still with a
+leading slash) can be accessed via dictionary index lookup.
+
+Reading PDFs
+~~~~~~~~~~~~~~~
+
+The PdfReader object is a subclass of PdfDict, which allows easy access
+to an entire document::
+
+    >>> from pdfrw import PdfReader
+    >>> x = PdfReader('source.pdf')
+    >>> x.keys()
+    ['/Info', '/Size', '/Root']
+    >>> x.Info
+    {'/Producer': '(cairo 1.8.6 (http://cairographics.org))',
+     '/Creator': '(cairo 1.8.6 (http://cairographics.org))'}
+    >>> x.Root.keys()
+    ['/Type', '/Pages']
+
+Info, Size, and Root are retrieved from the trailer of the PDF file.
+
+In addition to the tree structure, pdfrw creates a special attribute
+named *pages*, that is a list of all the pages in the document. pdfrw
+creates the *pages* attribute as a simplification for the user, because
+the PDF format allows arbitrarily complicated nested dictionaries to
+describe the page order. Each entry in the *pages* list is the PdfDict
+object for one of the pages in the file, in order.
+
+::
+
+    >>> len(x.pages)
+    1
+    >>> x.pages[0]
+    {'/Parent': {'/Kids': [{...}], '/Type': '/Pages', '/Count': '1'},
+     '/Contents': {'/Length': '11260', '/Filter': None},
+     '/Resources': ... (Lots more stuff snipped)
+    >>> x.pages[0].Contents
+    {'/Length': '11260', '/Filter': None}
+    >>> x.pages[0].Contents.stream
+    'q\n1 1 1 rg /a0 gs\n0 0 0 RG 0.657436
+      w\n0 J\n0 j\n[] 0.0 d\n4 M q' ... (Lots more stuff snipped)
+
+Writing PDFs
+~~~~~~~~~~~~~~~
+
+As you can see, it is quite easy to dig down into a PDF document. But
+what about when it's time to write it out?
+
+::
+
+    >>> from pdfrw import PdfWriter
+    >>> y = PdfWriter()
+    >>> y.addpage(x.pages[0])
+    >>> y.write('result.pdf')
+
+That's all it takes to create a new PDF. You may still need to read the
+`Adobe PDF reference manual`__ to figure out what needs to go *into*
+the PDF, but at least you don't have to sweat actually building it
+and getting the file offsets right.
+
+__ http://www.adobe.com/devnet/acrobat/pdfs/pdf_reference_1-7.pdf
+
+Manipulating PDFs in memory
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+For the most part, pdfrw tries to be agnostic about the contents of
+PDF files, and support them as containers, but to do useful work,
+something a little higher-level is required, so pdfrw works to
+understand a bit about the contents of the containers.  For example:
+
+-  PDF pages. pdfrw knows enough to find the pages in PDF files you read
+   in, and to write a set of pages back out to a new PDF file.
+-  Form XObjects. pdfrw can take any page or rectangle on a page, and
+   convert it to a Form XObject, suitable for use inside another PDF
+   file.  It knows enough about these to perform scaling, rotation,
+   and positioning.
+-  reportlab objects. pdfrw can recursively create a set of reportlab
+   objects from its internal object format. This allows, for example,
+   Form XObjects to be used inside reportlab, so that you can reuse
+   content from an existing PDF file when building a new PDF with
+   reportlab.
+
+There are several examples that demonstrate these features in
+the example code directory.
+
+Missing features
+~~~~~~~~~~~~~~~~~~~~~~~
+
+Even as a pure PDF container library, pdfrw comes up a bit short. It
+does not currently support:
+
+-  Most compression/decompression filters
+-  encryption
+
+`pdftk`__ is a wonderful command-line
+tool that can convert your PDFs to remove encryption and compression.
+However, in most cases, you can do a lot of useful work with PDFs
+without actually removing compression, because only certain elements
+inside PDFs are actually compressed.
+
+__ https://www.pdflabs.com/tools/pdftk-the-pdf-toolkit/
+
+Library internals
+==================
+
+Introduction
+------------
+
+**pdfrw** currently consists of 19 modules organized into a main
+package and one sub-package.
+
+The `__init.py__`__ module does the usual thing of importing a few
+major attributes from some of the submodules, and the `errors.py`__
+module supports logging and exception generation.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/__init__.py
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/errors.py
+
+
+PDF object model support
+--------------------------
+
+The `objects`__ sub-package contains one module for each of the
+internal representations of the kinds of basic objects that exist
+in a PDF file, with the `objects/__init__.py`__ module in that
+package simply gathering them up and making them available to the
+main pdfrw package.
+
+One feature that all the PDF object classes have in common is the
+inclusion of an 'indirect' attribute. If 'indirect' exists and evaluates
+to True, then when the object is written out, it is written out as an
+indirect object. That is to say, it is addressable in the PDF file, and
+could be referenced by any number (including zero) of container objects.
+This indirect object capability saves space in PDF files by allowing
+objects such as fonts to be referenced from multiple pages, and also
+allows PDF files to contain internal circular references.  This latter
+capability is used, for example, when each page object has a "parent"
+object in its dictionary.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/objects/
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/objects/__init__.py
+
+Ordinary objects
+~~~~~~~~~~~~~~~~
+
+The `objects/pdfobject.py`__ module contains the PdfObject class, which is
+a subclass of str, and is the catch-all object for any PDF file elements
+that are not explicitly represented by other objects, as described below.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/objects/pdfobject.py
+
+Name objects
+~~~~~~~~~~~~
+
+The `objects/pdfname.py`__ module contains the PdfName singleton object,
+which will convert a string into a PDF name by prepending a slash. It can
+be used either by calling it or getting an attribute, e.g.::
+
+    PdfName.Rotate == PdfName('Rotate') == PdfObject('/Rotate')
+
+In the example above, there is a slight difference between the objects
+returned from PdfName, and the object returned from PdfObject.  The
+PdfName objects are actually objects of class "BasePdfName".  This
+is important, because only these may be used as keys in PdfDict objects.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/objects/pdfname.py
+
+String objects
+~~~~~~~~~~~~~~
+
+The `objects/pdfstring.py`__
+module contains the PdfString class, which is a subclass of str that is
+used to represent encoded strings in a PDF file. The class has encode
+and decode methods for the strings.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/objects/pdfstring.py
+
+
+Array objects
+~~~~~~~~~~~~~
+
+The `objects/pdfarray.py`__
+module contains the PdfArray class, which is a subclass of list that is
+used to represent arrays in a PDF file. A regular list could be used
+instead, but use of the PdfArray class allows for an indirect attribute
+to be set, and also allows for proxying of unresolved indirect objects
+(that haven't been read in yet) in a manner that is transparent to pdfrw
+clients.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/objects/pdfarray.py
+
+Dict objects
+~~~~~~~~~~~~
+
+The `objects/pdfdict.py`__
+module contains the PdfDict class, which is a subclass of dict that is
+used to represent dictionaries in a PDF file. A regular dict could be
+used instead, but the PdfDict class matches the requirements of PDF
+files more closely:
+
+* Transparent (from the library client's viewpoint) proxying
+  of unresolved indirect objects
+* Return of None for non-existent keys (like dict.get)
+* Mapping of attribute accesses to the dict itself
+  (pdfdict.Foo == pdfdict[NameObject('Foo')])
+* Automatic management of following stream and /Length attributes
+  for content dictionaries
+* Indirect attribute
+* Other attributes may be set for private internal use of the
+  library and/or its clients.
+* Support for searching parent dictionaries for PDF "inheritable"
+  attributes.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/objects/pdfdict.py
+
+If a PdfDict has an associated data stream in the PDF file, the stream
+is accessed via the 'stream' (all lower-case) attribute.  Setting the
+stream attribute on the PdfDict will automatically set the /Length attribute
+as well.  If that is not what is desired (for example if the the stream
+is compressed), then _stream (same name with an underscore) may be used
+to associate the stream with the PdfDict without setting the length.
+
+To set private attributes (that will not be written out to a new PDF
+file) on a dictionary, use the 'private' attribute::
+
+    mydict.private.foo = 1
+
+Once the attribute is set, it may be accessed directly as an attribute
+of the dictionary::
+
+    foo = mydict.foo
+
+Some attributes of PDF pages are "inheritable."  That is, they may
+belong to a parent dictionary (or a parent of a parent dictionary, etc.)
+The "inheritable" attribute allows for easy discovery of these::
+
+    mediabox = mypage.inheritable.MediaBox
+
+
+Proxy objects
+~~~~~~~~~~~~~
+
+The `objects/pdfindirect.py`__
+module contains the PdfIndirect class, which is a non-transparent proxy
+object for PDF objects that have not yet been read in and resolved from
+a file. Although these are non-transparent inside the library, client code
+should never see one of these -- they exist inside the PdfArray and PdfDict
+container types, but are resolved before being returned to a client of
+those types.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/objects/pdfindirect.py
+
+
+File reading, tokenization and parsing
+--------------------------------------
+
+`pdfreader.py`__
+contains the PdfReader class, which can read a PDF file (or be passed a
+file object or already read string) and parse it. It uses the PdfTokens
+class in `tokens.py`__  for low-level tokenization.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/pdfreader.py
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/tokens.py
+
+
+The PdfReader class does not, in general, parse into containers (e.g.
+inside the content streams). There is a proof of concept for doing that
+inside the examples/rl2 subdirectory, but that is slow and not well-developed,
+and not useful for most applications.
+
+An instance of the PdfReader class is an instance of a PdfDict -- the
+trailer dictionary of the PDF file, to be exact.  It will have a private
+attribute set on it that is named 'pages' that is a list containing all
+the pages in the file.
+
+When instantiating a PdfReader object, there are options available
+for decompressing all the objects in the file.  pdfrw does not currently
+have very many options for decompression, so this is not all that useful,
+except in the specific case of compressed object streams.
+
+Also, there are no options for decryption yet.  If you have PDF files
+that are encrypted or heavily compressed, you may find that using another
+program like pdftk on them can make them readable by pdfrw.
+
+In general, the objects are read from the file lazily, but this is not
+currently true with compressed object streams -- all of these are decompressed
+and read in when the PdfReader is instantiated.
+
+
+File output
+-----------
+
+`pdfwriter.py`__
+contains the PdfWriter class, which can create and output a PDF file.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/pdfwriter.py
+
+There are a few options available when creating and using this class.
+
+In the simplest case, an instance of PdfWriter is instantiated, and
+then pages are added to it from one or more source files (or created
+programmatically), and then the write method is called to dump the
+results out to a file.
+
+If you have a source PDF and do not want to disturb the structure
+of it too badly, then you may pass its trailer directly to PdfWriter
+rather than letting PdfWriter construct one for you.  There is an
+example of this (alter.py) in the examples directory.
+
+
+Advanced features
+-----------------
+
+`buildxobj.py`__
+contains functions to build Form XObjects out of pages or rectangles on
+pages.  These may be reused in new PDFs essentially as if they were images.
+
+buildxobj is careful to cache any page used so that it only appears in
+the output once.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/buildxobj.py
+
+
+`toreportlab.py`__
+provides the makerl function, which will translate pdfrw objects into a
+format which can be used with `reportlab <http://www.reportlab.org/>`__.
+It is normally used in conjunction with buildxobj, to be able to reuse
+parts of existing PDFs when using reportlab.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/toreportlab.py
+
+
+`pagemerge.py`__ builds on the foundation laid by buildxobj.  It
+contains classes to create a new page (or overlay an existing page)
+using one or more rectangles from other pages.  There are examples
+showing its use for watermarking, scaling, 4-up output, splitting
+each page in 2, etc.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/pagemerge.py
+
+`findobjs.py`__ contains code that can find specific kinds of objects
+inside a PDF file.  The extract.py example uses this module to create
+a new PDF that places each image and Form XObject from a source PDF onto
+its own page, e.g. for easy reuse with some of the other examples or
+with reportlab.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/findobjs.py
+
+
+Miscellaneous
+----------------
+
+`compress.py`__ and `uncompress.py`__
+contains compression and decompression functions. Very few filters are
+currently supported, so an external tool like pdftk might be good if you
+require the ability to decompress (or, for that matter, decrypt) PDF
+files.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/compress.py
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/uncompress.py
+
+
+`py23_diffs.py`__ contains code to help manage the differences between
+Python 2 and Python 3.
+
+__ https://github.com/pmaupin/pdfrw/tree/master/pdfrw/py23_diffs.py
+
+Testing
+===============
+
+The tests associated with pdfrw require a large number of PDFs,
+which are not distributed with the library.
+
+To run the tests:
+
+* Download or clone the full package from github.com/pmaupin/pdfrw
+* cd into the tests directory, and then clone the package
+  github.com/pmaupin/static_pdfs into a subdirectory (also named
+  static_pdfs).
+* Now the tests may be run from that directory using unittest, or
+  py.test, or nose.
+* travisci is used at github, and runs the tests with py.test
+
+Other libraries
+=====================
+
+Pure Python
+-----------
+
+-  `reportlab <http://www.reportlab.org/>`__
+
+    reportlab is must-have software if you want to programmatically
+    generate arbitrary PDFs.
+
+-  `pyPdf <https://github.com/mstamy2/PyPDF2>`__
+
+    pyPdf is, in some ways, very full-featured. It can do decompression
+    and decryption and seems to know a lot about items inside at least
+    some kinds of PDF files. In comparison, pdfrw knows less about
+    specific PDF file features (such as metadata), but focuses on trying
+    to have a more Pythonic API for mapping the PDF file container
+    syntax to Python, and (IMO) has a simpler and better PDF file
+    parser.  The Form XObject capability of pdfrw means that, in many
+    cases, it does not actually need to decompress objects -- they
+    can be left compressed.
+
+-  `pdftools <http://www.boddie.org.uk/david/Projects/Python/pdftools/index.html>`__
+
+    pdftools feels large and I fell asleep trying to figure out how it
+    all fit together, but many others have done useful things with it.
+
+-  `pagecatcher <http://www.reportlab.com/docs/pagecatcher-ds.pdf>`__
+
+    My understanding is that pagecatcher would have done exactly what I
+    wanted when I built pdfrw. But I was on a zero budget, so I've never
+    had the pleasure of experiencing pagecatcher. I do, however, use and
+    like `reportlab <http://www.reportlab.org/>`__ (open source, from
+    the people who make pagecatcher) so I'm sure pagecatcher is great,
+    better documented and much more full-featured than pdfrw.
+
+-  `pdfminer <http://www.unixuser.org/~euske/python/pdfminer/index.html>`__
+
+    This looks like a useful, actively-developed program. It is quite
+    large, but then, it is trying to actively comprehend a full PDF
+    document. From the website:
+
+    "PDFMiner is a suite of programs that help extracting and analyzing
+    text data of PDF documents. Unlike other PDF-related tools, it
+    allows to obtain the exact location of texts in a page, as well as
+    other extra information such as font information or ruled lines. It
+    includes a PDF converter that can transform PDF files into other
+    text formats (such as HTML). It has an extensible PDF parser that
+    can be used for other purposes instead of text analysis."
+
+non-pure-Python libraries
+-------------------------
+
+-  `pyPoppler <https://launchpad.net/poppler-python/>`__ can read PDF
+   files.
+-  `pycairo <http://www.cairographics.org/pycairo/>`__ can write PDF
+   files.
+-  `PyMuPDF <https://github.com/rk700/PyMuPDF>`_ high performance rendering
+   of PDF, (Open)XPS, CBZ and EPUB
+
+Other tools
+-----------
+
+-  `pdftk <https://www.pdflabs.com/tools/pdftk-the-pdf-toolkit/>`__ is a wonderful command
+   line tool for basic PDF manipulation. It complements pdfrw extremely
+   well, supporting many operations such as decryption and decompression
+   that pdfrw cannot do.
+-  `MuPDF <http://www.mupdf.com/>`_ is a free top performance PDF, (Open)XPS, CBZ and EPUB rendering library
+   that also comes with some command line tools. One of those, ``mutool``, has big overlaps with pdftk's - 
+   except it is up to 10 times faster.
+
+Release information
+=======================
+
+Revisions:
+
+0.4 -- Released 18 September, 2017
+
+    - Python 3.6 added to test matrix
+    - Proper unicode support for text strings in PDFs added
+    - buildxobj fixes allow better support creating form XObjects
+      out of compressed pages in some cases
+    - Compression fixes for Python 3+
+    - New subset_booklets.py example
+    - Bug with non-compressed indices into compressed object streams fixed
+    - Bug with distinguishing compressed object stream first objects fixed
+    - Better error reporting added for some invalid PDFs (e.g. when reading
+      past the end of file)
+    - Better scrubbing of old bookmark information when writing PDFs, to
+      remove dangling references
+    - Refactoring of pdfwriter, including updating API, to allow future
+      enhancements for things like incremental writing
+    - Minor tokenizer speedup
+    - Some flate decompressor bugs fixed
+    - Compression and decompression tests added
+    - Tests for new unicode handling added
+    - PdfReader.readpages() recursion error (issue #92) fixed.
+    - Initial crypt filter support added
+
+
+0.3 -- Released 19 October, 2016.
+
+    - Python 3.5 added to test matrix
+    - Better support under Python 3.x for in-memory PDF file-like objects
+    - Some pagemerge and Unicode patches added
+    - Changes to logging allow better coexistence with other packages
+    - Fix for "from pdfrw import \*"
+    - New fancy_watermark.py example shows off capabilities of pagemerge.py
+    - metadata.py example renamed to cat.py
+
+
+0.2 -- Released 21 June, 2015.  Supports Python 2.6, 2.7, 3.3, and 3.4.
+
+    - Several bugs have been fixed
+    - New regression test functionally tests core with dozens of
+      PDFs, and also tests examples.
+    - Core has been ported and tested on Python3 by round-tripping
+      several difficult files and observing binary matching results
+      across the different Python versions.
+    - Still only minimal support for compression and no support
+      for encryption or newer PDF features.  (pdftk is useful
+      to put PDFs in a form that pdfrw can use.)
+
+0.1 -- Released to PyPI in 2012.  Supports Python 2.5 - 2.7
+
+
+

8210_A1P3-master/Lib/site-packages/pdfrw-0.4.dist-info/RECORD

@@ -0,0 +1,48 @@
+pdfrw/__init__.py,sha256=9FFH1bTZ-G4v8TmoQs02P-mKMJanmVfXraHvCP4uG-M,714
+pdfrw/buildxobj.py,sha256=NkBDhvnPUpqB21J5277wRwvtEag4G9uHNVoWu17ffxA,12391
+pdfrw/compress.py,sha256=J7IN1E_sBcB8fPDPgPVK3xY7NPcJVx6WH26VMSdYrwo,844
+pdfrw/crypt.py,sha256=4UzGRCBy95WSP0lBHJUcZ8FCggqRVyGTwqFOiYlA8lA,4711
+pdfrw/errors.py,sha256=OQagKuUxAn5GS2Vz8EUFIy5dxIm6YGLSdI0dUcHroPg,855
+pdfrw/findobjs.py,sha256=9jC-331zD_89YyiS2sTYVthISsfKBBeukBMTis_wPQY,4640
+pdfrw/pagemerge.py,sha256=Evoc-aONIeRi76tai6JNnmZITkCHErdfxiXRyGRpKhg,8646
+pdfrw/pdfreader.py,sha256=Ccij2Jxk_iQROy4IXNKV_UsYusD2-sHj9HQM5pCQ0p8,25990
+pdfrw/pdfwriter.py,sha256=cjH0KuOE4hArNtj6JARdcQnMOLUJU87dpTIbTSU8Bgk,13055
+pdfrw/py23_diffs.py,sha256=tOaBrjYLDXSvZU-MdgXy-WHGMDQzldCC0ZPjad9hPyE,943
+pdfrw/tokens.py,sha256=SqytfCrJVHTtYa4Y719rzTNz9Wub--yhHlGoqszG1xo,8644
+pdfrw/toreportlab.py,sha256=IOIMQS35kb-FgzALXWGSpzVwb9YwnPiw2drY-2e_qg0,4385
+pdfrw/uncompress.py,sha256=BmOWOUXo4LfZ2NuYMemQ7AIKdzjSi4ymP_lIQvlgHDQ,4633
+pdfrw/objects/__init__.py,sha256=Jfco1zYOrLgXuus_tQcwWexyKQzMHIi_SUjjEMrfdqE,654
+pdfrw/objects/pdfarray.py,sha256=hM9qJ3l-gXh3YfRABjYwzTmljMuLteOWouvuiUjFld8,2012
+pdfrw/objects/pdfdict.py,sha256=fEiBEHSOJyGVYyVu7YMtZt5gxSltldAA_En7QegLRkQ,8363
+pdfrw/objects/pdfindirect.py,sha256=RqiWtpLbeYmftG-Tv5-_qKACNd40FbhA1Ib1VyGdjQo,718
+pdfrw/objects/pdfname.py,sha256=Er8nIlBhC4jcBmOf7EtMwlTZAmGUIndvwHiKkWdsMVQ,2562
+pdfrw/objects/pdfobject.py,sha256=6HjsPbsxMhavG4erlj_8jz5ld4Y_AM2gjHCLz91mmsk,385
+pdfrw/objects/pdfstring.py,sha256=5PEsC062JVR6kVO1O5akSfXccUZs3tUIeksEuv_ShZY,23234
+pdfrw-0.4.dist-info/DESCRIPTION.rst,sha256=myfQQ0e2rAxQkHRL5yztGPSW87yDjJT5XHlnEKBlPos,31267
+pdfrw-0.4.dist-info/METADATA,sha256=A_h68f6ZD-SbO7ci8mpjwAlDscQVo3MnQ2LW1hOuQbE,32398
+pdfrw-0.4.dist-info/RECORD,,
+pdfrw-0.4.dist-info/WHEEL,sha256=o2k-Qa-RMNIJmUdIc7KU6VWR_ErNRbWNlxDIpl7lm34,110
+pdfrw-0.4.dist-info/metadata.json,sha256=IUe9p4Xlv5gDj0XjYJcT5-C5cbQtW2AafJIZ4yg0C_E,1226
+pdfrw-0.4.dist-info/top_level.txt,sha256=X9Jw2_LyhwZSsHQB03ht4DtoM2c_bJJaw441ODoPNdo,6
+pdfrw-0.4.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+pdfrw-0.4.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+pdfrw/objects/__pycache__/pdfarray.cpython-37.pyc,,
+pdfrw/objects/__pycache__/pdfdict.cpython-37.pyc,,
+pdfrw/objects/__pycache__/pdfindirect.cpython-37.pyc,,
+pdfrw/objects/__pycache__/pdfname.cpython-37.pyc,,
+pdfrw/objects/__pycache__/pdfobject.cpython-37.pyc,,
+pdfrw/objects/__pycache__/pdfstring.cpython-37.pyc,,
+pdfrw/objects/__pycache__/__init__.cpython-37.pyc,,
+pdfrw/__pycache__/buildxobj.cpython-37.pyc,,
+pdfrw/__pycache__/compress.cpython-37.pyc,,
+pdfrw/__pycache__/crypt.cpython-37.pyc,,
+pdfrw/__pycache__/errors.cpython-37.pyc,,
+pdfrw/__pycache__/findobjs.cpython-37.pyc,,
+pdfrw/__pycache__/pagemerge.cpython-37.pyc,,
+pdfrw/__pycache__/pdfreader.cpython-37.pyc,,
+pdfrw/__pycache__/pdfwriter.cpython-37.pyc,,
+pdfrw/__pycache__/py23_diffs.cpython-37.pyc,,
+pdfrw/__pycache__/tokens.cpython-37.pyc,,
+pdfrw/__pycache__/toreportlab.cpython-37.pyc,,
+pdfrw/__pycache__/uncompress.cpython-37.pyc,,
+pdfrw/__pycache__/__init__.cpython-37.pyc,,

8210_A1P3-master/Lib/site-packages/pdfrw-0.4.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.29.0)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

8210_A1P3-master/Lib/site-packages/pdfrw-0.4.dist-info/metadata.json

@@ -0,0 +1 @@
+{"classifiers": ["Development Status :: 4 - Beta", "Intended Audience :: Developers", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", "Programming Language :: Python", "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.6", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.3", "Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5", "Programming Language :: Python :: 3.6", "Topic :: Multimedia :: Graphics :: Graphics Conversion", "Topic :: Software Development :: Libraries", "Topic :: Text Processing", "Topic :: Printing", "Topic :: Utilities"], "extensions": {"python.details": {"contacts": [{"email": "pmaupin@gmail.com", "name": "Patrick Maupin", "role": "author"}], "document_names": {"description": "DESCRIPTION.rst"}, "project_urls": {"Home": "https://github.com/pmaupin/pdfrw"}}}, "generator": "bdist_wheel (0.29.0)", "keywords": ["pdf", "vector", "graphics", "PDF", "nup", "watermark", "split", "join", "merge"], "license": "MIT", "metadata_version": "2.0", "name": "pdfrw", "platform": "Independent", "summary": "PDF file reader/writer library", "version": "0.4"}