BeautifulSoup.BeautifulStoneSoup Class Reference

Inheritance diagram for BeautifulSoup.BeautifulStoneSoup:

Public Member Functions
def	__init__
def	__init__
def	endData
def	endData
def	extractCharsetFromMeta
def	extractCharsetFromMeta
def	handle_data
def	handle_data
def	isSelfClosingTag
def	isSelfClosingTag
def	popTag
def	popTag
def	pushTag
def	pushTag
def	reset
def	reset
def	unknown_endtag
def	unknown_endtag
def	unknown_starttag
def	unknown_starttag
Public Member Functions inherited from BeautifulSoup.PageElement
def	append
def	append
def	extract
def	extract
def	findAllNext
def	findAllNext
def	findAllPrevious
def	findAllPrevious
def	findNext
def	findNext
def	findNextSibling
def	findNextSibling
def	findNextSiblings
def	findNextSiblings
def	findParent
def	findParent
def	findParents
def	findParents
def	findPrevious
def	findPrevious
def	findPreviousSibling
def	findPreviousSibling
def	findPreviousSiblings
def	findPreviousSiblings
def	insert
def	insert
def	nextGenerator
def	nextGenerator
def	nextSiblingGenerator
def	nextSiblingGenerator
def	parentGenerator
def	parentGenerator
def	previousGenerator
def	previousGenerator
def	previousSiblingGenerator
def	previousSiblingGenerator
def	replaceWith
def	replaceWith
def	setup
def	setup
def	substituteEncoding
def	substituteEncoding
def	toEncoding
def	toEncoding

Public Attributes
	builder
	convertEntities
	convertHTMLEntities
	convertXMLEntities
	currentData
	currentTag
	declaredHTMLEncoding
	escapeUnrecognizedEntities
	fromEncoding
	hidden
	instanceSelfClosingTags
	literal
	markup
	markupMassage
	originalEncoding
	parseOnlyThese
	previous
	quoteStack
	smartQuotesTo
	tagStack
Public Attributes inherited from BeautifulSoup.PageElement
	next
	nextSibling
	parent
	previous
	previousSibling

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.PageElement
	fetchNextSiblings = findNextSiblings
	fetchParents = findParents
	fetchPrevious = findAllPrevious
	fetchPreviousSiblings = findPreviousSiblings

Private Member Functions
def	_feed
def	_feed
def	_popToTag
def	_popToTag
def	_smartPop
def	_smartPop

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 1120 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,
			builder = HTMLParserBuilder
	)

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.

HTMLParser will process most bad HTML, and the BeautifulSoup
class has some tricks for dealing with some HTML that kills
HTMLParser, 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 HTMLParser:

 <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 1167 of file BeautifulSoup.py.

                 builder=HTMLParserBuilder):
        """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.

        HTMLParser will process most bad HTML, and the BeautifulSoup
        class has some tricks for dealing with some HTML that kills
        HTMLParser, 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 HTMLParser:

         <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)
        self.builder = builder(self)
        self.reset()

        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.
        self.builder = None                # So can the builder.