BeautifulSoup.BeautifulStoneSoup Class Reference

Inheritance diagram for BeautifulSoup.BeautifulStoneSoup:

Public Member Functions
def	__getattr__ (self, methodName)
def	__init__ (self, markup="", parseOnlyThese=None, fromEncoding=None, markupMassage=True, smartQuotesTo=XML_ENTITIES, convertEntities=None, selfClosingTags=None, isHTML=False)
def	convert_charref (self, name)
def	endData (self, containerClass=NavigableString)
def	handle_charref (self, ref)
def	handle_comment (self, text)
def	handle_data (self, data)
def	handle_decl (self, data)
def	handle_entityref (self, ref)
def	handle_pi (self, text)
def	isSelfClosingTag (self, name)
def	parse_declaration (self, i)
def	popTag (self)
def	pushTag (self, tag)
def	reset (self)
def	unknown_endtag (self, name)
def	unknown_starttag (self, name, attrs, selfClosing=0)
Public Member Functions inherited from BeautifulSoup.Tag
def	__call__ (self, args, kwargs)
def	__contains__ (self, x)
def	__delitem__ (self, key)
def	__eq__ (self, other)
def	__getattr__ (self, tag)
def	__getitem__ (self, key)
def	__init__ (self, parser, name, attrs=None, parent=None, previous=None)
def	__iter__ (self)
def	__len__ (self)
def	__ne__ (self, other)
def	__nonzero__ (self)
def	__repr__ (self, encoding=DEFAULT_OUTPUT_ENCODING)
def	__setitem__ (self, key, value)
def	__str__ (self, encoding=DEFAULT_OUTPUT_ENCODING, prettyPrint=False, indentLevel=0)
def	__unicode__ (self)
def	childGenerator (self)
def	clear (self)
def	decompose (self)
def	fetchText (self, text=None, recursive=True, limit=None)
def	find (self, name=None, attrs={}, recursive=True, text=None, kwargs)
def	findAll (self, name=None, attrs={}, recursive=True, text=None, limit=None, kwargs)
def	firstText (self, text=None, recursive=True)
def	get (self, key, default=None)
def	getString (self)
def	getText (self, separator=u"")
def	has_key (self, key)
def	index (self, element)
def	prettify (self, encoding=DEFAULT_OUTPUT_ENCODING)
def	recursiveChildGenerator (self)
def	renderContents (self, encoding=DEFAULT_OUTPUT_ENCODING, prettyPrint=False, indentLevel=0)
def	setString (self, string)
Public Member Functions inherited from BeautifulSoup.PageElement
def	append (self, tag)
def	extract (self)
def	findAllNext (self, name=None, attrs={}, text=None, limit=None, kwargs)
def	findAllPrevious (self, name=None, attrs={}, text=None, limit=None, kwargs)
def	findNext (self, name=None, attrs={}, text=None, kwargs)
def	findNextSibling (self, name=None, attrs={}, text=None, kwargs)
def	findNextSiblings (self, name=None, attrs={}, text=None, limit=None, kwargs)
def	findParent (self, name=None, attrs={}, kwargs)
def	findParents (self, name=None, attrs={}, limit=None, kwargs)
def	findPrevious (self, name=None, attrs={}, text=None, kwargs)
def	findPreviousSibling (self, name=None, attrs={}, text=None, kwargs)
def	findPreviousSiblings (self, name=None, attrs={}, text=None, limit=None, kwargs)
def	insert (self, position, newChild)
def	nextGenerator (self)
def	nextSiblingGenerator (self)
def	parentGenerator (self)
def	previousGenerator (self)
def	previousSiblingGenerator (self)
def	replaceWith (self, replaceWith)
def	replaceWithChildren (self)
def	setup (self, parent=None, previous=None)
def	substituteEncoding (self, str, encoding=None)
def	toEncoding (self, s, encoding=None)

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
Public Attributes inherited from BeautifulSoup.PageElement
	next
	nextSibling
	parent
	previous
	previousSibling

Static Public Attributes
	ALL_ENTITIES
	HTML_ENTITIES
	MARKUP_MASSAGE
	NESTABLE_TAGS
	PRESERVE_WHITESPACE_TAGS
	QUOTE_TAGS
	RESET_NESTING_TAGS
	ROOT_TAG_NAME
	SELF_CLOSING_TAGS
	STRIP_ASCII_SPACES
	XHTML_ENTITIES
	XML_ENTITIES
Static Public Attributes inherited from BeautifulSoup.Tag
	fetch
	findChild
	findChildren
	first
Static Public Attributes inherited from BeautifulSoup.PageElement
	BARE_AMPERSAND_OR_BRACKET
	fetchNextSiblings
	fetchParents
	fetchPrevious
	fetchPreviousSiblings
	XML_ENTITIES_TO_SPECIAL_CHARS
	XML_SPECIAL_CHARS_TO_ENTITIES

Private Member Functions
def	_feed (self, inDocumentEncoding=None, isHTML=False)
def	_popToTag (self, name, inclusivePop=True)
def	_smartPop (self, name)
def	_toStringSubclass (self, text, subclass)

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

__init__()

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

Member Function Documentation

__getattr__()

def BeautifulSoup.BeautifulStoneSoup.__getattr__	(		self,
			methodName
	)

This method routes method call requests to either the SGMLParser
superclass or the Tag superclass, depending on the method name.

Definition at line 1195 of file BeautifulSoup.py.

Referenced by VarParsing.VarParsing.setType().

    def __getattr__(self, methodName):
        """This method routes method call requests to either the SGMLParser
        superclass or the Tag superclass, depending on the method name."""
        #print "__getattr__ called on %s.%s" % (self.__class__, methodName)

        if methodName.startswith('start_') or methodName.startswith('end_') \
               or methodName.startswith('do_'):
            return SGMLParser.__getattr__(self, methodName)
        elif not methodName.startswith('__'):
            return Tag.__getattr__(self, methodName)
        else:
            raise AttributeError

_feed()

def BeautifulSoup.BeautifulStoneSoup._feed (   self,   inDocumentEncoding = None,   isHTML = False  )

private

Definition at line 1162 of file BeautifulSoup.py.

References BeautifulSoup.BeautifulStoneSoup.markup.

    def _feed(self, inDocumentEncoding=None, isHTML=False):
        # Convert the document to Unicode.
        markup = self.markup
        if isinstance(markup, unicode):
            if not hasattr(self, 'originalEncoding'):
                self.originalEncoding = None
        else:
            dammit = UnicodeDammit\
                     (markup, [self.fromEncoding, inDocumentEncoding],
                      smartQuotesTo=self.smartQuotesTo, isHTML=isHTML)
            markup = dammit.unicode
            self.originalEncoding = dammit.originalEncoding
            self.declaredHTMLEncoding = dammit.declaredHTMLEncoding
        if markup:
            if self.markupMassage:
                if not hasattr(self.markupMassage, "__iter__"):
                    self.markupMassage = self.MARKUP_MASSAGE
                for fix, m in self.markupMassage:
                    markup = fix.sub(m, markup)
                # 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)
        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:
            self.popTag()

_popToTag()

def BeautifulSoup.BeautifulStoneSoup._popToTag (   self,   name,   inclusivePop = True  )

private

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.

Definition at line 1262 of file BeautifulSoup.py.

References BeautifulSoup.BeautifulStoneSoup.popTag(), FastTimerService_cff.range, BeautifulSoup.BeautifulStoneSoup.ROOT_TAG_NAME, and BeautifulSoup.BeautifulStoneSoup.tagStack.

Referenced by BeautifulSoup.BeautifulStoneSoup._smartPop(), and BeautifulSoup.BeautifulStoneSoup.unknown_endtag().

    def _popToTag(self, name, inclusivePop=True):
        """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

        numPops = 0
        mostRecentTag = None
        for i in range(len(self.tagStack)-1, 0, -1):
            if name == self.tagStack[i].name:
                numPops = len(self.tagStack)-i
                break
        if not inclusivePop:
            numPops = numPops - 1

        for i in range(0, numPops):
            mostRecentTag = self.popTag()
        return mostRecentTag

_smartPop()

def BeautifulSoup.BeautifulStoneSoup._smartPop (   self,   name  )

private

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'

Definition at line 1284 of file BeautifulSoup.py.

References BeautifulSoup.BeautifulStoneSoup._popToTag(), BeautifulSoup.Tag.get(), BeautifulSoup.Tag.has_key(), BeautifulSoup.BeautifulStoneSoup.NESTABLE_TAGS, FastTimerService_cff.range, BeautifulSoup.BeautifulStoneSoup.RESET_NESTING_TAGS, and BeautifulSoup.BeautifulStoneSoup.tagStack.

Referenced by BeautifulSoup.BeautifulStoneSoup.unknown_starttag().

    def _smartPop(self, name):

        """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'
        """

        nestingResetTriggers = self.NESTABLE_TAGS.get(name)
        isNestable = nestingResetTriggers != None
        isResetNesting = self.RESET_NESTING_TAGS.has_key(name)
        popTo = None
        inclusive = True
        for i in range(len(self.tagStack)-1, 0, -1):
            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
            if (nestingResetTriggers is not None
                and p.name in nestingResetTriggers) \
                or (nestingResetTriggers is None and isResetNesting
                    and self.RESET_NESTING_TAGS.has_key(p.name)):

                #If we encounter one of the nesting reset triggers
                #peculiar to this tag, or we encounter another tag
                #that causes nesting to reset, pop up to but not
                #including that tag.
                popTo = p.name
                inclusive = False
                break
            p = p.parent
        if popTo:
            self._popToTag(popTo, inclusive)

_toStringSubclass()

def BeautifulSoup.BeautifulStoneSoup._toStringSubclass (   self,   text,   subclass  )

private

Adds a certain piece of text to the tree as a NavigableString
subclass.

Definition at line 1376 of file BeautifulSoup.py.

References BeautifulSoup.BeautifulStoneSoup.endData(), and BeautifulSoup.BeautifulStoneSoup.handle_data().

Referenced by BeautifulSoup.BeautifulStoneSoup.handle_comment(), BeautifulSoup.BeautifulStoneSoup.handle_decl(), BeautifulSoup.BeautifulStoneSoup.handle_pi(), and BeautifulSoup.BeautifulStoneSoup.parse_declaration().

    def _toStringSubclass(self, text, subclass):
        """Adds a certain piece of text to the tree as a NavigableString
        subclass."""
        self.endData()
        self.handle_data(text)
        self.endData(subclass)

convert_charref()

def BeautifulSoup.BeautifulStoneSoup.convert_charref	(		self,
			name
	)

This method fixes a bug in Python's SGMLParser.

Definition at line 1152 of file BeautifulSoup.py.

References createfilelist.int.

    def convert_charref(self, name):
        """This method fixes a bug in Python's SGMLParser."""
        try:
            n = int(name)
        except ValueError:
            return
        if not 0 <= n <= 127 : # ASCII ends at 127, not 255
            return
        return self.convert_codepoint(n)

endData()

def BeautifulSoup.BeautifulStoneSoup.endData	(		self,
			containerClass = NavigableString
	)

Definition at line 1239 of file BeautifulSoup.py.

References BeautifulSoup.BeautifulStoneSoup.currentData, BeautifulSoup.BeautifulStoneSoup.currentTag, reco::helper::VirtualJetProducerHelper.intersection(), join(), BeautifulSoup.BeautifulStoneSoup.parseOnlyThese, BeautifulSoup.BeautifulStoneSoup.PRESERVE_WHITESPACE_TAGS, BeautifulSoup.PageElement.previous, cond::persistency.search(), BeautifulSoup.BeautifulStoneSoup.STRIP_ASCII_SPACES, and BeautifulSoup.BeautifulStoneSoup.tagStack.

Referenced by BeautifulSoup.BeautifulStoneSoup._toStringSubclass(), BeautifulSoup.BeautifulStoneSoup.unknown_endtag(), and BeautifulSoup.BeautifulStoneSoup.unknown_starttag().

    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)):
                if '\n' in currentData:
                    currentData = '\n'
                else:
                    currentData = ' '
            self.currentData = []
            if self.parseOnlyThese and len(self.tagStack) <= 1 and \
                   (not self.parseOnlyThese.text or \
                    not self.parseOnlyThese.search(currentData)):
                return
            o = containerClass(currentData)
            o.setup(self.currentTag, self.previous)
            if self.previous:
                self.previous.next = o
            self.previous = o
            self.currentTag.contents.append(o)

handle_charref()

def BeautifulSoup.BeautifulStoneSoup.handle_charref	(		self,
			ref
	)

Definition at line 1395 of file BeautifulSoup.py.

References BeautifulSoup.BeautifulStoneSoup.convertEntities, BeautifulSoup.BeautifulStoneSoup.handle_data(), and createfilelist.int.

    def handle_charref(self, ref):
        "Handle character references as data."
        if self.convertEntities:
            data = unichr(int(ref))
        else:
            data = '&#%s;' % ref
        self.handle_data(data)

handle_comment()

def BeautifulSoup.BeautifulStoneSoup.handle_comment	(		self,
			text
	)

Definition at line 1391 of file BeautifulSoup.py.

References BeautifulSoup.BeautifulStoneSoup._toStringSubclass().

    def handle_comment(self, text):
        "Handle comments as Comment objects."
        self._toStringSubclass(text, Comment)

handle_data()

def BeautifulSoup.BeautifulStoneSoup.handle_data	(		self,
			data
	)

Definition at line 1373 of file BeautifulSoup.py.

References BeautifulSoup.PageElement.append(), and BeautifulSoup.BeautifulStoneSoup.currentData.

Referenced by BeautifulSoup.BeautifulStoneSoup._toStringSubclass(), BeautifulSoup.BeautifulStoneSoup.handle_charref(), BeautifulSoup.BeautifulStoneSoup.handle_entityref(), BeautifulSoup.BeautifulStoneSoup.parse_declaration(), BeautifulSoup.BeautifulStoneSoup.unknown_endtag(), and BeautifulSoup.BeautifulStoneSoup.unknown_starttag().

    def handle_data(self, data):
        self.currentData.append(data)

handle_decl()

def BeautifulSoup.BeautifulStoneSoup.handle_decl	(		self,
			data
	)

Definition at line 1446 of file BeautifulSoup.py.

References BeautifulSoup.BeautifulStoneSoup._toStringSubclass().

    def handle_decl(self, data):
        "Handle DOCTYPEs and the like as Declaration objects."
        self._toStringSubclass(data, Declaration)

handle_entityref()

def BeautifulSoup.BeautifulStoneSoup.handle_entityref	(		self,
			ref
	)

Handle entity references as data, possibly converting known
HTML and/or XML entity references to the corresponding Unicode
characters.

Definition at line 1403 of file BeautifulSoup.py.

References BeautifulSoup.Tag.convertHTMLEntities, BeautifulSoup.Tag.convertXMLEntities, BeautifulSoup.Tag.get(), BeautifulSoup.BeautifulStoneSoup.handle_data(), and BeautifulSoup.PageElement.XML_ENTITIES_TO_SPECIAL_CHARS.

    def handle_entityref(self, 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

        if not data and self.convertXMLEntities:
                data = self.XML_ENTITIES_TO_SPECIAL_CHARS.get(ref)

        if not data and self.convertHTMLEntities and \
            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
        if not data:
            # 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
        self.handle_data(data)

handle_pi()

def BeautifulSoup.BeautifulStoneSoup.handle_pi	(		self,
			text
	)

Handle a processing instruction as a ProcessingInstruction
object, possibly one with a %SOUP-ENCODING% slot into which an
encoding will be plugged later.

Definition at line 1383 of file BeautifulSoup.py.

References BeautifulSoup.BeautifulStoneSoup._toStringSubclass().

    def handle_pi(self, text):
        """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)

isSelfClosingTag()

def BeautifulSoup.BeautifulStoneSoup.isSelfClosingTag	(		self,
			name
	)

Returns true iff the given string is the name of a
self-closing tag according to this parser.

Definition at line 1208 of file BeautifulSoup.py.

References BeautifulSoup.Tag.has_key(), BeautifulSoup.BeautifulStoneSoup.instanceSelfClosingTags, and BeautifulSoup.BeautifulStoneSoup.SELF_CLOSING_TAGS.

Referenced by BeautifulSoup.BeautifulStoneSoup.unknown_starttag().

    def isSelfClosingTag(self, name):
        """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)

parse_declaration()

def BeautifulSoup.BeautifulStoneSoup.parse_declaration	(		self,
			i
	)

Treat a bogus SGML declaration as raw data. Treat a CDATA
declaration as a CData object.

Definition at line 1450 of file BeautifulSoup.py.

References BeautifulSoup.BeautifulStoneSoup._toStringSubclass(), BeautifulSoup.Tag.find(), BeautifulSoup.BeautifulStoneSoup.handle_data(), and DQMNet::Object.rawdata.

    def parse_declaration(self, i):
        """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)
             data = self.rawdata[i+9:k]
             j = k+3
             self._toStringSubclass(data, CData)
        else:
            try:
                j = SGMLParser.parse_declaration(self, i)
            except SGMLParseError:
                toHandle = self.rawdata[i:]
                self.handle_data(toHandle)
                j = i + len(toHandle)
        return j

popTag()

def BeautifulSoup.BeautifulStoneSoup.popTag

(

self

)

Definition at line 1224 of file BeautifulSoup.py.

References BeautifulSoup.BeautifulStoneSoup.currentTag, and BeautifulSoup.BeautifulStoneSoup.tagStack.

Referenced by BeautifulSoup.BeautifulStoneSoup._popToTag(), and BeautifulSoup.BeautifulStoneSoup.unknown_starttag().

    def popTag(self):
        tag = self.tagStack.pop()

        #print "Pop", tag.name
        if self.tagStack:
            self.currentTag = self.tagStack[-1]
        return self.currentTag

pushTag()

def BeautifulSoup.BeautifulStoneSoup.pushTag	(		self,
			tag
	)

Definition at line 1232 of file BeautifulSoup.py.

References BeautifulSoup.PageElement.append(), BeautifulSoup.BeautifulStoneSoup.currentTag, and BeautifulSoup.BeautifulStoneSoup.tagStack.

Referenced by BeautifulSoup.BeautifulStoneSoup.unknown_starttag().

    def pushTag(self, tag):
        #print "Push", tag.name
        if self.currentTag:
            self.currentTag.contents.append(tag)
        self.tagStack.append(tag)
        self.currentTag = self.tagStack[-1]

reset()

def BeautifulSoup.BeautifulStoneSoup.reset

(

self

)

Definition at line 1214 of file BeautifulSoup.py.

References BeautifulSoup.BeautifulStoneSoup.ROOT_TAG_NAME.

    def reset(self):
        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)

unknown_endtag()

def BeautifulSoup.BeautifulStoneSoup.unknown_endtag	(		self,
			name
	)

Definition at line 1360 of file BeautifulSoup.py.

References BeautifulSoup.BeautifulStoneSoup._popToTag(), BeautifulSoup.BeautifulStoneSoup.endData(), BeautifulSoup.BeautifulStoneSoup.handle_data(), BeautifulSoup.BeautifulStoneSoup.literal, and BeautifulSoup.BeautifulStoneSoup.quoteStack.

    def unknown_endtag(self, name):
        #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.endData()
        self._popToTag(name)
        if self.quoteStack and self.quoteStack[-1] == name:
            self.quoteStack.pop()
            self.literal = (len(self.quoteStack) > 0)

unknown_starttag()

def BeautifulSoup.BeautifulStoneSoup.unknown_starttag	(		self,
			name,
			attrs,
			selfClosing = 0
	)

Definition at line 1330 of file BeautifulSoup.py.

References BeautifulSoup.BeautifulStoneSoup._smartPop(), BeautifulSoup.PageElement.append(), BeautifulSoup.BeautifulStoneSoup.currentTag, BeautifulSoup.BeautifulStoneSoup.endData(), BeautifulSoup.BeautifulStoneSoup.handle_data(), BeautifulSoup.BeautifulStoneSoup.isSelfClosingTag(), join(), BeautifulSoup.BeautifulStoneSoup.parseOnlyThese, BeautifulSoup.BeautifulStoneSoup.popTag(), BeautifulSoup.PageElement.previous, BeautifulSoup.BeautifulStoneSoup.pushTag(), BeautifulSoup.BeautifulStoneSoup.QUOTE_TAGS, BeautifulSoup.BeautifulStoneSoup.quoteStack, and BeautifulSoup.BeautifulStoneSoup.tagStack.

    def unknown_starttag(self, name, attrs, selfClosing=0):
        #print "Start tag %s: %s" % (name, attrs)
        if self.quoteStack:
            #This is not a real tag.
            #print "<%s> is not real!" % name
            attrs = ''.join([' %s="%s"' % (x, y) for x, y in attrs])
            self.handle_data('<%s%s>' % (name, attrs))
            return
        self.endData()

        if not self.isSelfClosingTag(name) and not selfClosing:
            self._smartPop(name)

        if self.parseOnlyThese and len(self.tagStack) <= 1 \
               and (self.parseOnlyThese.text or not self.parseOnlyThese.searchTag(name, attrs)):
            return

        tag = Tag(self, name, attrs, self.currentTag, self.previous)
        if self.previous:
            self.previous.next = tag
        self.previous = tag
        self.pushTag(tag)
        if selfClosing or self.isSelfClosingTag(name):
            self.popTag()
        if name in self.QUOTE_TAGS:
            #print "Beginning quote (%s)" % name
            self.quoteStack.append(name)
            self.literal = 1
        return tag

Member Data Documentation

ALL_ENTITIES

BeautifulSoup.BeautifulStoneSoup.ALL_ENTITIES

static

Definition at line 1075 of file BeautifulSoup.py.

convertEntities

BeautifulSoup.BeautifulStoneSoup.convertEntities

Definition at line 1114 of file BeautifulSoup.py.

Referenced by BeautifulSoup.BeautifulStoneSoup.handle_charref().

convertHTMLEntities

BeautifulSoup.BeautifulStoneSoup.convertHTMLEntities

Definition at line 1124 of file BeautifulSoup.py.

convertXMLEntities

BeautifulSoup.BeautifulStoneSoup.convertXMLEntities

Definition at line 1123 of file BeautifulSoup.py.

currentData

BeautifulSoup.BeautifulStoneSoup.currentData

Definition at line 1218 of file BeautifulSoup.py.

Referenced by BeautifulSoup.BeautifulStoneSoup.endData(), and BeautifulSoup.BeautifulStoneSoup.handle_data().

currentTag

BeautifulSoup.BeautifulStoneSoup.currentTag

Definition at line 1219 of file BeautifulSoup.py.

Referenced by BeautifulSoup.BeautifulStoneSoup.endData(), BeautifulSoup.BeautifulStoneSoup.popTag(), BeautifulSoup.BeautifulStoneSoup.pushTag(), and BeautifulSoup.BeautifulStoneSoup.unknown_starttag().

declaredHTMLEncoding

BeautifulSoup.BeautifulStoneSoup.declaredHTMLEncoding

Definition at line 1174 of file BeautifulSoup.py.

Referenced by BeautifulSoup.UnicodeDammit._detectEncoding(), and BeautifulSoup.BeautifulSoup.start_meta().

escapeUnrecognizedEntities

BeautifulSoup.BeautifulStoneSoup.escapeUnrecognizedEntities

Definition at line 1125 of file BeautifulSoup.py.

fromEncoding

BeautifulSoup.BeautifulStoneSoup.fromEncoding

Definition at line 1112 of file BeautifulSoup.py.

hidden

BeautifulSoup.BeautifulStoneSoup.hidden

Definition at line 1216 of file BeautifulSoup.py.

HTML_ENTITIES

BeautifulSoup.BeautifulStoneSoup.HTML_ENTITIES

static

Definition at line 1071 of file BeautifulSoup.py.

Referenced by BeautifulSoup.BeautifulSoup.__init__().

instanceSelfClosingTags

BeautifulSoup.BeautifulStoneSoup.instanceSelfClosingTags

Definition at line 1139 of file BeautifulSoup.py.

Referenced by BeautifulSoup.BeautifulStoneSoup.isSelfClosingTag().

literal

BeautifulSoup.BeautifulStoneSoup.literal

Definition at line 1357 of file BeautifulSoup.py.

Referenced by BeautifulSoup.BeautifulStoneSoup.unknown_endtag().

markup

BeautifulSoup.BeautifulStoneSoup.markup

Definition at line 1144 of file BeautifulSoup.py.

Referenced by BeautifulSoup.UnicodeDammit._convertFrom(), and BeautifulSoup.BeautifulStoneSoup._feed().

MARKUP_MASSAGE

BeautifulSoup.BeautifulStoneSoup.MARKUP_MASSAGE

static

Definition at line 1063 of file BeautifulSoup.py.

markupMassage

BeautifulSoup.BeautifulStoneSoup.markupMassage

Definition at line 1145 of file BeautifulSoup.py.

NESTABLE_TAGS

BeautifulSoup.BeautifulStoneSoup.NESTABLE_TAGS

static

Definition at line 1058 of file BeautifulSoup.py.

Referenced by BeautifulSoup.BeautifulStoneSoup._smartPop().

originalEncoding

BeautifulSoup.BeautifulStoneSoup.originalEncoding

Definition at line 1167 of file BeautifulSoup.py.

parseOnlyThese

BeautifulSoup.BeautifulStoneSoup.parseOnlyThese

Definition at line 1111 of file BeautifulSoup.py.

Referenced by BeautifulSoup.BeautifulStoneSoup.endData(), and BeautifulSoup.BeautifulStoneSoup.unknown_starttag().

PRESERVE_WHITESPACE_TAGS

BeautifulSoup.BeautifulStoneSoup.PRESERVE_WHITESPACE_TAGS

static

Definition at line 1061 of file BeautifulSoup.py.

Referenced by BeautifulSoup.BeautifulStoneSoup.endData().

previous

BeautifulSoup.BeautifulStoneSoup.previous

Definition at line 1258 of file BeautifulSoup.py.

QUOTE_TAGS

BeautifulSoup.BeautifulStoneSoup.QUOTE_TAGS

static

Definition at line 1060 of file BeautifulSoup.py.

Referenced by BeautifulSoup.BeautifulStoneSoup.unknown_starttag().

quoteStack

BeautifulSoup.BeautifulStoneSoup.quoteStack

Definition at line 1221 of file BeautifulSoup.py.

Referenced by BeautifulSoup.BeautifulStoneSoup.unknown_endtag(), and BeautifulSoup.BeautifulStoneSoup.unknown_starttag().

RESET_NESTING_TAGS

BeautifulSoup.BeautifulStoneSoup.RESET_NESTING_TAGS

static

Definition at line 1059 of file BeautifulSoup.py.

Referenced by BeautifulSoup.BeautifulStoneSoup._smartPop().

ROOT_TAG_NAME

BeautifulSoup.BeautifulStoneSoup.ROOT_TAG_NAME

static

Definition at line 1069 of file BeautifulSoup.py.

Referenced by BeautifulSoup.BeautifulStoneSoup._popToTag(), and BeautifulSoup.BeautifulStoneSoup.reset().

SELF_CLOSING_TAGS

BeautifulSoup.BeautifulStoneSoup.SELF_CLOSING_TAGS

static

Definition at line 1057 of file BeautifulSoup.py.

Referenced by BeautifulSoup.BeautifulStoneSoup.isSelfClosingTag().

smartQuotesTo

BeautifulSoup.BeautifulStoneSoup.smartQuotesTo

Definition at line 1113 of file BeautifulSoup.py.

Referenced by BeautifulSoup.UnicodeDammit._convertFrom(), and BeautifulSoup.UnicodeDammit._subMSChar().

STRIP_ASCII_SPACES

BeautifulSoup.BeautifulStoneSoup.STRIP_ASCII_SPACES

static

Definition at line 1081 of file BeautifulSoup.py.

Referenced by BeautifulSoup.BeautifulStoneSoup.endData().

tagStack

BeautifulSoup.BeautifulStoneSoup.tagStack

Definition at line 1220 of file BeautifulSoup.py.

Referenced by BeautifulSoup.BeautifulStoneSoup._popToTag(), BeautifulSoup.BeautifulStoneSoup._smartPop(), BeautifulSoup.BeautifulStoneSoup.endData(), BeautifulSoup.BeautifulStoneSoup.popTag(), BeautifulSoup.BeautifulSOAP.popTag(), BeautifulSoup.BeautifulStoneSoup.pushTag(), and BeautifulSoup.BeautifulStoneSoup.unknown_starttag().

XHTML_ENTITIES

BeautifulSoup.BeautifulStoneSoup.XHTML_ENTITIES

static

Definition at line 1073 of file BeautifulSoup.py.

XML_ENTITIES

BeautifulSoup.BeautifulStoneSoup.XML_ENTITIES

static

Definition at line 1072 of file BeautifulSoup.py.