'''

Copyright (c) 2015, 2016, 2017, 2018, 2019 Tim Savannah under LGPLv3. All Rights Reserved.

See LICENSE (https://gnu.org/licenses/lgpl-3.0.txt) for more information.

Parser Implementation

'''

# In general below, all "tag names" (body, div, etc) should be lowercase. The parser will lowercase internally. All attribute names (like `id` in id="123") provided to search functions should be lowercase. Values are not lowercase. This is because doing tons of searches, lowercasing every search can quickly build up. Lowercase it once in your code, not every time you call a function.

import re

#import sys

import uuid

# Python 2/3 compatibility:

try:

from HTMLParser import HTMLParser

pyver = 2

except ImportError:

from html.parser import HTMLParser

pyver = 3

try:

file

except NameError:

from io import TextIOWrapper as file

from collections import defaultdict

from .constants import IMPLICIT_SELF_CLOSING_TAGS, INVISIBLE_ROOT_TAG, INVISIBLE_ROOT_TAG_START, INVISIBLE_ROOT_TAG_END

from .exceptions import MultipleRootNodeException

from .Tags import AdvancedTag, TagCollection, canFilterTags, FilterableTagCollection

import codecs

from .utils import stripIEConditionals, addStartTag

__all__ = ('AdvancedHTMLParser', 'IndexedAdvancedHTMLParser')

def isInvisibleRootTag(tag):

'''

isInvisibleRootTag - Check if #tag is a the special root tag when there are multiple root elements.

@param tag <AdvancedTag> - A tag

@return <bool> - True if tag is the "fake" root tag used when multiple elements are at root level, otherwise False.

'''

return bool(tag.tagName == INVISIBLE_ROOT_TAG)

class AdvancedHTMLParser(HTMLParser):

'''

AdvancedHTMLParser - This class parses and allows searching of documents

'''

def __init__(self, filename=None, encoding='utf-8'):

'''

__init__ - Creates an Advanced HTML parser object. For read-only parsing, consider IndexedAdvancedHTMLParser for faster searching.

@param filename <str> - Optional filename to parse. Otherwise use parseFile or parseStr methods.

@param encoding <str> - Specifies the document encoding. Default utf-8

'''

HTMLParser.__init__(self)

# Do not automatically convert charrefs in python3

self.convert_charrefs = False

# Encoding to use for this document

self.encoding = encoding

self._inTag = []

self.root = None

self.doctype = None

self.reset = self._reset # Must assign after first call, otherwise members won't yet be present

if filename is not None:

self.parseFile(filename)

###########################################

##### INTERNAL #######

###########################################

def __getstate__(self):

'''

__getstate__ - Get state for pickling

@return <dict>

'''

state = self.__dict__

# Python2 compat

del state['reset']

return state

def __setstate__(self, state):

'''

__setstate - Restore state for loading pickle

@param state <dict> - The state

'''

for key, value in state.items():

setattr(self, key, value)

# Python2 compat

self.reset = self._reset

def _hasTagInParentLine(self, tag, root):

if tag == root or tag.parentNode == root:

return True

if tag.parentNode is None:

return False

return self._hasTagInParentLine(tag.parentNode, root)

def _handleRootArg(self, root):

# Check if tag is string of root and apply to real root.

# If real root is unparsed: raise an error.

# Otherwise: return passed arg.

# Return is tuple (root, isRoot)

if root == 'root' or root == self.root:

return (self.root, True)

return (root, False)

######## Parsing #########

def handle_starttag(self, tagName, attributeList, isSelfClosing=False):

'''

Internal for parsing

'''

tagName = tagName.lower()

inTag = self._inTag

if isSelfClosing is False and tagName in IMPLICIT_SELF_CLOSING_TAGS:

isSelfClosing = True

newTag = AdvancedTag(tagName, attributeList, isSelfClosing, ownerDocument=self)

if self.root is None:

self.root = newTag

elif len(inTag) > 0:

inTag[-1].appendChild(newTag)

else:

raise MultipleRootNodeException()

if isSelfClosing is False:

inTag.append(newTag)

return newTag

def handle_startendtag(self, tagName, attributeList):

'''

Internal for parsing

'''

return self.handle_starttag(tagName, attributeList, True)

def handle_endtag(self, tagName):

'''

Internal for parsing

'''

try:

foundIt = False

inTag = self._inTag

for i in range(len(inTag)):

if inTag[i].tagName == tagName:

foundIt = True

break

if not foundIt:

return

# Handle closing tags which should have been closed but weren't

while inTag[-1].tagName != tagName:

inTag.pop()

inTag.pop()

except:

pass

def handle_data(self, data):

'''

Internal for parsing

'''

if data:

inTag = self._inTag

if len(inTag) > 0:

inTag[-1].appendText(data)

elif data.strip(): #and not self.getRoot():

# Must be text prior to or after root node

raise MultipleRootNodeException()

def handle_entityref(self, entity):

'''

Internal for parsing

'''

inTag = self._inTag

if len(inTag) > 0:

inTag[-1].appendText('&%s;' %(entity,))

else:

raise MultipleRootNodeException()

def handle_charref(self, charRef):

'''

Internal for parsing

'''

inTag = self._inTag

if len(inTag) > 0:

inTag[-1].appendText('&#%s;' %(charRef,))

else:

raise MultipleRootNodeException()

def handle_comment(self, comment):

'''

Internal for parsing

'''

inTag = self._inTag

if len(inTag) > 0:

inTag[-1].appendText('<!-- %s -->' %(comment,))

else:

raise MultipleRootNodeException()

def handle_decl(self, decl):

'''

Internal for parsing

'''

self.doctype = decl

def unknown_decl(self, decl):

'''

Internal for parsing

'''

if not self.doctype:

self.doctype = decl

###########################################

##### Public #######

###########################################

def getRoot(self):

'''

getRoot - returns the root Tag.

NOTE: if there are multiple roots, this will be a special tag.

You may want to consider using getRootNodes instead if this

is a possible situation for you.

@return AdvancedTag

'''

return self.root

def getRootNodes(self):

'''

getRootNodes - Gets all objects at the "root" (first level; no parent). Use this if you may have multiple roots (not children of <html>)

Use this method to get objects, for example, in an AJAX request where <html> may not be your root.

Note: If there are multiple root nodes (i.e. no <html> at the top), getRoot will return a special tag. This function automatically

handles that, and returns all root nodes.

@return list<AdvancedTag> - A list of AdvancedTags which are at the root level of the tree.

'''

root = self.root

if not root:

return []

if root.tagName == INVISIBLE_ROOT_TAG:

return list(root.children)

return [root]

def getAllNodes(self):

'''

getAllNodes - Get every element

@return TagCollection<AdvancedTag>

'''

ret = TagCollection()

for rootNode in self.getRootNodes():

ret.append(rootNode)

ret += rootNode.getAllChildNodes()

return ret

def setRoot(self, root):

'''

Sets the root node, and reprocesses the indexes

'''

self.root = root

def setDoctype(self, newDoctype):

'''

setDoctype - Set the doctype for this document, or clear it.

@param newDoctype <str/None> -

If None, will clear the doctype and not return one with #getHTML

Otherwise, a string of the full doctype tag.

For example, the HTML5 doctype would be "DOCTYPE html"

'''

self.doctype = newDoctype

def getElementsByTagName(self, tagName, root='root'):

'''

getElementsByTagName - Searches and returns all elements with a specific tag name.

@param tagName <lowercase str> - A lowercase string of the tag name.

@param root <AdvancedTag/'root'> - Search starting at a specific node, if provided. if string 'root', the root of the parsed tree will be used.

'''

(root, isFromRoot) = self._handleRootArg(root)

elements = []

if isFromRoot is True and root.tagName == tagName:

elements.append(root)

getElementsByTagName = self.getElementsByTagName

for child in root.children:

if child.tagName == tagName:

elements.append(child)

elements += getElementsByTagName(tagName, child)

return TagCollection(elements)

def getElementsByName(self, name, root='root'):

'''

getElementsByName - Searches and returns all elements with a specific name.

@param name <str> - A string of the name attribute

@param root <AdvancedTag/'root'> - Search starting at a specific node, if provided. if string 'root' [default], the root of the parsed tree will be used.

'''

(root, isFromRoot) = self._handleRootArg(root)

elements = []

if isFromRoot is True and root.name == name:

elements.append(root)

getElementsByName = self.getElementsByName

for child in root.children:

if child.getAttribute('name') == name:

elements.append(child)

elements += getElementsByName(name, child)

return TagCollection(elements)

def getElementById(self, _id, root='root'):

'''

getElementById - Searches and returns the first (should only be one) element with the given ID.

@param id <str> - A string of the id attribute.

@param root <AdvancedTag/'root'> - Search starting at a specific node, if provided. if string 'root' [default], the root of the parsed tree will be used.

'''

(root, isFromRoot) = self._handleRootArg(root)

if isFromRoot is True and root.id == _id:

return root

getElementById = self.getElementById

for child in root.children:

if child.getAttribute('id') == _id:

return child

potential = getElementById(_id, child)

if potential is not None:

return potential

return None

def getElementsByClassName(self, className, root='root'):

'''

getElementsByClassName - Searches and returns all elements containing a given class name.

@param className <str> - One or more space-separated class names

@param root <AdvancedTag/'root'> - Search starting at a specific node, if provided. if string 'root' [default], the root of the parsed tree will be used.

'''

(root, isFromRoot) = self._handleRootArg(root)

elements = []

# Generate list of all classnames to match

classNames = [x.strip() for x in className.strip().split(' ') if x.strip()]

# Run through entire tree on the first

className = classNames.pop(0)

if isFromRoot is True and className in root.classNames:

elements.append(root)

getElementsByClassName = self.getElementsByClassName

for child in root.children:

if className in child.classNames:

elements.append(child)

elements += getElementsByClassName(className, child)

# Check if we need to match against any other names

if len(classNames) > 0:

elements = [ em for em in elements for matchClassName in classNames if matchClassName in em.classList ]

return TagCollection(elements)

def getElementsByAttr(self, attrName, attrValue, root='root'):

'''

getElementsByAttr - Searches the full tree for elements with a given attribute name and value combination. This is always a full scan.

@param attrName <lowercase str> - A lowercase attribute name

@param attrValue <str> - Expected value of attribute

@param root <AdvancedTag/'root'> - Search starting at a specific node, if provided. if string 'root', the root of the parsed tree will be used.

'''

(root, isFromRoot) = self._handleRootArg(root)

elements = []

if isFromRoot is True and root.getAttribute(attrName) == attrValue:

elements.append(root)

getElementsByAttr = self.getElementsByAttr

for child in root.children:

if child.getAttribute(attrName) == attrValue:

elements.append(child)

elements += getElementsByAttr(attrName, attrValue, child)

return TagCollection(elements)

def getElementsWithAttrValues(self, attrName, attrValues, root='root'):

'''

getElementsWithAttrValues - Returns elements with an attribute, named by #attrName contains one of the values in the list, #values

@param attrName <lowercase str> - A lowercase attribute name

@param attrValues set<str> - A set of all valid values.

@return - TagCollection of all matching elements

'''

(root, isFromRoot) = self._handleRootArg(root)

if type(attrValues) != set:

attrValues = set(attrValues)

return root.getElementsWithAttrValues(attrName, attrValues)

def getElementsCustomFilter(self, filterFunc, root='root'):

'''

getElementsCustomFilter - Scan elements using a provided function

@param filterFunc <function>(node) - A function that takes an AdvancedTag as an argument, and returns True if some arbitrary criteria is met

@return - TagCollection of all matching elements

'''

(root, isFromRoot) = self._handleRootArg(root)

elements = []

if isFromRoot is True and filterFunc(root) is True:

elements.append(root)

getElementsCustomFilter = self.getElementsCustomFilter

for child in root.children:

if filterFunc(child) is True:

elements.append(child)

elements += getElementsCustomFilter(filterFunc, child)

return TagCollection(elements)

def getElementsByXPathExpression(self, xpathExprStr):

'''

getElementsByXPathExpression - Evaluate an XPath expression string against this document

@param xpathExprStr <str> - An XPath expression string (e.x. """//div[@name="someName"]/span[3]""" )

@return <TagCollection> - TagCollection of all matching elements

@see AdvancedHTMLParser.xpath.XPathExpression.evaluate for @throws and similar

'''

rootNodes = self.getRootNodes()

# Late-binding import

from . import xpath as axpath

# May raise a parsing error, if invalid xpath expression string

xpathExpression = axpath.XPathExpression(xpathExprStr)

# TODO: From multiple root nodes??

return xpathExpression.evaluate(rootNodes)

getElementsByXPath = getElementsByXPathExpression

def getFirstElementCustomFilter(self, filterFunc, root='root'):

'''

getFirstElementCustomFilter - Scan elements using a provided function, stop and return the first match.

@see getElementsCustomFilter to match multiple elements

@param filterFunc <function>(node) - A function that takes an AdvancedTag as an argument, and returns True if some arbitrary criteria is met

@return - An AdvancedTag of the node that matched, or None if no match.

'''

(root, isFromRoot) = self._handleRootArg(root)

#elements = []

if isFromRoot is True and filterFunc(root) is True:

return root

getFirstElementCustomFilter = self.getFirstElementCustomFilter

for child in root.children:

if filterFunc(child) is True:

return child

subRet = getFirstElementCustomFilter(filterFunc, child)

if subRet:

return subRet

return None

def evaluate(self, xpathExprStr, whichDoc=None):

'''

evaluate - Evaluate an xpath expression against this document

@param xpathExprStr <str> - An XPath expression string (e.x. """//div[@name="someName"]/span[3]""" )

@param whichDoc <None/Parser.AdvancedHTMLParser> Default None - Which document.

NOTE: This is for compatibility with the JS DOM interface.

This must be None (Default) to refer to the current document, or "self" to refer to the same.

May allow other values in the future.

@return <TagCollection> - TagCollection of all matching elements

NOTE: JS DOM returns an iterable object for this function's return. May in the future match that interface.

For now the XPath engine does not run off a generator, so this will likely at first be a wrapper for interface compatibility sake

@see AdvancedHTMLParser.xpath.XPathExpression.evaluate for @throws and similar

'''

# Just validate for interface sake right now

if whichDoc is not None and whichDoc is not self:

raise ValueError('Parser.AdvancedHTMLParser.evaluate must be called with None/default as second argument, or self.')

# Break from interface and just return the straight tag collection

return self.getElementsByXPathExpression(xpathExprStr)

@property

def body(self):

'''

body - Get the body element

@return <AdvancedTag> - The body tag, or None if no body tag present

'''

return self.getFirstElementCustomFilter(lambda em : em.tagName == 'body')

@property

def head(self):

'''

head - Get the head element

@return <AdvancedTag> - The head tag, or None if no head tag present

'''

return self.getFirstElementCustomFilter(lambda em : em.tagName == 'head')

@property

def forms(self):

'''

forms - Return all forms associated with this document

@return <TagCollection> - All "form" elements

'''

return self.getElementsByTagName('form')

def contains(self, em):

'''

Checks if #em is found anywhere within this element tree

@param em <AdvancedTag> - Tag of interest

@return <bool> - If element #em is within this tree

'''

for rootNode in self.getRootNodes():

if rootNode.contains(em):

return True

return False

__contains__ = contains

def containsUid(self, uid):

'''

Check if #uid is found anywhere within this element tree

@param uid <uuid.UUID> - Uid

@return <bool> - If #uid is found within this tree

'''

for rootNode in self.getRootNodes():

if rootNode.containsUid(uid):

return True

return False

def __contains__(self, other):

if isinstance(other, uuid.UUID):

return self.containsUid(other)

elif issubclass(other.__class__, AdvancedTag):

return self.contains(other)

else:

raise TypeError('Invalid operand, should be either a uuid.UUID object or an AdvancedTag')

def filter(self, **kwargs):

'''

filter aka filterAnd - Filter ALL the elements in this DOM.

Results must match ALL the filter criteria. for ANY, use the *Or methods

Requires the QueryableList module to be installed (i.e. AdvancedHTMLParser was installed

without '--no-deps' flag.)

For alternative without QueryableList,

consider #AdvancedHTMLParser.AdvancedHTMLParser.find method or the getElement* methods

Special Keys:

tagname - The tag name

text - The inner text

@return TagCollection<AdvancedTag>

'''

if canFilterTags is False:

raise NotImplementedError('filter methods requires QueryableList installed, it is not. Either install QueryableList, or try the less-robust "find" method, or the getElement* methods.')

allNodes = self.getAllNodes()

filterableNodes = FilterableTagCollection(allNodes)

return filterableNodes.filterAnd(**kwargs)

filterAnd = filter

def filterOr(self, **kwargs):

'''

filterOr - Perform a filter operation on this node and all children (and their children, onto the end)

Results must match ANY the filter criteria. for ALL, use the *AND methods

For special filter keys, @see #AdvancedHTMLParser.AdvancedHTMLParser.filter

Requires the QueryableList module to be installed (i.e. AdvancedHTMLParser was installed

without '--no-deps' flag.)

For alternative, consider AdvancedHTMLParser.AdvancedHTMLParser.find method or the getElement* methods

@return TagCollection<AdvancedTag>

'''

if canFilterTags is False:

raise NotImplementedError('filter methods requires QueryableList installed, it is not. Either install QueryableList, or try the less-robust "find" method, or the getElement* methods.')

allNodes = self.getAllNodes() + [self]

filterableNodes = FilterableTagCollection(allNodes)

return filterableNodes.filterOr(**kwargs)

def find(self, **kwargs):

'''

find - Perform a search of elements using attributes as keys and potential values as values

(i.e. parser.find(name='blah', tagname='span') will return all elements in this document

with the name "blah" of the tag type "span" )

Arguments are key = value, or key can equal a tuple/list of values to match ANY of those values.

Append a key with __contains to test if some strs (or several possible strs) are within an element

Append a key with __icontains to perform the same __contains op, but ignoring case

Special keys:

tagname - The tag name of the element

text - The text within an element

NOTE: Empty string means both "not set" and "no value" in this implementation.

NOTE: If you installed the QueryableList module (i.e. ran setup.py without --no-deps) it is

better to use the "filter"/"filterAnd" or "filterOr" methods, which are also available

on all tags and tag collections (tag collections also have filterAllAnd and filterAllOr)

@return TagCollection<AdvancedTag> - A list of tags that matched the filter criteria

'''

if not kwargs:

return TagCollection()

# Because of how closures work in python, need a function to generate these lambdas

# because the closure basically references "current key in iteration" and not

# "actual instance" of variable. Seems to me to be a bug... but whatever

def _makeTagnameLambda(tagName):

return lambda em : em.tagName == tagName

def _makeAttributeLambda(_key, _value):

return lambda em : em.getAttribute(_key, '') == _value

def _makeTagnameInLambda(tagNames):

return lambda em : em.tagName in tagNames

def _makeAttributeInLambda(_key, _values):

return lambda em : em.getAttribute(_key, '') in _values

def _makeTextLambda(_value):

return lambda em : em.text == _value

def _makeTextInLambda(_values):

return lambda em : em.text in _values

def _makeAttributeContainsLambda(_key, _value, icontains=False):

if icontains is False:

return lambda em : _value in em.getAttribute(_key, '')

else:

_value = _value.lower()

return lambda em : _value in em.getAttribute(_key, '').lower()

def _makeTextContainsLambda(_value, icontains=False):

if icontains is False:

return lambda em : _value in em.text

else:

_value = _value.lower()

return lambda em : _value in em.text.lower()

def _makeAttributeContainsInLambda(_key, _values, icontains=False):

if icontains:

_values = tuple([x.lower() for x in _values])

def _testFunc(em):

attrValue = em.getAttribute(_key, '')

if icontains:

attrValue = attrValue.lower()

for value in _values:

if value in attrValue:

return True

return False

return _testFunc

def _makeTextContainsInLambda(_values, icontains=False):

if icontains:

_values = tuple([x.lower() for x in _values])

def _testFunc(em):

text = em.text

if icontains:

text = text.lower()

for value in _values:

if value in text:

return True

return False

return _testFunc

# This will hold all the functions we will chain for matching

matchFunctions = []

# Iterate over all the filter portions, and build a filter.

for key, value in kwargs.items():

key = key.lower()

endsIContains = key.endswith('__icontains')

endsContains = key.endswith('__contains')

isValueList = isinstance(value, (list, tuple))

thisFunc = None

if endsIContains or endsContains:

key = re.sub('__[i]{0,1}contains$', '', key)

if key == 'tagname':

raise ValueError('tagname is not supported for contains')

if isValueList:

if key == 'text':

thisFunc = _makeTextContainsInLambda(value, icontains=endsIContains)

else:

thisFunc = _makeAttributeContainsLambda(key, value, icontains=endsIContains)

else:

if key == 'text':

thisFunc = _makeTextContainsLambda(value, icontains=endsIContains)

else:

thisFunc = _makeAttributeContainsLambda(key, value, icontains=endsIContains)

else:

# Not contains, straight up

if isValueList:

if key == 'tagname':

thisFunc = _makeTagnameInLambda(value)

elif key == 'text':

thisFunc = _makeTextInLambda(value)

else:

thisFunc = _makeAttributeInLambda(key, value)

else:

if key == 'tagname':

thisFunc = _makeTagnameLambda(value)

elif key == 'text':

thisFunc = _makeTextLambda(value)

else:

thisFunc = _makeAttributeLambda(key, value)

matchFunctions.append( thisFunc )

# The actual matching function - This will run through the assembled

# #matchFunctions list, testing the element against each match

# and returning all elements in a TagCollection that match this list.

def doMatchFunc(em):

for matchFunction in matchFunctions:

if matchFunction(em) is False:

return False

return True

return self.getElementsCustomFilter(doMatchFunc)

def getHTML(self):

'''

getHTML - Get the full HTML as contained within this tree.

If parsed from a document, this will contain the original whitespacing.

@returns - <str> of html

@see getFormattedHTML

@see getMiniHTML

'''

root = self.getRoot()

if root is None:

raise ValueError('Did not parse anything. Use parseFile or parseStr')

if self.doctype:

doctypeStr = '<!%s>\n' %(self.doctype)

else:

doctypeStr = ''

# 6.6.0: If we have a real root tag, print the outerHTML. If we have a fake root tag (for multiple root condition),

# then print the innerHTML (skipping the outer root tag). Otherwise, we will miss

# untagged text (between the multiple root nodes).

rootNode = self.getRoot()

if rootNode.tagName == INVISIBLE_ROOT_TAG:

return doctypeStr + rootNode.innerHTML

else:

return doctypeStr + rootNode.outerHTML

# return doctypeStr + ''.join([elem.outerHTML for elem in self.getRootNodes()])

# toHTML - Alias of getHTML

toHTML = getHTML

# asHTML - Alias of getHTML

asHTML = getHTML

def getFormattedHTML(self, indent=' '):

'''

getFormattedHTML - Get formatted and xhtml of this document, replacing the original whitespace

with a pretty-printed version

@param indent - space/tab/newline of each level of indent, or integer for how many spaces per level

@return - <str> Formatted html

@see getHTML - Get HTML with original whitespace

@see getMiniHTML - Get HTML with only functional whitespace remaining

'''

from .Formatter import AdvancedHTMLFormatter

html = self.getHTML()

formatter = AdvancedHTMLFormatter(indent, None) # Do not double-encode

formatter.feed(html)

return formatter.getHTML()

def getMiniHTML(self):

'''

getMiniHTML - Gets the HTML representation of this document without any pretty formatting

and disregarding original whitespace beyond the functional.

@return <str> - HTML with only functional whitespace present

'''

from .Formatter import AdvancedHTMLMiniFormatter

html = self.getHTML()

formatter = AdvancedHTMLMiniFormatter(None) # Do not double-encode

formatter.feed(html)

return formatter.getHTML()

def _reset(self):

'''

_reset - reset this object. Assigned to .reset after __init__ call.

'''

HTMLParser.reset(self)

self.root = None

self.doctype = None

self._inTag = []

def feed(self, contents):

'''

feed - Feed contents. Use parseStr or parseFile instead.

@param contents - Contents

'''

contents = stripIEConditionals(contents)

try:

HTMLParser.feed(self, contents)

except MultipleRootNodeException:

self.reset()

HTMLParser.feed(self, "%s%s" %(addStartTag(contents, INVISIBLE_ROOT_TAG_START), INVISIBLE_ROOT_TAG_END))

def parseFile(self, filename):

'''

parseFile - Parses a file and creates the DOM tree and indexes

@param filename <str/file> - A string to a filename or a file object. If file object, it will not be closed, you must close.

'''

self.reset()

if isinstance(filename, file):

contents = filename.read()

else:

with codecs.open(filename, 'r', encoding=self.encoding) as f:

contents = f.read()

self.feed(contents)

def parseStr(self, html):

'''

parseStr - Parses a string and creates the DOM tree and indexes.

@param html <str> - valid HTML

'''

self.reset()

if isinstance(html, bytes):

self.feed(html.decode(self.encoding))

else:

self.feed(html)

def createElement(self, tagName):

'''

createElement - Create an unattached tag with the given tag name

@param tagName <str> - Name of tag

@return <AdvancedTag> - A tag with the given tag name

'''

return AdvancedTag(tagName=tagName.lower())

@classmethod

def createElementFromHTML(cls, html, encoding='utf-8'):

'''

createElementFromHTML - Creates an element from a string of HTML.

If this could create multiple root-level elements (children are okay),

you must use #createElementsFromHTML which returns a list of elements created.