def __repr__(self):
'''
Describes current function wrapper.
Examples:
>>> function_decorator = FunctionDecorator(
... FunctionDecorator.__repr__)
>>> function_decorator.class_object = FunctionDecorator
>>> repr(function_decorator) # doctest: +ELLIPSIS
'Object of "FunctionDecorator" ... "__repr__" ... (NoneType).'
>>> repr(FunctionDecorator(FunctionDecorator)) # doctest: +ELLIPSIS
'Object of "FunctionDecorator" with wrapped function "None" and...'
'''
function_name = 'None'
if self.__func__ is not None:
function_name = self.__func__.__name__
if self.class_object:
# # python3.5
# # return (
# # 'Object of "{class_name}" with class object '
# # '"{class_object}", object "{object}", wrapped function '
# # '"{wrapped_function}" and return value "{value}" '
# # '({type}).'.format(
# # class_name=self.__class__.__name__,
# # class_object=self.class_object.__name__,
# # object=builtins.repr(self.object),
# # wrapped_function=function_name,
# # value=builtins.str(self.return_value),
# # type=builtins.type(self.return_value).__name__))
# # return (
# # 'Object of "{class_name}" with wrapped function '
# # '"{wrapped_function}" and return value "{value}" '
# # '({type}).'.format(
# # class_name=self.__class__.__name__,
# # wrapped_function=function_name,
# # value=builtins.str(self.return_value),
# # type=builtins.type(self.return_value).__name__))
return (
'Object of "{class_name}" with class object '
'"{class_object}", object "{object}", wrapped function '
'"{wrapped_function}" and return value "{value}" '
'({type}).'.format(
class_name=self.__class__.__name__,
class_object=self.class_object.__name__,
object=builtins.repr(self.object),
wrapped_function=function_name,
value=convert_to_unicode(self.return_value),
type=builtins.type(self.return_value).__name__))
return (
'Object of "{class_name}" with wrapped function '
'"{wrapped_function}" and return value "{value}" '
'({type}).'.format(
class_name=self.__class__.__name__,
wrapped_function=function_name,
value=convert_to_unicode(self.return_value),
type=builtins.type(self.return_value).__name__))
def get_content(self):
'''
Getter for the current content.
Examples:
>>> Buffer().write('test').content
'test'
>>> Buffer(queue=True).write('test').content
'test'
'''
with self._lock:
if self.file is not None:
self._content = self.file.content
elif self.queue:
self._content = ''
temp_buffer = []
while not self.queue.empty():
# # python3.5
# # temp_buffer.append(self.queue.get())
temp_buffer.append(convert_to_unicode(
self.queue.get()))
# #
self._content += temp_buffer[-1]
for content in temp_buffer:
self.queue.put(content)
# # python3.5
# # pass
if self.force_string and builtins.isinstance(
self._content, builtins.unicode
):
self._content = convert_to_string(self._content)
# #
return self._content
def __repr__(self):
'''
Represents the current handled function call.
Examples:
>>> class A:
... def a(self): pass
>>> return_aspect = ReturnAspect()
>>> return_aspect.class_object = A
>>> return_aspect.object = A()
>>> return_aspect.__func__ = A().a
>>> return_aspect.arguments = ()
>>> return_aspect.keywords = {}
>>> repr(return_aspect) # doctest: +ELLIPSIS
'Object of "ReturnAspect" with class object "A", object "...'
'''
# # python3.5
# # return (
# # 'Object of "{class_name}" with class object "{class_object}", '
# # 'object "{object}", function "{function}", arguments '
# # '"{arguments}", keywords "{keywords}" and return value '
# # '"{value}" ({type}).'.format(
# # class_name=self.__class__.__name__,
# # class_object=self.class_object.__name__,
# # object=builtins.repr(self.object),
# # function=self.__func__.__name__,
# # arguments='", "'.join(self.arguments),
# # keywords=builtins.str(self.keywords),
# # value=builtins.str(self.return_value),
# # type=builtins.str(builtins.type(self.return_value))))
return (
'Object of "{class_name}" with class object "{class_object}", '
'object "{object}", function "{function}", arguments '
'"{arguments}", keywords "{keywords}" and return value '
'"{value}" ({type}).'.format(
class_name=self.__class__.__name__,
class_object=self.class_object.__name__,
object=builtins.repr(self.object),
function=self.__func__.__name__,
arguments='", "'.join(self.arguments),
keywords=builtins.str(self.keywords),
value=convert_to_unicode(self.return_value),
type=builtins.str(builtins.type(self.return_value))))
def __str__(self):
'''
Is triggered if this object should be converted to string.
Examples:
>>> str(Print('peter', buffer=Buffer()))
'peter\\n'
>>> print = Print('', buffer=Buffer())
>>> print.buffer = None
>>> str(print)
''
'''
if builtins.isinstance(self.buffer, Buffer):
# # python3.5 return builtins.str(self.buffer)
return convert_to_unicode(self.buffer)
return ''
def __repr__(cls):
'''
Invokes if this object should describe itself by a string.
Examples:
>>> repr(Logger()) # doctest: +ELLIPSIS
'Object of "Logger" with logger "...
>>> logger1 = Logger.get()
>>> repr(Logger()) # doctest: +ELLIPSIS
'Object of "Logger" with logger "...
>>> logger1 = Logger.get()
>>> logger2 = Logger.get('hans')
>>> repr(Logger()) # doctest: +ELLIPSIS
'Object of "Logger" with logger "... and ...
'''
handler_string = formatter_string = ''
for index, logger in builtins.enumerate(cls.instances):
start = ', "'
end = '"'
if index + 1 == builtins.len(cls.instances):
start = ' and "'
end = ''
if index == 0:
start = ''
handler_string += start + builtins.repr(logger.handlers[0]) + end
formatter_string += start + builtins.repr(
logger.handlers[0].formatter
) + end
# # python3.5
# # return (
# # 'Object of "{class_name}" with logger "{handler}", formatter '
# # '"{formatter}" and buffer "{buffer}".'.format(
# # class_name=cls.__name__, handler=handler_string,
# # formatter=formatter_string,
# # buffer=builtins.str(cls.buffer)))
return (
'Object of "{class_name}" with logger "{handler}", formatter '
'"{formatter}" and buffer "{buffer}".'.format(
class_name=cls.__name__, handler=handler_string,
formatter=formatter_string,
buffer=convert_to_unicode(cls.buffer)))
def __repr__(self):
'''
Invokes if this object should describe itself by a string.
Examples:
>>> repr(Buffer())
'Object of "Buffer" (memory buffered) with content "".'
>>> buffer = Buffer(file=__test_folder__.path + '__repr__')
>>> buffer.write('hans') # doctest: +ELLIPSIS
Object of "Buffer" (file buffered with "...__repr__" (type: file...
>>> repr(Buffer(queue=True))
'Object of "Buffer" (queue buffered) with content "".'
>>> repr(Buffer(queue=native_queue.Queue()))
'Object of "Buffer" (queue buffered) with content "".'
'''
buffer_type = 'memory'
type_addition = ''
if self.file:
buffer_type = 'file'
type_addition = ' with "%s"' % builtins.repr(self.file)
elif self.queue:
buffer_type = 'queue'
# # python3.5
# # pass
if self.force_string:
return (
'Object of "{class_name}" ({type} buffered{type_addition})'
' with content "{content}".'.format(
class_name=self.__class__.__name__,
type=buffer_type, type_addition=type_addition,
content=convert_to_unicode(self.content)))
# #
return (
'Object of "{class_name}" ({type} buffered{type_addition}) '
'with content "{content}".'.format(
class_name=self.__class__.__name__, type=buffer_type,
type_addition=type_addition, content=self.content))
def __str__(cls):
'''
Is triggered if a "Logger" object should be converted to string.
Examples:
>>> str(Logger())
''
>>> logger_backup = Logger.buffer
>>> Logger.buffer = Buffer(),
>>> str(Logger()) # doctest: +ELLIPSIS
''
>>> Logger.buffer = logger_backup
'''
result = ''
for buffer in cls.buffer:
if builtins.isinstance(buffer, Buffer):
# # python3.5 result += builtins.str(buffer)
result += convert_to_unicode(buffer)
return result
def _join_distinct_types(self, types, meta_type):
# #
'''Joins a given list of objects to a single human readable string.'''
result = ''
for type in types:
if type is Self:
# # python3.5
# # result += '"%s (self)"' % builtins.str(self.object)
result += '"%s (self)"' % convert_to_unicode(self.object)
# #
elif type is SelfClass:
result += '"%s (self class)"' % self.class_object.__name__
elif type is SelfClassObject:
result += '"%s (self class object)"' % \
self.class_object.__name__
elif meta_type:
result += '"%s"' % type.__name__
else:
result += '"%s"' % builtins.str(type)
if type is types[-2]:
result += ' or '
elif type is not types[-1]:
result += ', '
return result
def __init__(self, *output, **codewords):
# #
'''
Writes something to the output buffer or prints to standard \
output.
Examples:
>>> buffer = Buffer()
>>> Print(native_queue.Queue(), buffer=buffer) # doctest: +ELLIPSIS
Object of "Print" with "...
>>> queue1 = native_queue.Queue()
>>> queue2 = native_queue.Queue()
>>> queue1.put('hans')
>>> queue2.put('hans')
>>> Print(
... queue1, queue2, buffer=buffer, flush=True
... ) # doctest: +ELLIPSIS
Object of "Print" with "...
>>> Print.default_buffer = Buffer()
>>> Print('hans', 'hans again') # doctest: +ELLIPSIS
Object of "Print" with "Object of "Buffer" (mem... "hans hans again
".".
>>> buffer = Buffer()
>>> Print(
... 'hans,', 'peter', end=' and klaus', sep=' ', buffer=buffer
... ) # doctest: +ELLIPSIS
Object of "Print" with "Object of "Buffer" (memory buffered...".".
>>> buffer # doctest: +ELLIPSIS
Object ... (memory buffered) with content "hans, peter and klaus".
'''
keywords = {
'replace': self.__class__.replace,
'start': self.__class__.start,
'separator': self.__class__.separator,
'end': self.__class__.end,
'buffer': self.__class__.default_buffer,
'flush': codewords.get('replace', False)}
keywords.update(codewords)
'''Redirect print output to this buffer.'''
self.buffer = keywords['buffer']
output = builtins.list(output)
for index, out in builtins.enumerate(output):
if builtins.isinstance(out, native_queue.Queue):
result = ''
while not out.empty():
if index != 0 and keywords['separator']:
# # python3.5
# # result += builtins.str(keywords['separator'])
# # result += out.get()
result += convert_to_unicode(
keywords['separator'])
result += convert_to_unicode(out.get())
# #
output[index] = result
elif index == 0:
# # python3.5 output[index] = builtins.str(out)
output[index] = convert_to_unicode(out)
else:
# # python3.5
# # output[index] = '%s%s' % (builtins.str(
# # keywords['separator']
# # ), builtins.str(out))
output[index] = '%s%s' % (convert_to_unicode(
keywords['separator']
), convert_to_unicode(out))
# #
line_replace = '\033[1A\r\033[2K' if keywords['replace'] else ''
output = [keywords['start'], line_replace] + output + [keywords['end']]
# # python3.5
# # builtins.print(
# # *output, sep='', end='', file=keywords['buffer'],
# # flush=keywords['flush'])
builtins.print(*filter(lambda content: convert_to_string(
content
), output), sep='', end='', file=keywords['buffer'])
if keywords['flush']:
sys.stdout.flush()
