Python ElementTree._setroot方法代码示例

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import _setroot [as 别名]
    def makeXML(self, work_directory):
        # </Artifact>
        TheArtifact = Element( 'Artifact')
        TheArtifact.attrib['xmlns']="http://geni.net/schema"
        TheArtifact.attrib['xmlns:xsi']="http://www.w3.org/2001/XMLSchema-instance"
        TheArtifact.attrib['xsi:schemaLocation']="http://geni.net/schema GENIObject.xsd"

        # <Artifact><Type/>
        Type = SubElement( TheArtifact, 'Type')

        # <Artifact><Type><Primary/>
        Primary = SubElement( Type, 'Primary')
        Primary.text = self.art_type_prime

        # <Artifact><Interpretation/>
        Interpretation = SubElement( TheArtifact, 'Interpretation')
    
        # <Artifact><Interpretation><Interpretation_read_me_text/>
        Read_me_text = SubElement( Interpretation, 'Interpretation_read_me_text')
        Read_me_text.text = self.interpretation_read_me

        #To print to file
        Test = ElementTree()
        Test._setroot(TheArtifact)
        root = Test.getroot()
        self.indent(root)
        Test.write(work_directory+'/artifact.xml')

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import _setroot [as 别名]
def save_settings_data(mainTree,data):
    for s in data:
        if mainTree.find(s)!=None:
            if s=="ICON_PATH" or s=="SAVE_SCREEN_MAP_PATH" or s=="SET_FILE_PATH" or s=="GRAP_PF_NAME"  or s=="GRAP_PF_NAME" :
                mainTree.find(s).text=str(data[s])
            else:
                ()#mainTree.find(s).text=str(data[s])#str(data[s])
                print "xxx"
        else:
            item=Element(s)
            if s=="ICON_PATH" or  s=="SAVE_SCREEN_MAP_PATH" or s=="SET_FILE_PATH" or s=="GRAP_PF_NAME"  or s=="GRAP_PF_NAME" :
                item.text=str(data[s])#"\""+data[s].replace("\\","/")+"\""
            else:
                item.text=str(data[s])
            mainTree.append(item)

        #string
        '''
        #int
        elif s=="LANGUAGE_TYPE" or s=="IMAGE_MAX_SIZE" or s== "IMAGE_MIN_SIZE":
            data_str=str(data[s])
        #float
        elif s=="ADJUST_SCALE_SPEED" or s=="SCALE_SPEED" :
            data_str=str(data[s])
        #array
        elif s=="IMAGE_SCALE_MIN_MAX" :
            for s in data[s]:
                data_str=+str(s)+" "
        '''
        #item.text=data_str
        #mainTree.append(item)
        settings=ElementTree("root")
        settings._setroot(indent(mainTree))
        settings.write(SET_FILE_PATH,"utf-8")
        print "\n save_settings_data: "

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import _setroot [as 别名]
 def writeXML(self,xmlpath="template.xml"):
     tree=ElementTree()
     root=Element("ts")
     for t in self.__torrentStores:
         root.append(t.toElement())
     tree._setroot(root)
     tree.write(xmlpath)

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import _setroot [as 别名]
def saveChange(mainTree,name,s,pos,sc):

	sTree=grapPartElement(name,s,pos,str(sc))

	if mainTree.find(name)!=None:
		mainTree.remove(mainTree.find(name))
	mainTree.append(sTree)

	settings=ElementTree("fengx")
	settings._setroot(indent(mainTree))
	settings.write(SET_FILE_PATH,"utf-8")

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import _setroot [as 别名]
def changeGameMap(usd,m):
    uf=getXMLRoot(usd)

    uf.clear()
    
    item=Element("root")
    itemm=Element(m)
    itemm.text=" "
    item.append(itemm)

    outV = ElementTree()
    outV._setroot(item)
    outV.write(usd)#,"utf-8")

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import _setroot [as 别名]
def addEmoticon(xmlPath,files):
	ID=int(time.time())
	print  xmlPath, files
	fs=files#os.listdir(ROOT_DIR)
	mainXML=ElementTree(file=xmlPath)
	mainRoot=mainXML.getroot()
	haveOn=False
	mainData=mainRoot.find("Catalog")
	'''
	for s in mainRoot.findall("Catalog"):
		if s.get("Title")=="fengx":
			haveOn=True
			#mainData=s
			mainData=mainRoot.find("Catalog")
	if haveOn==False:
		mainData=Element("Catalog", {'id' : "ID_fengx", 'Path' : ' ', "Title":"fengx"})
	
	print haveOn
	'''
	if len(fs)!=0:
		i=1
		for f in fs:
			fileType=os.path.splitext(os.path.split(f)[1])[1] 
			name=os.path.splitext(os.path.split(f)[1])[0]
			if fileType==".jpg" or fileType==".png" or fileType==".bmp" or fileType==".JPG" or fileType==".PNG" or fileType==".GIF" or fileType==".gif":  
				n=name+str(i)
				print n
				print ID
				ID+=1
				print ID
				fileName=n+fileType

				tPath=os.path.split(xmlPath)[0]+"\\"+fileName 		
				shutil.copy(f,  tPath)

				#copyFiles(f, tPath)

				#os.system ("xcopy /s %s %s" % (f, tPath))
				item=emotionElement(str(ID),n,fileName)
				i+=1
				mainData.append(item)
		#if haveOn==False:
		#	mainRoot.append(mainData)
		mainXML._setroot(indent(mainRoot))
		mainXML.write(xmlPath,"utf-8")

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import _setroot [as 别名]
def createSetingsFile():
	global ROOT_DIR
	global GRAP_PF_NAME
	t=Element("root")
	#t.text="fengx"
	files= os.listdir(ROOT_DIR)
	fElement=[]
	i=1
	for m in files:
		nameParts=string.split(os.path.basename(m),"_")
		print nameParts
		if nameParts[0]==GRAP_PF_NAME:
			if os.path.splitext(m)[1]==".png":
				fElement.append(grapPartElement(m,True,[10,10],1))
	for s in fElement:
		t.append(s)

	settings=ElementTree("fengxx")
	settings._setroot(indent(t))
	settings.write(SET_FILE_PATH,"utf-8")

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import _setroot [as 别名]
def createSetingsFile():
    global ROOT_DIR
    global GRAP_PF_NAME
    main_element=Element("root")
    images_element=Element("images")
    #images_element.text="imagePin"
    files= os.listdir(ROOT_DIR)
    haveImage=False
    #print files
    for m in files:
        nameParts=os.path.basename(m).split("_")
        if nameParts[0]==GRAP_PF_NAME:
            if os.path.splitext(m)[1]==".png":
                #image_element.text=m
                haveImage=True
                images_element.append(grapPartElement(m,True,[10,10],1,m))
    settings=ElementTree("fengxx")
    main_element.append(images_element)
    settings._setroot(indent(main_element))
    settings.write(SET_FILE_PATH,"utf-8")
    print "\ncreateSetingsFile: ", SET_FILE_PATH

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import _setroot [as 别名]
def saveChange(mainTree,name,s,pos,sc,filePath):
    global SET_FILE_PATH
    sTree=grapPartElement(name,s,pos,str(sc),filePath)
    changeOn=False
    for s in mainTree.findall("images/image"):
        if s.find("path").text==filePath:
            s.find("path").text=sTree.find("path").text
            s.find("name").text=sTree.find("name").text
            s.find("miniState").text=sTree.find("miniState").text
            s.find("posx").text=sTree.find("posx").text
            s.find("posy").text=sTree.find("posy").text
            s.find("scale").text=sTree.find("scale").text
            changeOn=True
    if changeOn==False:
        mainTree.find("images").append(sTree)


        #for s in mainTree.findall("images/image"):
        #print  s.find("path").text,filePath
    settings=ElementTree("root")
    settings._setroot(indent(mainTree))
    settings.write(SET_FILE_PATH,"utf-8")

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import _setroot [as 别名]
def makeDITA(ts,ctp,node,idir):
    global node_data

    # maximum images per row
    maxrow = 3
    
    if debugMode():
        print("makeDITA",ctp,node.get("id"),node.text)
  
    
    # initialize the DITA XML
    root = fromstring(ts)
    tree = ElementTree()
    tree._setroot(root)
            
    node_text = node.text
    node_id = node.get("id")
    node_author = node.get("user")
    node_created = node.get("created")
    node_textp = node.get("path")
    
    # read in the node body text file
    fp = open(node_textp,"r")
    node_text = fp.read()
    fp.close()

    # set output id and file path
    ditaid = ctp+"_"+node_id
    ditafile = ditaid+".dita"

    if sorttype == SCHRON:
     node_data[node_id] = [ctp,node_created,ditafile,"?"]
    else:
     title_key = node.text.upper()
     title_key = title_key.strip()
     title_key = title_key.replace('\n','')
     while '  ' in title_key:
         title_key = title_key.replace('  ',' ')
     node_data[node_id] = [ctp,title_key,node_created,ditafile,"?"]
     
    title_date = titleDate(node_created)

    # get all the image elements for the node
    images = node.find("images")
    imagelist = iter(images)

    top_images = []
    bot_images = []
    
    # build the image lists
    for image in imagelist:
        top_images.append(image)
       
    # common for all content types
    root.set("id",ditaid)
    titlee = root.find("title")
    # title
    if develMode():
      title_date=title_date+" "+ditafile
    if longtitle:
      titlee.text = node.text+" - "+title_date+", by "+node_author
    else:
        titlee.text = node.text

    # find the body
    conbody = root.find("conbody")

    # tags
    keywords = root.find("prolog/metadata/keywords")
    tags = node.find("tags")
    tlist = iter(tags)
    for t in tlist:
        indt = SubElement(keywords,"indexterm")
        indt.text = t.text

    # create a section for the top images
    if len(top_images)>0:
        section = SubElement(conbody,"section")
        section.set("id","images_top")
        sectp = SubElement(section,"p")
        ni = 0
        for imge in top_images:
          imagefn = idir+'/'+imge.get("filename")
          imagefn = imagefn.replace("\\","/")
          img = SubElement(sectp,"image")
          img.set("href",imagePath(imagefn))
          if not imge.text==None:
            img.set("alt",imge.text)
          ni=ni+1
          if ni>=maxrow:
              sectp = SubElement(section,"p")
              ni=0
              
        
    # create a section for the text
    
    # get filtered node text
    filtered = filterText(node_text)
        
    # write out text in case we bomb out trying to parse it
#.........这里部分代码省略.........

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import _setroot [as 别名]

#.........这里部分代码省略.........
                    else:
                        changeMapOn=False
                try:
                    mmap.find("Texture").text
                except:
                    #print mmap.text
                    #print m.text
                    if changeMapOn==True:
                          LOG+=("\n     can't find diffuse path :   ")
                    changeMapOn=False
                else:
                    DPath=mmap.find("Texture").text.replace("\t","")
                    if  os.path.isfile((ROOTDIR+DPath).replace("\t","")) and changeMapOn==True:
                        LOG+=("\n   difusseMap path :   " +DPath)
                        m.find("fx").text="\tshaders/core/scene_dns.fx\t"
                        
                        try:
                            m.find("collisionFlags").text
                        except:
                            SubElement(m,"collisionFlags").text=" 0 "
                        
                        try:
                            m.find("materialKind").text
                        except:
                            SubElement(m,"materialKind").text=" 0 "
                        mmap.text=mapTypes[0]
                        materialChange=True
            if changeMapOn==True:
                for mmap in m.findall("property"):
                    if len(m.findall("property"))<3:
                        LOG+=("\n   start change material......")
                        miOn=False
                        # check mi 
                        #----set mi
                        try:
                            a=m.find("mi").text
                            #b=m.find("mixxx").text
                            #if a=="" or a=="\r":
                                #miOn=True
                            #changeMapOn=False
                        except:
                            miPath=""
                            name=os.path.splitext(os.path.split(DPath)[1])[0]
                            for p in miPaths:
                                #print (miRootPath+p+"/"+name+".mi")
                                if os.path.isfile((miRootPath+p+"/"+name+".mi").replace("\t","")):
                                    miPath="mi/"+p+name+".mi"  
                                    SubElement(m,"mi").text=miPath
                                    LOG+="\n        set material son: "+miPath
                                    miOn=True
                        if miOn==False:
                            LOG+="\n        can't find the material son  so starting set map:"
                            #----set normal map and specular map
                            maps=getDNS(DPath)
                            #LOG+="\n找到的法线高光"+str(maps)
                            i=0
                            LOG+="\n            set map...."
                            for texP in  maps:
                                if i!=0:
                                    item= Element("property")
                                    item.text=mapTypes[i]
                                    texN=Element("Texture")
                                    if os.path.isfile((ROOTDIR+texP).replace("\t","")):
                                        LOG+="\n                set map ....."+mapTypes[i] + " : "+texP
                                        texN.text=texP
                                        item.append(texN)
                                        m.append(item)
                                    else: 
                                        LOG+="\n                 set map ....."+mapTypes[i] + " : can't find"
                                        texN.text="   "
                                        item.append(texN)
                                        m.append(item)
                                i+=1

                            #---set alhpa
                            name=os.path.splitext(os.path.split(DPath)[1])[0]
                            nameParts=string.split(name,"_")
                            if len(nameParts)>3:
                                if nameParts[len(nameParts)-2]=="a":
                                    LOG+="\n                    set Alpha True"
                                    try:
                                        m.find("\tdoubleSided").text
                                        m.find("\tdoubleSided").find("Int").text
                                    except:
                                        item= Element("property")
                                        item.text=("\tdoubleSided")
                                        itemA=Element("Int")
                                        itemA.text=("\t1\t")
                                        item.append(itemA)
                                        m.append(item)
                                    else:
                                        m.find("\tdoubleSided").find("Int").text="\t1\t"
    outV = ElementTree()
    #print materialChange
    #if materialChange==True:
    outV._setroot(indent(v))
    LOG+="\n        save to a temp "
    print LOG
    #raw_input("LOG")
    outV.write(outVPath,"utf-8")

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import _setroot [as 别名]
def item2DITA(item,topic_string):
    if debugMode():
        print("item2DITA",item.tag,topic_string[0:10])

    DITAnode = None
    
    # initialize the DITA XML from the template
    root = fromstring(topic_string)
    tree = ElementTree()
    tree._setroot(root)
    # find the body
    econbody = root.find('conbody')
    
    # start by setting the title
    eititle = item.find('title')
    edtitle = root.find('title')
    edtitle.text = eititle.text
    if develMode():
        edtitle.text = itemFile(item,'dita')+": "+edtitle.text

    # point to the shortdesc element
    edshort = root.find("shortdesc")
    
    # set the author information
    eprolog = root.find('prolog')
    eauthors = eprolog.findall('author')
    eiauthor = item.find(dcns+'creator')
    creator = eiauthor.text
    for a in eauthors:
        a.text = author_table[creator]
        if debugMode():
            print("author set to",a.text)

    
    
    # set the dates
    epubdate = item.find(wpns+'post_date')
    pubstring = epubdate.text[0:10]
    if develMode():
        edtitle.text = edtitle.text+" - "+pubstring
    edates = eprolog.find('critdates')
    ecreate = edates.find('created')
    ecreate.set('date',pubstring)
    erevised = edates.find('revised')
    erevised.set('modified',pubstring)

    # set the short description
    edshort.text = "Posted "+pubstring+" by "+author_table[creator]

    # make the metadata list
    meta_list = []
    all_cats = item.findall('category')
    for c in all_cats:
        try:
           mkey = c.get('nicename')           
           metadata = meta_table[c.get('nicename')]
           meta_list.append(metadata)
           if debugMode():
            print(' *metadata*',c.get('domain'),metadata)
        except:
            meta_list.append(c.text)

    # set the topic metadata index and keyword information
    emetadata = eprolog.find('metadata')
    ekeywords = emetadata.find('keywords')
    for m in meta_list:
        ek = SubElement(ekeywords,'indexterm')
        ek.text = m
    
    elink = item.find('link')
    eother = SubElement(emetadata,'othermeta')
    eother.set('content',elink.text)
    eother.set('name','URL')
    epostid = item.find(wpns+'post_id')
    eother = SubElement(emetadata,'othermeta')
    eother.set('content',epostid.text)
    eother.set('name','post_id')
    eposttype = item.find(wpns+'post_type')
    eother = SubElement(emetadata,'othermeta')
    eother.set('content',eposttype.text)
    ret_type = eposttype.text
    eother.set('name','post_type')

    # if there is a featured image, create a section for it
    allpmeta = item.findall(wpns+'postmeta')
    if len(allpmeta)>0:
        for pm in allpmeta:
            ekey = pm.find(wpns+'meta_key')
            if not ekey==None:
                if ekey.text=='_thumbnail_id':
                    evalue = pm.find(wpns+'meta_value')
                    if debugMode():
                        print("**featured image is",evalue.text)
                    esection = SubElement(econbody,'section')
                    ep = SubElement(esection,'p')
                    eimage = SubElement(ep,'image')
                    eimage.set("id","featured_image")
                    eimage.set("href",iPath(evalue.text))

    # convert the html body text to DITA sections
#.........这里部分代码省略.........

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import _setroot [as 别名]

#.........这里部分代码省略.........
        
        for element in elist:
            defid = element.getId()
            if defid and defid == ovalid:
                return element
            
                    
        
    
    def addElement(self, element, replace=True):
        """
        Adds the element to the ElementTree for this OVAL document
        The element argument must be of type OvalElement
        This method uses the OVALID of the element to determine what type of element it is
        and if an existing element with that OVALID already exists.
        This method will also create the necessary structure (id est, adding <definitions>, <tests>, etc)
        if the ElementTree does not already contain it.
        By default this method will replace an existing item with the same OVALID, but this behavior can
        be overridden by changing the option second argument to a value of "False"
        Returns True on success, otherwise False
        
        @rtype:    boolean
        @return:    True if the element was added to the document, otherwise False
        """
        if not element or element is None:
            return False
        if not self.tree or self.tree is None:
            return False
        
        ovalid = element.getId()
        if not ovalid:
            return False
        
        root = self.tree.getroot()
        if not root:
            root = Element("{" + OvalDocument.NS_DEFAULT.get("def") + "}oval_definitions")
            self.tree._setroot(root)
            
        # If replace has been set to False, then we want to exit with no changes
        #  when an element with this OVALID already appears in the document            
        if not replace:
            existing = self.getElementByID(ovalid)
            if existing:
                return False;
            
        
        try:
            oval_type = OvalElement.getElementTypeFromOvalID(ovalid)
        except Exception:
            return False
                
        # Depending on the ID type, find the parent for it or create that parent if it doesn't exist
        # Then append the current element
        if oval_type == OvalDefinition.DEFINITION:
            parent = root.find("def:definitions", OvalDocument.NS_DEFAULT)
            if parent is None:
                parent = Element("{" + OvalDocument.NS_DEFAULT.get("def") + "}definitions")
                root.append(parent)
                
            parent.append(element.getElement())
            return True
        
        elif oval_type == OvalDefinition.TEST:
            parent = root.find("def:tests", OvalDocument.NS_DEFAULT)
            if parent is None:
                parent = Element("{" + OvalDocument.NS_DEFAULT.get("def") + "}tests")
                root.append(parent)
                
            parent.append(element.getElement())
            return True
        
        elif oval_type == OvalDefinition.OBJECT:
            parent = root.find("def:objects", OvalDocument.NS_DEFAULT)
            if parent is None:
                parent = Element("{" + OvalDocument.NS_DEFAULT.get("def") + "}objects")
                root.append(parent)
                
            parent.append(element.getElement())
            return True
        
        elif oval_type == OvalDefinition.STATE:
            parent = root.find("def:states", OvalDocument.NS_DEFAULT)
            if parent is None:
                parent = Element("{" + OvalDocument.NS_DEFAULT.get("def") + "}states")
                root.append(parent)
                
            parent.append(element.getElement())
            return True
        
        elif oval_type == OvalDefinition.VARIABLE:
            parent = root.find("def:variables", OvalDocument.NS_DEFAULT)
            if parent is None:
                parent = Element("{" + OvalDocument.NS_DEFAULT.get("def") + "}variables")
                root.append(parent)
                
            parent.append(element.getElement())
            return True
        
        else:
            return False

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import _setroot [as 别名]
def load_weibo_from_bs():
    bs_input = load_bs()
    h = 0
    f = open('jsonTOXML.xml', 'w')
    f.write('<?xml version="1.0" encoding="utf-8"?>'+'\n'+'<statuses>')
    
    for _id, weibo in bs_input.reads():
        id = _id
        created_at = weibo['created_at']
        text = weibo['text']
        source = weibo['source']
        reposts_count = weibo['reposts_count']
        comments_count = weibo['comments_count']
        attitudes_count = weibo['attitudes_count']
        geo = weibo['geo']

        if 'user' not in weibo:
            continue
        user = weibo['user']

        u_id = user['id']
        u_name = user['name']
        u_gender = user['gender']
        u_province = user['province']
        u_city = user['city']
        u_location = user['location']

        if 'description' not in user:
            continue
        u_description = user['description']

        u_verified = user['verified']
        u_followers_count = user['followers_count']
        u_statuses_count = user['statuses_count']
        u_friends_count = user['friends_count']
        u_profile_image_url = user['profile_image_url']
        u_bi_followers_count = user['bi_followers_count']

        if 'verified_type' not in user:
            continue
        u_verified_type = user['verified_type']

        if 'retweeted_status' not in weibo:
            continue

        
        h = h + 1
        print h
        if h > 4:
            break
        if not weibo['retweeted_status']:
            xml_data = ElementTree()
            root = Element('status')
            xml_data._setroot(root)

            root = buildET('id',root,id)
            root = buildET('created_at',root,created_at)
            root = buildET('text',root,text)
            root = buildET('source',root,source)
            root = buildET('reposts_count',root,reposts_count)
            root = buildET('comments_count',root,comments_count)
            root = buildET('attitudes_count',root,attitudes_count)
            root = buildET('geo',root,geo)

            weibo_ip = generateIP()#随机产生一个微博的IP地址
            weibo_city = IP_City(weibo_ip)#将随机产生的IP解析成对应的城市

            while weibo_city == 'Error':#判断IP是否存在
                weibo_ip = generateIP()
                weibo_city = IP_City(weibo_ip)

            root = buildET('IP',root,weibo_ip)            
            root = buildET('address',root,weibo_city)
            
            root = subET(user,'user',root)

            xml_data.write(f, 'utf-8')
            f.write('\n')

        else:
            if 'description' not in weibo['retweeted_status']['user']:
                continue
            if 'user' not in weibo['retweeted_status']:
                continue
            if 'verified_type' not in weibo['retweeted_status']['user']:
                continue
            xml_data = ElementTree()
            root = Element('status')
            xml_data._setroot(root)

            root = buildET('id',root,id)
            root = buildET('created_at',root,created_at)
            root = buildET('text',root,text)
            root = buildET('source',root,source)
            root = buildET('reposts_count',root,reposts_count)
            root = buildET('comments_count',root,comments_count)
            root = buildET('attitudes_count',root,attitudes_count)
            root = buildET('geo',root,geo)

            weibo_ip = generateIP()#随机产生一个微博的IP地址
#.........这里部分代码省略.........

# 需要导入模块: from xml.etree import ElementTree [as 别名]
# 或者: from xml.etree.ElementTree import _setroot [as 别名]
    def makeXML(self, work_directory):
        # </Experiment>
        TheExperiment =Element( 'Experiment')
        TheExperiment.attrib['xmlns']="http://geni.net/schema"
        TheExperiment.attrib['xmlns:xsi']="http://www.w3.org/2001/XMLSchema-instance"
        TheExperiment.attrib['xsi:schemaLocation']="http://geni.net/schema GENIObject.xsd"


        # <Experiment><Name/>
        Name = SubElement( TheExperiment, 'Name')

        # <Experiment><Name><Authority/>
        Authority = SubElement( Name, 'Authority')
        Authority.text = self.exp_authority

        # <Experiment><Name><Name2/>
        Name2 = SubElement( Name, 'Name')
        Name2.attrib['xml:lang']="en-US"
        Name2.text = self.name

        # <Experiment><GENI_experiment_identifier/>
        Exp_id = SubElement( TheExperiment, 'GENI_experiment_identifier')
        Exp_id.text = self.exp_id

        # <Experiment><Individuals/>
        Individuals = SubElement( TheExperiment, 'Individuals')

        # <Experiment><Individuals><Individual/>
        Individual = SubElement( Individuals, 'Individual')

        # <Experiment><Individuals><Individual><Role/>
        Role = SubElement( Individual, 'Role')
        Role.text = self.individual_role

        # <Experiment><Individuals><Individual><Authority/>
        IndAuthority = SubElement( Individual, 'Authority')
        IndAuthority.text = self.individual_authority
  
        # <Experiment><Individuals><Individual><User_name/>
        User = SubElement( Individual, 'User_name')
        User.text = self.individual_user

        # <Experiment><Dates_and_times/>
        Dates_and_times = SubElement( TheExperiment, 'Dates_and_times')
    
        # <Experiment><Dates_and_times><Date_and_time/>
        Date_and_time = SubElement( Dates_and_times, 'Date_and_time')

        # <Experiment><Dates_and_times><Date_and_time><Date_time_type/>
        Date_time_type = SubElement( Date_and_time, 'Date_time_type')
        Date_time_type.text = self.date_time_type

        # <Experiment><Dates_and_times><Date_and_time><Date_time_start/>
        Start = SubElement( Date_and_time, 'Date_time_start')
        Start.text = self.start


        #To print to file
        Test = ElementTree()
        Test._setroot(TheExperiment)
        root = Test.getroot()
        self.indent(root)
        Test.write(work_directory+'/experiment.xml')