Inheritance diagram for BeautifulSoup.PageElement:

Public Member Functions
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
	next

	nextSibling

	parent

	previous

	previousSibling

Private Member Functions
def	_findAll (self, name, attrs, text, limit, generator, kwargs)

def	_findOne (self, method, name, attrs, text, kwargs)

def	_invert (h)

def	_lastRecursiveChild (self)

def	_sub_entity (self, x)

Detailed Description

Contains the navigational information for some part of the page
(either a tag or a piece of text)

Definition at line 113 of file BeautifulSoup.py.

Member Function Documentation

def BeautifulSoup.PageElement._findAll	(	self,
		name,
		attrs,
		text,
		limit,
		generator,
		kwargs
	)

private

Definition at line 348 of file BeautifulSoup.py.

References cmsBatch.generator.

Referenced by BeautifulSoup.Tag.findAll(), BeautifulSoup.PageElement.findAllNext(), BeautifulSoup.PageElement.findAllPrevious(), BeautifulSoup.PageElement.findNextSiblings(), BeautifulSoup.PageElement.findParents(), and BeautifulSoup.PageElement.findPreviousSiblings().

     def _findAll(self, name, attrs, text, limit, generator, **kwargs):
         "Iterates over a generator looking for things that match."
 
         if isinstance(name, SoupStrainer):
             strainer = name
         # (Possibly) special case some findAll*(...) searches
         elif text is None and not limit and not attrs and not kwargs:
             # findAll*(True)
             if name is True:
                 return [element for element in generator()
                         if isinstance(element, Tag)]
             # findAll*('tag-name')
             elif isinstance(name, basestring):
                 return [element for element in generator()
                         if isinstance(element, Tag) and
                         element.name == name]
             else:
                 strainer = SoupStrainer(name, attrs, text, **kwargs)
         # Build a SoupStrainer
         else:
             strainer = SoupStrainer(name, attrs, text, **kwargs)
         results = ResultSet(strainer)
         g = generator()
         while True:
             try:
                 i = g.next()
             except StopIteration:
                 break
             if i:
                 found = strainer.search(i)
                 if found:
                     results.append(found)
                     if limit and len(results) >= limit:
                         break
         return results
 

def BeautifulSoup.PageElement._findOne	(	self,
		method,
		name,
		attrs,
		text,
		kwargs
	)

private

Definition at line 341 of file BeautifulSoup.py.

References AlcaSiPixelAliHarvester0T_cff.method.

Referenced by BeautifulSoup.PageElement.findNext(), BeautifulSoup.PageElement.findNextSibling(), BeautifulSoup.PageElement.findPrevious(), and BeautifulSoup.PageElement.findPreviousSibling().

     def _findOne(self, method, name, attrs, text, **kwargs):
         r = None
         l = method(name, attrs, text, 1, **kwargs)
         if l:
             r = l[0]
         return r
 

def BeautifulSoup.PageElement._invert ( h )

private

Definition at line 117 of file BeautifulSoup.py.

     def _invert(h):
         "Cheap function to invert a hash."
         i = {}
         for k,v in h.items():
             i[v] = k
         return i
 

def BeautifulSoup.PageElement._lastRecursiveChild ( self )

private

Definition at line 197 of file BeautifulSoup.py.

Referenced by BeautifulSoup.PageElement.extract(), BeautifulSoup.Tag.getText(), and BeautifulSoup.Tag.recursiveChildGenerator().

     def _lastRecursiveChild(self):
         "Finds the last element beneath this object to be parsed."
         lastChild = self
         while hasattr(lastChild, 'contents') and lastChild.contents:
             lastChild = lastChild.contents[-1]
         return lastChild
 

def BeautifulSoup.PageElement._sub_entity	(	self,
		x
	)

private

Used with a regular expression to substitute the
appropriate XML entity for an XML special character.

Definition at line 443 of file BeautifulSoup.py.

Referenced by BeautifulSoup.NavigableString.__str__(), and BeautifulSoup.Tag.__str__().

     def _sub_entity(self, x):
         """Used with a regular expression to substitute the
         appropriate XML entity for an XML special character."""
         return "&" + self.XML_SPECIAL_CHARS_TO_ENTITIES[x.group(0)[0]] + ";"
 
 

def BeautifulSoup.PageElement.append	(	self,
		tag
	)

Appends the given tag to the contents of this tag.

Definition at line 263 of file BeautifulSoup.py.

Referenced by diclist.diclist.add(), Vispa.Views.PropertyView.PropertyView.addProperty(), and BeautifulSoup.Tag.setString().

     def append(self, tag):
         """Appends the given tag to the contents of this tag."""
         self.insert(len(self.contents), tag)
 

def BeautifulSoup.PageElement.extract ( self )

Destructively rips this element out of the tree.

Definition at line 168 of file BeautifulSoup.py.

References BeautifulSoup.PageElement._lastRecursiveChild(), BeautifulSoup.PageElement.nextSibling, BeautifulSoup.PageElement.parent, BeautifulSoup.PageElement.previous, and BeautifulSoup.PageElement.previousSibling.

Referenced by BeautifulSoup.Tag.decompose(), BeautifulSoup.PageElement.replaceWith(), and BeautifulSoup.PageElement.replaceWithChildren().

     def extract(self):
         """Destructively rips this element out of the tree."""
         if self.parent:
             try:
                 del self.parent.contents[self.parent.index(self)]
             except ValueError:
                 pass
 
         #Find the two elements that would be next to each other if
         #this element (and any children) hadn't been parsed. Connect
         #the two.
         lastChild = self._lastRecursiveChild()
         nextElement = lastChild.next
 
         if self.previous:
             self.previous.next = nextElement
         if nextElement:
             nextElement.previous = self.previous
         self.previous = None
         lastChild.next = None
 
         self.parent = None
         if self.previousSibling:
             self.previousSibling.nextSibling = self.nextSibling
         if self.nextSibling:
             self.nextSibling.previousSibling = self.previousSibling
         self.previousSibling = self.nextSibling = None
         return self
 

def BeautifulSoup.PageElement.findAllNext	(	self,
		name = `None`,
		attrs = `{}`,
		text = `None`,
		limit = `None`,
		kwargs
	)

Returns all items that match the given criteria and appear
after this Tag in the document.

Definition at line 273 of file BeautifulSoup.py.

References BeautifulSoup.PageElement._findAll(), and BeautifulSoup.PageElement.nextGenerator().

Referenced by BeautifulSoup.PageElement.findNext().

                     **kwargs):
         """Returns all items that match the given criteria and appear
         after this Tag in the document."""
         return self._findAll(name, attrs, text, limit, self.nextGenerator,
                              **kwargs)
 

def BeautifulSoup.PageElement.findAllPrevious	(	self,
		name = `None`,
		attrs = `{}`,
		text = `None`,
		limit = `None`,
		kwargs
	)

Returns all items that match the given criteria and appear
before this Tag in the document.

Definition at line 299 of file BeautifulSoup.py.

References BeautifulSoup.PageElement._findAll(), and BeautifulSoup.PageElement.previousGenerator().

Referenced by BeautifulSoup.PageElement.findPrevious().

                         **kwargs):
         """Returns all items that match the given criteria and appear
         before this Tag in the document."""
         return self._findAll(name, attrs, text, limit, self.previousGenerator,
                            **kwargs)

def BeautifulSoup.PageElement.findNext	(	self,
		name = `None`,
		attrs = `{}`,
		text = `None`,
		kwargs
	)

Returns the first item that matches the given criteria and
appears after this Tag in the document.

Definition at line 267 of file BeautifulSoup.py.

References BeautifulSoup.PageElement._findOne(), and BeautifulSoup.PageElement.findAllNext().

     def findNext(self, name=None, attrs={}, text=None, **kwargs):
         """Returns the first item that matches the given criteria and
         appears after this Tag in the document."""
         return self._findOne(self.findAllNext, name, attrs, text, **kwargs)
 

def BeautifulSoup.PageElement.findNextSibling	(	self,
		name = `None`,
		attrs = `{}`,
		text = `None`,
		kwargs
	)

Returns the closest sibling to this Tag that matches the
given criteria and appears after this Tag in the document.

Definition at line 279 of file BeautifulSoup.py.

References BeautifulSoup.PageElement._findOne(), and BeautifulSoup.PageElement.findNextSiblings().

     def findNextSibling(self, name=None, attrs={}, text=None, **kwargs):
         """Returns the closest sibling to this Tag that matches the
         given criteria and appears after this Tag in the document."""
         return self._findOne(self.findNextSiblings, name, attrs, text,
                              **kwargs)
 

def BeautifulSoup.PageElement.findNextSiblings	(	self,
		name = `None`,
		attrs = `{}`,
		text = `None`,
		limit = `None`,
		kwargs
	)

Returns the siblings of this Tag that match the given
criteria and appear after this Tag in the document.

Definition at line 286 of file BeautifulSoup.py.

References BeautifulSoup.PageElement._findAll(), and BeautifulSoup.PageElement.nextSiblingGenerator().

Referenced by BeautifulSoup.PageElement.findNextSibling().

                          **kwargs):
         """Returns the siblings of this Tag that match the given
         criteria and appear after this Tag in the document."""
         return self._findAll(name, attrs, text, limit,
                              self.nextSiblingGenerator, **kwargs)

def BeautifulSoup.PageElement.findParent	(	self,
		name = `None`,
		attrs = `{}`,
		kwargs
	)

Returns the closest parent of this Tag that matches the given
criteria.

Definition at line 320 of file BeautifulSoup.py.

References BeautifulSoup.PageElement.findParents().

     def findParent(self, name=None, attrs={}, **kwargs):
         """Returns the closest parent of this Tag that matches the given
         criteria."""
         # NOTE: We can't use _findOne because findParents takes a different
         # set of arguments.
         r = None
         l = self.findParents(name, attrs, 1)
         if l:
             r = l[0]
         return r
 

def BeautifulSoup.PageElement.findParents	(	self,
		name = `None`,
		attrs = `{}`,
		limit = `None`,
		kwargs
	)

Returns the parents of this Tag that match the given
criteria.

Definition at line 331 of file BeautifulSoup.py.

References BeautifulSoup.PageElement._findAll(), and BeautifulSoup.PageElement.parentGenerator().

Referenced by BeautifulSoup.PageElement.findParent().

     def findParents(self, name=None, attrs={}, limit=None, **kwargs):
         """Returns the parents of this Tag that match the given
         criteria."""
 
         return self._findAll(name, attrs, None, limit, self.parentGenerator,
                              **kwargs)

def BeautifulSoup.PageElement.findPrevious	(	self,
		name = `None`,
		attrs = `{}`,
		text = `None`,
		kwargs
	)

Returns the first item that matches the given criteria and
appears before this Tag in the document.

Definition at line 293 of file BeautifulSoup.py.

References BeautifulSoup.PageElement._findOne(), and BeautifulSoup.PageElement.findAllPrevious().

     def findPrevious(self, name=None, attrs={}, text=None, **kwargs):
         """Returns the first item that matches the given criteria and
         appears before this Tag in the document."""
         return self._findOne(self.findAllPrevious, name, attrs, text, **kwargs)
 

def BeautifulSoup.PageElement.findPreviousSibling	(	self,
		name = `None`,
		attrs = `{}`,
		text = `None`,
		kwargs
	)

Returns the closest sibling to this Tag that matches the
given criteria and appears before this Tag in the document.

Definition at line 306 of file BeautifulSoup.py.

References BeautifulSoup.PageElement._findOne(), and BeautifulSoup.PageElement.findPreviousSiblings().

     def findPreviousSibling(self, name=None, attrs={}, text=None, **kwargs):
         """Returns the closest sibling to this Tag that matches the
         given criteria and appears before this Tag in the document."""
         return self._findOne(self.findPreviousSiblings, name, attrs, text,
                              **kwargs)
 

def BeautifulSoup.PageElement.findPreviousSiblings	(	self,
		name = `None`,
		attrs = `{}`,
		text = `None`,
		limit = `None`,
		kwargs
	)

Returns the siblings of this Tag that match the given
criteria and appear before this Tag in the document.

Definition at line 313 of file BeautifulSoup.py.

References BeautifulSoup.PageElement._findAll(), and BeautifulSoup.PageElement.previousSiblingGenerator().

Referenced by BeautifulSoup.PageElement.findPreviousSibling().

                              limit=None, **kwargs):
         """Returns the siblings of this Tag that match the given
         criteria and appear before this Tag in the document."""
         return self._findAll(name, attrs, text, limit,
                              self.previousSiblingGenerator, **kwargs)

def BeautifulSoup.PageElement.insert	(	self,
		position,
		newChild
	)

Definition at line 204 of file BeautifulSoup.py.

Referenced by BeautifulSoup.PageElement.append().

     def insert(self, position, newChild):
         if isinstance(newChild, basestring) \
             and not isinstance(newChild, NavigableString):
             newChild = NavigableString(newChild)
 
         position =  min(position, len(self.contents))
         if hasattr(newChild, 'parent') and newChild.parent is not None:
             # We're 'inserting' an element that's already one
             # of this object's children.
             if newChild.parent is self:
                 index = self.index(newChild)
                 if index > position:
                     # Furthermore we're moving it further down the
                     # list of this object's children. That means that
                     # when we extract this element, our target index
                     # will jump down one.
                     position = position - 1
             newChild.extract()
 
         newChild.parent = self
         previousChild = None
         if position == 0:
             newChild.previousSibling = None
             newChild.previous = self
         else:
             previousChild = self.contents[position-1]
             newChild.previousSibling = previousChild
             newChild.previousSibling.nextSibling = newChild
             newChild.previous = previousChild._lastRecursiveChild()
         if newChild.previous:
             newChild.previous.next = newChild
 
         newChildsLastElement = newChild._lastRecursiveChild()
 
         if position >= len(self.contents):
             newChild.nextSibling = None
 
             parent = self
             parentsNextSibling = None
             while not parentsNextSibling:
                 parentsNextSibling = parent.nextSibling
                 parent = parent.parent
                 if not parent: # This is the last element in the document.
                     break
             if parentsNextSibling:
                 newChildsLastElement.next = parentsNextSibling
             else:
                 newChildsLastElement.next = None
         else:
             nextChild = self.contents[position]
             newChild.nextSibling = nextChild
             if newChild.nextSibling:
                 newChild.nextSibling.previousSibling = newChild
             newChildsLastElement.next = nextChild
 
         if newChildsLastElement.next:
             newChildsLastElement.next.previous = newChildsLastElement
         self.contents.insert(position, newChild)
 

def BeautifulSoup.PageElement.nextGenerator ( self )

Definition at line 386 of file BeautifulSoup.py.

Referenced by BeautifulSoup.PageElement.findAllNext().

     def nextGenerator(self):
         i = self
         while i is not None:
             i = i.next
             yield i
 

def BeautifulSoup.PageElement.nextSiblingGenerator ( self )

Definition at line 392 of file BeautifulSoup.py.

Referenced by BeautifulSoup.PageElement.findNextSiblings().

     def nextSiblingGenerator(self):
         i = self
         while i is not None:
             i = i.nextSibling
             yield i
 

def BeautifulSoup.PageElement.parentGenerator ( self )

Definition at line 410 of file BeautifulSoup.py.

Referenced by BeautifulSoup.PageElement.findParents().

     def parentGenerator(self):
         i = self
         while i is not None:
             i = i.parent
             yield i
 

def BeautifulSoup.PageElement.previousGenerator ( self )

Definition at line 398 of file BeautifulSoup.py.

Referenced by BeautifulSoup.PageElement.findAllPrevious().

     def previousGenerator(self):
         i = self
         while i is not None:
             i = i.previous
             yield i
 

def BeautifulSoup.PageElement.previousSiblingGenerator ( self )

Definition at line 404 of file BeautifulSoup.py.

Referenced by BeautifulSoup.PageElement.findPreviousSiblings().

     def previousSiblingGenerator(self):
         i = self
         while i is not None:
             i = i.previousSibling
             yield i
 

def BeautifulSoup.PageElement.replaceWith	(	self,
		replaceWith
	)

Definition at line 144 of file BeautifulSoup.py.

References BeautifulSoup.PageElement.extract(), and BeautifulSoup.PageElement.parent.

     def replaceWith(self, replaceWith):
         oldParent = self.parent
         myIndex = self.parent.index(self)
         if hasattr(replaceWith, "parent")\
                   and replaceWith.parent is self.parent:
             # We're replacing this element with one of its siblings.
             index = replaceWith.parent.index(replaceWith)
             if index and index < myIndex:
                 # Furthermore, it comes before this element. That
                 # means that when we extract it, the index of this
                 # element will change.
                 myIndex = myIndex - 1
         self.extract()
         oldParent.insert(myIndex, replaceWith)
 

def BeautifulSoup.PageElement.replaceWithChildren ( self )

Definition at line 159 of file BeautifulSoup.py.

References FastLineRecognition::Cluster.contents, L1GctProcessor::Pipeline< T >.contents, dqm_interfaces.DirFetcher.contents, BeautifulSoup.Tag.contents, BeautifulSoup.PageElement.extract(), list(), and BeautifulSoup.PageElement.parent.

     def replaceWithChildren(self):
         myParent = self.parent
         myIndex = self.parent.index(self)
         self.extract()
         reversedChildren = list(self.contents)
         reversedChildren.reverse()
         for child in reversedChildren:
             myParent.insert(myIndex, child)
 

def BeautifulSoup.PageElement.setup	(	self,
		parent = `None`,
		previous = `None`
	)

Sets up the initial relations between this element and
other elements.

Definition at line 132 of file BeautifulSoup.py.

     def setup(self, parent=None, previous=None):
         """Sets up the initial relations between this element and
         other elements."""
         self.parent = parent
         self.previous = previous
         self.next = None
         self.previousSibling = None
         self.nextSibling = None
         if self.parent and self.parent.contents:
             self.previousSibling = self.parent.contents[-1]
             self.previousSibling.nextSibling = self
 

def BeautifulSoup.PageElement.substituteEncoding	(	self,
		str,
		encoding = `None`
	)

Definition at line 417 of file BeautifulSoup.py.

Referenced by BeautifulSoup.ProcessingInstruction.__str__(), and BeautifulSoup.Tag.__str__().

     def substituteEncoding(self, str, encoding=None):
         encoding = encoding or "utf-8"
         return str.replace("%SOUP-ENCODING%", encoding)
 

def BeautifulSoup.PageElement.toEncoding	(	self,
		s,
		encoding = `None`
	)

Encodes an object to a string in some encoding, or to Unicode.
.

Definition at line 421 of file BeautifulSoup.py.

References str, and BeautifulSoup.PageElement.toEncoding().

Referenced by BeautifulSoup.ProcessingInstruction.__str__(), BeautifulSoup.Tag.__str__(), and BeautifulSoup.PageElement.toEncoding().

     def toEncoding(self, s, encoding=None):
         """Encodes an object to a string in some encoding, or to Unicode.
         ."""
         if isinstance(s, unicode):
             if encoding:
                 s = s.encode(encoding)
         elif isinstance(s, str):
             if encoding:
                 s = s.encode(encoding)
             else:
                 s = unicode(s)
         else:
             if encoding:
                 s  = self.toEncoding(str(s), encoding)
             else:
                 s = unicode(s)
         return s
 