Use loguru and appdirs to replace logging and hard coded path

.cmake-format.py

@@ -1,8 +1,6 @@
 # ------------------------------------------------
 # Options affecting comment reflow and formatting.
 # ------------------------------------------------
-from __future__ import annotations
-
 with section("markup"):
     # enable comment markup parsing and reflow
     enable_markup = False

.pre-commit-config.yaml

@@ -10,12 +10,8 @@ repos:
       - id: end-of-file-fixer
       - id: mixed-line-ending
       - id: trailing-whitespace
-  - repo: https://github.com/pycqa/isort
-    rev: 5.12.0
-    hooks:
-      - id: isort
-  - repo: https://github.com/psf/black
-    rev: 23.1.0
+  - repo: https://github.com/psf/black-pre-commit-mirror
+    rev: 23.9.1
     hooks:
       - id: black
   - repo: https://github.com/PyCQA/autoflake
@@ -31,10 +27,10 @@ repos:
           # - "--remove-unused-variables"
           - "--remove-all-unused-imports"
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.254
+    rev: v0.0.292
     hooks:
-    - id: ruff
-      args: [--fix, --exit-non-zero-on-fix, --no-cache]
+      - id: ruff
+        args: [--fix, --exit-non-zero-on-fix, --no-cache]
   - repo: https://github.com/asottile/yesqa
     rev: v1.4.0
     hooks:

examples/native_interpreter/pyproject.toml

@@ -0,0 +1,3 @@
+[tool.ruff.isort]
+lines-between-types = 1
+known-first-party = ["build"]

examples/native_interpreter/use_interpreter.py

@@ -2,10 +2,9 @@
 
 import paddle
 
-from build import myinterpreter
-
 import paddlefx
 
+from build import myinterpreter
 from paddlefx import symbolic_trace
 
 
@@ -22,8 +21,8 @@ def net(a, b):
 traced_layer.graph.print_tabular()
 
 # the very simple IR we want to lower fx graph to
-# each instruction is a list of string of:  operation, left_operand, right_operand, result
-# only two op supported: add, mul
+# each instruction is a list of string of:  operation, left_operand,
+# right_operand, result only two op supported: add, mul
 input_names = []
 instructions = []
 

examples/resnet_dynamo.py

@@ -12,7 +12,7 @@
 from paddlefx.compiler.tvm import TVMCompiler
 
 paddle.seed(1234)
-# logging.getLogger().setLevel(logging.DEBUG)
+
 
 compiler = TVMCompiler(
     full_graph=True,

examples/simple_compiler.py

@@ -11,7 +11,7 @@
 
 paddle.seed(1234)
 
-# logging.getLogger().setLevel(logging.DEBUG)
+
 
 
 def inner_func(x, y):

examples/simple_dynamo.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-import logging
-
 import numpy as np
 import paddle
 import paddle.nn
@@ -10,7 +8,6 @@
 
 from paddlefx.compiler import DummyCompiler, TVMCompiler
 
-logging.getLogger().setLevel(logging.DEBUG)
 static_compier = DummyCompiler(full_graph=True, print_tabular_mode="rich")
 compiler = TVMCompiler(full_graph=True, print_tabular_mode="rich")
 

examples/targets/target_0_add.py

@@ -11,8 +11,6 @@
 
 import paddlefx
 
-logging.basicConfig(level=logging.DEBUG, format="%(message)s")
-
 
 def my_compiler(gl: paddlefx.GraphLayer, example_inputs: list[paddle.Tensor] = None):
     print("my_compiler() called with FX graph:")

examples/targets/target_1_print.py

@@ -11,8 +11,6 @@
 
 import paddlefx
 
-logging.basicConfig(level=logging.DEBUG, format="%(message)s")
-
 # TODO: support grpah break for `print`
 
 

examples/targets/target_2_func.py

@@ -1,20 +1,11 @@
 from __future__ import annotations
 
-import logging
-
-# ignore DeprecationWarning from `pkg_resources`
-logging.captureWarnings(True)
-
-
 import paddle
 import paddle.nn
 
 import paddlefx
 import paddlefx.utils
 
-# logging.basicConfig(level=logging.DEBUG, format="%(message)s")
-logging.basicConfig(level=logging.INFO, format="%(message)s")
-
 
 def my_compiler(gl: paddlefx.GraphLayer, example_inputs: list[paddle.Tensor] = None):
     print("my_compiler() called with FX graph:")

examples/targets/target_3_add_paddle.py

@@ -1,22 +1,12 @@
 from __future__ import annotations
 
-import logging
-
-# ignore DeprecationWarning from `pkg_resources`
-logging.captureWarnings(True)
-
 import paddle
 import paddle._C_ops
 
 import paddlefx
 
 from paddlefx.compiler import TVMCompiler
 
-logging.basicConfig(level=logging.DEBUG, format="%(message)s")
-# logging.basicConfig(level=logging.INFO, format="%(message)s")
-
-paddle.seed(1234)
-
 
 def func(x, y):
     z = paddle.add(x, y)

pyproject.toml

@@ -14,19 +14,25 @@ skip-string-normalization = true
 # default value may too big to run
 workers = 4
 
-# https://pycqa.github.io/isort/docs/configuration/options.html
-[tool.isort]
-profile = "black"
-lines_between_types = 1
-known_first_party = ["paddlefx"]
-add_imports = ["from __future__ import annotations"]
-
 # https://beta.ruff.rs/docs/configuration/
 [tool.ruff]
-select = ["UP"]
-ignore = ["UP015"]
+exclude = [".cmake-format.py"]
+select = [
+    "UP",
+    "F",
+    "I"
+]
+ignore = [
+    "UP015",
+    "F405"
+]
 target-version = "py38"
 
+[tool.ruff.isort]
+lines-between-types = 1
+known-first-party = ["paddlefx"]
+required-imports = ["from __future__ import annotations"]
+
 [tool.pytest.ini_options]
 minversion = "7.0.0"
 pythonpath = "tests"

requirements.txt

@@ -1,2 +1,4 @@
 paddlepaddle>=2.4.0
 pydot
+loguru
+appdirs

src/paddlefx/cache_manager.py

@@ -5,6 +5,8 @@
 
 from typing import TYPE_CHECKING, Callable
 
+from loguru import logger
+
 if TYPE_CHECKING:
     GuardFunction = Callable[[types.FrameType], bool]
     GuardedCodes = list["GuardedCode"]
@@ -28,7 +30,7 @@ def add_cache(cls, code: types.CodeType, guarded_code: GuardedCode):
     def get_cache(cls, frame: types.FrameType) -> GuardedCode | None:
         code: types.CodeType = frame.f_code
         if code not in cls.cache_dict:
-            print(f"Firstly call {code}\n")
+            logger.success(f"Firstly call {code}\n")
             return None
         return cls.lookup(frame, cls.cache_dict[code])
 
@@ -44,17 +46,17 @@ def lookup(
             try:
                 guard_fn = guarded_code.guard_fn
                 if guard_fn(frame):
-                    print(
+                    logger.success(
                         f"[Cache]: Cache hit, GuardFunction is {guard_fn}\n",
                     )
                     return guarded_code
                 else:
-                    print(
+                    logger.info(
                         f"[Cache]: Cache miss, GuardFunction is {guard_fn}\n",
                     )
             except Exception as e:
-                print(f"[Cache]: GuardFunction function error: {e}\n")
+                logger.exception(f"[Cache]: GuardFunction function error: {e}\n")
                 continue
 
-        print("[Cache]: all guards missed\n")
+        logger.success("[Cache]: all guards missed\n")
         return None

src/paddlefx/compiler/tvm.py

@@ -6,6 +6,8 @@
 import paddle.device
 import tvm
 
+from appdirs import user_cache_dir
+from loguru import logger
 from tvm import auto_scheduler, relay
 
 import paddlefx
@@ -36,14 +38,16 @@ def __init__(
         self.tune_mode = tune_mode
 
     def compile(self, gl: paddlefx.GraphLayer, example_inputs: list) -> Callable:
+        cache_path = user_cache_dir('paddlefx')
+
         shape_dict = {}
         for node in gl.graph.nodes:
             if node.op == "placeholder":
                 shape_dict[node.name] = example_inputs[self.input_index].shape
                 self.input_index += 1
         static_func = paddle.jit.to_static(gl.forward)
         static_func(*example_inputs)
-        model_path = f"~/.cache/paddlefx/model_{id(gl)}"
+        model_path = f"{cache_path}/paddle_static_model/{id(gl)}"
         paddle.jit.save(static_func, model_path)
         translated_layer = paddle.jit.load(model_path)
         mod, params = relay.frontend.from_paddle(translated_layer)
@@ -53,21 +57,21 @@ def compile(self, gl: paddlefx.GraphLayer, example_inputs: list) -> Callable:
             )
 
             for idx, task in enumerate(tasks):
-                print(
-                    "========== Task %d  (workload key: %s) =========="
-                    % (idx, task.workload_key)
+                logger.info(
+                    f"========== Task {idx}  (workload key: {task.workload_key}) =========="
                 )
-                print(task.compute_dag)
+                logger.info(task.compute_dag)
 
             tuner = auto_scheduler.TaskScheduler(tasks, task_weights)
+            log_file_path = f"{cache_path}/paddle_static_model/{id(gl)}"
             tune_option = auto_scheduler.TuningOptions(
                 num_measure_trials=200,
                 early_stopping=10,
-                measure_callbacks=[auto_scheduler.RecordToFile("log_file")],
+                measure_callbacks=[auto_scheduler.RecordToFile(log_file_path)],
             )
 
             tuner.tune(tune_option)
-            with auto_scheduler.ApplyHistoryBest("log_file"):
+            with auto_scheduler.ApplyHistoryBest(log_file_path):
                 with tvm.transform.PassContext(
                     opt_level=3, config={"relay.backend.use_auto_scheduler": True}
                 ):

src/paddlefx/convert_frame.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
-import logging
 import types
 
 from typing import TYPE_CHECKING, Callable
 
+from loguru import logger
+
 from .bytecode_transformation import Instruction, transform_code_object
 from .cache_manager import CodeCacheManager, GuardedCode
 from .paddle_utils import Tensor, skip_paddle_filename, skip_paddle_frame
@@ -31,7 +32,7 @@ def skip_frame(frame: types.FrameType) -> bool:
 
 def convert_frame(frame: types.FrameType, compiler_fn: Callable) -> GuardedCode | None:
     if skip_frame(frame):
-        logging.debug(f"skip_frame: {frame}")
+        logger.debug(f"skip_frame: {frame}")
         return None
     # TODO: guard_fn is not declared in this scope
     guard_fn = None
@@ -45,12 +46,12 @@ def transform(instructions: list[Instruction], code_options: dict):
         code_options.update(tracer.output.code_options)
         instructions[:] = tracer.output.instructions
 
-    logging.info(f"convert_frame: {frame}")
+    logger.info(f"convert_frame: {frame}")
     code = frame.f_code
     log_code(code, "ORIGINAL_BYTECODE")
 
     if (cached_code := CodeCacheManager.get_cache(frame)) is not None:
-        logging.info(f"cached_code: {cached_code}")
+        logger.info(f"cached_code: {cached_code}")
         return cached_code
 
     # TODO: rm torch code dependency

src/paddlefx/eval_frame.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
 import functools
-import logging
 import types
 
 from typing import Callable
 
+from loguru import logger
+
 from ._eval_frame import set_eval_frame
 from .compiler import DummyCompiler
 from .convert_frame import convert_frame
@@ -54,7 +55,7 @@ def __fn(frame: types.FrameType):
                 guarded_code = convert_frame(frame, backend)
                 return guarded_code
             except NotImplementedError as e:
-                logging.debug(f"!! NotImplementedError: {e}")
+                logger.debug(f"!! NotImplementedError: {e}")
             except Exception:
                 raise
             return None

src/paddlefx/legacy_module/translator.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import logging
 import operator
 import types
 
@@ -9,6 +8,8 @@
 import paddle
 import paddle.nn
 
+from loguru import logger
+
 from ..bytecode_transformation import Instruction, create_instruction
 from ..output_graph import OutputGraph
 from ..proxy import Attribute, Proxy
@@ -127,7 +128,7 @@ def call_function(self, fn, args, kwargs):
             res = self.output.create_node('call_function', fn, args, kwargs)
             self.stack.push(res)
         elif is_custom_call:
-            raise NotImplementedError(f"custom_call is not supported")
+            raise NotImplementedError("custom_call is not supported")
         else:
             raise NotImplementedError(f"call function {fn} is not supported")
 
@@ -236,7 +237,7 @@ def STORE_SUBSCR(self, inst):
         self.output.create_node('call_method', "__setitem__", [root, idx, value], {})
 
     def POP_TOP(self, inst: Instruction):
-        value = self.stack.pop()
+        self.stack.pop()
 
     def STORE_FAST(self, inst: Instruction):
         self.f_locals[inst.argval] = self.stack.pop()
@@ -323,7 +324,7 @@ def step(self, inst: Instruction):
         if not hasattr(self, inst.opname):
             raise NotImplementedError(f"missing: {inst.opname}")
 
-        logging.debug(f"TRACE {inst.opname} {inst.argval} {self.stack}")
+        logger.debug(f"TRACE {inst.opname} {inst.argval} {self.stack}")
         getattr(self, inst.opname)(inst)
 
     def run(self):