def __init__(self, browser, sample_composition_graph, template_graph):
self.browser = browser
self.sample_composition = sample_composition_graph
self.template_graph = template_graph.copy()
self.log = Loggable(self)
self.gid = next(self.counter)
self.solution = None
def test_copy(capsys):
"""We expect copies to initially inherit the log level of their parents."""
logger1 = Loggable("Parent")
logger1.set_level("INFO")
logger2 = logger1.copy("newname")
assert logger2.name == "newname"
# logger 1 output
logger1.info("msg")
log, _ = capsys.readouterr()
assert "msg" in log
# logger 2 output
logger2.info("msg")
log, _ = capsys.readouterr()
assert "msg" in log
logger1.set_level("ERROR")
# logger 1 output
logger1.info("msg")
log, _ = capsys.readouterr()
assert not log
# logger 2 output
logger2.info("msg")
log, _ = capsys.readouterr()
assert "msg" in log
def test_spawn(capsys):
"""We expect spawned copies to inherit the log level of their parents."""
logger1 = Loggable("Parent")
logger1.set_level("INFO")
logger2 = logger1.spawn("new name")
# logger 1 output
logger1.info("msg")
log, _ = capsys.readouterr()
assert "msg" in log
# logger 2 output
logger2.info("msg")
log, _ = capsys.readouterr()
assert "msg" in log
logger1.set_level("ERROR")
# logger 1 no output
logger1.info("msg")
log, _ = capsys.readouterr()
assert not log
# logger 2 no output
logger2.info("msg")
log, _ = capsys.readouterr()
assert not log
def test_pickle():
logger1 = Loggable("Parent")
s = pickle.dumps(logger1)
logger2 = pickle.loads(s)
assert logger1.name == "Parent"
def test_basic_log(self, capsys):
logger = Loggable("loggable_test")
logger.set_level("INFO")
logger.track("INFO").info("log2")
log, _ = capsys.readouterr()
assert "INFO" in log
def test_update(self, capsys):
logger = Loggable("loggable_test")
logger.set_level("INFO")
track = logger.track("INFO", total=100).enter()
track.update(10, "10% there!")
track.update(20, "20% there!")
track.exit()
def test_log(self, level, capsys):
logger = Loggable("test")
msg = str(uuid4())
logger.set_level(level)
logger.log(msg, level)
log, _ = capsys.readouterr()
print(log)
assert msg in log
def test_no_update(self, capsys):
logger = Loggable("loggable_test")
logger.set_level("CRITICAL")
assert not logger.is_enabled("INFO")
track = logger.track("INFO", total=100).enter()
track.update(10, "10% there!")
track.update(20, "20% there!")
track.exit()
def test_not_enabled(self):
logger = Loggable("loggable_test")
logger.set_level("CRITICAL")
track = logger.track("INFO")
assert not track.is_enabled()
track = logger.track("CRITICAL")
assert track.is_enabled()
def __init__(self,
cost: float,
paths: list,
graph: BrowserGraph,
item=None):
self.cost = cost
self.graph = graph
self.paths = paths
self.item = item
self.log = Loggable(self)
def test_spawn(self, capsys):
log = Loggable("loggable_test")
log.set_level("INFO")
log2 = log.timeit(logging.INFO)
log2.enter()
log2.info("log2")
log2.exit()
msg, _ = capsys.readouterr()
assert "started" in msg.lower()
assert "log2" in msg
assert "finished" in msg.lower()
def test_prefix(self, capsys):
log = Loggable("loggable_test")
log.set_level("INFO")
timeit = log.timeit(logging.INFO, "prefix")
timeit.enter()
timeit.info("Some information")
timeit.exit()
log, _ = capsys.readouterr()
print(log)
assert "prefix" in log
def test_does_not_log(self, capsys):
log = Loggable("loggable_test")
log.set_level("ERROR")
timeit = log.timeit(logging.INFO)
timeit.enter()
timeit.info("ok")
time.sleep(0.1)
timeit.exit()
log, _ = capsys.readouterr()
print(log)
assert not log
def __setstate__(self, state):
self._edge_counter = state["_edge_counter"]
self._node_counter = state["_node_counter"]
self.edges = state["edges"]
self._plans = []
self._plan_ids = state["plan_ids"]
self.is_cached = state["is_cached"]
self._weights = state["_weights"]
self.updated_at = state["updated_at"]
self.created_at = state["created_at"]
# self.browser = state['browser']
self.log = Loggable(self)
def test_timeit(self, capsys):
log = Loggable("loggable_test")
log.set_level("INFO")
timeit = log.timeit(logging.INFO)
timeit.enter()
timeit.info("ok")
time.sleep(0.1)
timeit.exit()
log, _ = capsys.readouterr()
print(log)
assert "started" in log.lower()
assert "ok" in log
assert "finished" in log.lower()
def test_does_log(self, level, level_as_str, capsys):
logger = Loggable("test")
fxn = getattr(logger, level.lower())
level_str = level
if not level_as_str:
level = getattr(logging, level.upper())
# check log
logger.set_level(level)
msg = str(uuid4())
fxn(msg)
log, _ = capsys.readouterr()
print(log)
assert msg in log
assert level_str.upper() in log
def __init__(self, browser, plans=None, name=None):
self.browser = browser
self.log = Loggable(
self, "AutoPlanner@{url}".format(url=self.browser.session.url)
)
if plans:
self.plans = plans
self.browser.update_cache(plans)
self.weight_container = EdgeWeightContainer(
self.browser, self._hash_afts, self._external_aft_hash, plans=plans
)
self._template_graph = None
self.model_filters = {}
if name is None:
name = "unnamed_{}".format(id(self))
self.name = name
self._version = __version__
self.created_at = str(arrow.now())
self.updated_at = str(arrow.now())
def test_does_not_log(self, level, capsys):
logger = Loggable("test")
fxn = getattr(logger, level.lower())
# does log
logger.set_level(level)
msg = str(uuid4())
fxn(msg)
log, _ = capsys.readouterr()
# print(log)
assert msg in log
assert level.upper() in log
# does not log
logger.set_level(logging.CRITICAL + 1)
msg = str(uuid4())
fxn(msg)
log, _ = capsys.readouterr()
assert not log
assert not _
def test_pickle_span():
logger1 = Loggable("Parent")
logger1.set_level("INFO")
logger2 = logger1.spawn("new name")
assert logger1._children
assert logger2._children == {}
logger3 = pickle.loads(pickle.dumps(logger1))
logger4 = pickle.loads(pickle.dumps(logger2))
assert dict(logger3._children)
assert logger3._children[logger2._id] is logger2
assert logger4._children == {}
for lvl in ["ERROR", "DEBUG", "INFO"]:
logger1.set_level(lvl)
assert logger1.level_name() == lvl
assert logger2.level_name() == lvl
assert logger3.level_name() == lvl
assert logger4.level_name() == lvl
def __init__(self, browser, edge_hash, node_hash, plans, plan_ids=None):
"""EdgeCalculator initializer.
:param browser: the Browser object
:type browser: Browser
:param edge_hash: The edge hashing function. Should take exactly 2 arguments.
:type edge_hash: function
:param node_hash: The node hashing function. Should take exactly 1 argument.
:type node_hash: function
:param plans: optional list of plans
:type plans: list
"""
self.browser = browser
self.log = Loggable(
self, "EdgeWeightContainer({})".format(self.browser.session)
)
# filter only those plans that have operations
self._plans = []
if plan_ids is not None:
self._plan_ids = plan_ids
else:
self._plan_ids = []
if plans is not None:
self.plans = plans
def new_edge_hash(pair):
h = edge_hash(pair)
return "{}_{}_{}".format(
pair[0].field_type.parent_id, h, pair[1].field_type.parent_id
)
self.edges = []
self._edge_counter = HashCounter(new_edge_hash)
self._node_counter = HashCounter(node_hash)
self._weights = {}
self.created_at = str(arrow.now())
self.updated_at = None
self.is_cached = False
def logger(self):
return Loggable(self)
def test_exception_is_raised_for_pbar(self):
logger = Loggable("test loggable")
with pytest.raises(ValueError) as e:
for i in logger.tqdm(range(10), "ERROR"):
if i == 5:
raise ValueError
def test_exception_is_raised_for_track(self):
logger = Loggable("test loggable")
with pytest.raises(ValueError) as e:
with logger.track("ERROR", 100):
raise ValueError
"""DASi's logger."""
from loggable import Loggable
logger = Loggable("dasi")
def __init__(self):
self.log = Loggable(self)
def test_basic_progress_bar(self):
log = Loggable("test")
for x in tqdm(range(10)):
log.info(x)
time.sleep(0.01)
log.info("This is more information")
def test_leveled_progress_bar(self, level):
log = Loggable("Test")
for x in log.tqdm(range(10), level, desc="this is a description"):
log.info(x)
log.info("This is more information")
def test_timeit(self):
log = Loggable("loggable_test")
log.set_level("INFO")
with log.timeit(logging.INFO, "TimeItTest"):
log.info("ok")
from loggable import Loggable
logger = Loggable("pyblast")
def test_track_iterable(self):
logger = Loggable("loggable_test")
logger.set_level("INFO")
track = logger.track("INFO", desc="This is a progress bar")
for x in track(range(10)):
track.info(x)
