def test_with_backtrace(writer):
logger.add(writer, backtrace=True)
def c():
a = 2
b = 0
a / b
decorated = logger.catch()(c)
decorated()
result_with = writer.read()
logger.remove()
writer.clear()
logger.add(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 test_with_and_without_backtrace(writer):
logger.add(writer, backtrace=True)
def c():
a = 2
b = 0
a / b
decorated = logger.catch()(c)
decorated()
result_with = writer.read()
logger.remove()
writer.clear()
logger.add(writer, backtrace=False)
decorated = logger.catch()(c)
decorated()
result_without = writer.read()
assert len(result_with.splitlines()) > len(result_without.splitlines())
assert result_with.endswith("ZeroDivisionError: division by zero\n")
assert result_without.endswith("ZeroDivisionError: division by zero\n")
def _catch(self) -> Generator[None, None, None]:
with logger.catch(BaseException,
level='TRACE',
reraise=not self.catch_exceptions):
if self.catch_exceptions:
with logger.catch(reraise=self.debug):
yield
else:
yield
def test_exception(writer, exception, should_raise, keyword, wrap_mode):
logger.add(writer)
if keyword:
if wrap_mode == "decorator":
@logger.catch(exception=exception)
def a():
1 / 0
elif wrap_mode == "function":
def a():
1 / 0
a = logger.catch(exception=exception)(a)
elif wrap_mode == "context_manager":
def a():
with logger.catch(exception=exception):
1 / 0
else:
if wrap_mode == "decorator":
@logger.catch(exception)
def a():
1 / 0
elif wrap_mode == "function":
def a():
1 / 0
a = logger.catch(exception)(a)
elif wrap_mode == "context_manager":
def a():
with logger.catch(exception):
1 / 0
if should_raise:
with pytest.raises(ZeroDivisionError):
a()
assert writer.read() == ""
else:
a()
assert writer.read().endswith(zero_division_error)
async def on_ready(self) -> None:
"""Initialize some stuff once the bot is ready."""
if self.first_on_ready:
self.first_on_ready = False
try:
self.pool = await asyncpg.create_pool(**config.DATABASE)
except asyncpg.exceptions.PostgresError:
print("Database connection error. Killing program.")
return await self.close()
# Load all extensions
for extension in self.extension_list:
with logger.catch(message=f"Cog {extension} failed to load"):
self.load_extension(extension)
logger.debug(f"Cog {extension} loaded.")
logger.info("Bot is ready")
else:
logger.info("Bot connection reinitialized")
query = "SELECT * FROM public.prefixes"
async with self.pool.acquire(timeout=5) as database:
for row in await database.fetch(query):
self.prefix_dict[row["ctx_id"]] = row["prefix"]
async def exception_logger(request: Request, call_next: Callable[..., Any]) -> Any:
"""
Just to log all exception with godlike logger from loguru.
"""
target_func = logger.catch()(call_next)
response = await target_func(request)
return response
def test_level(writer, wrap_mode, level, expected):
logger.add(writer, format="{level.name} | {level.no}")
if wrap_mode == "decorator":
@logger.catch(level=level)
def a():
1 / 0
elif wrap_mode == "function":
def a():
1 / 0
a = logger.catch(level=level)(a)
elif wrap_mode == "context_manager":
def a():
with logger.catch(level=level):
1 / 0
a()
lines = writer.read().strip().splitlines()
assert lines[0] == expected
def test_reraise(writer, wrap_mode):
logger.add(writer)
if wrap_mode == "decorator":
@logger.catch(reraise=True)
def a():
1 / 0
elif wrap_mode == "function":
def a():
1 / 0
a = logger.catch(reraise=True)(a)
elif wrap_mode == "context_manager":
def a():
with logger.catch(reraise=True):
1 / 0
with pytest.raises(ZeroDivisionError):
a()
assert writer.read().endswith(zero_division_error)
def test_context_manager(writer):
logger.add(writer)
with logger.catch():
1 / 0
assert writer.read().endswith(zero_division_error)
def test_returnwriter(writer, wrap_mode):
logger.add(writer, format="{message}")
if wrap_mode == "decorator":
@logger.catch
def a(x):
return 100 / x
result = a(50)
elif wrap_mode == "function":
def a(x):
return 100 / x
a = logger.catch()(a)
result = a(50)
elif wrap_mode == "context_manager":
def a(x):
with logger.catch():
return 100 / x
result = a(50)
assert writer.read() == ""
assert result == 2
def test_context_manager(writer):
logger.add(writer)
with logger.catch():
1 / 0
assert writer.read().endswith("ZeroDivisionError: division by zero\n")
def write_example(logger_name):
"""Writes log entries to the given logger."""
logger.add(StackDriverSink(logger_name))
logger.info('Hello, world!')
logger.debug('Goodbye, world!')
with logger.catch(
message='devide by zero'): #, onerror=lambda _: sys.exit(1)):
1 / 0
print('Wrote logs to {}.'.format(logger))
def test_message(writer, wrap_mode):
logger.start(writer, format='{message}')
message = 'An error occured:'
if wrap_mode == 'decorator':
@logger.catch(message=message)
def a():
1 / 0
a()
elif wrap_mode == 'function':
def a():
1 / 0
a = logger.catch(message=message)(a)
a()
elif wrap_mode == "context_manager":
with logger.catch(message=message):
1 / 0
assert writer.read().startswith(message + '\n')
def test_function(writer):
logger.add(writer)
def a():
1 / 0
a = logger.catch()(a)
a()
assert writer.read().endswith("ZeroDivisionError: division by zero\n")
def test_not_raising(writer, wrap_mode):
logger.start(writer, format='{message}')
message = "It's ok"
if wrap_mode == "decorator":
@logger.catch
def a():
logger.debug(message)
a()
elif wrap_mode == "function":
def a():
logger.debug(message)
a = logger.catch()(a)
a()
elif wrap_mode == "context_manager":
with logger.catch():
logger.debug(message)
assert writer.read() == message + '\n'
def main():
email = environ.get("CODEWARS_EMAIL")
password = environ.get("CODEWARS_PASSWORD")
if not email or not password:
raise Exception(
"Environment variables CODEWARS_EMAIL and CODEWARS_PASSWORD are required"
)
args = arguments()
if args.json:
if args.path:
logger.warning(
"JSON output will be ignored because --path was provided")
else:
logger.remove()
logger.catch(scrape)(args, email, password)
def test_function(writer):
logger.add(writer)
def a():
1 / 0
a = logger.catch()(a)
a()
assert writer.read().endswith(zero_division_error)
def test_not_raising(writer):
logger.add(writer, format="{message}")
message = "It's ok"
def a():
logger.debug(message)
a = logger.catch()(a)
a()
assert writer.read() == message + "\n"
def test_message(writer):
logger.add(writer, format="{message}")
message = "An error occurred:"
def a():
1 / 0
a = logger.catch(message=message)(a)
a()
assert writer.read().startswith(message + "\n")
assert writer.read().endswith("ZeroDivisionError: division by zero\n")
def test_onerror_with_reraise(writer):
called = False
logger.add(writer, format="{message}")
def onerror(_):
nonlocal called
called = True
with pytest.raises(ZeroDivisionError):
with logger.catch(onerror=onerror, reraise=True):
1 / 0
assert called
def make_post(self, r):
""""Uses currently open Response object to test for existence of various CSS
tags. Returns dictionary for insertion into MongoDB, or None if the
ingredients field is blank."""
post = dict()
soup = BeautifulSoup(r)
for key, val in zip(list(self.tags.keys())[3:],
list(self.tags.values())[3:]):
try:
post[key] = soup.find(val.split('.')).string
except AttributeError:
pass
raw_ingredients = soup.find(self.tags['full_recipe'].split('.'))
if len(raw_ingredients) == 0:
return None
else:
post['ingredients'] = raw_ingredients
try:
post['keywords'] = post['keywords'].split(',')
except Exception as e:
logger.catch(e)
pass
return post
def test_message(writer, wrap_mode):
logger.add(writer, format="{message}")
message = "An error occurred:"
if wrap_mode == "decorator":
@logger.catch(message=message)
def a():
1 / 0
a()
elif wrap_mode == "function":
def a():
1 / 0
a = logger.catch(message=message)(a)
a()
elif wrap_mode == "context_manager":
with logger.catch(message=message):
1 / 0
assert writer.read().startswith(message + "\n")
def __post_init__(self):
self.prefixes = list(self.prefixes)
self.names = list(self.names)
if not self.names:
self.names = self.handler.__name__
self.handler = logger.catch(self.handler)
self._text_arguments: typing.List[CommandTextArgument] = []
self._message_storage_argument_name = None
self._message_storage_argument_name: str
self._parse_handler_arguments()
self._routing_regex: typing.Pattern
self._build_routing_regex()
def normal_insert(self, allow_duplicates=False):
if allow_duplicates == False:
verbatim_docs = self.verbatim_docs()
if len(verbatim_docs) > 0 and allow_duplicates == False:
# Not adding docs because we're not allowing duplicates
return verbatim_docs[0].id, False
insert_variables = self.insert_builder.build()
_doc_id = self.insert_builder.doc_id
index_name = self.client.index_name
fields = [i.redis_args()[0] for i in self.indexable]
with logger.catch(message=f"{index_name} - {fields}", reraise=True):
self.client.add_document(_doc_id,
payload=_doc_id,
**insert_variables)
return _doc_id, True
def reorder_csv_rows(test_jsonl, src):
with logger.catch(reraise=True):
# src = pd.read_csv(sub_csv)
val_mtx = src.T.to_dict()
id2row = {}
for row in val_mtx.values():
id2row[int(row['id'])] = row
test_row_idx = []
with open(test_jsonl, mode='r') as f:
for row in f:
test_row_idx.append(json.loads(row)['id'])
reorder = [{
'id': int(id2row[i]['id']),
'proba': id2row[i]['proba'],
'label': int(id2row[i]['proba'] > 0.5),
} for i in test_row_idx]
dst = pd.DataFrame.from_dict(reorder)[['id', 'proba', 'label']]
return dst
def catch(decorated_function):
"""Customizing loguru's @catch decorator in one place
sends tg message if SUDOISBOT_SYSTEMD env var is set
"""
def onerror(e):
# squawk to telegram, runs after error has been logged
if os.environ.get("SUDOISBOT_SYSTEMD"):
name = sys.argv[0]
msg = f"{name} | {type(e).__name__}: {e}"
logger.debug("sending notification of my impending death")
try:
send_to_me(f"``` {msg} ```")
except Exception as e:
logger.error(f"failed to send message: {e}")
logger.debug("Exiting with '1'")
sys.exit(1)
return logger.catch(onerror=onerror)(decorated_function)
def test_returnwriter(writer, wrap_mode):
logger.start(writer, format='{message}')
if wrap_mode == 'decorator':
@logger.catch
def a(x):
return 100 / x
result = a(50)
elif wrap_mode == 'function':
def a(x):
return 100 / x
a = logger.catch()(a)
result = a(50)
elif wrap_mode == "context_manager":
def a(x):
with logger.catch():
return 100 / x
result = a(50)
assert writer.read() == ""
assert result == 2
def client(self):
"""client
Get the client for the user. If it doesn't exist yet, create a new one with the given stop words.
For subkeys it adds fields if we've created them recently.
.. code-block:: python
>>> self.client.add_document(_id, payload, **records)
Returns
-------
[type]
A redis connected client. Gets connection from Jamboree processor.
"""
# self.processor
if self.current_client is None:
# We would insert a connection here. Use the connection from the search processor to operate.
with logger.catch(ResponseError):
self.current_client = Client(self.index,
conn=self.processor.rconn)
if len(self.indexable) > 0:
self.current_client.create_index(
self.indexable,
stopwords=[
"but", "there", "these", "they", "this", "to"
],
)
if self.is_sub_key:
if not self.finished_alter:
for i in self.indexable:
with suppress(ResponseError):
self.current_client.alter_schema_add([i])
self.finished_alter = True
return self.current_client
def run(action, args):
algorithms = {}
debug("algorithms detected:")
for algorithm in ReinforcementLearningAlgorithm.subclasses:
debug(algorithm.__name__)
algorithms.update({algorithm.__name__: algorithm})
debug("")
try:
if args.algorithm not in algorithms:
valid_algorithms = ", ".join(algorithms.keys())
error(f"choose a valid algorithm: {valid_algorithms}")
return 1
try:
env = gym.make(args.environment)
except gym.error.Error:
valid_environments = "\n".join([
env.id for env in gym.envs.registry.all()
if env.id.startswith("MiniGrid")
])
error(f"choose a valid gym enviroment:\n{valid_environments}")
return 1
algo = algorithms[args.algorithm](env=env, args=args)
with logger.catch(reraise=True):
if action == "train":
algo.train()
if action == "visualize":
algo.visualize()
except AlgorithmError as e:
error(e.msg)
return 1
except Exception as e:
error(e)
return 1
return 0
def b(x):
def nested(i):
1 / i
with logger.catch():
nested(x)
