def init_prettyprinter() -> Formatter:
"""Initialize prettyprinter and add all IMPLICIT_MODULES."""
prettyprinter.install_extras(include={"python", "dataclasses"})
for filepath in Path("wolfbot").rglob("*.py"):
module_name = filepath.stem
if "__" not in module_name:
prefix = ".".join(filepath.parts[:-1] + (module_name, ))
IMPLICIT_MODULES.add(prefix)
return Formatter(prettyprinter)
def _setup_logger(console_log_level):
with warnings.catch_warnings():
warnings.simplefilter("ignore")
prettyprinter.install_extras()
verboselogs.install()
if sys.platform == "win32":
# In Windows the default black is black, which is invisible on the default terminal.
coloredlogs.DEFAULT_FIELD_STYLES["levelname"] = {"color": "blue"}
root_logger = logging.getLogger()
root_logger.setLevel(min(console_log_level, logging.DEBUG))
console_log_handler = ConsoleLogHandler()
console_log_handler.setLevel(console_log_level)
root_logger.addHandler(console_log_handler)
sys.excepthook = _exception_handler
logging.captureWarnings(True)
| num
| ( expr )
id -> [a-zA-Z]\w*
num -> [0-9]+
type -> float int
"""
import dataclasses
import enum
import functools
import unittest
from typing import List
import prettyprinter
prettyprinter.install_extras()
class TokenType(str, enum.Enum):
EOF = ''
NUM = 'num'
ID = 'id'
MUL = 'mul'
ADD = 'add'
DOT = 'dot'
COMMA = 'comma'
LBRACK = 'lrback'
RBRACK = 'rrback'
EQ = 'eq'
PRINT = 'print'
SEMI = 'semicolon'
import pytest
from prettyprinter import install_extras, pformat
from coreapp.models import MyModel
install_extras(['django'])
@pytest.mark.django_db
def test_simple_case():
instance = MyModel.objects.create(name='John', slug='john', version=2)
expected = "coreapp.models.MyModel(id={}, slug='john', version=2, name='John')".format(
instance.id)
assert pformat(instance, width=999) == expected
@pytest.mark.django_db
def test_blank_field():
instance = MyModel.objects.create(name='', slug=None, version=2)
expected = """\
coreapp.models.MyModel(
id={},
version=2,
# Null fields: slug
# Blank fields: name
)""".format(instance.id)
assert pformat(instance, width=999) == expected
@pytest.mark.django_db
def test_default_field():
#!/usr/bin/env python3
from contextlib import contextmanager
from dataclasses import dataclass
from pathlib import Path
from prettyprinter import pprint, install_extras
from secrets import token_hex
from typing import List, Any
from sly import Lexer, Parser
# Pretty printer dataclasses support
install_extras(include=['dataclasses'], warn_on_error=True)
@contextmanager
def next_token(state):
token = "r" + token_hex(4)
state['tokens'].append(token)
try:
yield token
finally:
state['tokens'].pop()
def indent(s, amount=1):
return str(s).replace('\n', '\n' + ' ' * amount)
def mdc_compile(source, verbose=False):
lexer = MindusLexer()
parser = MindusParser()
import numpy as np
import pytest
from prettyprinter import install_extras, pformat
install_extras(["numpy"])
@pytest.mark.parametrize(
'nptype', (np.sctypes["uint"] + np.sctypes["int"] + np.sctypes["float"]))
def test_numpy_numeric_types(nptype):
val = nptype(1)
py_val = val.item()
if type(py_val) in (int, float):
inner_printed = pformat(py_val)
else:
# numpy renders types such as float128,
# that are not representable in native Python
# types, with Python syntax
inner_printed = repr(py_val)
expected = "numpy.{}({})".format(nptype.__name__, inner_printed)
assert pformat(val) == expected
def test_numpy_bool_type():
assert pformat(np.bool_(False)) == "numpy.bool_(False)"
assert pformat(np.bool_(True)) == "numpy.bool_(True)"
import logging
import sys
import prettyprinter
import uvicore
# Enable extras like @dataclass
prettyprinter.install_extras(exclude=[
# Not using django, no need to print django models
'django',
# Maybe when I get a shell ?
'ipython_repr_pretty',
'ipython',
'attrs',
])
def dump(*args):
"""Dump variables using prettyprinter"""
# Detect if running in pytest
if "pytest" in sys.modules: level = None
for arg in args:
if type(arg) == str:
# I don't want string printed with dump because it adds quotes to the string
# which seems confusing at times.
#prettyprinter.cpprint(arg, width=10000, ribbon_width=10000)
print(arg)
import logging
from statistics import mean
import pandas as pd
import prettyprinter
import wandb
from prettyprinter import pprint
from sklearn.metrics import accuracy_score
from simpletransformers.classification import ClassificationArgs, ClassificationModel
from utils import load_rte_data_file
prettyprinter.install_extras(
include=[
"dataclasses",
],
warn_on_error=True,
)
logging.basicConfig(level=logging.INFO)
transformers_logger = logging.getLogger("transformers")
transformers_logger.setLevel(logging.WARNING)
# Preparing train data
train_df = load_rte_data_file("data/train.jsonl")
eval_df = pd.read_json("data/eval_df.jsonl", lines=True, orient="records")
test_df = pd.read_json("data/test_df.jsonl", lines=True, orient="records")
sweep_result = pd.read_csv("sweep_results/deep-sweep.csv")
best_params = sweep_result.to_dict()
import click
import egpt.processing as proc
import prettyprinter # type: ignore
from distributed import Client # type: ignore
prettyprinter.install_extras(
# Comment out any packages you are not using.
include=[
'dataclasses',
],
warn_on_error=True)
@click.group()
def jobgroup():
pass
@jobgroup.group("job")
def job():
pass
@job.command("run")
@click.argument("jobfile")
@click.option("--scheduler")
def run(jobfile: str, scheduler: str):
if scheduler is not None:
Client(scheduler)
else:
Client()
res = proc.submit(jobfile)
from attr import attrs, attrib, Factory
from prettyprinter import install_extras, pformat
install_extras(['attrs'])
@attrs
class MyClass:
one = attrib()
optional = attrib(default=1)
optional2 = attrib(default=Factory(list))
def test_simple_case():
value = MyClass(1)
expected = "tests.test_attrs.MyClass(one=1)"
assert pformat(value, width=999) == expected
def test_different_from_default():
value = MyClass(1, optional=2, optional2=[1])
expected = "tests.test_attrs.MyClass(one=1, optional=2, optional2=[1])"
assert pformat(value, width=999) == expected
@attrs
class MyOtherClass:
one = attrib(repr=False)
AssocNodeOr,
PlusNode,
BarNode,
walk,
AssocNode,
map_contents,
WordType,
OptionalNode,
EmptyNode,
tree_has_gram,
)
from itertools import chain
from typing import Callable, Optional, List, Tuple, Iterable, Iterator
from prettyprinter import pprint, install_extras
install_extras(exclude=["django", "ipython", "ipython_repr_pretty"])
def intersect_none(s1, s2):
if s1 is None:
return s2
if s2 is None:
return s1
return s1.intersection(s2)
def uni(dl1, dl2):
all_keys = {*dl1.keys(), *dl2.keys()}
res = {}
for key in all_keys:
res[key] = dl1.get(key, []) + dl2.get(key, [])
DEBUG = False
DNS_HEADER = '!HBBHHHH'
DNS_HEADER_SIZE = struct.calcsize(DNS_HEADER)
DNS_DOMAIN_PATTERN = re.compile('^[A-Za-z0-9\-\.\_]+$')
NEW_ACCOUNT_URL = None
NONCE_URL = None
NEW_ORDER_URL = None
REVOKE_CERT_URL = None
ACME_SERVER_CERT = './pebble_https_ca.pem'
if DEBUG:
import prettyprinter
prettyprinter.install_extras(['requests'])
def read_answer(name):
ans = ''
try:
apath = FILE_PATH + name
if DEBUG:
print('Trying to open file ', apath)
afile = open(apath, 'r')
ans = afile.read().strip()
afile.close()
except:
pass
return ans
import prettyprinter prettyprinter.install_extras(exclude=['django'])
import time
import prettyprinter
import numpy as np
from geode.dispatcher import Dispatcher
prettyprinter.install_extras(include=['dataclasses'])
DESTS = np.array([[37.55799625, -97.78447195], [37.55799625, -97.78447195],
[34.821800, -92.052100], [31.419600, -83.230200],
[33.213000, -87.331800], [31.529500, -88.531600]])
ORIGS = np.array([[31.782000, -83.508600], [32.766200, -83.763700],
[37.755600, -96.773100], [35.393400, -95.272200],
[35.219700, -84.235400], [31.252500, -81.308500],
[31.646600, -91.954300], [30.384600, -97.415300],
[31.492100, -98.697900], [38.339300, -84.797900],
[31.719300, -96.396000], [39.113700, -96.249100],
[30.203000, -98.977700], [39.179000, -90.797400],
[39.707000, -81.610200], [38.978100, -87.091100],
[35.412000, -93.640600], [34.440900, -82.486700],
[32.529100, -95.140700], [36.434000, -86.271000],
[36.367600, -95.154600], [33.436000, -84.739100],
[36.499200, -91.634700], [39.323800, -88.615600],
[31.106400, -89.572400], [33.930700, -92.971900],
[36.977800, -84.871600], [35.019000, -85.219900],
[38.368600, -94.349600], [37.914100, -94.475800],
[31.318100, -91.481100], [33.983800, -98.433300],
[30.322100, -94.631500], [30.643200, -82.238600],
[36.893800, -98.801000], [33.035600, -99.468700],
[33.331600, -91.767900], [32.907600, -87.142700],
Snyk Shell provides a convenient shell interface to the Snyk API. You can
use any valid Python expression as well as make calls to the Snyk API using
the pre-configured Snyk API client. When you load the the shell it will
pre-load a list of your organizations and projects so you have some data to explore.
"""
import os
import sys
import prettyprinter
import snyk
from IPython.terminal.embed import InteractiveShellEmbed
from prettyprinter import cpprint as pprint
from termcolor import colored, cprint
prettyprinter.install_extras(include=["requests", "dataclasses"])
def run():
try:
token = os.environ["SNYK_TOKEN"]
except KeyError:
sys.exit("You must provide a SNYK_TOKEN to run Snyk Shell")
client = snyk.SnykClient(token)
organizations = client.organizations.all()
projects = client.projects.all()
shell = InteractiveShellEmbed(
banner1=colored("Welcome to Snyk Shell", "blue"))
shell(
import builtins
import prettyprinter
prettyprinter.install_extras(include=['attrs'])
prettyprinter.set_default_style("light")
builtins.pretty = prettyprinter.cpprint
@prettyprinter.register_pretty('regulator.location.Location')
def pretty_location(value, ctx):
return "Location({})".format(value)
@prettyprinter.register_pretty('regulator.decode.Type')
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))),
))
@prettyprinter.register_pretty('regulator.decode.Cluster')
def pretty_decoder_type(value, ctx):
return prettyprinter.pretty_call_alt(ctx,
type(value),
from dataclasses import (
dataclass,
fields,
field,
)
from typing import Any
from prettyprinter import install_extras, pformat
install_extras(['dataclasses'])
@dataclass
class MyClass:
one: Any
optional: Any = field(default=1)
optional2: Any = field(default_factory=list)
def test_simple_case():
value = MyClass(1)
expected = "tests.test_dataclasses.MyClass(one=1)"
assert pformat(value, width=999) == expected
def test_different_from_default():
value = MyClass(1, optional=2, optional2=[1])
expected = "tests.test_dataclasses.MyClass(one=1, optional=2, optional2=[1])"
assert pformat(value, width=999) == expected
from datetime import timedelta
from io import BytesIO
from requests import (
Request,
Response,
Session,
)
from requests.structures import CaseInsensitiveDict
from prettyprinter import (
install_extras,
pformat,
pprint,
)
install_extras(['requests'])
def test_session():
sess = Session()
sess.auth = ('user', 'pass')
assert pformat(sess, width=999) == """\
requests.Session(
headers=requests.structures.CaseInsensitiveDict({
'Accept': '*/*',
'Accept-Encoding': 'gzip, deflate',
'Connection': 'keep-alive',
'User-Agent': 'python-requests/2.18.4'
}),
auth=('user', 'pass')
)"""
import dataclasses
import logging
import os
import sys
# Use prettyprinter for dataclass formatting
try:
import prettyprinter as pprint
# NOTE ipython extra has issue, throwing a warning if installed and log a DF
# 'ZMQInteractiveShell' object has no attribute 'highlighting_style'
pprint.install_extras(exclude=["django", "ipython"], warn_on_error=False)
# Set a fairly aggressive limit to sequence by default
# This makes printing more similar to pandas truncation, which is nice
# NOTE However, this doesn't seem to work for big nested structures, so we
# might still have to apply a limit on total formatted string lines
# TODO Add a way to bypass sequence length when needed
pprint.set_default_config(
style="dark",
max_seq_len=20,
width=79,
ribbon_width=71,
depth=None,
)
except ImportError:
import pprint
# ANSI codes that will generate colored text
def_color_map = {
# reset should suffix any use of the other following prefixes
from pathlib import Path
from tempfile import NamedTemporaryFile
import click
from prettyprinter import install_extras
from . import commands
from . import exceptions
from .cache import purge
from .uri_handlers.base import URIHandler
from . import __version__
from . import config
install_extras(include=("dataclasses",))
LOGGER = config.get_logger(__name__)
CONTEXT_SETTINGS = dict(help_option_names=["-h", "--help"])
def scan_help_text():
help_text = """
Perform a security audit for a given package/data
"""
help_text = textwrap.dedent(help_text)
for uri_handler in URIHandler.__subclasses__():
if hasattr(uri_handler, "help"):
uhelp = textwrap.dedent(uri_handler.help).strip()
help_text += f"\n{uhelp}\n"
import yaml
import parglare
from parglare.actions import collect_sep
import prettyprinter
from prettyprinter import pprint
import dataclasses
import json
import sys
from parglare_adapter import to_parglare_grammar
from facts import Fact, Judgement, Variable, Name, ComplexTerm, List
prettyprinter.install_extras(['dataclasses'])
with open('semantics.bnf.yml', 'rt') as f:
grammar = yaml.load(f, Loader=yaml.Loader)
for s in grammar['string_terminals']:
assert s not in grammar['terminals']
grammar['terminals'][s] = ('string', s)
def pass_many(indexes):
def action(_, nodes):
return [nodes[i] for i in indexes]
return action
def pass_single(i):
def action(_, nodes):
import icdiff
from prettyprinter import install_extras, pformat
install_extras()
def pretty_compare(config, op, left, right):
very_verbose = config.option.verbose >= 2
if not very_verbose:
return None
if op != "==":
return None
try:
if abs(left + right) < 100:
return None
except TypeError:
pass
try:
pretty_left = pformat(left, indent=4, width=80,
sort_dict_keys=True).splitlines()
pretty_right = pformat(right, indent=4, width=80,
sort_dict_keys=True).splitlines()
differ = icdiff.ConsoleDiff(cols=160, tabsize=4)
icdiff_lines = list(
differ.make_table(pretty_left, pretty_right, context=False))
return (["equals failed"] +
["<left>".center(79) + "|" + "<right>".center(80)] +
# 3rd party
import prettyprinter # type: ignore # nodep
from prettyprinter.prettyprinter import _BASE_DISPATCH, pretty_dispatch # type: ignore # nodep
except ImportError as e: # pragma: no cover
exc = type(
e
)(f"Could not import 'prettyprinter'. Perhaps you need to install 'attr_utils[pprint]'?\n\n{e}"
)
raise exc.with_traceback(e.__traceback__) from None
__all__ = ["pretty_repr", "register_pretty", "PrettyFormatter", "_PF"]
_T = TypeVar("_T")
_PF = TypeVar("_PF", bound="PrettyFormatter")
prettyprinter.install_extras(["attrs"])
@runtime_checkable
class PrettyFormatter(Protocol):
"""
:class:`typing.Protocol` representing the pretty formatting functions decorated by :func:`register_pretty`.
.. versionadded:: 0.6.0
.. latex:vspace:: 10px
"""
def __call__(self, value: Any, ctx: Any) -> str:
"""
Call the function.
:param value: The value to pretty print.
