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

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

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

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
 

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()
 

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(), 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
 

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(), 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)
 

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)
 

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)
 

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.PageElement.previous, 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)
 
 

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)
 

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)
 

def BeautifulSoup.BeautifulStoneSoup.handle_data	(	self,
		data
	)

Definition at line 1373 of file BeautifulSoup.py.

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)
 

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)
 

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, and BeautifulSoup.BeautifulStoneSoup.handle_data().

     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 = "&amp;%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)
 

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)
 

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.

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)
 

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.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
 

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
 

def BeautifulSoup.BeautifulStoneSoup.pushTag	(	self,
		tag
	)

Definition at line 1232 of file BeautifulSoup.py.

References 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]
 

def BeautifulSoup.BeautifulStoneSoup.reset ( self )

Definition at line 1214 of file BeautifulSoup.py.

     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)
 

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)
 

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

Definition at line 1330 of file BeautifulSoup.py.

     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
 