"""Beautiful Soup Elixir and Tonic "The Screen-Scraper's Friend" http://www.crummy.com/software/BeautifulSoup/
Beautiful Soup parses a (possibly invalid) XML or HTML document into a tree representation. It provides methods and Pythonic idioms that make it easy to navigate, search, and modify the tree.
A well-formed XML/HTML document yields a well-formed data structure. An ill-formed XML/HTML document yields a correspondingly ill-formed data structure. If your document is only locally well-formed, you can use this library to find and process the well-formed part of it.
Beautiful Soup works with Python 2.2 and up. It has no external dependencies, but you'll have more success at converting data to UTF-8 if you also install these three packages:
* chardet, for auto-detecting character encodings
* cjkcodecs and iconv_codec, which add more encodings to the ones supported
- by stock Python.
Beautiful Soup defines classes for two main parsing strategies:
BeautifulStoneSoup, for parsing XML, SGML, or your domain-specific
- language that kind of looks like XML.
BeautifulSoup, for parsing run-of-the-mill HTML code, be it valid
- or invalid. This class has web browser-like heuristics for obtaining a sensible parse tree in the face of common HTML errors.
Beautiful Soup also defines a class (UnicodeDammit) for autodetecting the encoding of an HTML or XML document, and converting it to Unicode. Much of this code is taken from Mark Pilgrim's Universal Feed Parser.
For more than you ever wanted to know about Beautiful Soup, see the documentation: http://www.crummy.com/software/BeautifulSoup/documentation.html
Here, have some legalese:
Copyright (c) 2004-2008, Leonard Richardson
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above
- copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
- Neither the name of the the Beautiful Soup Consortium and All
- Night Kosher Bakery nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE, DAMMIT.
""" from future import generators
author = "Leonard Richardson (leonardr@segfault.org)" version = "3.0.7a" copyright = "Copyright (c) 2004-2008 Leonard Richardson" license = "New-style BSD"
from sgmllib import SGMLParser, SGMLParseError import codecs import markupbase import types import re import sgmllib try:
- from htmlentitydefs import name2codepoint
except ImportError:
- name2codepoint = {}
try:
- set
except NameError:
- from sets import Set as set
#These hacks make Beautiful Soup able to parse XML with namespaces sgmllib.tagfind = re.compile('[a-zA-Z][-_.:a-zA-Z0-9]*') markupbase._declname_match = re.compile(r'[a-zA-Z][-_.:a-zA-Z0-9]*\s*').match
DEFAULT_OUTPUT_ENCODING = "utf-8"
# First, the classes that represent markup elements.
class PageElement:
- """Contains the navigational information for some part of the page (either a tag or a piece of text)""" def setup(self, parent=None, previous=None):
- """Sets up the initial relations between this element and other elements.""" self.parent = parent self.previous = previous self.next = None self.previousSibling = None self.nextSibling = None if self.parent and self.parent.contents:
- self.previousSibling = self.parent.contents[-1] self.previousSibling.nextSibling = self
- oldParent = self.parent myIndex = self.parent.contents.index(self) if hasattr(replaceWith, 'parent') and replaceWith.parent == self.parent:
- # We're replacing this element with one of its siblings. index = self.parent.contents.index(replaceWith)
if index and index < myIndex:
- # Furthermore, it comes before this element. That # means that when we extract it, the index of this # element will change. myIndex = myIndex - 1
- # We're replacing this element with one of its siblings. index = self.parent.contents.index(replaceWith)
- """Destructively rips this element out of the tree.""" if self.parent:
- try:
- self.parent.contents.remove(self)
except ValueError:
- pass
- self.previous.next = nextElement
- nextElement.previous = self.previous
- self.previousSibling.nextSibling = self.nextSibling
- self.nextSibling.previousSibling = self.previousSibling
- try:
- "Finds the last element beneath this object to be parsed." lastChild = self while hasattr(lastChild, 'contents') and lastChild.contents:
- lastChild = lastChild.contents[-1]
- if (isinstance(newChild, basestring)
- or isinstance(newChild, unicode)) \
and not isinstance(newChild, NavigableString): newChild = NavigableString(newChild)
- # We're 'inserting' an element that's already one # of this object's children. if newChild.parent == self:
- index = self.find(newChild)
if index and index < position:
- # Furthermore we're moving it further down the # list of this object's children. That means that # when we extract this element, our target index # will jump down one. position = position - 1
- index = self.find(newChild)
- newChild.previousSibling = None newChild.previous = self
- previousChild = self.contents[position-1] newChild.previousSibling = previousChild newChild.previousSibling.nextSibling = newChild newChild.previous = previousChild._lastRecursiveChild()
- newChild.previous.next = newChild
if position >= len(self.contents):
- newChild.nextSibling = None parent = self parentsNextSibling = None while not parentsNextSibling:
- parentsNextSibling = parent.nextSibling parent = parent.parent if not parent: # This is the last element in the document.
- break
- newChildsLastElement.next = parentsNextSibling
- newChildsLastElement.next = None
- parentsNextSibling = parent.nextSibling parent = parent.parent if not parent: # This is the last element in the document.
- nextChild = self.contents[position] newChild.nextSibling = nextChild if newChild.nextSibling:
- newChild.nextSibling.previousSibling = newChild
- newChildsLastElement.next.previous = newChildsLastElement
- or isinstance(newChild, unicode)) \
- """Appends the given tag to the contents of this tag.""" self.insert(len(self.contents), tag)
- """Returns the first item that matches the given criteria and appears after this Tag in the document.""" return self._findOne(self.findAllNext, name, attrs, text, **kwargs)
- *kwargs):
- """Returns all items that match the given criteria and appear after this Tag in the document.""" return self._findAll(name, attrs, text, limit, self.nextGenerator,
- *kwargs)
- """Returns the closest sibling to this Tag that matches the given criteria and appears after this Tag in the document.""" return self._findOne(self.findNextSiblings, name, attrs, text,
- *kwargs)
- *kwargs):
- """Returns the siblings of this Tag that match the given criteria and appear after this Tag in the document.""" return self._findAll(name, attrs, text, limit,
- self.nextSiblingGenerator, **kwargs)
- """Returns the first item that matches the given criteria and appears before this Tag in the document.""" return self._findOne(self.findAllPrevious, name, attrs, text, **kwargs)
- *kwargs):
- """Returns all items that match the given criteria and appear before this Tag in the document.""" return self._findAll(name, attrs, text, limit, self.previousGenerator,
- *kwargs)
- """Returns the closest sibling to this Tag that matches the given criteria and appears before this Tag in the document.""" return self._findOne(self.findPreviousSiblings, name, attrs, text,
- *kwargs)
- limit=None, **kwargs):
- """Returns the siblings of this Tag that match the given criteria and appear before this Tag in the document.""" return self._findAll(name, attrs, text, limit,
- self.previousSiblingGenerator, **kwargs)
- """Returns the closest parent of this Tag that matches the given criteria.""" # NOTE: We can't use _findOne because findParents takes a different # set of arguments. r = None l = self.findParents(name, attrs, 1) if l:
- r = l[0]
- """Returns the parents of this Tag that match the given criteria.""" return self._findAll(name, attrs, None, limit, self.parentGenerator,
- *kwargs)
- r = None l = method(name, attrs, text, 1, **kwargs) if l:
- r = l[0]
- "Iterates over a generator looking for things that match."
if isinstance(name, SoupStrainer):
- strainer = name
# Build a SoupStrainer strainer = SoupStrainer(name, attrs, text, **kwargs)
results = ResultSet(strainer) g = generator() while True:
- try:
- i = g.next()
except StopIteration:
- break
- found = strainer.search(i) if found:
- results.append(found)
if limit and len(results) >= limit:
- break
- results.append(found)
#NavigableStrings and Tags. def nextGenerator(self):
- i = self while i:
- i = i.next yield i
- i = self while i:
- i = i.nextSibling yield i
- i = self while i:
- i = i.previous yield i
- i = self while i:
- i = i.previousSibling yield i
- i = self while i:
- i = i.parent yield i
- encoding = encoding or "utf-8" return str.replace("%SOUP-ENCODING%", encoding)
- """Encodes an object to a string in some encoding, or to Unicode.
- """ if isinstance(s, unicode):
- if encoding:
- s = s.encode(encoding)
- if encoding:
- s = s.encode(encoding)
- s = unicode(s)
- if encoding:
- s = self.toEncoding(str(s), encoding)
- s = unicode(s)
- if encoding:
- """Sets up the initial relations between this element and other elements.""" self.parent = parent self.previous = previous self.next = None self.previousSibling = None self.nextSibling = None if self.parent and self.parent.contents:
class NavigableString(unicode, PageElement):
def new(cls, value):
"""Create a new NavigableString.
When unpickling a NavigableString, this method is called with the string in DEFAULT_OUTPUT_ENCODING. That encoding needs to be passed in to the superclass's new or the superclass won't know how to handle non-ASCII characters. """ if isinstance(value, unicode):
return unicode.new(cls, value)
return unicode.new(cls, value, DEFAULT_OUTPUT_ENCODING)
def getnewargs(self):
return (NavigableString.str(self),)
def getattr(self, attr):
- """text.string gives you text. This is for backwards compatibility for Navigable*String, but for CData* it lets you get the string without the CData wrapper.""" if attr == 'string':
- return self
raise AttributeError, "'%s' object has no attribute '%s'" % (self.class.name, attr)
def unicode(self):
- return str(self).decode(DEFAULT_OUTPUT_ENCODING)
def str(self, encoding=DEFAULT_OUTPUT_ENCODING):
- if encoding:
- return self.encode(encoding)
- return self
class CData(NavigableString):
def str(self, encoding=DEFAULT_OUTPUT_ENCODING):
return "<![CDATA[%s]]>" % NavigableString.str(self, encoding)
class ProcessingInstruction(NavigableString):
def str(self, encoding=DEFAULT_OUTPUT_ENCODING):
- output = self if "%SOUP-ENCODING%" in output:
- output = self.substituteEncoding(output, encoding)
return "<?%s?>" % self.toEncoding(output, encoding)
- output = self if "%SOUP-ENCODING%" in output:
class Comment(NavigableString):
def str(self, encoding=DEFAULT_OUTPUT_ENCODING):
return "<!--%s-->" % NavigableString.str(self, encoding)
class Declaration(NavigableString):
def str(self, encoding=DEFAULT_OUTPUT_ENCODING):
return "<!%s>" % NavigableString.str(self, encoding)
class Tag(PageElement):
- """Represents a found HTML tag with its attributes and contents.""" def _invert(h):
- "Cheap function to invert a hash." i = {} for k,v in h.items():
- i[v] = k
- "quot" : '"',
"amp" : "&", "lt" : "<", "gt" : ">" }
- """Used in a call to re.sub to replace HTML, XML, and numeric entities with the appropriate Unicode characters. If HTML entities are being converted, any unrecognized entities are escaped.""" x = match.group(1) if self.convertHTMLEntities and x in name2codepoint:
- return unichr(name2codepoint[x])
- if self.convertXMLEntities:
- return self.XML_ENTITIES_TO_SPECIAL_CHARS[x]
return u'&%s;' % x
elif len(x) > 0 and x[0] == '#':
- # Handle numeric entities
if len(x) > 1 and x[1] == 'x':
- return unichr(int(x[2:], 16))
- return unichr(int(x[1:]))
return u'&%s;' % x
return u'&%s;' % x
def init(self, parser, name, attrs=None, parent=None,
- previous=None):
- "Basic constructor." # We don't actually store the parser object: that lets extracted # chunks be garbage-collected
self.parserClass = parser.class self.isSelfClosing = parser.isSelfClosingTag(name) self.name = name if attrs == None:
- attrs = []
re.sub("&(#\d+|#x[0-9a-fA-F]+|\w+);",
- self._convertEntities, val))
- """Returns the value of the 'key' attribute for the tag, or the value given for 'default' if it doesn't have that attribute.""" return self._getAttrMap().get(key, default)
- return self._getAttrMap().has_key(key)
def getitem(self, key):
- """tag[key] returns the value of the 'key' attribute for the tag, and throws an exception if it's not there.""" return self._getAttrMap()[key]
def iter(self):
- "Iterating over a tag iterates over its contents." return iter(self.contents)
def len(self):
- "The length of a tag is the length of its list of contents." return len(self.contents)
def contains(self, x):
- return x in self.contents
def nonzero(self):
- "A tag is non-None even if it has no contents." return True
def setitem(self, key, value):
- """Setting tag[key] sets the value of the 'key' attribute for the tag.""" self._getAttrMap() self.attrMap[key] = value found = False for i in range(0, len(self.attrs)):
- if self.attrs[i][0] == key:
- self.attrs[i] = (key, value) found = True
- self.attrs.append((key, value))
- if self.attrs[i][0] == key:
def delitem(self, key):
- "Deleting tag[key] deletes all 'key' attributes for the tag." for item in self.attrs:
- if item[0] == key:
- self.attrs.remove(item) #We don't break because bad HTML can define the same #attribute multiple times.
- del self.attrMap[key]
- if item[0] == key:
def call(self, *args, **kwargs):
- """Calling a tag like a function is the same as calling its findAll() method. Eg. tag('a') returns a list of all the A tags found within this tag.""" return apply(self.findAll, args, kwargs)
def getattr(self, tag):
#print "Getattr %s.%s" % (self.class, tag) if len(tag) > 3 and tag.rfind('Tag') == len(tag)-3:
- return self.find(tag[:-3])
elif tag.find('') != 0:
- return self.find(tag)
raise AttributeError, "'%s' object has no attribute '%s'" % (self.
class, tag)
def eq(self, other):
- """Returns true iff this tag has the same name, the same attributes, and the same contents (recursively) as the given tag. NOTE: right now this will return false if two tags have the same attributes in a different order. Should this be fixed?""" if not hasattr(other, 'name') or not hasattr(other, 'attrs') or not hasattr(other, 'contents') or self.name != other.name or self.attrs != other.attrs or len(self) != len(other):
- return False
- if self.contents[i] != other.contents[i]:
- return False
def
ne(self, other):- """Returns true iff this tag is not identical to the other tag,
as defined in
- "Cheap function to invert a hash." i = {} for k,v in h.items():
def repr(self, encoding=DEFAULT_OUTPUT_ENCODING): return self. def return self. BARE_AMPERSAND_OR_BRACKET = re.compile("([<>]|" + "&(?!#\d+;|#x[0-9a-fA-F]+;|\w+;)" + ")") return "&" + self.XML_SPECIAL_CHARS_TO_ENTITIES[x.group(0)[0]] + ";" def val = val.replace("'", "&squot;") close = closeTag = if self.isSelfClosing: closeTag = '</%s>' % encodedName attributeString = if attrs: s.append('<%s%s%s>' % (encodedName, attributeString, close)) if prettyPrint: s = return self. if isinstance(c, NavigableString): text = c. s.append(c. return .join(s) #Soup methods def find(self, name=None, attrs={}, recursive=True, text=None, raise StopIteration if i < len(tag.contents) - 1: raise StopIteration # Next, a couple classes to represent queries and their results. class SoupStrainer: def def if isinstance(element, NavigableString) \ elif isinstance(markup, NavigableString) or \ % markup. if matchAgainst == True and type(matchAgainst) == types.BooleanType: class ResultSet(list): """A ResultSet is just a list that keeps track of the SoupStrainer that created it.""" def list. # Now, some helper functions. def isList(l): return hasattr(l, ' def isString(s): except NameError: def buildTagMap(default, *args): # Now, the parser classes. class BeautifulStoneSoup(Tag, SGMLParser): That is, "<foo><bar></foo>" actually means "<foo><bar></bar></foo>". [Another possible explanation is "<foo><bar /></foo>", but since this class defines no SELF_CLOSING_TAGS, it will never use that explanation.] This class is useful for parsing XML or made-up markup languages, or when BeautifulSoup makes an assumption counter to what you were expecting.""" SELF_CLOSING_TAGS = {} NESTABLE_TAGS = {} RESET_NESTING_TAGS = {} QUOTE_TAGS = {} PRESERVE_WHITESPACE_TAGS = [] MARKUP_MASSAGE = [(re.compile('(<[^<>]*)/>'), lambda x: x.group(1) + ' />'), (re.compile('<!\s+([^<>]*)>'), lambda x: '<!' + x.group(1) + '>') def sgmllib will process most bad HTML, and the BeautifulSoup class has some tricks for dealing with some HTML that kills sgmllib, but Beautiful Soup can nonetheless choke or lose data if your data uses self-closing tags or declarations incorrectly. By default, Beautiful Soup uses regexes to sanitize input, avoiding the vast majority of these problems. If the problems don't apply to you, pass in False for markupMassage, and you'll get better performance. The default parser massage techniques fix the two most common instances of invalid HTML that choke sgmllib: <br/> (No space between name of closing tag and tag close) <! --Comment--> (Extraneous whitespace in declaration) SGMLParser. except StopParsing: except ValueError: if not 0 <= n <= 127 : # ASCII ends at 127, not 255 dammit = UnicodeDammit\ def #print " return SGMLParser. elif methodName.find('
str(encoding)
str(None)
def _sub_entity(self, x):
def decompose(self):
attrs.append(fmt % (self.toEncoding(key, encoding),
# The attribute value either: # # * Contains no embedded double quotes or single quotes. # No problem: we enclose it in double quotes. # * Contains embedded single quotes. No problem: # double quotes work here too. # * Contains embedded double quotes. No problem: # we enclose it in single quotes. # * Embeds both single _and_ double quotes. This # can't happen naturally, but it can happen if # you modify an attribute value after parsing # the document. Now we have a bit of a # problem. We solve it by enclosing the # attribute in single quotes, and escaping any # embedded single quotes to XML entities. if '"' in val:
# Now we're okay w/r/t quotes. But the attribute # value might also contain angle brackets, or # ampersands that aren't part of entities. We need # to escape those to XML entities too. val = self.BARE_AMPERSAND_OR_BRACKET.sub(self._sub_entity, val)
else:
indentTag, indentContents = 0, 0 if prettyPrint:
contents = self.renderContents(encoding, prettyPrint, indentContents) if self.hidden:
else:
return s
if prettyPrint:
s.append(contents) if prettyPrint and contents and contents[-1] != "\n":
if prettyPrint and closeTag:
s.append(closeTag) if prettyPrint and closeTag and self.nextSibling:
def prettify(self, encoding=DEFAULT_OUTPUT_ENCODING):
self.extract()
else:
str(encoding, True) def renderContents(self, encoding=DEFAULT_OUTPUT_ENCODING,
str(encoding) elif isinstance(c, Tag):
str(encoding, prettyPrint, indentLevel)) if text and prettyPrint:
if text:
s.append(text) if prettyPrint:
findChild = find def findAll(self, name=None, attrs={}, recursive=True, text=None,
return r
findChildren = findAll # Pre-3.x compatibility methods first = find fetch = findAll def fetchText(self, text=None, recursive=True, limit=None):
return self._findAll(name, attrs, text, limit, generator, **kwargs)
def firstText(self, text=None, recursive=True):
#Private methods def _getAttrMap(self):
#Generator methods def childGenerator(self):
return self.attrMap
def recursiveChildGenerator(self):
stack.append((a, 0)) break
if kwargs:
self.attrs = attrs self.text = text
else:
def searchTag(self, markupName=None, markupAttrs={}):
else:
def search(self, markup):
callFunctionWithTagData = callable(self.name) \
if (not self.name) \
return found
else:
if match:
attrValue = markupAttrMap.get(attr) if not self._matches(attrValue, matchAgainst):
else:
else:
class return found def _matches(self, markup, matchAgainst):
# If it's a Tag, make sure its name or attributes match. # Don't bother with Tags if we're searching for text. elif isinstance(markup, Tag):
# If it's text, make sure the text matches.
else:
elif callable(matchAgainst):
else:
return result
if markup and not isString(markup):
#Now we know that chunk is either a string, or None. if hasattr(matchAgainst, 'match'):
elif isList(matchAgainst):
elif hasattr(matchAgainst, 'items'):
elif matchAgainst and isString(markup):
if not result:
else:
init(self, source):
init([]) self.source = source
iter') \
return built
elif isList(portion):
else:
init(self, markup="", parseOnlyThese=None, fromEncoding=None,
ROOT_TAG_NAME = u'[document]' HTML_ENTITIES = "html" XML_ENTITIES = "xml" XHTML_ENTITIES = "xhtml" # TODO: This only exists for backwards-compatibility ALL_ENTITIES = XHTML_ENTITIES # Used when determining whether a text node is all whitespace and # can be replaced with a single space. A text node that contains # fancy Unicode spaces (usually non-breaking) should be left # alone. STRIP_ASCII_SPACES = { 9: None, 10: None, 12: None, 13: None, 32: None, }
]
init(self) if hasattr(markup, 'read'): # It's a file-type object.
You can pass in a custom list of (RE object, replace method) tuples to get Beautiful Soup to scrub your input the way you want.""" self.parseOnlyThese = parseOnlyThese self.fromEncoding = fromEncoding self.smartQuotesTo = smartQuotesTo self.convertEntities = convertEntities # Set the rules for how we'll deal with the entities we # encounter if self.convertEntities:
else:
elif convertEntities == self.XHTML_ENTITIES:
elif convertEntities == self.XML_ENTITIES:
self.instanceSelfClosingTags = buildTagMap(None, selfClosingTags)
self.markup = markup self.markupMassage = markupMassage try:
self.markup = None # The markup can now be GCed def convert_charref(self, name):
def _feed(self, inDocumentEncoding=None, isHTML=False):
return self.convert_codepoint(n)
else:
if markup:
markup = dammit.unicode self.originalEncoding = dammit.originalEncoding self.declaredHTMLEncoding = dammit.declaredHTMLEncoding
self.reset() SGMLParser.feed(self, markup) # Close out any unfinished strings and close all the open tags. self.endData() while self.currentTag.name != self.ROOT_TAG_NAME:
for fix, m in self.markupMassage:
# TODO: We get rid of markupMassage so that the # soup object can be deepcopied later on. Some # Python installations can't copy regexes. If anyone # was relying on the existence of markupMassage, this # might cause problems. del(self.markupMassage)
getattr called on %s.%s" % (self.class, methodName) if methodName.find('start_') == 0 or methodName.find('end_') == 0 \
getattr(self, methodName)
return Tag.getattr(self, methodName)
raise AttributeError
- """Returns true iff the given string is the name of a self-closing tag according to this parser.""" return self.SELF_CLOSING_TAGS.has_key(name) \
- or self.instanceSelfClosingTags.has_key(name)
Tag.init(self, self, self.ROOT_TAG_NAME) self.hidden = 1 SGMLParser.reset(self) self.currentData = [] self.currentTag = None self.tagStack = [] self.quoteStack = [] self.pushTag(self)
- tag = self.tagStack.pop() # Tags with just one string-owning child get the child as a # 'string' property, so that soup.tag.string is shorthand for # soup.tag.contents[0] if len(self.currentTag.contents) == 1 and \
isinstance(self.currentTag.contents[0], NavigableString):
- self.currentTag.string = self.currentTag.contents[0]
- self.currentTag = self.tagStack[-1]
- #print "Push", tag.name if self.currentTag:
- self.currentTag.contents.append(tag)
def endData(self, containerClass=NavigableString):
- if self.currentData:
currentData = u.join(self.currentData) if (currentData.translate(self.STRIP_ASCII_SPACES) == and
- not set([tag.name for tag in self.tagStack]).intersection(
- self.PRESERVE_WHITESPACE_TAGS)):
- currentData = '\n'
- currentData = ' '
if self.parseOnlyThese and len(self.tagStack) <= 1 and \
- (not self.parseOnlyThese.text or \
- not self.parseOnlyThese.search(currentData)):
- return
- self.previous.next = o
- not set([tag.name for tag in self.tagStack]).intersection(
- """Pops the tag stack up to and including the most recent instance of the given tag. If inclusivePop is false, pops the tag stack up to but *not* including the most recent instqance of the given tag.""" #print "Popping to %s" % name if name == self.ROOT_TAG_NAME:
- return
- if name == self.tagStack[i].name:
- numPops = len(self.tagStack)-i break
- numPops = numPops - 1
- mostRecentTag = self.popTag()
- """We need to pop up to the previous tag of this type, unless one of this tag's nesting reset triggers comes between this tag and the previous tag of this type, OR unless this tag is a generic nesting trigger and another generic nesting trigger comes between this tag and the previous tag of this type. Examples:
<p>Foo<b>Bar *<p>* should pop to 'p', not 'b'. <p>Foo<table>Bar *<p>* should pop to 'table', not 'p'. <p>Foo<table><tr>Bar *<p>* should pop to 'tr', not 'p'.
<li><ul><li> *<li>* should pop to 'ul', not the first 'li'. <tr><table><tr> *<tr>* should pop to 'table', not the first 'tr' <td><tr><td> *<td>* should pop to 'tr', not the first 'td'
- p = self.tagStack[i] if (not p or p.name == name) and not isNestable:
- #Non-nestable tags get popped to the top or to their #last occurance. popTo = name break
- and p.name in nestingResetTriggers) \ or (nestingResetTriggers == None and isResetNesting
- and self.RESET_NESTING_TAGS.has_key(p.name)):
- self._popToTag(popTo, inclusive)
- #print "Start tag %s: %s" % (name, attrs) if self.quoteStack:
- #This is not a real tag.
#print "<%s> is not real!" % name attrs = .join(map(lambda(x, y): ' %s="%s"' % (x, y), attrs)) self.handle_data('<%s%s>' % (name, attrs)) return
- self._smartPop(name)
if self.parseOnlyThese and len(self.tagStack) <= 1 \
- and (self.parseOnlyThese.text or not self.parseOnlyThese.searchTag(name, attrs)):
- return
- self.previous.next = tag
- self.popTag()
- #print "Beginning quote (%s)" % name self.quoteStack.append(name) self.literal = 1
- #This is not a real tag.
- #print "End tag %s" % name if self.quoteStack and self.quoteStack[-1] != name:
- #This is not a real end tag.
#print "</%s> is not real!" % name self.handle_data('</%s>' % name) return
- self.quoteStack.pop()
self.literal = (len(self.quoteStack) > 0)
- #This is not a real end tag.
- self.currentData.append(data)
"""Adds a certain piece of text to the tree as a NavigableString subclass.""" self.endData() self.handle_data(text) self.endData(subclass)
"""Handle a processing instruction as a ProcessingInstruction object, possibly one with a %SOUP-ENCODING% slot into which an encoding will be plugged later.""" if text[:3] == "xml":
- text = u"xml version='1.0' encoding='%SOUP-ENCODING%'"
self._toStringSubclass(text, ProcessingInstruction)
- "Handle comments as Comment objects." self._toStringSubclass(text, Comment)
- "Handle character references as data." if self.convertEntities:
- data = unichr(int(ref))
data = '&#%s;' % ref
- """Handle entity references as data, possibly converting known HTML and/or XML entity references to the corresponding Unicode characters.""" data = None if self.convertHTMLEntities:
- try:
- data = unichr(name2codepoint[ref])
except KeyError:
- pass
- data = self.XML_ENTITIES_TO_SPECIAL_CHARS.get(ref)
- not self.XML_ENTITIES_TO_SPECIAL_CHARS.get(ref):
- # TODO: We've got a problem here. We're told this is # an entity reference, but it's not an XML entity # reference or an HTML entity reference. Nonetheless, # the logical thing to do is to pass it through as an # unrecognized entity reference. #
# Except: when the input is "&carol;" this function # will be called with input "carol". When the input is # "AT&T", this function will be called with input # "T". We have no way of knowing whether a semicolon # was present originally, so we don't know whether # this is an unknown entity or just a misplaced # ampersand. # # The more common case is a misplaced ampersand, so I # escape the ampersand and omit the trailing semicolon. data = "&%s" % ref
- # TODO: We've got a problem here. We're told this is # an entity reference, but it's not an XML entity # reference or an HTML entity reference. Nonetheless, # the logical thing to do is to pass it through as an # unrecognized entity reference. #
- # This case is different from the one above, because we # haven't already gone through a supposedly comprehensive # mapping of entities to Unicode characters. We might not # have gone through any mapping at all. So the chances are # very high that this is a real entity, and not a # misplaced ampersand.
data = "&%s;" % ref
- try:
- "Handle DOCTYPEs and the like as Declaration objects." self._toStringSubclass(data, Declaration)
- """Treat a bogus SGML declaration as raw data. Treat a CDATA declaration as a CData object.""" j = None
if self.rawdata[i:i+9] == '<![CDATA[':
k = self.rawdata.find(']]>', i) if k == -1:
- k = len(self.rawdata)
- try:
- j = SGMLParser.parse_declaration(self, i)
- toHandle = self.rawdata[i:] self.handle_data(toHandle) j = i + len(toHandle)
class BeautifulSoup(BeautifulStoneSoup):
- """This parser knows the following facts about HTML:
- Some tags have no closing tag and should be interpreted as being
- closed as soon as they are encountered.
- The text inside some tags (ie. 'script') may contain tags which
- are not really part of the document and which should be parsed as text, not tags. If you want to parse the text as tags, you can always fetch it and parse it explicitly.
- Tag nesting rules:
- Most tags can't be nested at all. For instance, the occurance of
a <p> tag should implicitly close the previous <p> tag.
<p>Para1<p>Para2
- should be transformed into:
<p>Para1</p><p>Para2
of a <blockquote> tag should _not_ implicitly close the previous <blockquote> tag.
Alice said: <blockquote>Bob said: <blockquote>Blah
- should NOT be transformed into:
Alice said: <blockquote>Bob said: </blockquote><blockquote>Blah
interposition of other tags. For instance, a <tr> tag should implicitly close the previous <tr> tag within the same <table>, but not close a <tr> tag in another table.
<table><tr>Blah<tr>Blah
- should be transformed into:
<table><tr>Blah</tr><tr>Blah
- but,
<tr>Blah<table><tr>Blah
- should NOT be transformed into
<tr>Blah<table></tr><tr>Blah
of problems with the BeautifulSoup class. If BeautifulSoup is not treating as nestable a tag your page author treats as nestable, try ICantBelieveItsBeautifulSoup, MinimalSoup, or BeautifulStoneSoup before writing your own subclass."""
def init(self, *args, **kwargs):
- if not kwargs.has_key('smartQuotesTo'):
- kwargs['smartQuotesTo'] = self.HTML_ENTITIES
BeautifulStoneSoup.init(self, *args, **kwargs)
- ['br' , 'hr', 'input', 'img', 'meta', 'spacer', 'link', 'frame', 'base'])
- 'center']
- 'ul' : [], 'li' : ['ul', 'ol'], 'dl' : [], 'dd' : ['dl'], 'dt' : ['dl'] }
- 'tr' : ['table', 'tbody', 'tfoot', 'thead'], 'td' : ['tr'], 'th' : ['tr'], 'thead' : ['table'], 'tbody' : ['table'], 'tfoot' : ['table'], }
- NON_NESTABLE_BLOCK_TAGS, NESTABLE_LIST_TAGS, NESTABLE_TABLE_TAGS)
- NESTABLE_LIST_TAGS, NESTABLE_TABLE_TAGS)
CHARSET_RE = re.compile("((|;)\s*charset=)([;]*)", re.M) def start_meta(self, attrs):
- """Beautiful Soup can detect a charset included in a META tag, try to convert the document to that charset, and re-parse the document from the beginning.""" httpEquiv = None contentType = None contentTypeIndex = None tagNeedsEncodingSubstitution = False for i in range(0, len(attrs)):
- key, value = attrs[i] key = key.lower() if key == 'http-equiv':
- httpEquiv = value
- contentType = value contentTypeIndex = i
- match = self.CHARSET_RE.search(contentType) if match:
- if (self.declaredHTMLEncoding is not None or
- self.originalEncoding == self.fromEncoding): # An HTML encoding was sniffed while converting # the document to Unicode, or an HTML encoding was # sniffed during a previous pass through the # document, or an encoding was specified # explicitly and it worked. Rewrite the meta tag. def rewrite(match):
- return match.group(1) + "%SOUP-ENCODING%"
- newAttr)
- # This is our first pass through the document. # Go through it again with the encoding information. newCharset = match.group(3) if newCharset and newCharset != self.originalEncoding:
- self.declaredHTMLEncoding = newCharset self._feed(self.declaredHTMLEncoding)
raise StopParsing
- self.declaredHTMLEncoding = newCharset self._feed(self.declaredHTMLEncoding)
- self.originalEncoding == self.fromEncoding): # An HTML encoding was sniffed while converting # the document to Unicode, or an HTML encoding was # sniffed during a previous pass through the # document, or an encoding was specified # explicitly and it worked. Rewrite the meta tag. def rewrite(match):
- if (self.declaredHTMLEncoding is not None or
- tag.containsSubstitutions = True
- key, value = attrs[i] key = key.lower() if key == 'http-equiv':
- Most tags can't be nested at all. For instance, the occurance of
class StopParsing(Exception):
- pass
class ICantBelieveItsBeautifulSoup(BeautifulSoup):
"""The BeautifulSoup class is oriented towards skipping over common HTML errors like unclosed tags. However, sometimes it makes errors of its own. For instance, consider this fragment:
<b>Foo<b>Bar</b></b>
BeautifulSoup class will implicitly close the first b tag when it encounters the second 'b'. It will think the author wrote "<b>Foo<b>Bar", and didn't close the first 'b' tag, because there's no real-world reason to bold something that's already bold. When it encounters '</b></b>' it will close two more 'b' tags, for a grand total of three tags closed instead of two. This can throw off the rest of your document structure. The same is true of a number of other tags, listed below. It's much more common for someone to forget to close a 'b' tag
than to actually use nested 'b' tags, and the BeautifulSoup class handles the common case. This class handles the not-co-common case: where you can't believe someone wrote what they did, but it's valid HTML and BeautifulSoup screwed up by assuming it wouldn't be.""" I_CANT_BELIEVE_THEYRE_NESTABLE_INLINE_TAGS = \
- ['em', 'big', 'i', 'small', 'tt', 'abbr', 'acronym', 'strong',
- 'cite', 'code', 'dfn', 'kbd', 'samp', 'strong', 'var', 'b', 'big']
NESTABLE_TAGS = buildTagMap([], BeautifulSoup.NESTABLE_TAGS,
- I_CANT_BELIEVE_THEYRE_NESTABLE_BLOCK_TAGS, I_CANT_BELIEVE_THEYRE_NESTABLE_INLINE_TAGS)
class MinimalSoup(BeautifulSoup):
"""The MinimalSoup class is for parsing HTML that contains pathologically bad markup. It makes no assumptions about tag nesting, but it does know which tags are self-closing, that <script> tags contain Javascript and should not be parsed, that META tags may contain encoding information, and so on.
This also makes it better for subclassing than BeautifulStoneSoup or BeautifulSoup.""" RESET_NESTING_TAGS = buildTagMap('noscript') NESTABLE_TAGS = {}
class BeautifulSOAP(BeautifulStoneSoup):
- """This class will push a tag with only a single string child into the tag's parent as an attribute. The attribute's name is the tag name, and the value is the string child. An example should give the flavor of the change:
<foo><bar>baz</bar></foo>
=>
<foo bar="baz"><bar>baz</bar></foo> You can then access fooTag['bar'] instead of fooTag.barTag.string. This is, of course, useful for scraping structures that tend to use subelements instead of attributes, such as SOAP messages. Note that it modifies its input, so don't print the modified version out. I'm not sure how many people really want to use this class; let me know if you do. Mainly I like the name.""" def popTag(self):
if len(self.tagStack) > 1:
- tag = self.tagStack[-1] parent = self.tagStack[-2] parent._getAttrMap() if (isinstance(tag, Tag) and len(tag.contents) == 1 and
isinstance(tag.contents[0], NavigableString) and not parent.attrMap.has_key(tag.name)): parent[tag.name] = tag.contents[0]
BeautifulStoneSoup.popTag(self)
- tag = self.tagStack[-1] parent = self.tagStack[-2] parent._getAttrMap() if (isinstance(tag, Tag) and len(tag.contents) == 1 and
#Enterprise class names! It has come to our attention that some people #think the names of the Beautiful Soup parser classes are too silly #and "unprofessional" for use in enterprise screen-scraping. We feel #your pain! For such-minded folk, the Beautiful Soup Consortium And #All-Night Kosher Bakery recommends renaming this file to #"RobustParser.py" (or, in cases of extreme enterprisiness, #"RobustParserBeanInterface.class") and using the following #enterprise-friendly class aliases: class RobustXMLParser(BeautifulStoneSoup):
- pass
class RobustHTMLParser(BeautifulSoup):
- pass
class RobustWackAssHTMLParser(ICantBelieveItsBeautifulSoup):
- pass
class RobustInsanelyWackAssHTMLParser(MinimalSoup):
- pass
class SimplifyingSOAPParser(BeautifulSOAP):
- pass
# # Bonus library: Unicode, Dammit # # This class forces XML data into a standard format (usually to UTF-8 # or Unicode). It is heavily based on code from Mark Pilgrim's # Universal Feed Parser. It does not rewrite the XML or HTML to # reflect a new encoding: that happens in BeautifulStoneSoup.handle_pi # (XML) and BeautifulSoup.start_meta (HTML).
# Autodetects character encodings. # Download from http://chardet.feedparser.org/ try:
- import chardet
# import chardet.constants # chardet.constants._debug = 1 except ImportError:
- chardet = None
# cjkcodecs and iconv_codec make Python know about more character encodings. # Both are available from http://cjkpython.i18n.org/ # They're built in if you use Python 2.4. try:
- import cjkcodecs.aliases
except ImportError:
- pass
try:
- import iconv_codec
except ImportError:
- pass
class UnicodeDammit:
- """A class for detecting the encoding of a *ML document and converting it to a Unicode string. If the source encoding is windows-1252, can replace MS smart quotes with their HTML or XML equivalents.""" # This dictionary maps commonly seen values for "charset" in HTML # meta tags to the corresponding Python codec names. It only covers # values that aren't in Python's aliases and can't be determined # by the heuristics in find_codec. CHARSET_ALIASES = { "macintosh" : "mac-roman",
- "x-sjis" : "shift-jis" }
def init(self, markup, overrideEncodings=[],
- smartQuotesTo='xml', isHTML=False):
- self.declaredHTMLEncoding = None self.markup, documentEncoding, sniffedEncoding = \
- self._detectEncoding(markup, isHTML)
if markup == or isinstance(markup, unicode):
- self.originalEncoding = None self.unicode = unicode(markup) return
- u = self._convertFrom(proposedEncoding) if u: break
- for proposedEncoding in (documentEncoding, sniffedEncoding):
- u = self._convertFrom(proposedEncoding) if u: break
- u = self._convertFrom(chardet.detect(self.markup)['encoding'])
- for proposed_encoding in ("utf-8", "windows-1252"):
- u = self._convertFrom(proposed_encoding) if u: break
- """Changes a MS smart quote character to an XML or HTML entity.""" sub = self.MS_CHARS.get(orig)
if type(sub) == types.TupleType:
- if self.smartQuotesTo == 'xml':
sub = '&#x%s;' % sub[1]
sub = '&%s;' % sub[0]
- if self.smartQuotesTo == 'xml':
- proposed = self.find_codec(proposed) if not proposed or proposed in self.triedEncodings:
- return None
- "iso-8859-1", "iso-8859-2"):
- markup = re.compile("([\x80-\x9f])").sub \
- (lambda(x): self._subMSChar(x.group(1)),
- markup)
- (lambda(x): self._subMSChar(x.group(1)),
- # print "Trying to convert document to %s" % proposed u = self._toUnicode(markup, proposed) self.markup = u self.originalEncoding = proposed
- # print "That didn't work!" # print e return None
Given a string and its encoding, decodes the string into Unicode. %encoding is a string recognized by encodings.aliases # strip Byte Order Mark (if present)
if (len(data) >= 4) and (data[:2] == '\xfe\xff') \
- and (data[2:4] != '\x00\x00'):
- encoding = 'utf-16be' data = data[2:]
elif (len(data) >= 4) and (data[:2] == '\xff\xfe') \
- and (data[2:4] != '\x00\x00'):
- encoding = 'utf-16le' data = data[2:]
- encoding = 'utf-8' data = data[3:]
- encoding = 'utf-32be' data = data[4:]
- encoding = 'utf-32le' data = data[4:]
- """Given a document, tries to detect its XML encoding.""" xml_encoding = sniffed_xml_encoding = None try:
- if xml_data[:4] == '\x4c\x6f\xa7\x94':
- # EBCDIC xml_data = self._ebcdic_to_ascii(xml_data)
- # UTF-16BE sniffed_xml_encoding = 'utf-16be' xml_data = unicode(xml_data, 'utf-16be').encode('utf-8')
elif (len(xml_data) >= 4) and (xml_data[:2] == '\xfe\xff') \
- and (xml_data[2:4] != '\x00\x00'):
- # UTF-16BE with BOM sniffed_xml_encoding = 'utf-16be' xml_data = unicode(xml_data[2:], 'utf-16be').encode('utf-8')
- # UTF-16LE sniffed_xml_encoding = 'utf-16le' xml_data = unicode(xml_data, 'utf-16le').encode('utf-8')
elif (len(xml_data) >= 4) and (xml_data[:2] == '\xff\xfe') and \
- (xml_data[2:4] != '\x00\x00'):
- # UTF-16LE with BOM sniffed_xml_encoding = 'utf-16le' xml_data = unicode(xml_data[2:], 'utf-16le').encode('utf-8')
- # UTF-32BE sniffed_xml_encoding = 'utf-32be' xml_data = unicode(xml_data, 'utf-32be').encode('utf-8')
- # UTF-32LE sniffed_xml_encoding = 'utf-32le' xml_data = unicode(xml_data, 'utf-32le').encode('utf-8')
- # UTF-32BE with BOM sniffed_xml_encoding = 'utf-32be' xml_data = unicode(xml_data[4:], 'utf-32be').encode('utf-8')
- # UTF-32LE with BOM sniffed_xml_encoding = 'utf-32le' xml_data = unicode(xml_data[4:], 'utf-32le').encode('utf-8')
- # UTF-8 with BOM sniffed_xml_encoding = 'utf-8' xml_data = unicode(xml_data[3:], 'utf-8').encode('utf-8')
- sniffed_xml_encoding = 'ascii' pass
- xml_encoding_match = None
'^<\?.*encoding=[\'"](.*?)[\'"].*\?>').match(xml_data)
regexp = re.compile('<\s*meta[>]+charset=([>]*?)[;\'">]', re.I) xml_encoding_match = regexp.search(xml_data)
- xml_encoding = xml_encoding_match.groups()[0].lower() if isHTML:
- self.declaredHTMLEncoding = xml_encoding
- (xml_encoding in ('iso-10646-ucs-2', 'ucs-2', 'csunicode',
- 'iso-10646-ucs-4', 'ucs-4', 'csucs4', 'utf-16', 'utf-32', 'utf_16', 'utf_32', 'utf16', 'u16')):
- xml_encoding = sniffed_xml_encoding
- if xml_data[:4] == '\x4c\x6f\xa7\x94':
- return self._codec(self.CHARSET_ALIASES.get(charset, charset)) \
- or (charset and self._codec(charset.replace("-", ""))) \ or (charset and self._codec(charset.replace("-", "_"))) \ or charset
- if not charset: return charset codec = None try:
- codecs.lookup(charset) codec = charset
except (LookupError, ValueError):
- pass
c = self.class if not c.EBCDIC_TO_ASCII_MAP:
- emap = (0,1,2,3,156,9,134,127,151,141,142,11,12,13,14,15,
- 16,17,18,19,157,133,8,135,24,25,146,143,28,29,30,31, 128,129,130,131,132,10,23,27,136,137,138,139,140,5,6,7, 144,145,22,147,148,149,150,4,152,153,154,155,20,21,158,26, 32,160,161,162,163,164,165,166,167,168,91,46,60,40,43,33, 38,169,170,171,172,173,174,175,176,177,93,36,42,41,59,94, 45,47,178,179,180,181,182,183,184,185,124,44,37,95,62,63, 186,187,188,189,190,191,192,193,194,96,58,35,64,39,61,34, 195,97,98,99,100,101,102,103,104,105,196,197,198,199,200, 201,202,106,107,108,109,110,111,112,113,114,203,204,205, 206,207,208,209,126,115,116,117,118,119,120,121,122,210, 211,212,213,214,215,216,217,218,219,220,221,222,223,224, 225,226,227,228,229,230,231,123,65,66,67,68,69,70,71,72, 73,232,233,234,235,236,237,125,74,75,76,77,78,79,80,81, 82,238,239,240,241,242,243,92,159,83,84,85,86,87,88,89, 90,244,245,246,247,248,249,48,49,50,51,52,53,54,55,56,57, 250,251,252,253,254,255)
.join(map(chr, range(256))), .join(map(chr, emap)))
- emap = (0,1,2,3,156,9,134,127,151,141,142,11,12,13,14,15,
- '\x81' : ' ', '\x82' : ('sbquo', '201A'), '\x83' : ('fnof', '192'), '\x84' : ('bdquo', '201E'), '\x85' : ('hellip', '2026'), '\x86' : ('dagger', '2020'), '\x87' : ('Dagger', '2021'), '\x88' : ('circ', '2C6'), '\x89' : ('permil', '2030'), '\x8A' : ('Scaron', '160'), '\x8B' : ('lsaquo', '2039'), '\x8C' : ('OElig', '152'), '\x8D' : '?', '\x8E' : ('#x17D', '17D'), '\x8F' : '?', '\x90' : '?', '\x91' : ('lsquo', '2018'), '\x92' : ('rsquo', '2019'), '\x93' : ('ldquo', '201C'), '\x94' : ('rdquo', '201D'), '\x95' : ('bull', '2022'), '\x96' : ('ndash', '2013'), '\x97' : ('mdash', '2014'), '\x98' : ('tilde', '2DC'), '\x99' : ('trade', '2122'), '\x9a' : ('scaron', '161'), '\x9b' : ('rsaquo', '203A'), '\x9c' : ('oelig', '153'), '\x9d' : '?', '\x9e' : ('#x17E', '17E'),
'\x9f' : ('Yuml', ),}
#By default, act as an HTML pretty-printer. if name == 'main':
- import sys
soup = BeautifulSoup(sys.stdin) print soup.prettify()