

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: reprlib.py</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'>&quot;&quot;&quot;Redo the builtin repr() (representation) but with limits on most sizes.&quot;&quot;&quot;

__all__ = [&quot;Repr&quot;, &quot;repr&quot;, &quot;recursive_repr&quot;]

import builtins
from itertools import islice
from _thread import get_ident

def recursive_repr(fillvalue=&#039;...&#039;):
    &#039;Decorator to make a repr function return fillvalue for a recursive call&#039;

    def decorating_function(user_function):
        repr_running = set()

        def wrapper(self):
            key = id(self), get_ident()
            if key in repr_running:
                return fillvalue
            repr_running.add(key)
            try:
                result = user_function(self)
            finally:
                repr_running.discard(key)
            return result

        # Can&#039;t use functools.wraps() here because of bootstrap issues
        wrapper.__module__ = getattr(user_function, &#039;__module__&#039;)
        wrapper.__doc__ = getattr(user_function, &#039;__doc__&#039;)
        wrapper.__name__ = getattr(user_function, &#039;__name__&#039;)
        wrapper.__qualname__ = getattr(user_function, &#039;__qualname__&#039;)
        wrapper.__annotations__ = getattr(user_function, &#039;__annotations__&#039;, {})
        wrapper.__type_params__ = getattr(user_function, &#039;__type_params__&#039;, ())
        return wrapper

    return decorating_function

class Repr:
    _lookup = {
        &#039;tuple&#039;: &#039;builtins&#039;,
        &#039;list&#039;: &#039;builtins&#039;,
        &#039;array&#039;: &#039;array&#039;,
        &#039;set&#039;: &#039;builtins&#039;,
        &#039;frozenset&#039;: &#039;builtins&#039;,
        &#039;deque&#039;: &#039;collections&#039;,
        &#039;dict&#039;: &#039;builtins&#039;,
        &#039;str&#039;: &#039;builtins&#039;,
        &#039;int&#039;: &#039;builtins&#039;
    }

    def __init__(
        self, *, maxlevel=6, maxtuple=6, maxlist=6, maxarray=5, maxdict=4,
        maxset=6, maxfrozenset=6, maxdeque=6, maxstring=30, maxlong=40,
        maxother=30, fillvalue=&#039;...&#039;, indent=None,
    ):
        self.maxlevel = maxlevel
        self.maxtuple = maxtuple
        self.maxlist = maxlist
        self.maxarray = maxarray
        self.maxdict = maxdict
        self.maxset = maxset
        self.maxfrozenset = maxfrozenset
        self.maxdeque = maxdeque
        self.maxstring = maxstring
        self.maxlong = maxlong
        self.maxother = maxother
        self.fillvalue = fillvalue
        self.indent = indent

    def repr(self, x):
        return self.repr1(x, self.maxlevel)

    def repr1(self, x, level):
        cls = type(x)
        typename = cls.__name__

        if &#039; &#039; in typename:
            parts = typename.split()
            typename = &#039;_&#039;.join(parts)

        method = getattr(self, &#039;repr_&#039; + typename, None)
        if method:
            # not defined in this class
            if typename not in self._lookup:
                return method(x, level)
            module = getattr(cls, &#039;__module__&#039;, None)
            # defined in this class and is the module intended
            if module == self._lookup[typename]:
                return method(x, level)

        return self.repr_instance(x, level)

    def _join(self, pieces, level):
        if self.indent is None:
            return &#039;, &#039;.join(pieces)
        if not pieces:
            return &#039;&#039;
        indent = self.indent
        if isinstance(indent, int):
            if indent &lt; 0:
                raise ValueError(
                    f&#039;Repr.indent cannot be negative int (was {indent!r})&#039;
                )
            indent *= &#039; &#039;
        try:
            sep = &#039;,\n&#039; + (self.maxlevel - level + 1) * indent
        except TypeError as error:
            raise TypeError(
                f&#039;Repr.indent must be a str, int or None, not {type(indent)}&#039;
            ) from error
        return sep.join((&#039;&#039;, *pieces, &#039;&#039;))[1:-len(indent) or None]

    def _repr_iterable(self, x, level, left, right, maxiter, trail=&#039;&#039;):
        n = len(x)
        if level &lt;= 0 and n:
            s = self.fillvalue
        else:
            newlevel = level - 1
            repr1 = self.repr1
            pieces = [repr1(elem, newlevel) for elem in islice(x, maxiter)]
            if n &gt; maxiter:
                pieces.append(self.fillvalue)
            s = self._join(pieces, level)
            if n == 1 and trail and self.indent is None:
                right = trail + right
        return &#039;%s%s%s&#039; % (left, s, right)

    def repr_tuple(self, x, level):
        return self._repr_iterable(x, level, &#039;(&#039;, &#039;)&#039;, self.maxtuple, &#039;,&#039;)

    def repr_list(self, x, level):
        return self._repr_iterable(x, level, &#039;[&#039;, &#039;]&#039;, self.maxlist)

    def repr_array(self, x, level):
        if not x:
            return &quot;array(&#039;%s&#039;)&quot; % x.typecode
        header = &quot;array(&#039;%s&#039;, [&quot; % x.typecode
        return self._repr_iterable(x, level, header, &#039;])&#039;, self.maxarray)

    def repr_set(self, x, level):
        if not x:
            return &#039;set()&#039;
        x = _possibly_sorted(x)
        return self._repr_iterable(x, level, &#039;{&#039;, &#039;}&#039;, self.maxset)

    def repr_frozenset(self, x, level):
        if not x:
            return &#039;frozenset()&#039;
        x = _possibly_sorted(x)
        return self._repr_iterable(x, level, &#039;frozenset({&#039;, &#039;})&#039;,
                                   self.maxfrozenset)

    def repr_deque(self, x, level):
        return self._repr_iterable(x, level, &#039;deque([&#039;, &#039;])&#039;, self.maxdeque)

    def repr_dict(self, x, level):
        n = len(x)
        if n == 0:
            return &#039;{}&#039;
        if level &lt;= 0:
            return &#039;{&#039; + self.fillvalue + &#039;}&#039;
        newlevel = level - 1
        repr1 = self.repr1
        pieces = []
        for key in islice(_possibly_sorted(x), self.maxdict):
            keyrepr = repr1(key, newlevel)
            valrepr = repr1(x[key], newlevel)
            pieces.append(&#039;%s: %s&#039; % (keyrepr, valrepr))
        if n &gt; self.maxdict:
            pieces.append(self.fillvalue)
        s = self._join(pieces, level)
        return &#039;{%s}&#039; % (s,)

    def repr_str(self, x, level):
        s = builtins.repr(x[:self.maxstring])
        if len(s) &gt; self.maxstring:
            i = max(0, (self.maxstring-3)//2)
            j = max(0, self.maxstring-3-i)
            s = builtins.repr(x[:i] + x[len(x)-j:])
            s = s[:i] + self.fillvalue + s[len(s)-j:]
        return s

    def repr_int(self, x, level):
        s = builtins.repr(x) # XXX Hope this isn&#039;t too slow...
        if len(s) &gt; self.maxlong:
            i = max(0, (self.maxlong-3)//2)
            j = max(0, self.maxlong-3-i)
            s = s[:i] + self.fillvalue + s[len(s)-j:]
        return s

    def repr_instance(self, x, level):
        try:
            s = builtins.repr(x)
            # Bugs in x.__repr__() can cause arbitrary
            # exceptions -- then make up something
        except Exception:
            return &#039;&lt;%s instance at %#x&gt;&#039; % (x.__class__.__name__, id(x))
        if len(s) &gt; self.maxother:
            i = max(0, (self.maxother-3)//2)
            j = max(0, self.maxother-3-i)
            s = s[:i] + self.fillvalue + s[len(s)-j:]
        return s


def _possibly_sorted(x):
    # Since not all sequences of items can be sorted and comparison
    # functions may raise arbitrary exceptions, return an unsorted
    # sequence in that case.
    try:
        return sorted(x)
    except Exception:
        return list(x)

aRepr = Repr()
repr = aRepr.repr
</textarea><br><br><input type='hidden' name='archivo_editar' value='/usr/lib64/python3.12/reprlib.py'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Fusr%2Flib64%2Fpython3.12' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>