Python strutils.bytes_to_escaped_str函数代码示例

 def _echo_headers(self, headers):
     for k, v in headers.fields:
         k = strutils.bytes_to_escaped_str(k)
         v = strutils.bytes_to_escaped_str(v)
         out = "{}: {}".format(
             click.style(k, fg="blue"),
             click.style(v)
         )
         self.echo(out, ident=4)

    def _echo_message(self, message):
        if self.flow_detail >= 2 and hasattr(message, "headers"):
            headers = "\r\n".join(
                "{}: {}".format(
                    click.style(
                        strutils.bytes_to_escaped_str(k), fg="blue", bold=True
                    ),
                    click.style(
                        strutils.bytes_to_escaped_str(v), fg="blue"
                    )
                )
                for k, v in message.headers.fields
            )
            self.echo(headers, ident=4)
        if self.flow_detail >= 3:
                _, lines, error = contentviews.get_message_content_view(
                    self.default_contentview,
                    message
                )
                if error:
                    ctx.log.debug(error)

                styles = dict(
                    highlight=dict(bold=True),
                    offset=dict(fg="blue"),
                    header=dict(fg="green", bold=True),
                    text=dict(fg="green")
                )

                def colorful(line):
                    yield u"    "  # we can already indent here
                    for (style, text) in line:
                        yield click.style(text, **styles.get(style, {}))

                if self.flow_detail == 3:
                    lines_to_echo = itertools.islice(lines, 70)
                else:
                    lines_to_echo = lines

                content = u"\r\n".join(
                    u"".join(colorful(line)) for line in lines_to_echo
                )
                if content:
                    self.echo("")
                    self.echo(content)

                if next(lines, None):
                    self.echo("(cut off)", ident=4, dim=True)

        if self.flow_detail >= 2:
            self.echo("")

 def freeze(self, settings):
     f = self.parsed.freeze(settings).spec()
     return self.__class__(
         base.TokValueLiteral(
             strutils.bytes_to_escaped_str(f.encode(), escape_single_quotes=True)
         )
     )

 def _handle_pong_received(self, event, source_conn, other_conn, is_server):
     self.log(
         "Pong Received from {}".format("server" if is_server else "client"),
         "info",
         [strutils.bytes_to_escaped_str(bytes(event.payload))]
     )
     return True

 def __init__(self, data: strbytes) -> None:
     self.data = data
     if isinstance(data, bytes):
         escaped = strutils.bytes_to_escaped_str(data)
     else:
         escaped = data.encode()
     w = urwid.Text(escaped, wrap="any")
     super().__init__(w)

 def __init__(self, data: typing.Any) -> None:
     self.data = data
     if isinstance(data, bytes):
         data = strutils.bytes_to_escaped_str(data)
     if not isinstance(data, str):
         data = repr(data)
     w = urwid.Text(data, wrap="any")
     super().__init__(w)

 def log(self, settings):
     """
         A dictionary that should be logged if this message is served.
     """
     ret = {}
     for i in self.logattrs:
         v = getattr(self, i)
         # Careful not to log any VALUE specs without sanitizing them first.
         # We truncate at 1k.
         if hasattr(v, "values"):
             v = [x[:LOG_TRUNCATE] for x in v.values(settings)]
             v = strutils.bytes_to_escaped_str(b"".join(v))
         elif hasattr(v, "__len__"):
             v = v[:LOG_TRUNCATE]
             v = strutils.bytes_to_escaped_str(v)
         ret[i] = v
     ret["spec"] = self.spec()
     return ret

 def tcp_message(self, f):
     super().tcp_message(f)
     message = f.messages[-1]
     direction = "->" if message.from_client else "<-"
     signals.add_log("{client} {direction} tcp {direction} {server}".format(
         client=repr(f.client_conn.address),
         server=repr(f.server_conn.address),
         direction=direction,
     ), "info")
     signals.add_log(strutils.bytes_to_escaped_str(message.content), "debug")

 def tcp_message(self, f):
     message = f.messages[-1]
     direction = "->" if message.from_client else "<-"
     ctx.log.info("{client_host}:{client_port} {direction} tcp {direction} {server_host}:{server_port}".format(
         client_host=f.client_conn.address[0],
         client_port=f.client_conn.address[1],
         server_host=f.server_conn.address[0],
         server_port=f.server_conn.address[1],
         direction=direction,
     ))
     ctx.log.debug(strutils.bytes_to_escaped_str(message.content))

 def _handle_ping_received(self, event, source_conn, other_conn, is_server):
     # PING is automatically answered with a PONG by wsproto
     self.connections[other_conn].ping()
     other_conn.send(self.connections[other_conn].bytes_to_send())
     source_conn.send(self.connections[source_conn].bytes_to_send())
     self.log(
         "Ping Received from {}".format("server" if is_server else "client"),
         "info",
         [strutils.bytes_to_escaped_str(bytes(event.payload))]
     )
     return True

 def __repr__(self):
     if self.alpn_proto_negotiated:
         alpn = "[ALPN: {}] ".format(
             strutils.bytes_to_escaped_str(self.alpn_proto_negotiated)
         )
     else:
         alpn = ""
     return "<ClientConnection: {ssl}{alpn}{address}>".format(
         ssl="[ssl] " if self.ssl_established else "",
         alpn=alpn,
         address=repr(self.address)
     )

def tcp_message(flow: tcp.TCPFlow):
    message = flow.messages[-1]
    old_content = message.content
    message.content = old_content.replace(b"foo", b"bar")

    ctx.log.info(
        "[tcp_message{}] from {} to {}:\n{}".format(
            " (modified)" if message.content != old_content else "",
            "client" if message.from_client else "server",
            "server" if message.from_client else "client",
            strutils.bytes_to_escaped_str(message.content))
    )

def tcp_message(tcp_msg):
    modified_msg = tcp_msg.message.replace("foo", "bar")

    is_modified = False if modified_msg == tcp_msg.message else True
    tcp_msg.message = modified_msg

    print(
        "[tcp_message{}] from {} {} to {} {}:\r\n{}".format(
            " (modified)" if is_modified else "",
            "client" if tcp_msg.sender == tcp_msg.client_conn else "server",
            tcp_msg.sender.address,
            "server" if tcp_msg.receiver == tcp_msg.server_conn else "client",
            tcp_msg.receiver.address, strutils.bytes_to_escaped_str(tcp_msg.message))
    )

def httpie_command(f: flow.Flow) -> str:
    raise_if_missing_request(f)
    request = f.request.copy()  # type: ignore
    data = "http %s " % request.method
    request.decode(strict=False)
    data += "%s" % request.url
    for k, v in request.headers.items(multi=True):
        data += " '%s:%s'" % (k, v)
    if request.content:
        data += " <<< '%s'" % strutils.bytes_to_escaped_str(
            request.content,
            escape_single_quotes=True
        )
    return data

def curl_command(f: flow.Flow) -> str:
    raise_if_missing_request(f)
    data = "curl "
    request = f.request.copy()  # type: ignore
    request.decode(strict=False)
    for k, v in request.headers.items(multi=True):
        data += "-H '%s:%s' " % (k, v)
    if request.method != "GET":
        data += "-X %s " % request.method
    data += "'%s'" % request.url
    if request.content:
        data += " --data-binary '%s'" % strutils.bytes_to_escaped_str(
            request.content,
            escape_single_quotes=True
        )
    return data