def pretty_frozen_spec_data(value, ctx):
"""
PrettyPrinter for :class:``~.FrozenSpecData``.
"""
cls = type(value)
attributes = cls.__attrs_attrs__
kwargs = []
for attribute in attributes:
if not attribute.repr:
continue
display_attr = False
if attribute.default == attr.NOTHING:
display_attr = True
elif isinstance(attribute.default, attr.Factory): # type: ignore
default_value = (attribute.default.factory(value)
if attribute.default.takes_self else
attribute.default.factory())
if default_value != getattr(value, attribute.name):
display_attr = True
else:
if attribute.default != getattr(value, attribute.name):
display_attr = True
if display_attr:
if attribute.name in {"x_data", "y_data"}:
kwargs.append((attribute.name,
[*getattr(value, attribute.name)[:10], etc]))
else:
kwargs.append((attribute.name, getattr(value, attribute.name)))
return pretty_call_alt(ctx, cls, kwargs=kwargs)
def pretty_request(request, ctx):
kwargs = [
('method', request.method),
('url', request.url),
]
if request.cookies:
kwargs.append(('cookies', request.cookies))
if request.auth:
kwargs.append(('auth', request.auth))
if request.json:
kwargs.append(('json', request.json))
if request.data:
kwargs.append(('data', request.data))
if request.files:
kwargs.append(('files', request.files))
if request.headers:
kwargs.append(('headers', request.headers))
if request.params:
kwargs.append(('params', request.params))
if request.hooks:
from requests.hooks import default_hooks
if request.hooks != default_hooks():
kwargs.append(('hooks', request.hooks))
return pretty_call_alt(ctx, 'requests.Request', kwargs=kwargs)
def pretty_prepared_request(request, ctx):
from requests.hooks import default_hooks
kwargs = [
('method', request.method),
('url', request.url),
]
if request.headers:
kwargs.append(('headers', request.headers))
if request.body is not None:
count_bytes = len(request.body)
count_display_bytes = 10
count_bytes = len(request.body)
if count_bytes > count_display_bytes:
truncated_body = comment(
request.body[:count_display_bytes],
'... and {} more bytes'.format(count_bytes -
count_display_bytes))
else:
truncated_body = request.body
kwargs.append(('body', truncated_body))
if request.hooks != default_hooks():
kwargs.append(('hooks', request.hooks))
return pretty_call_alt(ctx, 'requests.PreparedRequest', kwargs=kwargs)
def pretty_session(session, ctx):
from requests.models import DEFAULT_REDIRECT_LIMIT
kwargs = []
if session.headers:
kwargs.append(('headers', session.headers))
if session.auth is not None:
kwargs.append(('auth', session.auth))
if session.params:
kwargs.append(('params', session.params))
if session.stream:
kwargs.append(('stream', session.stream))
if session.cert is not None:
kwargs.append(('cert', session.cert))
if session.max_redirects != DEFAULT_REDIRECT_LIMIT:
kwargs.append(('max_redirects', session.max_redirects))
if session.cookies:
kwargs.append(('cookies', session.cookies))
return pretty_call_alt(ctx, 'requests.Session', kwargs=kwargs)
def pretty_response(resp, ctx):
content_consumed = bool(resp._content_consumed)
if not content_consumed:
return comment(
pretty_call_alt(ctx,
'requests.Response',
kwargs=[('status_code',
comment(resp.status_code, resp.reason)),
('url', resp.url),
('elapsed', resp.elapsed),
('headers', resp.headers)]),
'Response content not loaded yet')
kwargs = [
('url', resp.url),
('status_code', comment(resp.status_code, resp.reason)),
('elapsed', resp.elapsed),
('headers', resp.headers),
]
has_valid_json_payload = False
if resp.headers.get('Content-Type',
'text/plain').startswith('application/json'):
try:
data = resp.json()
except ValueError:
pass
else:
has_valid_json_payload = True
kwargs.append(('json', comment(data, 'Access with .json()')))
if not has_valid_json_payload:
text = resp.text
count_chars_truncated = max(0, len(text) - MAX_CONTENT_CHARS)
if count_chars_truncated:
truncated = text[:MAX_CONTENT_CHARS]
kwargs.append(
('text',
comment(
truncated,
'{} characters truncated'.format(count_chars_truncated))))
else:
kwargs.append(('text', text))
return pretty_call_alt(ctx, 'requests.Response', kwargs=kwargs)
def pretty_decoder_type(value, ctx):
return prettyprinter.pretty_call_alt(ctx,
type(value),
kwargs=(
('name', value.name),
('kind', value.kind),
('fields',
list(reversed(value.fields))),
))
def pretty_decoder_type(value, ctx):
return prettyprinter.pretty_call_alt(ctx,
type(value),
kwargs=(
('name', value.name),
('size', value.size),
('types', value.types),
('registers',
list(value.registers)),
('word_size', value.word_size),
))
def pretty_spec_data(value, ctx): # pragma: no cover (!Windows)
"""
PrettyPrinter for :class:``~.SpecData``.
"""
cls = type(value)
kwargs = []
for key, value in value.to_dict().items():
if key in {"x_data", "y_data"}:
kwargs.append((key, [*value[:10], etc]))
else:
kwargs.append((key, value))
return pretty_call_alt(ctx, cls, kwargs=kwargs)
def pretty_myclass(value, ctx):
return pretty_call_alt(ctx, MyClass)
def pretty_struct(ctx, title, args, kwargs, sep=' :: '):
"""Pretty print a struct."""
kwargs = {f'{k}<<{sep}>>': v for k, v in kwargs.items()}
return pp.pretty_call_alt(ctx, str(title), args, kwargs)
def pretty_call(ctx, title, args, sep=' :: '):
"""Pretty print a call."""
args = _force_sequence(args)
return pp.pretty_call_alt(ctx, str(title), args, {})
def pretty_headers(headers, ctx):
return pretty_call_alt(ctx, type(headers), args=(dict(headers.items()), ))
