def test_no_sys_stderr(capsys, monkeypatch):
monkeypatch.setattr(sys, 'stderr', None)
logger.start(broken_sink)
logger.debug('a')
out, err = capsys.readouterr()
assert out == err == ""
def test_lazy(writer):
counter = 0
def laziness():
nonlocal counter
counter += 1
return counter
logger.start(writer, level=10, format="{level.no} => {message}")
logger.opt(lazy=True).log(10, "1: {lazy}", lazy=laziness)
logger.opt(lazy=True).log(5, "2: {0}", laziness)
logger.stop()
logger.opt(lazy=True).log(20, "3: {}", laziness)
a = logger.start(writer, level=15, format="{level.no} => {message}")
b = logger.start(writer, level=20, format="{level.no} => {message}")
logger.log(17, "4: {}", counter)
logger.opt(lazy=True).log(14, "5: {lazy}", lazy=lambda: counter)
logger.stop(a)
logger.opt(lazy=True).log(16, "6: {0}", lambda: counter)
logger.opt(lazy=True).info("7: {}", laziness)
logger.debug("7: {}", counter)
assert writer.read() == "10 => 1: 1\n17 => 4: 1\n20 => 7: 2\n"
def test_function_format_without_exception(writer):
logger.start(writer, format=lambda _: "{message}\n")
try:
1 / 0
except ZeroDivisionError:
logger.exception("Error!")
assert writer.read() == "Error!\n"
def test_ansi_raising(writer, message):
logger.start(writer,
format="<red>{message}</red>",
colorize=True,
catch=False)
with pytest.raises(ansimarkup.markup.MismatchedTag):
logger.opt(ansi=True).debug(message)
def test_ansi_with_record(writer):
logger.start(writer, format="{message}", colorize=True)
logger_ = logger.bind(start="<red>", end="</red>")
logger_.opt(
ansi=True,
record=True).debug("{record[extra][start]}B{record[extra][end]}")
assert writer.read() == ansimarkup.parse("<red>B</red>\n")
def test_manage_formatted_files(monkeypatch_date, tmpdir):
monkeypatch_date(2018, 1, 1, 0, 0, 0, 0)
f1 = tmpdir.join('temp/2018/file.log')
f2 = tmpdir.join('temp/file2018.log')
f3 = tmpdir.join('temp/d2018/f2018.2018.log')
a = logger.start(tmpdir.join('temp/{time:YYYY}/file.log'), retention=0)
b = logger.start(tmpdir.join('temp/file{time:YYYY}.log'), retention=0)
c = logger.start(
tmpdir.join('temp/d{time:YYYY}/f{time:YYYY}.{time:YYYY}.log'),
retention=0)
logger.debug("test")
assert f1.check(exists=1)
assert f2.check(exists=1)
assert f3.check(exists=1)
logger.stop(a)
logger.stop(b)
logger.stop(c)
assert f1.check(exists=0)
assert f2.check(exists=0)
assert f3.check(exists=0)
def test_frame_values_forward(writer):
logger.start(writer, backtrace=True, colorize=False)
k = 2
def a(n):
1 / n
def b(n):
a(n - 1)
@logger.catch
def c(n):
b(n - 1)
c(k)
lines = [line.strip() for line in writer.read().splitlines()]
line_1 = dropwhile(lambda x: x != '1 / n', lines)
line_2 = dropwhile(lambda x: x != 'a(n - 1)', lines)
line_3 = dropwhile(lambda x: x != 'b(n - 1)', lines)
line_4 = dropwhile(lambda x: x != 'c(k)', lines)
next(line_1)
next(line_2)
next(line_3)
next(line_4)
assert next(line_1).endswith(' 0')
assert next(line_2).endswith(' 1')
assert next(line_3).endswith(' 2')
assert next(line_4).endswith(' 2')
def test_ansi_double_message(writer):
logger.start(writer,
format="<red><b>{message}...</b> - <c>...{message}</c></red>",
colorize=True)
logger.opt(ansi=True).debug("<g>Double</g>")
assert writer.read() == ansimarkup.parse(
"<red><b><g>Double</g>...</b> - <c>...<g>Double</g></c></red>\n")
def Data_merge(self):
logger.start('Data merge start')
for i, values in enumerate(self.data_df2['code']):
for k, name in enumerate(self.data_df1['종목코드']):
if name in values:
self.data_df2['industry(Main_Category)'][
i] = self.data_df1['업종(대분류)'][k]
self.data_df2['industry(intermediate_classification)'][
i] = self.data_df1['업종(중분류)'][k]
self.data_df2['industry(subclass)'][i] = self.data_df1[
'업종(소분류)'][k]
from datetime import datetime
now = datetime.now()
self.data_df2['_id'] = str(now)[:10].replace(
'-', '') + '_' + self.data_df2['code']
self.dff = self.data_df2[[
'_id', 'Market', 'code', 'event_name', 'industry(Main_Category)',
'industry(intermediate_classification)', 'industry(subclass)',
'listed_stock_issued_count', 'market_cap'
]]
self.df_dict = self.dff.to_dict(orient="record")
logger.success('Data merge start')
def test_file_not_delayed(tmpdir):
file = tmpdir.join("test.log")
logger.start(file.realpath(), format="{message}", delay=False)
assert file.check(exists=1)
assert file.read() == ""
logger.debug("Not delayed")
assert file.read() == "Not delayed\n"
def mongoDB_insert(self):
import pymongo
import urllib
logger.start('mongoDB insert start')
# DB init
HOSTNAME = 'IP'
PORT = int(port)
username = urllib.parse.quote_plus('ID')
password = urllib.parse.quote_plus('PW')
connection = pymongo.MongoClient('mongodb://%s:%s@%s:%s/' %
(username, password, HOSTNAME, PORT))
DB = connection['test_seibro']
DB_insert = DB['FICS_data']
logger.success('mongoDB connection success')
for i in self.df_dict:
try:
DB_insert.insert_one(i)
logger.info(i)
except:
logger.info('Duplicate occurrence')
pass
now = datetime.now()
now = str(now)
self.dff.to_excel(
'/home/2digit/tmp/seibro_FICS_datafile/2Digit_FICS(seibro)_Crawlling_'
+ now[:4] + '_' + now[5:7] + now[8:11] + '.xlsx')
self.dff.to_excel(
'/home/2digit/tmp/seibro_FICS_datafile/2Digit_FICS(seibro).xlsx')
logger.success('mongoDB insert success')
logger.complete()
def test_catch():
def sink(msg):
raise 1 / 0
logger.start(sink, catch=False)
with pytest.raises(ZeroDivisionError):
logger.debug("fail")
def test_file_buffering(tmpdir):
file = tmpdir.join("test.log")
logger.start(file.realpath(), format="{message}", buffering=-1)
logger.debug("x" * (io.DEFAULT_BUFFER_SIZE // 2))
assert file.read() == ""
logger.debug("x" * (io.DEFAULT_BUFFER_SIZE * 2))
assert file.read() != ""
def test_context_manager(writer):
logger.start(writer)
with logger.catch():
1 / 0
assert writer.read().endswith(zero_division_error)
def test_with_backtrace(writer):
logger.start(writer, backtrace=True)
def c():
a = 2
b = 0
a / b
decorated = logger.catch()(c)
decorated()
result_with = writer.read()
logger.stop()
writer.clear()
logger.start(writer, backtrace=False)
decorated = logger.catch()(c)
decorated()
result_without = writer.read()
assert len(result_with) > len(result_without)
assert result_with.endswith(zero_division_error)
assert result_without.endswith(zero_division_error)
def __init__(self, log_format: str, target) -> None:
logger.start(sys.stdout, colorize=True,
format="<green>{time:YY-MM-DD HH:mm:ss}</green> | {message}",
filter='extensions.colored_quart.logging')
# logger.add(sys.stderr, format="{time} {message}")
self.logger = logger
self.log_format = log_format
def test_file_formatters(tmpdir, format, validator, part):
if part == "file":
file = tmpdir.join(format)
elif part == "dir":
file = tmpdir.join(format, 'log.log')
elif part == "both":
file = tmpdir.join(format, format)
logger.start(file.realpath())
logger.debug("Message")
files = [f for f in tmpdir.visit() if f.check(file=1)]
assert len(files) == 1
file = files[0]
if part == 'file':
assert validator(file.basename)
elif part == 'dir':
assert file.basename == 'log.log'
assert validator(file.dirpath().basename)
elif part == 'both':
assert validator(file.basename)
assert validator(file.dirpath().basename)
def test_invalid_function_kwargs():
def function(message, a="Y"):
pass
logger.start(function, b="X", catch=False)
with pytest.raises(TypeError):
logger.debug("Nope")
def test_keep_extra(writer):
logger.configure(extra=dict(test=123))
logger.start(writer, format='{extra[test]}')
logger.opt().debug("")
logger.opt().log(50, "")
assert writer.read() == "123\n123\n"
def test_reset_previous_extra(writer):
logger.configure(extra={"a": 123})
logger.start(writer, format="{extra[a]}", catch=False)
logger.configure(extra={})
with pytest.raises(KeyError):
logger.debug("Nope")
def test_reset_previous_handlers(writer):
logger.start(writer, format="{message}")
logger.configure(handlers=[])
logger.debug("Test")
assert writer.read() == ""
def test_intercept_too_low(writer, make_logging_logger):
logging_logger = make_logging_logger("tests.test_interception",
InterceptHandler())
logger.start(writer, format='{message}')
logging.getLogger('tests').error("Nope 1")
logging.getLogger('foobar').error("Nope 2")
result = writer.read()
assert result == ""
def test_record(writer):
logger.start(writer, format="{message}")
logger.opt(record=True).debug("1")
logger.opt(record=True).debug("2 {record[level]}")
logger.opt(record=True).log(11, "3 {0} {a} {record[level].no}", 4, a=5)
assert writer.read() == '1\n2 DEBUG\n3 4 5 11\n'
def test_ansi_with_message_specs(writer):
logger.start(writer, colorize=False, format="<g>{message}</g>")
logger.opt(ansi=True).debug("{} <b>A</b> {{nope}} {key:03d} {let!r}",
1,
key=10,
let='c')
logger.opt(ansi=True).debug("<b>{0:0{1}d}</b>", 2, 4)
assert writer.read() == ("1 A {nope} 010 'c'\n" "0002\n")
def test_file_handler(tmpdir):
file = tmpdir.join('test.log')
logger.start(FileHandler(file), format="{message}")
logger.info("test")
logger.stop()
logger.warning("nope")
assert file.read() == "test\n"
def test_enqueue_broken_sink(monkeypatch):
out = []
monkeypatch.setattr(loguru._handler.Handler, 'handle_error',
lambda *args: out.append('Handled'))
logger.start(broken_sink, enqueue=True)
logger.debug('a')
time.sleep(0.1)
assert out[0] == 'Handled'
def test_log_level(writer, make_logging_logger):
logging_logger = make_logging_logger("tests", InterceptHandler())
logger.start(writer, format="{level.no} - {level.name} - {message}")
logging_logger.log(12, "Hop")
result = writer.read()
assert result == '12 - Level 12 - Hop\n'
def test_start_before_intercept(writer, make_logging_logger):
logger.start(writer, format="{message}")
logging_logger = make_logging_logger(None, InterceptHandler())
logging_logger.info("Test")
result = writer.read()
assert result == 'Test\n'
def test_null_handler(capsys):
logger.start(NullHandler())
logger.error("nope")
logger.stop()
out, err = capsys.readouterr()
assert out == ""
assert err == ""
def test_log_before_disable(writer):
logger.start(writer, format="{message}")
logger.enable("")
logger.debug("yes")
logger.disable("tests")
logger.debug("nope")
result = writer.read()
assert result == "yes\n"
