bazarr/libs/dynaconf/vendor/ruamel/yaml/representer.py

from __future__ import print_function,absolute_import,division
_T='tag:yaml.org,2002:'
_S='tag:yaml.org,2002:python/object:'
_R='__getstate__'
_Q='tag:yaml.org,2002:set'
_P='base64'
_O='tag:yaml.org,2002:python/object/new:'
_N='tag:yaml.org,2002:timestamp'
_M='tag:yaml.org,2002:map'
_L='tag:yaml.org,2002:seq'
_K='tag:yaml.org,2002:float'
_J='tag:yaml.org,2002:binary'
_I='tag:yaml.org,2002:null'
_H='%s.%s'
_G='tag:yaml.org,2002:int'
_F='comment'
_E='ascii'
_D='tag:yaml.org,2002:str'
_C=False
_B=True
_A=None
from.error import*
from.nodes import*
from.compat import text_type,binary_type,to_unicode,PY2,PY3
from.compat import ordereddict
from.compat import nprint,nprintf
from.scalarstring import LiteralScalarString,FoldedScalarString,SingleQuotedScalarString,DoubleQuotedScalarString,PlainScalarString
from.scalarint import ScalarInt,BinaryInt,OctalInt,HexInt,HexCapsInt
from.scalarfloat import ScalarFloat
from.scalarbool import ScalarBoolean
from.timestamp import TimeStamp
import datetime,sys,types
if PY3:import copyreg,base64
else:import copy_reg as copyreg
if _C:from typing import Dict,List,Any,Union,Text,Optional
__all__=['BaseRepresenter','SafeRepresenter','Representer','RepresenterError','RoundTripRepresenter']
class RepresenterError(YAMLError):0
if PY2:
	def get_classobj_bases(cls):
		bases=[cls]
		for base in cls.__bases__:bases.extend(get_classobj_bases(base))
		return bases
class BaseRepresenter:
	yaml_representers={};yaml_multi_representers={}
	def __init__(self,default_style=_A,default_flow_style=_A,dumper=_A):
		self.dumper=dumper
		if self.dumper is not _A:self.dumper._representer=self
		self.default_style=default_style;self.default_flow_style=default_flow_style;self.represented_objects={};self.object_keeper=[];self.alias_key=_A;self.sort_base_mapping_type_on_output=_B
	@property
	def serializer(self):
		try:
			if hasattr(self.dumper,'typ'):return self.dumper.serializer
			return self.dumper._serializer
		except AttributeError:return self
	def represent(self,data):node=self.represent_data(data);self.serializer.serialize(node);self.represented_objects={};self.object_keeper=[];self.alias_key=_A
	def represent_data(self,data):
		if self.ignore_aliases(data):self.alias_key=_A
		else:self.alias_key=id(data)
		if self.alias_key is not _A:
			if self.alias_key in self.represented_objects:node=self.represented_objects[self.alias_key];return node
			self.object_keeper.append(data)
		data_types=type(data).__mro__
		if PY2:
			if isinstance(data,types.InstanceType):data_types=get_classobj_bases(data.__class__)+list(data_types)
		if data_types[0]in self.yaml_representers:node=self.yaml_representers[data_types[0]](self,data)
		else:
			for data_type in data_types:
				if data_type in self.yaml_multi_representers:node=self.yaml_multi_representers[data_type](self,data);break
			else:
				if _A in self.yaml_multi_representers:node=self.yaml_multi_representers[_A](self,data)
				elif _A in self.yaml_representers:node=self.yaml_representers[_A](self,data)
				else:node=ScalarNode(_A,text_type(data))
		return node
	def represent_key(self,data):return self.represent_data(data)
	@classmethod
	def add_representer(cls,data_type,representer):
		if'yaml_representers'not in cls.__dict__:cls.yaml_representers=cls.yaml_representers.copy()
		cls.yaml_representers[data_type]=representer
	@classmethod
	def add_multi_representer(cls,data_type,representer):
		if'yaml_multi_representers'not in cls.__dict__:cls.yaml_multi_representers=cls.yaml_multi_representers.copy()
		cls.yaml_multi_representers[data_type]=representer
	def represent_scalar(self,tag,value,style=_A,anchor=_A):
		if style is _A:style=self.default_style
		comment=_A
		if style and style[0]in'|>':
			comment=getattr(value,_F,_A)
			if comment:comment=[_A,[comment]]
		node=ScalarNode(tag,value,style=style,comment=comment,anchor=anchor)
		if self.alias_key is not _A:self.represented_objects[self.alias_key]=node
		return node
	def represent_sequence(self,tag,sequence,flow_style=_A):
		value=[];node=SequenceNode(tag,value,flow_style=flow_style)
		if self.alias_key is not _A:self.represented_objects[self.alias_key]=node
		best_style=_B
		for item in sequence:
			node_item=self.represent_data(item)
			if not(isinstance(node_item,ScalarNode)and not node_item.style):best_style=_C
			value.append(node_item)
		if flow_style is _A:
			if self.default_flow_style is not _A:node.flow_style=self.default_flow_style
			else:node.flow_style=best_style
		return node
	def represent_omap(self,tag,omap,flow_style=_A):
		value=[];node=SequenceNode(tag,value,flow_style=flow_style)
		if self.alias_key is not _A:self.represented_objects[self.alias_key]=node
		best_style=_B
		for item_key in omap:item_val=omap[item_key];node_item=self.represent_data({item_key:item_val});value.append(node_item)
		if flow_style is _A:
			if self.default_flow_style is not _A:node.flow_style=self.default_flow_style
			else:node.flow_style=best_style
		return node
	def represent_mapping(self,tag,mapping,flow_style=_A):
		value=[];node=MappingNode(tag,value,flow_style=flow_style)
		if self.alias_key is not _A:self.represented_objects[self.alias_key]=node
		best_style=_B
		if hasattr(mapping,'items'):
			mapping=list(mapping.items())
			if self.sort_base_mapping_type_on_output:
				try:mapping=sorted(mapping)
				except TypeError:pass
		for(item_key,item_value)in mapping:
			node_key=self.represent_key(item_key);node_value=self.represent_data(item_value)
			if not(isinstance(node_key,ScalarNode)and not node_key.style):best_style=_C
			if not(isinstance(node_value,ScalarNode)and not node_value.style):best_style=_C
			value.append((node_key,node_value))
		if flow_style is _A:
			if self.default_flow_style is not _A:node.flow_style=self.default_flow_style
			else:node.flow_style=best_style
		return node
	def ignore_aliases(self,data):return _C
class SafeRepresenter(BaseRepresenter):
	def ignore_aliases(self,data):
		if data is _A or isinstance(data,tuple)and data==():return _B
		if isinstance(data,(binary_type,text_type,bool,int,float)):return _B
		return _C
	def represent_none(self,data):return self.represent_scalar(_I,'null')
	if PY3:
		def represent_str(self,data):return self.represent_scalar(_D,data)
		def represent_binary(self,data):
			if hasattr(base64,'encodebytes'):data=base64.encodebytes(data).decode(_E)
			else:data=base64.encodestring(data).decode(_E)
			return self.represent_scalar(_J,data,style='|')
	else:
		def represent_str(self,data):
			tag=_A;style=_A
			try:data=unicode(data,_E);tag=_D
			except UnicodeDecodeError:
				try:data=unicode(data,'utf-8');tag=_D
				except UnicodeDecodeError:data=data.encode(_P);tag=_J;style='|'
			return self.represent_scalar(tag,data,style=style)
		def represent_unicode(self,data):return self.represent_scalar(_D,data)
	def represent_bool(self,data,anchor=_A):
		try:value=self.dumper.boolean_representation[bool(data)]
		except AttributeError:
			if data:value='true'
			else:value='false'
		return self.represent_scalar('tag:yaml.org,2002:bool',value,anchor=anchor)
	def represent_int(self,data):return self.represent_scalar(_G,text_type(data))
	if PY2:
		def represent_long(self,data):return self.represent_scalar(_G,text_type(data))
	inf_value=1e300
	while repr(inf_value)!=repr(inf_value*inf_value):inf_value*=inf_value
	def represent_float(self,data):
		if data!=data or data==.0 and data==1.:value='.nan'
		elif data==self.inf_value:value='.inf'
		elif data==-self.inf_value:value='-.inf'
		else:
			value=to_unicode(repr(data)).lower()
			if getattr(self.serializer,'use_version',_A)==(1,1):
				if'.'not in value and'e'in value:value=value.replace('e','.0e',1)
		return self.represent_scalar(_K,value)
	def represent_list(self,data):return self.represent_sequence(_L,data)
	def represent_dict(self,data):return self.represent_mapping(_M,data)
	def represent_ordereddict(self,data):return self.represent_omap('tag:yaml.org,2002:omap',data)
	def represent_set(self,data):
		value={}
		for key in data:value[key]=_A
		return self.represent_mapping(_Q,value)
	def represent_date(self,data):value=to_unicode(data.isoformat());return self.represent_scalar(_N,value)
	def represent_datetime(self,data):value=to_unicode(data.isoformat(' '));return self.represent_scalar(_N,value)
	def represent_yaml_object(self,tag,data,cls,flow_style=_A):
		if hasattr(data,_R):state=data.__getstate__()
		else:state=data.__dict__.copy()
		return self.represent_mapping(tag,state,flow_style=flow_style)
	def represent_undefined(self,data):raise RepresenterError('cannot represent an object: %s'%(data,))
SafeRepresenter.add_representer(type(_A),SafeRepresenter.represent_none)
SafeRepresenter.add_representer(str,SafeRepresenter.represent_str)
if PY2:SafeRepresenter.add_representer(unicode,SafeRepresenter.represent_unicode)
else:SafeRepresenter.add_representer(bytes,SafeRepresenter.represent_binary)
SafeRepresenter.add_representer(bool,SafeRepresenter.represent_bool)
SafeRepresenter.add_representer(int,SafeRepresenter.represent_int)
if PY2:SafeRepresenter.add_representer(long,SafeRepresenter.represent_long)
SafeRepresenter.add_representer(float,SafeRepresenter.represent_float)
SafeRepresenter.add_representer(list,SafeRepresenter.represent_list)
SafeRepresenter.add_representer(tuple,SafeRepresenter.represent_list)
SafeRepresenter.add_representer(dict,SafeRepresenter.represent_dict)
SafeRepresenter.add_representer(set,SafeRepresenter.represent_set)
SafeRepresenter.add_representer(ordereddict,SafeRepresenter.represent_ordereddict)
if sys.version_info>=(2,7):import collections;SafeRepresenter.add_representer(collections.OrderedDict,SafeRepresenter.represent_ordereddict)
SafeRepresenter.add_representer(datetime.date,SafeRepresenter.represent_date)
SafeRepresenter.add_representer(datetime.datetime,SafeRepresenter.represent_datetime)
SafeRepresenter.add_representer(_A,SafeRepresenter.represent_undefined)
class Representer(SafeRepresenter):
	if PY2:
		def represent_str(self,data):
			tag=_A;style=_A
			try:data=unicode(data,_E);tag=_D
			except UnicodeDecodeError:
				try:data=unicode(data,'utf-8');tag='tag:yaml.org,2002:python/str'
				except UnicodeDecodeError:data=data.encode(_P);tag=_J;style='|'
			return self.represent_scalar(tag,data,style=style)
		def represent_unicode(self,data):
			tag=_A
			try:data.encode(_E);tag='tag:yaml.org,2002:python/unicode'
			except UnicodeEncodeError:tag=_D
			return self.represent_scalar(tag,data)
		def represent_long(self,data):
			tag=_G
			if int(data)is not data:tag='tag:yaml.org,2002:python/long'
			return self.represent_scalar(tag,to_unicode(data))
	def represent_complex(self,data):
		if data.imag==.0:data='%r'%data.real
		elif data.real==.0:data='%rj'%data.imag
		elif data.imag>0:data='%r+%rj'%(data.real,data.imag)
		else:data='%r%rj'%(data.real,data.imag)
		return self.represent_scalar('tag:yaml.org,2002:python/complex',data)
	def represent_tuple(self,data):return self.represent_sequence('tag:yaml.org,2002:python/tuple',data)
	def represent_name(self,data):
		try:name=_H%(data.__module__,data.__qualname__)
		except AttributeError:name=_H%(data.__module__,data.__name__)
		return self.represent_scalar('tag:yaml.org,2002:python/name:'+name,'')
	def represent_module(self,data):return self.represent_scalar('tag:yaml.org,2002:python/module:'+data.__name__,'')
	if PY2:
		def represent_instance(self,data):
			cls=data.__class__;class_name=_H%(cls.__module__,cls.__name__);args=_A;state=_A
			if hasattr(data,'__getinitargs__'):args=list(data.__getinitargs__())
			if hasattr(data,_R):state=data.__getstate__()
			else:state=data.__dict__
			if args is _A and isinstance(state,dict):return self.represent_mapping(_S+class_name,state)
			if isinstance(state,dict)and not state:return self.represent_sequence(_O+class_name,args)
			value={}
			if bool(args):value['args']=args
			value['state']=state;return self.represent_mapping(_O+class_name,value)
	def represent_object(self,data):
		cls=type(data)
		if cls in copyreg.dispatch_table:reduce=copyreg.dispatch_table[cls](data)
		elif hasattr(data,'__reduce_ex__'):reduce=data.__reduce_ex__(2)
		elif hasattr(data,'__reduce__'):reduce=data.__reduce__()
		else:raise RepresenterError('cannot represent object: %r'%(data,))
		reduce=(list(reduce)+[_A]*5)[:5];function,args,state,listitems,dictitems=reduce;args=list(args)
		if state is _A:state={}
		if listitems is not _A:listitems=list(listitems)
		if dictitems is not _A:dictitems=dict(dictitems)
		if function.__name__=='__newobj__':function=args[0];args=args[1:];tag=_O;newobj=_B
		else:tag='tag:yaml.org,2002:python/object/apply:';newobj=_C
		try:function_name=_H%(function.__module__,function.__qualname__)
		except AttributeError:function_name=_H%(function.__module__,function.__name__)
		if not args and not listitems and not dictitems and isinstance(state,dict)and newobj:return self.represent_mapping(_S+function_name,state)
		if not listitems and not dictitems and isinstance(state,dict)and not state:return self.represent_sequence(tag+function_name,args)
		value={}
		if args:value['args']=args
		if state or not isinstance(state,dict):value['state']=state
		if listitems:value['listitems']=listitems
		if dictitems:value['dictitems']=dictitems
		return self.represent_mapping(tag+function_name,value)
if PY2:Representer.add_representer(str,Representer.represent_str);Representer.add_representer(unicode,Representer.represent_unicode);Representer.add_representer(long,Representer.represent_long)
Representer.add_representer(complex,Representer.represent_complex)
Representer.add_representer(tuple,Representer.represent_tuple)
Representer.add_representer(type,Representer.represent_name)
if PY2:Representer.add_representer(types.ClassType,Representer.represent_name)
Representer.add_representer(types.FunctionType,Representer.represent_name)
Representer.add_representer(types.BuiltinFunctionType,Representer.represent_name)
Representer.add_representer(types.ModuleType,Representer.represent_module)
if PY2:Representer.add_multi_representer(types.InstanceType,Representer.represent_instance)
Representer.add_multi_representer(object,Representer.represent_object)
Representer.add_multi_representer(type,Representer.represent_name)
from.comments import CommentedMap,CommentedOrderedMap,CommentedSeq,CommentedKeySeq,CommentedKeyMap,CommentedSet,comment_attrib,merge_attrib,TaggedScalar
class RoundTripRepresenter(SafeRepresenter):
	def __init__(self,default_style=_A,default_flow_style=_A,dumper=_A):
		if not hasattr(dumper,'typ')and default_flow_style is _A:default_flow_style=_C
		SafeRepresenter.__init__(self,default_style=default_style,default_flow_style=default_flow_style,dumper=dumper)
	def ignore_aliases(self,data):
		try:
			if data.anchor is not _A and data.anchor.value is not _A:return _C
		except AttributeError:pass
		return SafeRepresenter.ignore_aliases(self,data)
	def represent_none(self,data):
		if len(self.represented_objects)==0 and not self.serializer.use_explicit_start:return self.represent_scalar(_I,'null')
		return self.represent_scalar(_I,'')
	def represent_literal_scalarstring(self,data):
		tag=_A;style='|';anchor=data.yaml_anchor(any=_B)
		if PY2 and not isinstance(data,unicode):data=unicode(data,_E)
		tag=_D;return self.represent_scalar(tag,data,style=style,anchor=anchor)
	represent_preserved_scalarstring=represent_literal_scalarstring
	def represent_folded_scalarstring(self,data):
		tag=_A;style='>';anchor=data.yaml_anchor(any=_B)
		for fold_pos in reversed(getattr(data,'fold_pos',[])):
			if data[fold_pos]==' 'and(fold_pos>0 and not data[fold_pos-1].isspace())and(fold_pos<len(data)and not data[fold_pos+1].isspace()):data=data[:fold_pos]+'\x07'+data[fold_pos:]
		if PY2 and not isinstance(data,unicode):data=unicode(data,_E)
		tag=_D;return self.represent_scalar(tag,data,style=style,anchor=anchor)
	def represent_single_quoted_scalarstring(self,data):
		tag=_A;style="'";anchor=data.yaml_anchor(any=_B)
		if PY2 and not isinstance(data,unicode):data=unicode(data,_E)
		tag=_D;return self.represent_scalar(tag,data,style=style,anchor=anchor)
	def represent_double_quoted_scalarstring(self,data):
		tag=_A;style='"';anchor=data.yaml_anchor(any=_B)
		if PY2 and not isinstance(data,unicode):data=unicode(data,_E)
		tag=_D;return self.represent_scalar(tag,data,style=style,anchor=anchor)
	def represent_plain_scalarstring(self,data):
		tag=_A;style='';anchor=data.yaml_anchor(any=_B)
		if PY2 and not isinstance(data,unicode):data=unicode(data,_E)
		tag=_D;return self.represent_scalar(tag,data,style=style,anchor=anchor)
	def insert_underscore(self,prefix,s,underscore,anchor=_A):
		A='_'
		if underscore is _A:return self.represent_scalar(_G,prefix+s,anchor=anchor)
		if underscore[0]:
			sl=list(s);pos=len(s)-underscore[0]
			while pos>0:sl.insert(pos,A);pos-=underscore[0]
			s=''.join(sl)
		if underscore[1]:s=A+s
		if underscore[2]:s+=A
		return self.represent_scalar(_G,prefix+s,anchor=anchor)
	def represent_scalar_int(self,data):
		if data._width is not _A:s='{:0{}d}'.format(data,data._width)
		else:s=format(data,'d')
		anchor=data.yaml_anchor(any=_B);return self.insert_underscore('',s,data._underscore,anchor=anchor)
	def represent_binary_int(self,data):
		if data._width is not _A:s='{:0{}b}'.format(data,data._width)
		else:s=format(data,'b')
		anchor=data.yaml_anchor(any=_B);return self.insert_underscore('0b',s,data._underscore,anchor=anchor)
	def represent_octal_int(self,data):
		if data._width is not _A:s='{:0{}o}'.format(data,data._width)
		else:s=format(data,'o')
		anchor=data.yaml_anchor(any=_B);return self.insert_underscore('0o',s,data._underscore,anchor=anchor)
	def represent_hex_int(self,data):
		if data._width is not _A:s='{:0{}x}'.format(data,data._width)
		else:s=format(data,'x')
		anchor=data.yaml_anchor(any=_B);return self.insert_underscore('0x',s,data._underscore,anchor=anchor)
	def represent_hex_caps_int(self,data):
		if data._width is not _A:s='{:0{}X}'.format(data,data._width)
		else:s=format(data,'X')
		anchor=data.yaml_anchor(any=_B);return self.insert_underscore('0x',s,data._underscore,anchor=anchor)
	def represent_scalar_float(self,data):
		B='{:{}0{}d}';A='0';value=_A;anchor=data.yaml_anchor(any=_B)
		if data!=data or data==.0 and data==1.:value='.nan'
		elif data==self.inf_value:value='.inf'
		elif data==-self.inf_value:value='-.inf'
		if value:return self.represent_scalar(_K,value,anchor=anchor)
		if data._exp is _A and data._prec>0 and data._prec==data._width-1:value='{}{:d}.'.format(data._m_sign if data._m_sign else'',abs(int(data)))
		elif data._exp is _A:
			prec=data._prec;ms=data._m_sign if data._m_sign else'';value='{}{:0{}.{}f}'.format(ms,abs(data),data._width-len(ms),data._width-prec-1)
			if prec==0 or prec==1 and ms!='':value=value.replace('0.','.')
			while len(value)<data._width:value+=A
		else:
			m,es='{:{}.{}e}'.format(data,data._width,data._width+(1 if data._m_sign else 0)).split('e');w=data._width if data._prec>0 else data._width+1
			if data<0:w+=1
			m=m[:w];e=int(es);m1,m2=m.split('.')
			while len(m1)+len(m2)<data._width-(1 if data._prec>=0 else 0):m2+=A
			if data._m_sign and data>0:m1='+'+m1
			esgn='+'if data._e_sign else''
			if data._prec<0:
				if m2!=A:e-=len(m2)
				else:m2=''
				while len(m1)+len(m2)-(1 if data._m_sign else 0)<data._width:m2+=A;e-=1
				value=m1+m2+data._exp+B.format(e,esgn,data._e_width)
			elif data._prec==0:e-=len(m2);value=m1+m2+'.'+data._exp+B.format(e,esgn,data._e_width)
			else:
				if data._m_lead0>0:m2=A*(data._m_lead0-1)+m1+m2;m1=A;m2=m2[:-data._m_lead0];e+=data._m_lead0
				while len(m1)<data._prec:m1+=m2[0];m2=m2[1:];e-=1
				value=m1+'.'+m2+data._exp+B.format(e,esgn,data._e_width)
		if value is _A:value=to_unicode(repr(data)).lower()
		return self.represent_scalar(_K,value,anchor=anchor)
	def represent_sequence(self,tag,sequence,flow_style=_A):
		value=[]
		try:flow_style=sequence.fa.flow_style(flow_style)
		except AttributeError:flow_style=flow_style
		try:anchor=sequence.yaml_anchor()
		except AttributeError:anchor=_A
		node=SequenceNode(tag,value,flow_style=flow_style,anchor=anchor)
		if self.alias_key is not _A:self.represented_objects[self.alias_key]=node
		best_style=_B
		try:
			comment=getattr(sequence,comment_attrib);node.comment=comment.comment
			if node.comment and node.comment[1]:
				for ct in node.comment[1]:ct.reset()
			item_comments=comment.items
			for v in item_comments.values():
				if v and v[1]:
					for ct in v[1]:ct.reset()
			item_comments=comment.items;node.comment=comment.comment
			try:node.comment.append(comment.end)
			except AttributeError:pass
		except AttributeError:item_comments={}
		for(idx,item)in enumerate(sequence):
			node_item=self.represent_data(item);self.merge_comments(node_item,item_comments.get(idx))
			if not(isinstance(node_item,ScalarNode)and not node_item.style):best_style=_C
			value.append(node_item)
		if flow_style is _A:
			if len(sequence)!=0 and self.default_flow_style is not _A:node.flow_style=self.default_flow_style
			else:node.flow_style=best_style
		return node
	def merge_comments(self,node,comments):
		if comments is _A:assert hasattr(node,_F);return node
		if getattr(node,_F,_A)is not _A:
			for(idx,val)in enumerate(comments):
				if idx>=len(node.comment):continue
				nc=node.comment[idx]
				if nc is not _A:assert val is _A or val==nc;comments[idx]=nc
		node.comment=comments;return node
	def represent_key(self,data):
		if isinstance(data,CommentedKeySeq):self.alias_key=_A;return self.represent_sequence(_L,data,flow_style=_B)
		if isinstance(data,CommentedKeyMap):self.alias_key=_A;return self.represent_mapping(_M,data,flow_style=_B)
		return SafeRepresenter.represent_key(self,data)
	def represent_mapping(self,tag,mapping,flow_style=_A):
		value=[]
		try:flow_style=mapping.fa.flow_style(flow_style)
		except AttributeError:flow_style=flow_style
		try:anchor=mapping.yaml_anchor()
		except AttributeError:anchor=_A
		node=MappingNode(tag,value,flow_style=flow_style,anchor=anchor)
		if self.alias_key is not _A:self.represented_objects[self.alias_key]=node
		best_style=_B
		try:
			comment=getattr(mapping,comment_attrib);node.comment=comment.comment
			if node.comment and node.comment[1]:
				for ct in node.comment[1]:ct.reset()
			item_comments=comment.items
			for v in item_comments.values():
				if v and v[1]:
					for ct in v[1]:ct.reset()
			try:node.comment.append(comment.end)
			except AttributeError:pass
		except AttributeError:item_comments={}
		merge_list=[m[1]for m in getattr(mapping,merge_attrib,[])]
		try:merge_pos=getattr(mapping,merge_attrib,[[0]])[0][0]
		except IndexError:merge_pos=0
		item_count=0
		if bool(merge_list):items=mapping.non_merged_items()
		else:items=mapping.items()
		for(item_key,item_value)in items:
			item_count+=1;node_key=self.represent_key(item_key);node_value=self.represent_data(item_value);item_comment=item_comments.get(item_key)
			if item_comment:
				assert getattr(node_key,_F,_A)is _A;node_key.comment=item_comment[:2];nvc=getattr(node_value,_F,_A)
				if nvc is not _A:nvc[0]=item_comment[2];nvc[1]=item_comment[3]
				else:node_value.comment=item_comment[2:]
			if not(isinstance(node_key,ScalarNode)and not node_key.style):best_style=_C
			if not(isinstance(node_value,ScalarNode)and not node_value.style):best_style=_C
			value.append((node_key,node_value))
		if flow_style is _A:
			if(item_count!=0 or bool(merge_list))and self.default_flow_style is not _A:node.flow_style=self.default_flow_style
			else:node.flow_style=best_style
		if bool(merge_list):
			if len(merge_list)==1:arg=self.represent_data(merge_list[0])
			else:arg=self.represent_data(merge_list);arg.flow_style=_B
			value.insert(merge_pos,(ScalarNode('tag:yaml.org,2002:merge','<<'),arg))
		return node
	def represent_omap(self,tag,omap,flow_style=_A):
		value=[]
		try:flow_style=omap.fa.flow_style(flow_style)
		except AttributeError:flow_style=flow_style
		try:anchor=omap.yaml_anchor()
		except AttributeError:anchor=_A
		node=SequenceNode(tag,value,flow_style=flow_style,anchor=anchor)
		if self.alias_key is not _A:self.represented_objects[self.alias_key]=node
		best_style=_B
		try:
			comment=getattr(omap,comment_attrib);node.comment=comment.comment
			if node.comment and node.comment[1]:
				for ct in node.comment[1]:ct.reset()
			item_comments=comment.items
			for v in item_comments.values():
				if v and v[1]:
					for ct in v[1]:ct.reset()
			try:node.comment.append(comment.end)
			except AttributeError:pass
		except AttributeError:item_comments={}
		for item_key in omap:
			item_val=omap[item_key];node_item=self.represent_data({item_key:item_val});item_comment=item_comments.get(item_key)
			if item_comment:
				if item_comment[1]:node_item.comment=[_A,item_comment[1]]
				assert getattr(node_item.value[0][0],_F,_A)is _A;node_item.value[0][0].comment=[item_comment[0],_A];nvc=getattr(node_item.value[0][1],_F,_A)
				if nvc is not _A:nvc[0]=item_comment[2];nvc[1]=item_comment[3]
				else:node_item.value[0][1].comment=item_comment[2:]
			value.append(node_item)
		if flow_style is _A:
			if self.default_flow_style is not _A:node.flow_style=self.default_flow_style
			else:node.flow_style=best_style
		return node
	def represent_set(self,setting):
		flow_style=_C;tag=_Q;value=[];flow_style=setting.fa.flow_style(flow_style)
		try:anchor=setting.yaml_anchor()
		except AttributeError:anchor=_A
		node=MappingNode(tag,value,flow_style=flow_style,anchor=anchor)
		if self.alias_key is not _A:self.represented_objects[self.alias_key]=node
		best_style=_B
		try:
			comment=getattr(setting,comment_attrib);node.comment=comment.comment
			if node.comment and node.comment[1]:
				for ct in node.comment[1]:ct.reset()
			item_comments=comment.items
			for v in item_comments.values():
				if v and v[1]:
					for ct in v[1]:ct.reset()
			try:node.comment.append(comment.end)
			except AttributeError:pass
		except AttributeError:item_comments={}
		for item_key in setting.odict:
			node_key=self.represent_key(item_key);node_value=self.represent_data(_A);item_comment=item_comments.get(item_key)
			if item_comment:assert getattr(node_key,_F,_A)is _A;node_key.comment=item_comment[:2]
			node_key.style=node_value.style='?'
			if not(isinstance(node_key,ScalarNode)and not node_key.style):best_style=_C
			if not(isinstance(node_value,ScalarNode)and not node_value.style):best_style=_C
			value.append((node_key,node_value))
		best_style=best_style;return node
	def represent_dict(self,data):
		try:t=data.tag.value
		except AttributeError:t=_A
		if t:
			if t.startswith('!!'):tag=_T+t[2:]
			else:tag=t
		else:tag=_M
		return self.represent_mapping(tag,data)
	def represent_list(self,data):
		try:t=data.tag.value
		except AttributeError:t=_A
		if t:
			if t.startswith('!!'):tag=_T+t[2:]
			else:tag=t
		else:tag=_L
		return self.represent_sequence(tag,data)
	def represent_datetime(self,data):
		A='delta';inter='T'if data._yaml['t']else' ';_yaml=data._yaml
		if _yaml[A]:data+=_yaml[A];value=data.isoformat(inter)
		else:value=data.isoformat(inter)
		if _yaml['tz']:value+=_yaml['tz']
		return self.represent_scalar(_N,to_unicode(value))
	def represent_tagged_scalar(self,data):
		try:tag=data.tag.value
		except AttributeError:tag=_A
		try:anchor=data.yaml_anchor()
		except AttributeError:anchor=_A
		return self.represent_scalar(tag,data.value,style=data.style,anchor=anchor)
	def represent_scalar_bool(self,data):
		try:anchor=data.yaml_anchor()
		except AttributeError:anchor=_A
		return SafeRepresenter.represent_bool(self,data,anchor=anchor)
RoundTripRepresenter.add_representer(type(_A),RoundTripRepresenter.represent_none)
RoundTripRepresenter.add_representer(LiteralScalarString,RoundTripRepresenter.represent_literal_scalarstring)
RoundTripRepresenter.add_representer(FoldedScalarString,RoundTripRepresenter.represent_folded_scalarstring)
RoundTripRepresenter.add_representer(SingleQuotedScalarString,RoundTripRepresenter.represent_single_quoted_scalarstring)
RoundTripRepresenter.add_representer(DoubleQuotedScalarString,RoundTripRepresenter.represent_double_quoted_scalarstring)
RoundTripRepresenter.add_representer(PlainScalarString,RoundTripRepresenter.represent_plain_scalarstring)
RoundTripRepresenter.add_representer(ScalarInt,RoundTripRepresenter.represent_scalar_int)
RoundTripRepresenter.add_representer(BinaryInt,RoundTripRepresenter.represent_binary_int)
RoundTripRepresenter.add_representer(OctalInt,RoundTripRepresenter.represent_octal_int)
RoundTripRepresenter.add_representer(HexInt,RoundTripRepresenter.represent_hex_int)
RoundTripRepresenter.add_representer(HexCapsInt,RoundTripRepresenter.represent_hex_caps_int)
RoundTripRepresenter.add_representer(ScalarFloat,RoundTripRepresenter.represent_scalar_float)
RoundTripRepresenter.add_representer(ScalarBoolean,RoundTripRepresenter.represent_scalar_bool)
RoundTripRepresenter.add_representer(CommentedSeq,RoundTripRepresenter.represent_list)
RoundTripRepresenter.add_representer(CommentedMap,RoundTripRepresenter.represent_dict)
RoundTripRepresenter.add_representer(CommentedOrderedMap,RoundTripRepresenter.represent_ordereddict)
if sys.version_info>=(2,7):import collections;RoundTripRepresenter.add_representer(collections.OrderedDict,RoundTripRepresenter.represent_ordereddict)
RoundTripRepresenter.add_representer(CommentedSet,RoundTripRepresenter.represent_set)
RoundTripRepresenter.add_representer(TaggedScalar,RoundTripRepresenter.represent_tagged_scalar)
RoundTripRepresenter.add_representer(TimeStamp,RoundTripRepresenter.represent_datetime)