Python xml.etree.cElementTree 模块,Element() 实例源码
我们从Python开源项目中,提取了以下50个代码示例,用于说明如何使用xml.etree.cElementTree.Element()。
def benchmark(self, benchmark_file):
xccdftree = ET.Element("Benchmark")
xccdftree.set("id", self.product)
xccdftree.set("xsi:schemaLocation", self.schema)
xccdftree.set("style", self.version.upper())
xccdftree.set("resolved", self.resolved.lower())
xccdftree.set("xml:lang", self.lang)
for prefix, uri in xccdf_ns.items():
xccdftree.set("xmlns:" + prefix, uri)
status = xccdf_subelement(xccdftree, "status", benchmark_file, attrib={"date": datestamp})
common_content = common_xccdf_content(xccdftree, benchmark_file)
notice = xccdf_subelement(xccdftree, "notice", attrib={"id": benchmark_file["notice"]["id"]})
front_matter = xccdf_subelement(xccdftree, "front-matter", "front-matter")
rear_matter = xccdf_subelement(xccdftree, "rear-matter", "rear-matter")
version = xccdf_subelement(xccdftree, "version", "version")
return xccdftree
def saveMean(fname, data):
root = et.Element('opencv_storage')
et.SubElement(root, 'Channel').text = '3'
et.SubElement(root, 'Row').text = str(imgSize)
et.SubElement(root, 'Col').text = str(imgSize)
meanImg = et.SubElement(root, 'MeanImg', type_id='opencv-matrix')
et.SubElement(meanImg, 'rows').text = '1'
et.SubElement(meanImg, 'cols').text = str(imgSize * imgSize * 3)
et.SubElement(meanImg, 'dt').text = 'f'
et.SubElement(meanImg, 'data').text = ' '.join(
['%e' % n for n in np.reshape(data, (imgSize * imgSize * 3))]
)
tree = et.ElementTree(root)
tree.write(fname)
x = xml.dom.minidom.parse(fname)
with open(fname, 'w') as f:
f.write(x.toprettyxml(indent=' '))
def saveMean(fname, 'data').text = ' '.join(['%e' % n for n in np.reshape(data, (imgSize * imgSize * 3))])
tree = et.ElementTree(root)
tree.write(fname)
x = xml.dom.minidom.parse(fname)
with open(fname, 'w') as f:
f.write(x.toprettyxml(indent = ' '))
def saveMean(fname, 'Row').text = str(ImgSize)
et.SubElement(root, 'Col').text = str(ImgSize)
meanImg = et.SubElement(root, 'cols').text = str(ImgSize * ImgSize * 3)
et.SubElement(meanImg, (ImgSize * ImgSize * 3))])
tree = et.ElementTree(root)
tree.write(fname)
x = xml.dom.minidom.parse(fname)
with open(fname, 'w') as f:
f.write(x.toprettyxml(indent = ' '))
def saveMean(fname, 'w') as f:
f.write(x.toprettyxml(indent = ' '))
def cve_parse(self):
"""
Resolve the latest rules,parse new rule from cve.xml
:return: None
"""
cve_file = self.get_cve_file()
if not isinstance(cve_file, list):
tree = self.parse_xml(cve_file)
root = tree.getroot()
childs = root.findall('.//%sentry' % self.NS)
for child in childs: # child is entry Element
cve_id = child.attrib['id']
cve_info = self.cve_info(child)
if len(cve_info) != 0:
self._result[cve_id] = cve_info
else:
for filename in cve_file:
tree = self.parse_xml(filename)
root = tree.getroot()
childs = root.findall('.//%sentry' % self.NS)
for child in childs: # child is entry Element
cve_id = child.attrib['id']
cve_info = self.cve_info(child)
if len(cve_info) != 0:
self._result[cve_id] = cve_info
def CreateEnumDataItem(self, node, data):
""" ?????? """
ed_ns = data.item_ns
ctx = data.item_val
ed_type, ed_desc, ed_items = ctx[:3]
ed_id = "%s.%s" %(ed_ns, ed_type)
tnode = xmllib.Element("Type", {"Id": ed_id,"Name":ed_type,
"Uuid": self.GetTypeUuid(ed_type, ed_ns),
"xsi:type":"Types:Enumeration"
} )
xmllib.SubElement(tnode, "Description").text = ed_desc
#xmllib.SubElement(tnode,"Source").text = "%s[%s]" %(data.source,data.part_name)
for item in ed_items:
it_name, it_value, it_desc = item[:3]
it_id = "%s.%s" %(ed_id, it_name)
inode = xmllib.SubElement(tnode, "Literal", {"Id":it_id,"Name":it_name,
"Value":str(int( it_value ) ) })
xmllib.SubElement(inode, "Description").text = it_desc
node.append(tnode)
#cache type node
self.datastructs[ed_id] = xmllib.tostring(tnode)
def _build_track_item(track, timeline_range, transition_offsets, br_map):
clip_item_e = cElementTree.Element('clipitem', frameBlend='FALSE')
_insert_new_sub_element(
clip_item_e,
'name',
text=os.path.basename(track.name)
)
track_e = _build_track(track, br_map)
clip_item_e.append(_build_rate(track.source_range.start_time))
clip_item_e.extend([_build_marker(m) for m in track.markers])
clip_item_e.append(track_e)
timecode = otio.opentime.RationalTime(0, timeline_range.start_time.rate)
_build_item_timings(
clip_item_e,
track,
timeline_range,
transition_offsets,
timecode
)
return clip_item_e
def _build_track(stack, br_map):
track_e = cElementTree.Element('sequence')
_insert_new_sub_element(track_e, 'name', text=stack.name)
_insert_new_sub_element(
track_e, 'duration',
text='{:.0f}'.format(timeline_range.duration.value)
)
track_e.append(_build_rate(timeline_range.start_time))
track_rate = timeline_range.start_time.rate
media_e = _insert_new_sub_element(track_e, 'media')
video_e = _insert_new_sub_element(media_e, 'video')
audio_e = _insert_new_sub_element(media_e, 'audio')
for track in stack:
if track.kind == otio.schema.TrackKind.Video:
video_e.append(_build_top_level_track(track, track_rate, br_map))
elif track.kind == otio.schema.TrackKind.Audio:
audio_e.append(_build_top_level_track(track, br_map))
for marker in stack.markers:
track_e.append(_build_marker(marker))
return track_e
def create_xml(self):
for i in range(self._hyperparams['num_objects']):
xmldir = '/'.join(str.split(self._hyperparams['filename'], '/')[:-1])
mass = np.random.uniform(.01, 1.)
root = ET.Element("top")
ET.SubElement(root, "inertial", pos="0 0 0", mass="{}".format(mass),
diaginertia="{0} {1} {2}".format(mass/2., mass/2., mass/2.))
tree = ET.ElementTree(root)
xml_str = minidom.parseString(ET.tostring(
tree.getroot(),
'utf-8')).toprettyxml(indent=" ")
xml_str = xml_str.splitlines()[1:]
xml_str = "\n".join(xml_str)
with open(xmldir+"/mass{}.xml".format(i), "wb") as f:
f.write(xml_str)
def saveMean(fname, 'w') as f:
f.write(x.toprettyxml(indent=' '))
def generate_settings_file(target_path):
source_path = xbmc.translatePath(
os.path.join(ADDON.getAddonInfo('path'), 'resources', 'settings.xml'))
root_target = ceT.Element("settings")
tree_source = eT.parse(source_path)
root_source = tree_source.getroot()
for item in root_source.findall('category'):
for setting in item.findall('setting'):
if 'id' in setting.attrib:
value = ''
if 'default' in setting.attrib:
value = setting.attrib['default']
ceT.SubElement(root_target, 'setting', id=setting.attrib['id'], value=value)
tree_target = ceT.ElementTree(root_target)
f = open(target_path, 'w')
tree_target.write(f)
f.close()
def saveMean(fname, 'Row').text = str(IMGSIZE)
et.SubElement(root, 'Col').text = str(IMGSIZE)
meanImg = et.SubElement(root, 'cols').text = str(IMGSIZE * IMGSIZE * 3)
et.SubElement(meanImg, (IMGSIZE * IMGSIZE * 3))])
tree = et.ElementTree(root)
tree.write(fname)
x = xml.dom.minidom.parse(fname)
with open(fname, 'w') as f:
f.write(x.toprettyxml(indent = ' '))
def validated_element(x, tags=None, attrs=None):
"""Checks if the root element of an XML document or Element meets the supplied criteria.
*tags* if specified is either a single allowable tag name or sequence of allowable alternatives
*attrs* if specified is a sequence of required attributes,each of which may be a sequence of several allowable alternatives
Raises :exc:`XMLError` if the requirements are not met.
"""
ele = to_ele(x)
if tags:
if isinstance(tags, basestring):
tags = [tags]
if ele.tag not in tags:
raise XMLError("Element [%s] does not meet requirement" % ele.tag)
if attrs:
for req in attrs:
if isinstance(req, basestring): req = [req]
for alt in req:
if alt in ele.attrib:
break
else:
raise XMLError("Element [%s] does not have required attributes" % ele.tag)
return ele
def _harvest_tree(self, tree, version=1):
"""Populates object members from the data in the tree Element."""
qname, elements, attributes = self.__class__._get_rules(version)
for element in tree:
if elements and element.tag in elements:
deFinition = elements[element.tag]
# If this is a repeating element,make sure the member is set to a
# list.
if deFinition[2]:
if getattr(self, deFinition[0]) is None:
setattr(self, deFinition[0], [])
getattr(self, deFinition[0]).append(_xml_element_from_tree(element,
deFinition[1]))
else:
setattr(self, _xml_element_from_tree(element,
deFinition[1]))
else:
self._other_elements.append(_xml_element_from_tree(element, XmlElement))
for attrib, value in tree.attrib.iteritems():
if attributes and attrib in attributes:
setattr(self, attributes[attrib], value)
else:
self._other_attributes[attrib] = value
if tree.text:
self.text = tree.text
def toXML(self, name):
sketch = ET.Element("sketch")
sketch.attrib["id"] = str(self.sketch_id)
for stk in self.strokes:
for pnt in stk.points:
ET.SubElement(sketch, "point", id = str(pnt.pid), time = str(pnt.time), x = str(pnt.x), y = str(pnt.y))
for stk in self.strokes:
stroke = ET.SubElement(sketch, "stroke")
stroke.attrib["id"] = str(stk.sid)
stroke.attrib["visible"] = "true"
for pnt in stk.points:
ET.SubElement(stroke, "arg", type = "point").text = str(pnt.pid)
tree = ET.ElementTree(sketch)
tree.write( os.path.join(os.getcwd(), 'XMLfiles', 'AfterTraining' , str(name) + ".xml") )
# resamples the sketch before IDM feature extraction
def toXML(self, str(name) + ".xml") )
# resamples the sketch before IDM feature extraction
def send_Feedback(self):
"""Print stored items to console/Alfred as XML."""
root = ET.Element('items')
for item in self._items:
root.append(item.elem)
sys.stdout.write('<?xml version="1.0" encoding="utf-8"?>\n')
sys.stdout.write(ET.tostring(root).encode('utf-8'))
sys.stdout.flush()
####################################################################
# Updating methods
####################################################################
def tree_from_html(htmldata, enc='utf-8'):
# type: (str,str) -> ETree.Element
text = htmldata
text = escape_illegal_xmlchars(text)
if NARROW_BUILD:
# Remove lonely surrogate halfs
text = u''.join(iterchars(text))
text = re.sub(' xmlns="[^"]+"', '', text, count=1)
text = text.replace(' ', ' ')
btext = bytestr('<?xml version="1.0" encoding="%s"?>\n' % enc) + surrencode(text, enc)
tree = ETree.fromstring(btext)
return tree
# The LINENRSEP must not be anything that appears in the line number column of the HTML
# generated by difflib which are digits and the line continuation character '>'.
def add_to_document(self, parent):
"""Adds an ``Argument`` object to this ElementTree document.
Adds an <arg> subelement to the parent element,typically <args>
and sets up its subelements with their respective text.
:param parent: An ``ET.Element`` to be the parent of a new <arg> subelement
:returns: An ``ET.Element`` object representing this argument.
"""
arg = ET.SubElement(parent, "arg")
arg.set("name", self.name)
if self.title is not None:
ET.SubElement(arg, "title").text = self.title
if self.description is not None:
ET.SubElement(arg, "description").text = self.description
if self.validation is not None:
ET.SubElement(arg, "validation").text = self.validation
# add all other subelements to this Argument,represented by (tag,text)
subelements = [
("data_type", self.data_type),
("required_on_edit", self.required_on_edit),
("required_on_create", self.required_on_create)
]
for name, value in subelements:
ET.SubElement(arg, name).text = str(value).lower()
return arg
def to_xml(self):
"""Creates an ``ET.Element`` representing self,then returns it.
:returns root,an ``ET.Element`` representing this scheme.
"""
root = ET.Element("scheme")
ET.SubElement(root, "title").text = self.title
# add a description subelement if it's defined
if self.description is not None:
ET.SubElement(root, "description").text = self.description
# add all other subelements to this Scheme,text)
subelements = [
("use_external_validation", self.use_external_validation),
("use_single_instance", self.use_single_instance),
("streaming_mode", self.streaming_mode)
]
for name, value in subelements:
ET.SubElement(root, name).text = str(value).lower()
endpoint = ET.SubElement(root, "endpoint")
args = ET.SubElement(endpoint, "args")
# add arguments as subelements to the <args> element
for arg in self.arguments:
arg.add_to_document(args)
return root
def write_to(self, stream):
"""Write an XML representation of self,an ``Event`` object,to the given stream.
The ``Event`` object will only be written if its data field is defined,
otherwise a ``ValueError`` is raised.
:param stream: stream to write XML to.
"""
if self.data is None:
raise ValueError("Events must have at least the data field set to be written to XML.")
event = ET.Element("event")
if self.stanza is not None:
event.set("stanza", self.stanza)
event.set("unbroken", str(int(self.unbroken)))
# if a time isn't set,let Splunk guess by not creating a <time> element
if self.time is not None:
ET.SubElement(event, "time").text = str(self.time)
# add all other subelements to this Event,text)
subelements = [
("source", self.source),
("sourcetype", self.sourceType),
("index", self.index),
("host", self.host),
("data", self.data)
]
for node, value in subelements:
if value is not None:
ET.SubElement(event, node).text = value
if self.done:
ET.SubElement(event, "done")
stream.write(ET.tostring(event))
stream.flush()
def send_Feedback(self):
"""Print stored items to console/Alfred as XML."""
root = ET.Element('items')
for item in self._items:
root.append(item.elem)
sys.stdout.write('<?xml version="1.0" encoding="utf-8"?>\n')
sys.stdout.write(ET.tostring(root).encode('utf-8'))
sys.stdout.flush()
####################################################################
# Updating methods
####################################################################
def send_Feedback(self):
"""Print stored items to console/Alfred as XML."""
root = ET.Element('items')
for item in self._items:
root.append(item.elem)
sys.stdout.write('<?xml version="1.0" encoding="utf-8"?>\n')
sys.stdout.write(ET.tostring(root).encode('utf-8'))
sys.stdout.flush()
####################################################################
# Updating methods
####################################################################
def add_to_document(self, name).text = str(value).lower()
return arg
def to_xml(self):
"""Creates an ``ET.Element`` representing self, "args")
# add arguments as subelements to the <args> element
for arg in self.arguments:
arg.add_to_document(args)
return root
def write_to(self, "done")
stream.write(ET.tostring(event))
stream.flush()
def __init__(self):
self.item_processor = itemprocessor()
self.root = ET.Element(u'??????????????????????')
self.root.set(u'???????????', '2.05')
self.root.set(u'????????????????', six.text_type(datetime.Now().date()))
def xccdf_element(xccdf_element, yamlcontent, yaml_key=None, attrib=None):
yaml_key = yaml_key_value(yamlcontent, yaml_key)
new_element = ET.Element(xccdf_element)
if attrib is not None:
new_element = add_attrib_to_element(new_element, attrib, yamlcontent)
return new_element
def send_Feedback(self):
"""Print stored items to console/Alfred as XML."""
root = ET.Element('items')
for item in self._items:
root.append(item.elem)
sys.stdout.write('<?xml version="1.0" encoding="utf-8"?>\n')
sys.stdout.write(ET.tostring(root).encode('utf-8'))
sys.stdout.flush()
####################################################################
# Updating methods
####################################################################
def send_Feedback(self):
"""Print stored items to console/Alfred as XML."""
root = ET.Element('items')
for item in self._items:
root.append(item.elem)
sys.stdout.write('<?xml version="1.0" encoding="utf-8"?>\n')
sys.stdout.write(ET.tostring(root).encode('utf-8'))
sys.stdout.flush()
####################################################################
# Updating methods
####################################################################
def __call__(self, target, width, height):
"""
Arguments:
target (annotation) : the target annotation to be made usable
will be an ET.Element
Returns:
a list containing lists of bounding Boxes [bBox coords,class name]
"""
res = []
for obj in target.iter('object'):
difficult = int(obj.find('difficult').text) == 1
if not self.keep_difficult and difficult:
continue
name = obj.find('name').text.lower().strip()
bBox = obj.find('bndBox')
pts = ['xmin', 'ymin', 'xmax', 'ymax']
bndBox = []
for i, pt in enumerate(pts):
cur_pt = int(bBox.find(pt).text) - 1
# scale height or width
cur_pt = cur_pt / width if i % 2 == 0 else cur_pt / height
bndBox.append(cur_pt)
label_idx = self.class_to_ind[name]
bndBox.append(label_idx)
res += [bndBox] # [xmin,ymin,xmax,ymax,label_ind]
# img_id = target.find('filename').text[:-4]
return res # [[xmin,label_ind],... ]
def _BecomeChildElement(self, tree):
"""
Note: Only for use with classes that have a _tag and _namespace class
member. It is in AtomBase so that it can be inherited but it should
not be called on instances of AtomBase.
"""
new_child = ElementTree.Element('')
tree.append(new_child)
new_child.tag = '{%s}%s' % (self.__class__._namespace,
self.__class__._tag)
self._AddMemberstoElementTree(new_child)
def _toElementTree(self):
"""
Note,this method is designed to be used only with classes that have a
_tag and _namespace. It is placed in AtomBase for inheritance but should
not be called on this class.
"""
new_tree = ElementTree.Element('{%s}%s' % (self.__class__._namespace,
self.__class__._tag))
self._AddMemberstoElementTree(new_tree)
return new_tree
def ToString(self):
element_tree = self._TransfertoElementTree(ElementTree.Element(''))
return ElementTree.tostring(element_tree, encoding="UTF-8")
def _BecomeChildElement(self, element_tree):
"""Converts this object into an etree element and adds it as a child node.
Adds self to the ElementTree. This method is required to avoid verbose XML
which constantly redefines the namespace.
Args:
element_tree: ElementTree._Element The element to which this object's XML
will be added.
"""
new_element = ElementTree.Element('')
element_tree.append(new_element)
self._TransfertoElementTree(new_element)
def _harvest_tree(self,make sure the member is set to a
# list.
if deFinition[2]:
if getattr(self,
deFinition[1], version))
else:
setattr(self, version))
else:
self._other_elements.append(_xml_element_from_tree(element, XmlElement,
version))
for attrib, value)
else:
self._other_attributes[attrib] = value
if tree.text:
self.text = tree.text
def _become_child(self, version=1):
"""Adds a child element to tree with the XML data in self."""
new_child = ElementTree.Element('')
tree.append(new_child)
new_child.tag = _get_qname(self, version)
self._attach_members(new_child, version)
def internal_to_elem(pfsh, factory=ET.Element):
"""Convert an internal dictionary (not JSON!) into an Element.
Whatever Element implementation we Could import will be
used by default; if you want to use something else,pass the
Element class as the factory parameter.
"""
attribs = {}
text = None
tail = None
sublist = []
tag = list(pfsh.keys())
if len(tag) != 1:
raise ValueError("Illegal structure with multiple tags: %s" % tag)
tag = tag[0]
value = pfsh[tag]
if isinstance(value, dict):
for k, v in list(value.items()):
if k[:1] == "@":
attribs[k[1:]] = v
elif k == "#text":
text = v
elif k == "#tail":
tail = v
elif isinstance(v, list):
for v2 in v:
sublist.append(internal_to_elem({k: v2}, factory=factory))
else:
sublist.append(internal_to_elem({k: v}, factory=factory))
else:
text = value
e = factory(tag, attribs)
for sub in sublist:
e.append(sub)
e.text = text
e.tail = tail
return e
def elem2json(elem, strip_ns=1, strip=1):
"""Convert an ElementTree or Element into a JSON string."""
if hasattr(elem, 'getroot'):
elem = elem.getroot()
return elem_to_internal(elem, strip_ns=strip_ns, strip=strip)
def json2elem(json_data, factory=ET.Element):
"""Convert a JSON string into an Element.
Whatever Element implementation we Could import will be used by
default; if you want to use something else,pass the Element class
as the factory parameter.
"""
return internal_to_elem(json.loads(json_data), factory)
def json2xml(json_data, factory=ET.Element):
"""Convert a JSON string into an XML string.
Whatever Element implementation we Could import will be used by
default; if you want to use something else,pass the Element class
as the factory parameter.
"""
if not isinstance(json_data, dict):
json_data = json.loads(json_data)
elem = internal_to_elem(json_data, factory)
return ET.tostring(elem)
def send_Feedback(self):
"""Print stored items to console/Alfred as XML."""
root = ET.Element('items')
for item in self._items:
root.append(item.elem)
sys.stdout.write('<?xml version="1.0" encoding="utf-8"?>\n')
sys.stdout.write(ET.tostring(root).encode('utf-8'))
sys.stdout.flush()
####################################################################
# Updating methods
####################################################################
def send_Feedback(self):
"""Print stored items to console/Alfred as XML."""
root = ET.Element('items')
for item in self._items:
root.append(item.elem)
sys.stdout.write('<?xml version="1.0" encoding="utf-8"?>\n')
sys.stdout.write(ET.tostring(root).encode('utf-8'))
sys.stdout.flush()
####################################################################
# Updating methods
####################################################################
def send_Feedback(self):
"""Print stored items to console/Alfred as XML."""
root = ET.Element('items')
for item in self._items:
root.append(item.elem)
sys.stdout.write('<?xml version="1.0" encoding="utf-8"?>\n')
sys.stdout.write(ET.tostring(root).encode('utf-8'))
sys.stdout.flush()
####################################################################
# Updating methods
####################################################################
def send_Feedback(self):
"""Print stored items to console/Alfred as XML."""
root = ET.Element('items')
for item in self._items:
root.append(item.elem)
sys.stdout.write('<?xml version="1.0" encoding="utf-8"?>\n')
sys.stdout.write(ET.tostring(root).encode('utf-8'))
sys.stdout.flush()
####################################################################
# Updating methods
####################################################################
def send_Feedback(self):
"""Print stored items to console/Alfred as XML."""
root = ET.Element('items')
for item in self._items:
root.append(item.elem)
sys.stdout.write('<?xml version="1.0" encoding="utf-8"?>\n')
sys.stdout.write(ET.tostring(root).encode('utf-8'))
sys.stdout.flush()
####################################################################
# Updating methods
####################################################################
def elem_create(self, class_tag, xml_doc=None, override_tag=None):
if xml_doc is None:
xml_obj = Element(class_tag)
else:
if override_tag:
xml_obj = SubElement(xml_doc, override_tag)
else:
xml_obj = SubElement(xml_doc, class_tag)
return xml_obj
def to_xml(self, option=None, cookie=None):
"""
This method returns the xml element node for the current object
with it's hierarchy.
Args:
xml_doc: document to which the Mo attributes are added.
Can be None.
option: not required for Generic Mo class object
Example:
from imcmsdk.imcmo import GenericMo\n
args = {"a": 1,"b": 2,"c":3}\n
obj = GenericMo("testLsA","org-root",**args)\n
obj1 = GenericMo("testLsB",**args)\n
obj.add_child(obj1)\n
elem = obj.write_xml()\n
import imcmsdk.imcxmlcodec as xc\n
xc.to_xml_str(elem)\n
Output:
'<testLsA a="1" b="2" c="3" dn="org-root/" rn="">\n
<testLsB a="1" b="2" c="3" dn="org-root/" rn="" />\n
</testLsA>'
"""
if xml_doc is None:
xml_obj = Element(imcgenutils.word_l(self._class_id))
else:
xml_obj = SubElement(xml_doc, imcgenutils.word_l(self._class_id))
for key in self.__dict__:
if not key.startswith('_'):
xml_obj.set(key, getattr(self, key))
self.child_to_xml(xml_obj)
return xml_obj
def send_Feedback(self):
"""Print stored items to console/Alfred as XML."""
root = ET.Element('items')
for item in self._items:
root.append(item.elem)
sys.stdout.write('<?xml version="1.0" encoding="utf-8"?>\n')
sys.stdout.write(ET.tostring(root).encode('utf-8'))
sys.stdout.flush()
####################################################################
# Updating methods
####################################################################