[
{
"path": "LICENSE.md",
"content": "Copyright 2017 Parallax Agency Ltd\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n"
},
{
"path": "README.md",
"content": "# Parallax SVG Animation Tools\n\nA simple set of python functions to help working with animated SVGs exported from Illustrator. More features coming soon!\nWe used it to create animations like this.\n\n[Viva La Velo](https://parall.ax/viva-le-velo)\n\n\n\n\n## Overview\n\nPart of animating with SVGs is getting references to elements in code and passing them to animation functions. For complicated animations this becomes difficult and hand editing SVG code is slow and gets overwritten when your artwork updates. We decided to write a post-processer for SVGs produced by Illustrator to help speed this up. Layer names are used to create attributes, classes and ID's making selecting them in JS or CSS far easier.\n\nThis is the what the svg code looks like before and after the processing step.\n\n```xml\n\n\n\n\n\n```\n\n\n\n\n## Quick Example\n\nDownload the [svg tools](parallax_svg_tools.zip) and unzip them into your project folder.\n\nCreate an Illustrator file, add an element and change its layer name to say `#class=my-element`. Export the SVG using the **File > Export > Export for Screens** option with the following settings. Call the svg `animation.svg`.\n\n\n\nCreate a HTML file as below. The import statements inline the SVG inline into our HTML file so we don't have to do any copy and pasting. Not strictly neccessary but makes the workflow a little easier. Save it as `animation.html`.\n\n```html\n\n\n\n\t\n\n\n\n//import processed_animation.svg\n\n\n\n```\n\n\nOpen the file called `run.py`. Here you can edit how the SVGs will be processed. The default looks like this. The sections below describe what the various options do.\n\n```javascript\nfrom svg import *\n\ncompile_svg('animation.svg', 'processed_animation.svg', \n{\n\t'process_layer_names': True,\n\t'namespace' : 'example'\n})\n\ninline_svg('animation.html', 'output/animation.html')\n```\n\nOpen the command line and navigate to your project folder. Call the script using `python parallax_svg_tools/run.py`. You should see a list of processed files (or just one in this case) printed to the console if everything worked correctly. Note that the script must be called from a directory that has access to the svg files.\n\nThere should now be a folder called `output` containing an `animation.html` file with your processed SVG in it. All that is left to do is animate it with your tool of choice (ours is [GSAP](https://greensock.com/)).\n\n\n## Functions\n\n### process\\_svg(src\\_path, dst\\_path, options)\nProcesses a single SVG and places it in the supplied destination directory. The following options are available.\n\n+ **process\\_layer\\_names:**\nConverts layer names as defined in Illustator into attributes. Begin the layer name with a '#' to indicate the layer should be parsed. \nFor example `#id=my-id, class=my-class my-other-class, role=my-role` ...etc.\nThis is useful for fetching elements with Javascript as well as marking up elements for accessibility - see this [CSS Tricks Accessible SVG ](https://css-tricks.com/accessible-svgs/) article.\nNOTE: Requires using commas to separate the attributes as that makes the parsing code a lot simpler :)\n\n+ **expand_origin:**\nAllows you to use `origin=100 100` to set origins for rotating/scaling with GSAP (expands to data-svg-origin). \n\n+ **namespace:** \nAppends a namespace to classes and IDs if one is provided. Useful for avoiding conflicts with other SVG files for things like masks and clipPaths.\n\n+ **nowhitespace:**\nRemoves unneeded whitespace. We don't do anything fancier than that so as to not break animations. Use the excellent [SVGO]() if you need better minification.\n\n+ **attributes:**\nAn object of key:value strings that will be applied as attributes to the root SVG element.\n\n+ **title:**\nSets the title or removes it completely when set to `false`\n\n+ **description:**\nSets the description or removes it completely when set to `false`\n\n+ **convert_svg_text_to_html:**\nConverts SVG text in HTML text via the foriegn object tag reducing file bloat and allowing you to style it with CSS. Requires the text be grouped inside a rectangle with the layer name set to `#TEXT`. \n\n+ **spirit:**\nExpands `#spirit=my-id` to `data-spirit-id` when set to `true` for use with the [Spirit animation app]()\n\n\n### inline\\_svg(src\\_path, dst\\_path)\nIn order to animate SVGs markup needs to be placed in-line with HTML. This function will look at the source HTML file and include any references defined by `//import` statements to SVGs that it finds."
},
{
"path": "example/animation.html",
"content": "\n\n\n\t\n\n\n\n//import processed_animation.svg\n\n\n"
},
{
"path": "example/output/animation.html",
"content": "\n\n\n\t\n\n\n\n\n\n\n"
},
{
"path": "example/parallax_svg_tools/bs4/__init__.py",
"content": "\"\"\"Beautiful Soup\nElixir and Tonic\n\"The Screen-Scraper's Friend\"\nhttp://www.crummy.com/software/BeautifulSoup/\n\nBeautiful Soup uses a pluggable XML or HTML parser to parse a\n(possibly invalid) document into a tree representation. Beautiful Soup\nprovides methods and Pythonic idioms that make it easy to navigate,\nsearch, and modify the parse tree.\n\nBeautiful Soup works with Python 2.7 and up. It works better if lxml\nand/or html5lib is installed.\n\nFor more than you ever wanted to know about Beautiful Soup, see the\ndocumentation:\nhttp://www.crummy.com/software/BeautifulSoup/bs4/doc/\n\n\"\"\"\n\n# Use of this source code is governed by a BSD-style license that can be\n# found in the LICENSE file.\n\n__author__ = \"Leonard Richardson (leonardr@segfault.org)\"\n__version__ = \"4.5.1\"\n__copyright__ = \"Copyright (c) 2004-2016 Leonard Richardson\"\n__license__ = \"MIT\"\n\n__all__ = ['BeautifulSoup']\n\nimport os\nimport re\nimport traceback\nimport warnings\n\nfrom .builder import builder_registry, ParserRejectedMarkup\nfrom .dammit import UnicodeDammit\nfrom .element import (\n CData,\n Comment,\n DEFAULT_OUTPUT_ENCODING,\n Declaration,\n Doctype,\n NavigableString,\n PageElement,\n ProcessingInstruction,\n ResultSet,\n SoupStrainer,\n Tag,\n )\n\n# The very first thing we do is give a useful error if someone is\n# running this code under Python 3 without converting it.\n'You are trying to run the Python 2 version of Beautiful Soup under Python 3. This will not work.'<>'You need to convert the code, either by installing it (`python setup.py install`) or by running 2to3 (`2to3 -w bs4`).'\n\nclass BeautifulSoup(Tag):\n \"\"\"\n This class defines the basic interface called by the tree builders.\n\n These methods will be called by the parser:\n reset()\n feed(markup)\n\n The tree builder may call these methods from its feed() implementation:\n handle_starttag(name, attrs) # See note about return value\n handle_endtag(name)\n handle_data(data) # Appends to the current data node\n endData(containerClass=NavigableString) # Ends the current data node\n\n No matter how complicated the underlying parser is, you should be\n able to build a tree using 'start tag' events, 'end tag' events,\n 'data' events, and \"done with data\" events.\n\n If you encounter an empty-element tag (aka a self-closing tag,\n like HTML's tag), call handle_starttag and then\n handle_endtag.\n \"\"\"\n ROOT_TAG_NAME = u'[document]'\n\n # If the end-user gives no indication which tree builder they\n # want, look for one with these features.\n DEFAULT_BUILDER_FEATURES = ['html', 'fast']\n\n ASCII_SPACES = '\\x20\\x0a\\x09\\x0c\\x0d'\n\n NO_PARSER_SPECIFIED_WARNING = \"No parser was explicitly specified, so I'm using the best available %(markup_type)s parser for this system (\\\"%(parser)s\\\"). This usually isn't a problem, but if you run this code on another system, or in a different virtual environment, it may use a different parser and behave differently.\\n\\nThe code that caused this warning is on line %(line_number)s of the file %(filename)s. To get rid of this warning, change code that looks like this:\\n\\n BeautifulSoup([your markup])\\n\\nto this:\\n\\n BeautifulSoup([your markup], \\\"%(parser)s\\\")\\n\"\n\n def __init__(self, markup=\"\", features=None, builder=None,\n parse_only=None, from_encoding=None, exclude_encodings=None,\n **kwargs):\n \"\"\"The Soup object is initialized as the 'root tag', and the\n provided markup (which can be a string or a file-like object)\n is fed into the underlying parser.\"\"\"\n\n if 'convertEntities' in kwargs:\n warnings.warn(\n \"BS4 does not respect the convertEntities argument to the \"\n \"BeautifulSoup constructor. Entities are always converted \"\n \"to Unicode characters.\")\n\n if 'markupMassage' in kwargs:\n del kwargs['markupMassage']\n warnings.warn(\n \"BS4 does not respect the markupMassage argument to the \"\n \"BeautifulSoup constructor. The tree builder is responsible \"\n \"for any necessary markup massage.\")\n\n if 'smartQuotesTo' in kwargs:\n del kwargs['smartQuotesTo']\n warnings.warn(\n \"BS4 does not respect the smartQuotesTo argument to the \"\n \"BeautifulSoup constructor. Smart quotes are always converted \"\n \"to Unicode characters.\")\n\n if 'selfClosingTags' in kwargs:\n del kwargs['selfClosingTags']\n warnings.warn(\n \"BS4 does not respect the selfClosingTags argument to the \"\n \"BeautifulSoup constructor. The tree builder is responsible \"\n \"for understanding self-closing tags.\")\n\n if 'isHTML' in kwargs:\n del kwargs['isHTML']\n warnings.warn(\n \"BS4 does not respect the isHTML argument to the \"\n \"BeautifulSoup constructor. Suggest you use \"\n \"features='lxml' for HTML and features='lxml-xml' for \"\n \"XML.\")\n\n def deprecated_argument(old_name, new_name):\n if old_name in kwargs:\n warnings.warn(\n 'The \"%s\" argument to the BeautifulSoup constructor '\n 'has been renamed to \"%s.\"' % (old_name, new_name))\n value = kwargs[old_name]\n del kwargs[old_name]\n return value\n return None\n\n parse_only = parse_only or deprecated_argument(\n \"parseOnlyThese\", \"parse_only\")\n\n from_encoding = from_encoding or deprecated_argument(\n \"fromEncoding\", \"from_encoding\")\n\n if from_encoding and isinstance(markup, unicode):\n warnings.warn(\"You provided Unicode markup but also provided a value for from_encoding. Your from_encoding will be ignored.\")\n from_encoding = None\n\n if len(kwargs) > 0:\n arg = kwargs.keys().pop()\n raise TypeError(\n \"__init__() got an unexpected keyword argument '%s'\" % arg)\n\n if builder is None:\n original_features = features\n if isinstance(features, basestring):\n features = [features]\n if features is None or len(features) == 0:\n features = self.DEFAULT_BUILDER_FEATURES\n builder_class = builder_registry.lookup(*features)\n if builder_class is None:\n raise FeatureNotFound(\n \"Couldn't find a tree builder with the features you \"\n \"requested: %s. Do you need to install a parser library?\"\n % \",\".join(features))\n builder = builder_class()\n if not (original_features == builder.NAME or\n original_features in builder.ALTERNATE_NAMES):\n if builder.is_xml:\n markup_type = \"XML\"\n else:\n markup_type = \"HTML\"\n\n caller = traceback.extract_stack()[0]\n filename = caller[0]\n line_number = caller[1]\n warnings.warn(self.NO_PARSER_SPECIFIED_WARNING % dict(\n filename=filename,\n line_number=line_number,\n parser=builder.NAME,\n markup_type=markup_type))\n\n self.builder = builder\n self.is_xml = builder.is_xml\n self.known_xml = self.is_xml\n self.builder.soup = self\n\n self.parse_only = parse_only\n\n if hasattr(markup, 'read'): # It's a file-type object.\n markup = markup.read()\n elif len(markup) <= 256 and (\n (isinstance(markup, bytes) and not b'<' in markup)\n or (isinstance(markup, unicode) and not u'<' in markup)\n ):\n # Print out warnings for a couple beginner problems\n # involving passing non-markup to Beautiful Soup.\n # Beautiful Soup will still parse the input as markup,\n # just in case that's what the user really wants.\n if (isinstance(markup, unicode)\n and not os.path.supports_unicode_filenames):\n possible_filename = markup.encode(\"utf8\")\n else:\n possible_filename = markup\n is_file = False\n try:\n is_file = os.path.exists(possible_filename)\n except Exception, e:\n # This is almost certainly a problem involving\n # characters not valid in filenames on this\n # system. Just let it go.\n pass\n if is_file:\n if isinstance(markup, unicode):\n markup = markup.encode(\"utf8\")\n warnings.warn(\n '\"%s\" looks like a filename, not markup. You should'\n 'probably open this file and pass the filehandle into'\n 'Beautiful Soup.' % markup)\n self._check_markup_is_url(markup)\n\n for (self.markup, self.original_encoding, self.declared_html_encoding,\n self.contains_replacement_characters) in (\n self.builder.prepare_markup(\n markup, from_encoding, exclude_encodings=exclude_encodings)):\n self.reset()\n try:\n self._feed()\n break\n except ParserRejectedMarkup:\n pass\n\n # Clear out the markup and remove the builder's circular\n # reference to this object.\n self.markup = None\n self.builder.soup = None\n\n def __copy__(self):\n copy = type(self)(\n self.encode('utf-8'), builder=self.builder, from_encoding='utf-8'\n )\n\n # Although we encoded the tree to UTF-8, that may not have\n # been the encoding of the original markup. Set the copy's\n # .original_encoding to reflect the original object's\n # .original_encoding.\n copy.original_encoding = self.original_encoding\n return copy\n\n def __getstate__(self):\n # Frequently a tree builder can't be pickled.\n d = dict(self.__dict__)\n if 'builder' in d and not self.builder.picklable:\n d['builder'] = None\n return d\n\n @staticmethod\n def _check_markup_is_url(markup):\n \"\"\" \n Check if markup looks like it's actually a url and raise a warning \n if so. Markup can be unicode or str (py2) / bytes (py3).\n \"\"\"\n if isinstance(markup, bytes):\n space = b' '\n cant_start_with = (b\"http:\", b\"https:\")\n elif isinstance(markup, unicode):\n space = u' '\n cant_start_with = (u\"http:\", u\"https:\")\n else:\n return\n\n if any(markup.startswith(prefix) for prefix in cant_start_with):\n if not space in markup:\n if isinstance(markup, bytes):\n decoded_markup = markup.decode('utf-8', 'replace')\n else:\n decoded_markup = markup\n warnings.warn(\n '\"%s\" looks like a URL. Beautiful Soup is not an'\n ' HTTP client. You should probably use an HTTP client like'\n ' requests to get the document behind the URL, and feed'\n ' that document to Beautiful Soup.' % decoded_markup\n )\n\n def _feed(self):\n # Convert the document to Unicode.\n self.builder.reset()\n\n self.builder.feed(self.markup)\n # Close out any unfinished strings and close all the open tags.\n self.endData()\n while self.currentTag.name != self.ROOT_TAG_NAME:\n self.popTag()\n\n def reset(self):\n Tag.__init__(self, self, self.builder, self.ROOT_TAG_NAME)\n self.hidden = 1\n self.builder.reset()\n self.current_data = []\n self.currentTag = None\n self.tagStack = []\n self.preserve_whitespace_tag_stack = []\n self.pushTag(self)\n\n def new_tag(self, name, namespace=None, nsprefix=None, **attrs):\n \"\"\"Create a new tag associated with this soup.\"\"\"\n return Tag(None, self.builder, name, namespace, nsprefix, attrs)\n\n def new_string(self, s, subclass=NavigableString):\n \"\"\"Create a new NavigableString associated with this soup.\"\"\"\n return subclass(s)\n\n def insert_before(self, successor):\n raise NotImplementedError(\"BeautifulSoup objects don't support insert_before().\")\n\n def insert_after(self, successor):\n raise NotImplementedError(\"BeautifulSoup objects don't support insert_after().\")\n\n def popTag(self):\n tag = self.tagStack.pop()\n if self.preserve_whitespace_tag_stack and tag == self.preserve_whitespace_tag_stack[-1]:\n self.preserve_whitespace_tag_stack.pop()\n #print \"Pop\", tag.name\n if self.tagStack:\n self.currentTag = self.tagStack[-1]\n return self.currentTag\n\n def pushTag(self, tag):\n #print \"Push\", tag.name\n if self.currentTag:\n self.currentTag.contents.append(tag)\n self.tagStack.append(tag)\n self.currentTag = self.tagStack[-1]\n if tag.name in self.builder.preserve_whitespace_tags:\n self.preserve_whitespace_tag_stack.append(tag)\n\n def endData(self, containerClass=NavigableString):\n if self.current_data:\n current_data = u''.join(self.current_data)\n # If whitespace is not preserved, and this string contains\n # nothing but ASCII spaces, replace it with a single space\n # or newline.\n if not self.preserve_whitespace_tag_stack:\n strippable = True\n for i in current_data:\n if i not in self.ASCII_SPACES:\n strippable = False\n break\n if strippable:\n if '\\n' in current_data:\n current_data = '\\n'\n else:\n current_data = ' '\n\n # Reset the data collector.\n self.current_data = []\n\n # Should we add this string to the tree at all?\n if self.parse_only and len(self.tagStack) <= 1 and \\\n (not self.parse_only.text or \\\n not self.parse_only.search(current_data)):\n return\n\n o = containerClass(current_data)\n self.object_was_parsed(o)\n\n def object_was_parsed(self, o, parent=None, most_recent_element=None):\n \"\"\"Add an object to the parse tree.\"\"\"\n parent = parent or self.currentTag\n previous_element = most_recent_element or self._most_recent_element\n\n next_element = previous_sibling = next_sibling = None\n if isinstance(o, Tag):\n next_element = o.next_element\n next_sibling = o.next_sibling\n previous_sibling = o.previous_sibling\n if not previous_element:\n previous_element = o.previous_element\n\n o.setup(parent, previous_element, next_element, previous_sibling, next_sibling)\n\n self._most_recent_element = o\n parent.contents.append(o)\n\n if parent.next_sibling:\n # This node is being inserted into an element that has\n # already been parsed. Deal with any dangling references.\n index = len(parent.contents)-1\n while index >= 0:\n if parent.contents[index] is o:\n break\n index -= 1\n else:\n raise ValueError(\n \"Error building tree: supposedly %r was inserted \"\n \"into %r after the fact, but I don't see it!\" % (\n o, parent\n )\n )\n if index == 0:\n previous_element = parent\n previous_sibling = None\n else:\n previous_element = previous_sibling = parent.contents[index-1]\n if index == len(parent.contents)-1:\n next_element = parent.next_sibling\n next_sibling = None\n else:\n next_element = next_sibling = parent.contents[index+1]\n\n o.previous_element = previous_element\n if previous_element:\n previous_element.next_element = o\n o.next_element = next_element\n if next_element:\n next_element.previous_element = o\n o.next_sibling = next_sibling\n if next_sibling:\n next_sibling.previous_sibling = o\n o.previous_sibling = previous_sibling\n if previous_sibling:\n previous_sibling.next_sibling = o\n\n def _popToTag(self, name, nsprefix=None, inclusivePop=True):\n \"\"\"Pops the tag stack up to and including the most recent\n instance of the given tag. If inclusivePop is false, pops the tag\n stack up to but *not* including the most recent instqance of\n the given tag.\"\"\"\n #print \"Popping to %s\" % name\n if name == self.ROOT_TAG_NAME:\n # The BeautifulSoup object itself can never be popped.\n return\n\n most_recently_popped = None\n\n stack_size = len(self.tagStack)\n for i in range(stack_size - 1, 0, -1):\n t = self.tagStack[i]\n if (name == t.name and nsprefix == t.prefix):\n if inclusivePop:\n most_recently_popped = self.popTag()\n break\n most_recently_popped = self.popTag()\n\n return most_recently_popped\n\n def handle_starttag(self, name, namespace, nsprefix, attrs):\n \"\"\"Push a start tag on to the stack.\n\n If this method returns None, the tag was rejected by the\n SoupStrainer. You should proceed as if the tag had not occurred\n in the document. For instance, if this was a self-closing tag,\n don't call handle_endtag.\n \"\"\"\n\n # print \"Start tag %s: %s\" % (name, attrs)\n self.endData()\n\n if (self.parse_only and len(self.tagStack) <= 1\n and (self.parse_only.text\n or not self.parse_only.search_tag(name, attrs))):\n return None\n\n tag = Tag(self, self.builder, name, namespace, nsprefix, attrs,\n self.currentTag, self._most_recent_element)\n if tag is None:\n return tag\n if self._most_recent_element:\n self._most_recent_element.next_element = tag\n self._most_recent_element = tag\n self.pushTag(tag)\n return tag\n\n def handle_endtag(self, name, nsprefix=None):\n #print \"End tag: \" + name\n self.endData()\n self._popToTag(name, nsprefix)\n\n def handle_data(self, data):\n self.current_data.append(data)\n\n def decode(self, pretty_print=False,\n eventual_encoding=DEFAULT_OUTPUT_ENCODING,\n formatter=\"minimal\"):\n \"\"\"Returns a string or Unicode representation of this document.\n To get Unicode, pass None for encoding.\"\"\"\n\n if self.is_xml:\n # Print the XML declaration\n encoding_part = ''\n if eventual_encoding != None:\n encoding_part = ' encoding=\"%s\"' % eventual_encoding\n prefix = u'\\n' % encoding_part\n else:\n prefix = u''\n if not pretty_print:\n indent_level = None\n else:\n indent_level = 0\n return prefix + super(BeautifulSoup, self).decode(\n indent_level, eventual_encoding, formatter)\n\n# Alias to make it easier to type import: 'from bs4 import _soup'\n_s = BeautifulSoup\n_soup = BeautifulSoup\n\nclass BeautifulStoneSoup(BeautifulSoup):\n \"\"\"Deprecated interface to an XML parser.\"\"\"\n\n def __init__(self, *args, **kwargs):\n kwargs['features'] = 'xml'\n warnings.warn(\n 'The BeautifulStoneSoup class is deprecated. Instead of using '\n 'it, pass features=\"xml\" into the BeautifulSoup constructor.')\n super(BeautifulStoneSoup, self).__init__(*args, **kwargs)\n\n\nclass StopParsing(Exception):\n pass\n\nclass FeatureNotFound(ValueError):\n pass\n\n\n#By default, act as an HTML pretty-printer.\nif __name__ == '__main__':\n import sys\n soup = BeautifulSoup(sys.stdin)\n print soup.prettify()\n"
},
{
"path": "example/parallax_svg_tools/bs4/builder/__init__.py",
"content": "# Use of this source code is governed by a BSD-style license that can be\n# found in the LICENSE file.\n\nfrom collections import defaultdict\nimport itertools\nimport sys\nfrom bs4.element import (\n CharsetMetaAttributeValue,\n ContentMetaAttributeValue,\n HTMLAwareEntitySubstitution,\n whitespace_re\n )\n\n__all__ = [\n 'HTMLTreeBuilder',\n 'SAXTreeBuilder',\n 'TreeBuilder',\n 'TreeBuilderRegistry',\n ]\n\n# Some useful features for a TreeBuilder to have.\nFAST = 'fast'\nPERMISSIVE = 'permissive'\nSTRICT = 'strict'\nXML = 'xml'\nHTML = 'html'\nHTML_5 = 'html5'\n\n\nclass TreeBuilderRegistry(object):\n\n def __init__(self):\n self.builders_for_feature = defaultdict(list)\n self.builders = []\n\n def register(self, treebuilder_class):\n \"\"\"Register a treebuilder based on its advertised features.\"\"\"\n for feature in treebuilder_class.features:\n self.builders_for_feature[feature].insert(0, treebuilder_class)\n self.builders.insert(0, treebuilder_class)\n\n def lookup(self, *features):\n if len(self.builders) == 0:\n # There are no builders at all.\n return None\n\n if len(features) == 0:\n # They didn't ask for any features. Give them the most\n # recently registered builder.\n return self.builders[0]\n\n # Go down the list of features in order, and eliminate any builders\n # that don't match every feature.\n features = list(features)\n features.reverse()\n candidates = None\n candidate_set = None\n while len(features) > 0:\n feature = features.pop()\n we_have_the_feature = self.builders_for_feature.get(feature, [])\n if len(we_have_the_feature) > 0:\n if candidates is None:\n candidates = we_have_the_feature\n candidate_set = set(candidates)\n else:\n # Eliminate any candidates that don't have this feature.\n candidate_set = candidate_set.intersection(\n set(we_have_the_feature))\n\n # The only valid candidates are the ones in candidate_set.\n # Go through the original list of candidates and pick the first one\n # that's in candidate_set.\n if candidate_set is None:\n return None\n for candidate in candidates:\n if candidate in candidate_set:\n return candidate\n return None\n\n# The BeautifulSoup class will take feature lists from developers and use them\n# to look up builders in this registry.\nbuilder_registry = TreeBuilderRegistry()\n\nclass TreeBuilder(object):\n \"\"\"Turn a document into a Beautiful Soup object tree.\"\"\"\n\n NAME = \"[Unknown tree builder]\"\n ALTERNATE_NAMES = []\n features = []\n\n is_xml = False\n picklable = False\n preserve_whitespace_tags = set()\n empty_element_tags = None # A tag will be considered an empty-element\n # tag when and only when it has no contents.\n\n # A value for these tag/attribute combinations is a space- or\n # comma-separated list of CDATA, rather than a single CDATA.\n cdata_list_attributes = {}\n\n\n def __init__(self):\n self.soup = None\n\n def reset(self):\n pass\n\n def can_be_empty_element(self, tag_name):\n \"\"\"Might a tag with this name be an empty-element tag?\n\n The final markup may or may not actually present this tag as\n self-closing.\n\n For instance: an HTMLBuilder does not consider a
tag to be\n an empty-element tag (it's not in\n HTMLBuilder.empty_element_tags). This means an empty