Updated all logging to be lazy-loaded

src/celpy/__init__.py

@@ -261,7 +261,7 @@ def __init__(
         self.logger = logging.getLogger(self.__class__.__name__)
         self.package: Optional[str] = package
         self.annotations: Dict[str, Annotation] = annotations or {}
-        self.logger.info(f"Type Annotations {self.annotations!r}")
+        self.logger.info("Type Annotations %r", self.annotations)
         self.runner_class: Type[Runner] = runner_class or InterpretedRunner
         self.cel_parser = CELParser()
         self.runnable: Runner
@@ -282,7 +282,7 @@ def program(
             functions: Optional[Dict[str, CELFunction]] = None
     ) -> Runner:
         """Transforms the AST into an executable runner."""
-        self.logger.info(f"Package {self.package!r}")
+        self.logger.info("Package %r", self.package)
         runner_class = self.runner_class
         self.runnable = runner_class(self, expr, functions)
         return self.runnable

src/celpy/__main__.py

@@ -341,11 +341,11 @@ def process_json_doc(
     except CELEvalError as ex:
         # ``jq`` KeyError problems result in ``None``.
         # Other errors should, perhaps, be more visible.
-        logger.debug(f"Encountered {ex} on document {document!r}")
+        logger.debug("Encountered %s on document %r", ex, document)
         display(None)
         return 0
     except json.decoder.JSONDecodeError as ex:
-        logger.error(f"{ex.args[0]} on document {document!r}")
+        logger.error("%s on document %r", ex.args[0], document)
         # print(f"{ex.args[0]} in {document!r}", file=sys.stderr)
         return 3
 
@@ -426,7 +426,7 @@ def output_display(result: Result) -> None:
                 if isinstance(result, (celtypes.BoolType, bool)):
                     summary = 0 if result else 1
                 else:
-                    logger.warning(f"Expected celtypes.BoolType, got {type(result)} = {result!r}")
+                    logger.warning("Expected celtypes.BoolType, got %s = %r", type(result), result)
                     summary = 2
             else:
                 output_display(result)

src/celpy/celtypes.py

@@ -266,7 +266,7 @@ def logical_condition(e: Value, x: Value, y: Value) -> Value:
     if not isinstance(e, BoolType):
         raise TypeError(f"Unexpected {type(e)} ? {type(x)} : {type(y)}")
     result = x if e else y
-    logger.debug(f"logical_condition({e!r}, {x!r}, {y!r}) = {result!r}")
+    logger.debug("logical_condition(%r, %r, %r) = %r", e, x, y, result)
     return result
 
 
@@ -299,7 +299,7 @@ def logical_not(x: Value) -> Value:
         result = BoolType(not x)
     else:
         raise TypeError(f"not {type(x)}")
-    logger.debug(f"logical_not({x!r}) = {result!r}")
+    logger.debug("logical_not(%r) = %r", x, result)
     return result
 
 

src/xlate/c7n_to_cel.py

@@ -449,7 +449,7 @@ def type_marked_for_op_rewrite(resource: str, c7n_filter: Dict[str, Any]) -> str
         if "tz" in c7n_filter:  # pragma: no cover
             # Not widely used.
             tz = c7n_filter.get("tz", "utc")
-            logger.error(f"Cannot convert mark-for-op: with tz: {tz} in {c7n_filter}")
+            logger.error("Cannot convert mark-for-op: with tz: %s in %s", tz, c7n_filter)
 
         clauses = [
             f'{key}.marked_key({C7N_Rewriter.q(tag)}).action == {C7N_Rewriter.q(op)}',
@@ -512,7 +512,7 @@ def type_image_rewrite(resource: str, c7n_filter: Dict[str, Any]) -> str:
         op = cast(str, c7n_filter["op"])
         cel_value = f'{C7N_Rewriter.q(c7n_filter["value"])}'
         if "(?!" in cel_value:
-            logger.error(f"Image patterns like {cel_value!r} require a manual rewrite.")
+            logger.error("Image patterns like %r require a manual rewrite.", cel_value)
 
         return C7N_Rewriter.atomic_op_map[op].format(key, cel_value)
 
@@ -1342,7 +1342,7 @@ def cross_account_rewrite(resource: str, c7n_filter: Dict[str, Any]) -> str:
             exclude = ""
         for k in c7n_filter:
             if k.startswith("whitelist_") and k != "whitelist_from":
-                logger.error(f"Not handled well {k}: {c7n_filter[k]}")
+                logger.error("Not handled well %s: %s", k, c7n_filter[k])
                 values = ", ".join(f'"{item}"' for item in c7n_filter[k])
                 exclude += f".filter(p, ! p.attr in [{values}])"
         return f"size({attr}{exclude}) > 0"

tests/test_adapter.py

@@ -25,6 +25,7 @@
 def test_json_to_cel():
     assert celpy.adapter.json_to_cel(True) == celpy.celtypes.BoolType(True)
     assert celpy.adapter.json_to_cel(False) == celpy.celtypes.BoolType(False)
+    assert str(celpy.adapter.json_to_cel(False)) == str(celpy.celtypes.BoolType(False))
     assert celpy.adapter.json_to_cel(2.5) == celpy.celtypes.DoubleType(2.5)
     assert celpy.adapter.json_to_cel(42) == celpy.celtypes.IntType(42)
     assert celpy.adapter.json_to_cel("Hello, world!") == celpy.celtypes.StringType("Hello, world!")

tests/test_evaluation.py

@@ -346,9 +346,8 @@ def method(self, tree):
     assert result == sentinel.result
 
     assert e.logger.info.mock_calls == [
-        call(f"| {mock_tree!r}"),
-        call('| ident -> sentinel.result'),
-
+        call('%s%r', '| ', mock_tree),
+        call('%s%s -> %r', '| ', 'ident', sentinel.result)
     ]
 
 def test_evaluator_init():

tests/test_parser.py

@@ -31,7 +31,7 @@
 from lark import Tree
 from pytest import *  # type: ignore[import]
 
-from celpy.celparser import CELParseError, CELParser, DumpAST
+from celpy.celparser import CELParseError, CELParser, DumpAST, tree_dump
 
 
 @fixture
@@ -437,3 +437,8 @@ def test_dump_ast(parser):
     # An odd degenerate case
     ast6 = parser.parse("[].min()")
     assert DumpAST.display(ast6) == ".min()"
+
+
+def test_tree_dump(parser):
+    ast = parser.parse("-(3*4+5-1/2%3==1)?name[index]:f(1,2)||false&&true")
+    assert tree_dump(ast) == '- (3 *  4 +  5 -  1 /  2 %  3 ==  1) ? name[index] : f(1, 2) || false && true'