From d8494d8010d09857ba8a50a64495b68bed817a5c Mon Sep 17 00:00:00 2001 From: Puppuccino <97849040+CrazyDubya@users.noreply.github.com> Date: Thu, 12 Jun 2025 00:29:15 -0400 Subject: [PATCH 1/2] Use logger for debug output in code analyzer --- src/analyzer/code_analyzer.py | 35 ++++++++++++++++++++--------------- 1 file changed, 20 insertions(+), 15 deletions(-) diff --git a/src/analyzer/code_analyzer.py b/src/analyzer/code_analyzer.py index 38d7b45..ce10bc8 100644 --- a/src/analyzer/code_analyzer.py +++ b/src/analyzer/code_analyzer.py @@ -3,6 +3,11 @@ import networkx as nx from dataclasses import dataclass from pathlib import Path +import logging + +# Set up logging +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger("CodeAnalyzer") @dataclass class AnalysisResult: @@ -212,7 +217,7 @@ def _infer_variable_type(self, node: ast.Assign) -> None: def _infer_expression_type(self, node: ast.AST) -> str: """Infer the type of an expression.""" - print(f"Inferring expression type for: {type(node)}") + logger.debug(f"Inferring expression type for: {type(node)}") if isinstance(node, ast.Constant): if isinstance(node.value, int): return 'int' @@ -410,9 +415,9 @@ def _infer_function_types(self, node: ast.FunctionDef) -> None: def _get_type_name(self, node: ast.AST) -> str: """Get C++ type name from Python type annotation.""" - print(f"Processing node type: {type(node)}") + logger.debug(f"Processing node type: {type(node)}") if isinstance(node, ast.Name): - print(f"Name node: {node.id}") + logger.debug(f"Name node: {node.id}") if node.id == 'int': return 'int' elif node.id == 'float': @@ -423,29 +428,29 @@ def _get_type_name(self, node: ast.AST) -> str: return 'bool' return node.id elif isinstance(node, ast.Tuple): - print("Tuple node") + logger.debug("Tuple node") # Handle tuple type annotations directly elt_types = [] for e in node.elts: - print(f" Processing tuple element type: {type(e)}") + logger.debug(f" Processing tuple element type: {type(e)}") if isinstance(e, ast.Name): elt_types.append(self._get_type_name(e)) elif isinstance(e, ast.Subscript): elt_types.append(self._get_type_name(e)) else: - print(f" Unknown tuple element type: {type(e)}") + logger.debug(f" Unknown tuple element type: {type(e)}") elt_types.append('int') # Default type return f'std::tuple<{", ".join(elt_types)}>' elif isinstance(node, ast.Subscript): - print("Subscript node") + logger.debug("Subscript node") if isinstance(node.value, ast.Name): base_type = node.value.id - print(f" Base type: {base_type}") + logger.debug(f" Base type: {base_type}") if isinstance(node.slice, ast.Index): # Python 3.8 and earlier elt = node.slice.value else: # Python 3.9 and later elt = node.slice - print(f" Element type: {type(elt)}") + logger.debug(f" Element type: {type(elt)}") if base_type == 'list': return f'std::vector<{self._get_type_name(elt)}>' @@ -462,13 +467,13 @@ def _get_type_name(self, node: ast.AST) -> str: if isinstance(elt, ast.Tuple): elt_types = [] for e in elt.elts: - print(f" Processing tuple element type: {type(e)}") + logger.debug(f" Processing tuple element type: {type(e)}") if isinstance(e, ast.Name): elt_types.append(self._get_type_name(e)) elif isinstance(e, ast.Subscript): elt_types.append(self._get_type_name(e)) else: - print(f" Unknown tuple element type: {type(e)}") + logger.debug(f" Unknown tuple element type: {type(e)}") elt_types.append('int') # Default type return f'std::tuple<{", ".join(elt_types)}>' else: @@ -479,13 +484,13 @@ def _get_type_name(self, node: ast.AST) -> str: # Handle tuple type annotations directly elt_types = [] for e in node.value.elts: - print(f" Processing tuple element type: {type(e)}") + logger.debug(f" Processing tuple element type: {type(e)}") if isinstance(e, ast.Name): elt_types.append(self._get_type_name(e)) elif isinstance(e, ast.Subscript): elt_types.append(self._get_type_name(e)) else: - print(f" Unknown tuple element type: {type(e)}") + logger.debug(f" Unknown tuple element type: {type(e)}") elt_types.append('int') # Default type return f'std::tuple<{", ".join(elt_types)}>' elif isinstance(node.value, ast.Subscript): @@ -493,7 +498,7 @@ def _get_type_name(self, node: ast.AST) -> str: return self._get_type_name(node.value) return 'int' # Default elif isinstance(node, ast.Constant): - print(f"Constant node: {node.value}") + logger.debug(f"Constant node: {node.value}") if isinstance(node.value, str): return 'std::string' elif isinstance(node.value, int): @@ -503,7 +508,7 @@ def _get_type_name(self, node: ast.AST) -> str: elif isinstance(node.value, bool): return 'bool' return 'int' # Default type - print(f"Unknown node type: {type(node)}") + logger.debug(f"Unknown node type: {type(node)}") return 'int' # Default type def _check_loop_performance(self, node: ast.For) -> None: From b8231cab1a052f13c54f0792c59c6e2bcdd8357d Mon Sep 17 00:00:00 2001 From: Puppuccino <97849040+CrazyDubya@users.noreply.github.com> Date: Wed, 23 Jul 2025 11:23:03 -0400 Subject: [PATCH 2/2] Update src/analyzer/code_analyzer.py Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- src/analyzer/code_analyzer.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/analyzer/code_analyzer.py b/src/analyzer/code_analyzer.py index ce10bc8..88b1608 100644 --- a/src/analyzer/code_analyzer.py +++ b/src/analyzer/code_analyzer.py @@ -5,8 +5,7 @@ from pathlib import Path import logging -# Set up logging -logging.basicConfig(level=logging.INFO) +# Set up logger logger = logging.getLogger("CodeAnalyzer") @dataclass