Initial import from Docker volume

tools/logging.py

@@ -0,0 +1,126 @@
+from collections.abc import Iterable, Mapping
+from itertools import islice
+
+_MAX_ARGUMENTS = 5
+_MAX_ITEMS = 5
+_ELLIPSE = '...'
+_MAX_STR_LENGTH = 20 - len(_ELLIPSE)
+
+
+class Ellipse:
+
+    __slots__ = ('text',)
+
+    def __init__(self, text=_ELLIPSE):
+        self.text = text
+
+    def __str__(self):
+        return self.text
+
+    __repr__ = __str__
+
+
+class EllipseDict:
+
+    __slots__ = ('items',)
+
+    def __init__(self, items):
+        self.items = items
+
+    def __str__(self):
+        strings = []
+        ellipse = False
+        for key, value in self.items:
+            if isinstance(key, Ellipse):
+                ellipse = True
+                break
+            strings.append(f'{key!r}: {value!r}')
+        if ellipse:
+            strings.append(_ELLIPSE)
+
+        s = ', '.join(strings)
+        return '{' + s + '}'
+
+    __repr__ = __str__
+
+
+class format_args:
+
+    __slots__ = ('args', 'kwargs', 'verbose', 'max_args', 'max_items')
+
+    def __init__(self, args, kwargs, verbose=False,
+            max_args=_MAX_ARGUMENTS, max_items=_MAX_ITEMS):
+        self.args = args
+        self.kwargs = kwargs
+        self.verbose = verbose
+        self.max_args = max_args
+        self.max_items = max_items
+
+    def __str__(self):
+        _nb_args = self.max_args
+        _nb_items = self.max_items
+
+        def _shorten_sequence(value):
+            nonlocal _nb_items
+
+            for v in islice(value, None, self.max_items + 1):
+                if not self.verbose and not _nb_items:
+                    yield Ellipse()
+                    break
+                yield v
+                _nb_items -= 1
+
+        def _log_repr(value):
+            if self.verbose:
+                return value
+            elif isinstance(value, bytes):
+                return Ellipse(f'<{len(value)} bytes>')
+            elif isinstance(value, str):
+                if len(value) <= _MAX_STR_LENGTH:
+                    return value
+                return (value[:_MAX_STR_LENGTH]
+                    + (_ELLIPSE if len(value) > _MAX_STR_LENGTH else ''))
+            elif isinstance(value, Mapping):
+                def shorten(value):
+                    for items in _shorten_sequence(value.items()):
+                        if isinstance(items, Ellipse):
+                            yield Ellipse(), Ellipse()
+                            break
+                        key, value = items
+                        yield _log_repr(key), _log_repr(value)
+
+                return EllipseDict(shorten(value))
+            elif isinstance(value, Iterable):
+                return type(value)(_log_repr(v)
+                    for v in _shorten_sequence(value))
+            else:
+                return value
+
+        s = '('
+
+        logged_args = []
+        for args in self.args:
+            if not _nb_args and not self.verbose:
+                logged_args.append(Ellipse())
+                break
+            _nb_items = self.max_items
+            logged_args.append(_log_repr(args))
+            _nb_args -= 1
+        s += ', '.join(repr(a) for a in logged_args)
+
+        if self.kwargs and (not logged_args
+                or not isinstance(logged_args[-1], Ellipse)):
+            s += ', ' if self.args and self.kwargs else ''
+            logged_kwargs = []
+            for key, value in self.kwargs.items():
+                if not _nb_args and not self.verbose:
+                    logged_kwargs.append(repr(Ellipse()))
+                    break
+                _nb_items = self.max_items
+                logged_kwargs.append(
+                    f'{_log_repr(key)}={_log_repr(value)!r}')
+                _nb_args -= 1
+            s += ', '.join(logged_kwargs)
+
+        s += ')'
+        return s