Python Element.set_text方法代码示例

# 需要导入模块: from element import Element [as 别名]
# 或者: from element.Element import set_text [as 别名]
	def build_element_tree(self, id_len=10):
		root = Element('html')
		
		if self._jsgen.rand.rint(2):
			style = Element('style')
			style.set_text('*{%s}' % self._jsgen.generate_style_attribute(
						self._jsgen.rand.rint(self.MAX_STYLE_COUNTS)))
			root.append_child(style)
		
		body = Element('body')
		body.set_attribute('id', 'body')
		body.set_attribute('onload', 'cold_start()')
		root.append_child(body)
		self._ids.append('body')
		self._elements.append(body)
		

		init_element_counts = self._jsgen.rand.rint(self.MAX_INIT_ELEMENTS)
		for i in xrange(init_element_counts):
			ele = Element(self._jsgen.random_item(self._jsgen.ELEMENTS))
			ele_id = self._jsgen.rand.rstr(id_len)
			ele.set_attribute('id', ele_id)
			self._jsgen.random_item(self._elements).append_child(ele)
			self._ids.append(ele_id)
			self._elements.append(ele)
			
			if self._jsgen.rand.rint(4) == 0:
				# style初始化处理
				ele.set_attribute('style', self._jsgen.generate_style_attribute(
							self._jsgen.rand.rint(self.MAX_STYLE_COUNTS)))
			
			if self._jsgen.rand.rint(4) == 0:
				# text节点处理
				ele.set_text('AAAAAAAA')
		return root

# 需要导入模块: from element import Element [as 别名]
# 或者: from element.Element import set_text [as 别名]
class Parser:
    """ Clase Parser

    Esta clase se utiliza para leer los archivos xml, tiene como base
    la clase expat del modulo xml de la libreria de python a la cual se le
    agregaron algunas funcionalidades
    """
    def __init__(self):
        """Constructor de la clase.

        Inicializa las propiedades privadas:
        -parser: la cual contiene el parser expat
        -buscando: propiedad que se utiliza en caso de que no se quiera leer
        todo el archivo xml y solo se necesita buscar un elemento en particular
        -nombre_buscar: se utiliza para almacenar el nombre del elemento a buscar
        en caso que no se quiera leer todo el archivo XML sino buscar un elemento
        en particular.
        -encontrado: se utiliza como bandera para indicar si ya fue o no encontrado
        un elemento en particular.
        -elemento: propiedad en la cual se almacena una instancia de la clase element.
        -vec_elementos: vector en el cual se almacenan los elementos que contiene el archivo XML.
        -attrs: dicccionario en el cual se almacenan los atributos del elemento actual que se
        esta leyendo.
        """
        self.__parser = expat.ParserCreate()
        self.__parser.StartElementHandler = self.__start_element
        self.__parser.EndElementHandler = self.__end_element
        self.__parser.CharacterDataHandler = self.__char_data
        self.__buscando = False
        self.__nombre_buscar = ""
        self.__encontrado = False
        self.__elemento = Element()
        self.__vec_elementos = []
        self.__attrs = {}

    def __start_element(self, name, attrs):
        """Wrapper del metodo del mismo nombre de la clase expat.

        La diferencia con el original es que permite dejar de leer el
        archivo una vez encontrado un elemento en particular.
        """
        if self.__buscando:
            if name == self.__nombre_buscar:
                self.__encontrado = True
                self.__elemento.set_name(repr(name))
                self.__elemento.set_attributes(attrs)
            elif self.__encontrado:
                self.__buscando = False

    def __end_element(self, name):
        """Wrapper del metodo del mismo nombre de la clase expat.

        La diferencia con el original es que permite dejar de leer el
        archivo una vez encontrado un elemento en particular.
        """
        if name == self.__nombre_buscar and self.__encontrado:
            self.__buscando = False

    def __char_data(self, data):
        """Wrapper del metodo del mismo nombre de la clase expat.

        La diferencia con el original es que permite dejar de leer el
        archivo una vez encontrado un elemento en particular.
        """
        if self.__buscando and self.__encontrado:
            self.__elemento.set_text(data)
            self.__buscando = False

    def __start_element_attributes(self, name, attrs):
        """ Metodo para buscar un elemento en particular teniendo en cuenta sus atributos.

        Si encuentra el elemento pedido almacena su nombre y sus atributos en
        las propiedades respectivas, luego setea la bandera encontrado a True.
        Si ya encontro el elemento, la siguiente vez que lea un elemento
        nuevo del archivo XML setea la bandera buscado a False para terminar
        con la busqueda.
        Parametros:
        -name: nombre del elemento a buscar.
        -attrs: atributos por los cuales buscar el elemento.
        """
        if self.__buscando:
            if name == self.__nombre_buscar and attrs == self.__attrs:
                self.__encontrado = True
                self.__elemento.set_name(repr(name))
                self.__elemento.set_attributes(attrs)
            elif self.__encontrado:
                self.__buscando = False

    def __start_element_childs(self, name, attrs):
        """ Metodo que se utiliza cuando se desea encontrar todos los hijos de un
        elemento en particular.

        Basicamente su funcionamiento consiste en buscar el elemento padre, una
        vez encontrado almacena todos sus elementos hijos en la propiedad vec_elementos.
        Paramentros:
        -name: nombre del elemento padre.
        -attrs: atributos del elemento padre (se utiliza solo a modo de compatibilidad con el parser expat)
        """
        if name == self.__nombre_buscar:
            self.__encontre_padre = True
#.........这里部分代码省略.........

# 需要导入模块: from element import Element [as 别名]
# 或者: from element.Element import set_text [as 别名]
	def dump_html(self):
		tree = self.build_element_tree()
		script = Element('script')
		script.set_text(JsGen(self._ids).fuzz())
		tree.append_child(script)
		return ''.join((self._htmlpage, tree.convert_to_code()))