BeautifulSoup.BeautifulStoneSoup Class Reference

Inheritance diagram for BeautifulSoup.BeautifulStoneSoup:

Public Member Functions
def	__getattr__
def	__init__
def	convert_charref
def	endData
def	handle_charref
def	handle_comment
def	handle_data
def	handle_decl
def	handle_entityref
def	handle_pi
def	isSelfClosingTag
def	parse_declaration
def	popTag
def	pushTag
def	reset
def	unknown_endtag
def	unknown_starttag
Public Member Functions inherited from BeautifulSoup.Tag
def	__call__
def	__contains__
def	__delitem__
def	__eq__
def	__getattr__
def	__getitem__
def	__init__
def	__iter__
def	__len__
def	__ne__
def	__nonzero__
def	__repr__
def	__setitem__
def	__str__
def	__unicode__
def	childGenerator
def	clear
def	decompose
def	fetchText
def	find
def	findAll
def	firstText
def	get
def	getString
def	getText
def	has_key
def	index
def	prettify
def	recursiveChildGenerator
def	renderContents
def	setString

Public Attributes
	convertEntities
	convertHTMLEntities
	convertXMLEntities
	currentData
	currentTag
	declaredHTMLEncoding
	escapeUnrecognizedEntities
	fromEncoding
	hidden
	instanceSelfClosingTags
	literal
	markup
	markupMassage
	originalEncoding
	parseOnlyThese
	previous
	quoteStack
	smartQuotesTo
	tagStack
Public Attributes inherited from BeautifulSoup.Tag
	attrMap
	attrs
	containsSubstitutions
	contents
	convertHTMLEntities
	convertXMLEntities
	escapeUnrecognizedEntities
	hidden
	isSelfClosing
	name
	parserClass

Static Public Attributes
	ALL_ENTITIES = XHTML_ENTITIES
string	HTML_ENTITIES = "html"
list	MARKUP_MASSAGE
dictionary	NESTABLE_TAGS = {}
list	PRESERVE_WHITESPACE_TAGS = []
dictionary	QUOTE_TAGS = {}
dictionary	RESET_NESTING_TAGS = {}
string	ROOT_TAG_NAME = u'[document]'
dictionary	SELF_CLOSING_TAGS = {}
dictionary	STRIP_ASCII_SPACES = { 9: None, 10: None, 12: None, 13: None, 32: None, }
string	XHTML_ENTITIES = "xhtml"
string	XML_ENTITIES = "xml"
Static Public Attributes inherited from BeautifulSoup.Tag
	fetch = findAll
	findChild = find
	findChildren = findAll
	first = find

Private Member Functions
def	_feed
def	_popToTag
def	_smartPop
def	_toStringSubclass

Additional Inherited Members
Properties inherited from BeautifulSoup.Tag
	string = property(getString, setString)
	text = property(getText)

Detailed Description

This class contains the basic parser and search code. It defines
a parser that knows nothing about tag behavior except for the
following:

  You can't close a tag without closing all the tags it encloses.
  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.

Definition at line 1039 of file BeautifulSoup.py.

Constructor & Destructor Documentation

def BeautifulSoup.BeautifulStoneSoup.__init__	(		self,
			markup = "",
			parseOnlyThese = None,
			fromEncoding = None,
			markupMassage = True,
			smartQuotesTo = XML_ENTITIES,
			convertEntities = None,
			selfClosingTags = None,
			isHTML = False
	)

The Soup object is initialized as the 'root tag', and the
provided markup (which can be a string or a file-like object)
is fed into the underlying parser.

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)

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.

Definition at line 1085 of file BeautifulSoup.py.

                 convertEntities=None, selfClosingTags=None, isHTML=False):
        """The Soup object is initialized as the 'root tag', and the
        provided markup (which can be a string or a file-like object)
        is fed into the underlying parser.

        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)

        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:
            # It doesn't make sense to convert encoded characters to
            # entities even while you're converting entities to Unicode.
            # Just convert it all to Unicode.
            self.smartQuotesTo = None
            if convertEntities == self.HTML_ENTITIES:
                self.convertXMLEntities = False
                self.convertHTMLEntities = True
                self.escapeUnrecognizedEntities = True
            elif convertEntities == self.XHTML_ENTITIES:
                self.convertXMLEntities = True
                self.convertHTMLEntities = True
                self.escapeUnrecognizedEntities = False
            elif convertEntities == self.XML_ENTITIES:
                self.convertXMLEntities = True
                self.convertHTMLEntities = False
                self.escapeUnrecognizedEntities = False
        else:
            self.convertXMLEntities = False
            self.convertHTMLEntities = False
            self.escapeUnrecognizedEntities = False

        self.instanceSelfClosingTags = buildTagMap(None, selfClosingTags)
        SGMLParser.__init__(self)

        if hasattr(markup, 'read'):        # It's a file-type object.
            markup = markup.read()
        self.markup = markup
        self.markupMassage = markupMassage
        try:
            self._feed(isHTML=isHTML)
        except StopParsing:
            pass
        self.markup = None                 # The markup can now be GCed