def test_precision(): """test various values for float_precision.""" f = PlainTextFormatter() nt.assert_equal(f(pi), repr(pi)) f.float_precision = 0 if numpy: po = numpy.get_printoptions() nt.assert_equal(po['precision'], 0) nt.assert_equal(f(pi), '3') f.float_precision = 2 if numpy: po = numpy.get_printoptions() nt.assert_equal(po['precision'], 2) nt.assert_equal(f(pi), '3.14') f.float_precision = '%g' if numpy: po = numpy.get_printoptions() nt.assert_equal(po['precision'], 2) nt.assert_equal(f(pi), '3.14159') f.float_precision = '%e' nt.assert_equal(f(pi), '3.141593e+00') f.float_precision = '' if numpy: po = numpy.get_printoptions() nt.assert_equal(po['precision'], 8) nt.assert_equal(f(pi), repr(pi))
def check_logging(config): os.makedirs(config.log_dir, exist_ok=True) os.makedirs(config.checkpoint_dir, exist_ok=True) try: from IPython.core.formatters import PlainTextFormatter formatter = PlainTextFormatter() except ImportError: formatter = str for directory in (config.log_dir, config.checkpoint_dir): with open(file=os.path.join(directory, 'config.json'), mode='w') as file: json.dump(config, file, indent=4, default=formatter) if config.mode == 'test' or config.load_checkpoint: initial_checkpoint = get_checkpoint(config.checkpoint_dir, by='epoch') else: initial_checkpoint = None if initial_checkpoint is not None: initial_epoch = int(CHECKPOINT_PATTERN.search(initial_checkpoint).group('epoch')) else: initial_epoch = 0 config.initial_checkpoint = initial_checkpoint config.initial_epoch = initial_epoch
def test_lookup(): f = PlainTextFormatter() f.for_type(C, foo_printer) nt.assert_is(f.lookup(C()), foo_printer) with nt.assert_raises(KeyError): f.lookup(A())
def test_lookup_by_type(): f = PlainTextFormatter() f.for_type(C, foo_printer) nt.assert_is(f.lookup_by_type(C), foo_printer) type_str = '%s.%s' % (C.__module__, 'C') with nt.assert_raises(KeyError): f.lookup_by_type(A)
def test_lookup(): f = PlainTextFormatter() f.for_type(C, foo_printer) assert f.lookup(C()) is foo_printer with pytest.raises(KeyError): f.lookup(A())
def test_precision(): """test various values for float_precision.""" f = PlainTextFormatter() nt.assert_equal(f(pi), repr(pi)) f.float_precision = 0 if numpy: po = numpy.get_printoptions() nt.assert_equal(po["precision"], 0) nt.assert_equal(f(pi), "3") f.float_precision = 2 if numpy: po = numpy.get_printoptions() nt.assert_equal(po["precision"], 2) nt.assert_equal(f(pi), "3.14") f.float_precision = "%g" if numpy: po = numpy.get_printoptions() nt.assert_equal(po["precision"], 2) nt.assert_equal(f(pi), "3.14159") f.float_precision = "%e" nt.assert_equal(f(pi), "3.141593e+00") f.float_precision = "" if numpy: po = numpy.get_printoptions() nt.assert_equal(po["precision"], 8) nt.assert_equal(f(pi), repr(pi))
def test_precision(): """test various values for float_precision.""" f = PlainTextFormatter() assert f(pi) == repr(pi) f.float_precision = 0 if numpy: po = numpy.get_printoptions() assert po["precision"] == 0 assert f(pi) == "3" f.float_precision = 2 if numpy: po = numpy.get_printoptions() assert po["precision"] == 2 assert f(pi) == "3.14" f.float_precision = "%g" if numpy: po = numpy.get_printoptions() assert po["precision"] == 2 assert f(pi) == "3.14159" f.float_precision = "%e" assert f(pi) == "3.141593e+00" f.float_precision = "" if numpy: po = numpy.get_printoptions() assert po["precision"] == 8 assert f(pi) == repr(pi)
def test_pretty(): f = PlainTextFormatter() f.for_type(A, foo_printer) nt.assert_equals(f(A()), 'foo') nt.assert_equals(f(B()), 'foo') f.pprint = False nt.assert_equals(f(A()), 'A()') nt.assert_equals(f(B()), 'B()')
def test_lookup_string(): f = PlainTextFormatter() type_str = '%s.%s' % (C.__module__, 'C') f.for_type(type_str, foo_printer) nt.assert_is(f.lookup(C()), foo_printer) # should move from deferred to imported dict nt.assert_not_in(_mod_name_key(C), f.deferred_printers) nt.assert_in(C, f.type_printers)
def test_lookup_string(): f = PlainTextFormatter() type_str = '%s.%s' % (C.__module__, 'C') f.for_type(type_str, foo_printer) assert f.lookup(C()) is foo_printer # should move from deferred to imported dict assert _mod_name_key(C) not in f.deferred_printers assert C in f.type_printers
def test_bad_precision(): """test various invalid values for float_precision.""" f = PlainTextFormatter() def set_fp(p): f.float_precision=p nt.assert_raises(ValueError, set_fp, '%') nt.assert_raises(ValueError, set_fp, '%.3f%i') nt.assert_raises(ValueError, set_fp, 'foo') nt.assert_raises(ValueError, set_fp, -1)
def test_bad_repr_traceback(): f = PlainTextFormatter() bad = BadRepr() with capture_output() as captured: result = f(bad) # catches error, returns None assert result is None assert "Traceback" in captured.stdout assert "__repr__" in captured.stdout assert "ValueError" in captured.stdout
def test_bad_repr_traceback(): f = PlainTextFormatter() bad = BadRepr() with capture_output() as captured: result = f(bad) # catches error, returns None nt.assert_is(result, None) nt.assert_in("Traceback", captured.stdout) nt.assert_in("__repr__", captured.stdout) nt.assert_in("ValueError", captured.stdout)
def test_pretty_max_seq_length(): f = PlainTextFormatter(max_seq_length=1) lis = list(range(3)) text = f(lis) assert text == "[0, ...]" f.max_seq_length = 0 text = f(lis) assert text == "[0, 1, 2]" text = f(list(range(1024))) lines = text.splitlines() assert len(lines) == 1024
def test_pretty_max_seq_length(): f = PlainTextFormatter(max_seq_length=1) lis = list(range(3)) text = f(lis) nt.assert_equal(text, '[0, ...]') f.max_seq_length = 0 text = f(lis) nt.assert_equal(text, '[0, 1, 2]') text = f(list(range(1024))) lines = text.splitlines() nt.assert_equal(len(lines), 1024)
def test_bad_precision(): """test various invalid values for float_precision.""" f = PlainTextFormatter() def set_fp(p): f.float_precision = p pytest.raises(ValueError, set_fp, "%") pytest.raises(ValueError, set_fp, "%.3f%i") pytest.raises(ValueError, set_fp, "foo") pytest.raises(ValueError, set_fp, -1)
def test_for_type(): f = PlainTextFormatter() # initial return, None assert f.for_type(C, foo_printer) is None # no func queries assert f.for_type(C) is foo_printer # shouldn't change anything assert f.for_type(C) is foo_printer # None should do the same assert f.for_type(C, None) is foo_printer assert f.for_type(C, None) is foo_printer
def test_warn_error_pretty_method(): f = PlainTextFormatter() class BadPretty(object): def _repr_pretty_(self): return "hello" bad = BadPretty() with capture_output() as captured: result = f(bad) nt.assert_is(result, None) nt.assert_in("WARNING", captured.stderr) nt.assert_in("text/plain", captured.stderr) nt.assert_in("argument", captured.stderr)
def test_for_type(): f = PlainTextFormatter() # initial return, None nt.assert_is(f.for_type(C, foo_printer), None) # no func queries nt.assert_is(f.for_type(C), foo_printer) # shouldn't change anything nt.assert_is(f.for_type(C), foo_printer) # None should do the same nt.assert_is(f.for_type(C, None), foo_printer) nt.assert_is(f.for_type(C, None), foo_printer)
def test_pretty(): f = PlainTextFormatter() f.for_type(A, foo_printer) assert f(A()) == "foo" assert f(B()) == "B()" assert f(GoodPretty()) == "foo" # Just don't raise an exception for the following: f(BadPretty()) f.pprint = False assert f(A()) == "A()" assert f(B()) == "B()" assert f(GoodPretty()) == "GoodPretty()"
def test_pretty(): f = PlainTextFormatter() f.for_type(A, foo_printer) nt.assert_equal(f(A()), 'foo') nt.assert_equal(f(B()), 'foo') nt.assert_equal(f(GoodPretty()), 'foo') # Just don't raise an exception for the following: f(BadPretty()) f.pprint = False nt.assert_equal(f(A()), 'A()') nt.assert_equal(f(B()), 'B()') nt.assert_equal(f(GoodPretty()), 'GoodPretty()')
def test_for_type_string(): f = PlainTextFormatter() type_str = '%s.%s' % (C.__module__, 'C') # initial return, None assert f.for_type(type_str, foo_printer) is None # no func queries assert f.for_type(type_str) is foo_printer assert _mod_name_key(C) in f.deferred_printers assert f.for_type(C) is foo_printer assert _mod_name_key(C) not in f.deferred_printers assert C in f.type_printers
def test_error_pretty_method(): f = PlainTextFormatter() class BadPretty(object): def _repr_pretty_(self): return "hello" bad = BadPretty() with capture_output() as captured: result = f(bad) nt.assert_is(result, None) nt.assert_in("Traceback", captured.stdout) nt.assert_in("_repr_pretty_", captured.stdout) nt.assert_in("given", captured.stdout) nt.assert_in("argument", captured.stdout)
def test_for_type_string(): f = PlainTextFormatter() type_str = "%s.%s" % (C.__module__, "C") # initial return, None nt.assert_is(f.for_type(type_str, foo_printer), None) # no func queries nt.assert_is(f.for_type(type_str), foo_printer) nt.assert_in(_mod_name_key(C), f.deferred_printers) nt.assert_is(f.for_type(C), foo_printer) nt.assert_not_in(_mod_name_key(C), f.deferred_printers) nt.assert_in(C, f.type_printers)
def test_for_type_by_name(): f = PlainTextFormatter() mod = C.__module__ # initial return, None assert f.for_type_by_name(mod, "C", foo_printer) is None # no func queries assert f.for_type_by_name(mod, "C") is foo_printer # shouldn't change anything assert f.for_type_by_name(mod, "C") is foo_printer # None should do the same assert f.for_type_by_name(mod, "C", None) is foo_printer assert f.for_type_by_name(mod, "C", None) is foo_printer
def test_pop(): f = PlainTextFormatter() f.for_type(C, foo_printer) nt.assert_is(f.lookup_by_type(C), foo_printer) nt.assert_is(f.pop(C, None), foo_printer) f.for_type(C, foo_printer) nt.assert_is(f.pop(C), foo_printer) with nt.assert_raises(KeyError): f.lookup_by_type(C) with nt.assert_raises(KeyError): f.pop(C) with nt.assert_raises(KeyError): f.pop(A) nt.assert_is(f.pop(A, None), None)
def test_pop(): f = PlainTextFormatter() f.for_type(C, foo_printer) assert f.lookup_by_type(C) is foo_printer assert f.pop(C, None) is foo_printer f.for_type(C, foo_printer) assert f.pop(C) is foo_printer with pytest.raises(KeyError): f.lookup_by_type(C) with pytest.raises(KeyError): f.pop(C) with pytest.raises(KeyError): f.pop(A) assert f.pop(A, None) is None
def test_for_type_by_name(): f = PlainTextFormatter() mod = C.__module__ # initial return, None nt.assert_is(f.for_type_by_name(mod, 'C', foo_printer), None) # no func queries nt.assert_is(f.for_type_by_name(mod, 'C'), foo_printer) # shouldn't change anything nt.assert_is(f.for_type_by_name(mod, 'C'), foo_printer) # None should do the same nt.assert_is(f.for_type_by_name(mod, 'C', None), foo_printer) nt.assert_is(f.for_type_by_name(mod, 'C', None), foo_printer)
def test_error_pretty_method(): f = PlainTextFormatter() class BadPretty(object): def _repr_pretty_(self): return "hello" bad = BadPretty() with capture_output() as captured: result = f(bad) assert result is None assert "Traceback" in captured.stdout assert "_repr_pretty_" in captured.stdout assert "given" in captured.stdout assert "argument" in captured.stdout
def test_lookup_by_type_string(): f = PlainTextFormatter() type_str = '%s.%s' % (C.__module__, 'C') f.for_type(type_str, foo_printer) # verify insertion nt.assert_in(_mod_name_key(C), f.deferred_printers) nt.assert_not_in(C, f.type_printers) nt.assert_is(f.lookup_by_type(type_str), foo_printer) # lookup by string doesn't cause import nt.assert_in(_mod_name_key(C), f.deferred_printers) nt.assert_not_in(C, f.type_printers) nt.assert_is(f.lookup_by_type(C), foo_printer) # should move from deferred to imported dict nt.assert_not_in(_mod_name_key(C), f.deferred_printers) nt.assert_in(C, f.type_printers)