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

     def __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."""
  
         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.

Reimplemented from BeautifulSoup.Tag.

Definition at line 1195 of file BeautifulSoup.py.

     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
  

Referenced by VarParsing.VarParsing.setType().

◆ _feed()

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

private

Definition at line 1162 of file BeautifulSoup.py.

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

References BeautifulSoup.BeautifulStoneSoup.markup.

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

     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
  

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

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

     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)
  

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

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

     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)
  

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

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

     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)
  

References createfilelist.int.

◆ endData()

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

Definition at line 1239 of file BeautifulSoup.py.

     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)
  
  

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

◆ handle_charref()

def BeautifulSoup.BeautifulStoneSoup.handle_charref	(	self,
		ref
	)

Definition at line 1395 of file BeautifulSoup.py.

     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)
  

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

◆ handle_comment()

def BeautifulSoup.BeautifulStoneSoup.handle_comment	(	self,
		text
	)

Definition at line 1391 of file BeautifulSoup.py.

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

References BeautifulSoup.BeautifulStoneSoup._toStringSubclass().

◆ handle_data()

def BeautifulSoup.BeautifulStoneSoup.handle_data	(	self,
		data
	)

Definition at line 1373 of file BeautifulSoup.py.

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

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

◆ handle_decl()

def BeautifulSoup.BeautifulStoneSoup.handle_decl	(	self,
		data
	)

Definition at line 1446 of file BeautifulSoup.py.

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

References BeautifulSoup.BeautifulStoneSoup._toStringSubclass().

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

     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)
  

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

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

     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)
  

References BeautifulSoup.BeautifulStoneSoup._toStringSubclass().

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

     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)
  

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

Referenced by BeautifulSoup.BeautifulStoneSoup.unknown_starttag().

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

     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
  

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

◆ popTag()

def BeautifulSoup.BeautifulStoneSoup.popTag ( self )

Reimplemented in BeautifulSoup.BeautifulSOAP.

Definition at line 1224 of file BeautifulSoup.py.

     def popTag(self):
         tag = self.tagStack.pop()
  
         #print "Pop", tag.name
         if self.tagStack:
             self.currentTag = self.tagStack[-1]
         return self.currentTag
  

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

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

◆ pushTag()

def BeautifulSoup.BeautifulStoneSoup.pushTag	(	self,
		tag
	)

Definition at line 1232 of file BeautifulSoup.py.

     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]
  

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

Referenced by BeautifulSoup.BeautifulStoneSoup.unknown_starttag().

◆ reset()

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)
  

References BeautifulSoup.BeautifulStoneSoup.ROOT_TAG_NAME.

◆ unknown_endtag()

def BeautifulSoup.BeautifulStoneSoup.unknown_endtag	(	self,
		name
	)

Definition at line 1360 of file BeautifulSoup.py.

     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)
  

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

◆ unknown_starttag()

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
  

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

Referenced by BeautifulSoup.BeautifulStoneSoup.handle_charref().

◆ convertHTMLEntities

BeautifulSoup.BeautifulStoneSoup.convertHTMLEntities

Definition at line 1122 of file BeautifulSoup.py.

◆ convertXMLEntities

BeautifulSoup.BeautifulStoneSoup.convertXMLEntities

Definition at line 1121 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 1123 of file BeautifulSoup.py.

◆ fromEncoding

BeautifulSoup.BeautifulStoneSoup.fromEncoding

Definition at line 1110 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 1137 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 1142 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 1143 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 1109 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 1111 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.

Public Member Functions

Public Attributes

Static Public Attributes

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ __getattr__()

◆ _feed()

◆ _popToTag()

◆ _smartPop()

◆ _toStringSubclass()

◆ convert_charref()

◆ endData()

◆ handle_charref()

◆ handle_comment()

◆ handle_data()

◆ handle_decl()

◆ handle_entityref()

◆ handle_pi()

◆ isSelfClosingTag()

◆ parse_declaration()

◆ popTag()

◆ pushTag()

◆ reset()

◆ unknown_endtag()

◆ unknown_starttag()

Member Data Documentation

◆ ALL_ENTITIES

◆ convertEntities

◆ convertHTMLEntities

◆ convertXMLEntities

◆ currentData

◆ currentTag

◆ declaredHTMLEncoding

◆ escapeUnrecognizedEntities

◆ fromEncoding

◆ hidden

◆ HTML_ENTITIES

◆ instanceSelfClosingTags

◆ literal

◆ markup

◆ MARKUP_MASSAGE

◆ markupMassage

◆ NESTABLE_TAGS

◆ originalEncoding

◆ parseOnlyThese

◆ PRESERVE_WHITESPACE_TAGS

◆ previous

◆ QUOTE_TAGS

◆ quoteStack

◆ RESET_NESTING_TAGS

◆ ROOT_TAG_NAME

◆ SELF_CLOSING_TAGS

◆ smartQuotesTo

◆ STRIP_ASCII_SPACES

◆ tagStack

◆ XHTML_ENTITIES

◆ XML_ENTITIES

◆ init()

◆ getattr()