testgenie-py 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

testgen/reinforcement/agent.py

@@ -4,6 +4,7 @@ from typing import List
 
 from testgen.models.test_case import TestCase
 from testgen.reinforcement.environment import ReinforcementEnvironment
+from testgen.service.logging_service import get_logger
 
 
 class ReinforcementAgent:
@@ -13,6 +14,7 @@ class ReinforcementAgent:
         self.env = environment
         self.q_table = q_table if q_table else {}
         self.actions = ["add", "merge", "remove", "z3"]
+        self.logger = get_logger()
 
     def collect_test_cases(self) -> List[TestCase]:
         max_time = 30
@@ -50,7 +52,7 @@ class ReinforcementAgent:
             self.env.reset()
 
             current_state = self.env.get_state()
-            print(f"Current state after reset: {current_state}")
+            self.logger.debug(f"Current state after reset: {current_state}")
 
             goal_state: float = 100.0
             steps_in_episode = 1
@@ -59,7 +61,7 @@ class ReinforcementAgent:
             start_time = time.time()
 
             while current_state[0] != goal_state and steps_in_episode < max_steps_per_episode and time.time() - start_time < max_time:
-                print(f"Step {steps_in_episode} in episode {episode}")
+                print(f"\nStep {steps_in_episode} in episode {episode}")
 
                 action = self.choose_action(current_state)
                 next_state, reward = self.env.step(action)
@@ -77,10 +79,10 @@ class ReinforcementAgent:
                 if current_state[0] > best_coverage:
                     best_coverage = current_state[0]
                     best_test_cases = self.env.test_cases.copy()
-                    print(f"New best coverage: {best_coverage}% with {len(best_test_cases)} test cases")
+                    self.logger.debug(f"New best coverage: {best_coverage}% with {len(best_test_cases)} test cases")
                 elif current_state[0] == best_coverage and len(best_test_cases) > len(self.env.test_cases):
                     best_test_cases = self.env.test_cases.copy()
-                    print(f"New best coverage: {best_coverage}% with {len(best_test_cases)} test cases")
+                    self.logger.debug(f"New best coverage: {best_coverage}% with {len(best_test_cases)} test cases")
 
         return best_test_cases
 
@@ -106,7 +108,29 @@ class ReinforcementAgent:
             print(f"CHOSEN EXPLOITATION ACTION: {chosen_action}")
             return chosen_action
 
-    def optimize_test_suit(self, current_state, executable_statements):
+    
+
+    @staticmethod
+    def get_action_list(test_case_length: int) -> List[str]:
+        action_list = ["add", "z3"]
+        if test_case_length >= 2:
+            action_list.extend(["merge", "remove"])
+        return action_list
+
+    def update_q_table(self, state: tuple, action: str, new_state:tuple, reward:float):
+        current_q = self.q_table.get((state, action), 0)
+        self.logger.debug(f"CURRENT Q: {current_q}")
+        valid_actions = self.get_action_list(new_state[1])
+
+        max_next_q = max(self.q_table.get((new_state, a), 0) for a in valid_actions)
+        self.logger.debug(f"MAX NEXT Q: {max_next_q}")
+
+        print(f"UPDATING Q TABLE FOR STATE: {state}, ACTION: {action} WITH REWARD: {reward}")
+        new_q = (1 - self.learning_rate) * current_q + self.learning_rate * (reward + max_next_q)
+        
+        self.q_table[(state, action)] = new_q
+        
+        """def optimize_test_suit(self, current_state, executable_statements):
         # Try to optimize test cases by repeatedly performing remove actions if reached full coverage
         test_case_count = current_state[1]
         optimization_attempts = min(10, test_case_count - 1)
@@ -130,24 +154,4 @@ class ReinforcementAgent:
                 self.env.step("add")
                 break
 
-        return current_state
-
-    @staticmethod
-    def get_action_list(test_case_length: int) -> List[str]:
-        action_list = ["add", "z3"]
-        if test_case_length >= 2:
-            action_list.extend(["merge", "remove"])
-        return action_list
-
-    def update_q_table(self, state: tuple, action: str, new_state:tuple, reward:float):
-        current_q = self.q_table.get((state, action), 0)
-        print(f"CURRENT Q: {current_q}")
-        valid_actions = self.get_action_list(new_state[1])
-
-        max_next_q = max(self.q_table.get((new_state, a), 0) for a in valid_actions)
-        print(f"MAX NEXT Q: {max_next_q}")
-
-        print(f"UPDATING Q TABLE FOR STATE: {state}, ACTION: {action} WITH REWARD: {reward}")
-        new_q = (1 - self.learning_rate) * current_q + self.learning_rate * (reward + max_next_q)
-        
-        self.q_table[(state, action)] = new_q
+        return current_state"""

testgen/reinforcement/environment.py

@@ -4,6 +4,7 @@ from typing import List, Tuple
 
 import coverage
 
+from testgen.service.logging_service import get_logger
 import testgen.util.coverage_utils
 import testgen.util.file_utils
 from testgen.reinforcement.abstract_state import AbstractState
@@ -21,6 +22,7 @@ class ReinforcementEnvironment:
         self.test_cases = initial_test_cases.copy()
         self.state = state
         self.cov = coverage.Coverage()
+        self.logger = get_logger()
 
     # State represented by covered_statements, test_count
     def get_state(self) -> Tuple:
@@ -29,7 +31,7 @@ class ReinforcementEnvironment:
     def step(self, action) -> Tuple[Tuple, float]:
         prev_coverage = self.state.get_state()[0]  # Get actual coverage before action
         prev_test_cases = self.state.get_state()[1]
-        print(f"STEP: Previous coverage: {prev_coverage} before action: {action}")
+        self.logger.debug(f"STEP: Previous coverage: {prev_coverage} before action: {action}")
 
         # Execute action
         if action == "add":
@@ -62,8 +64,7 @@ class ReinforcementEnvironment:
     def render(self):
         pass
 
-    @staticmethod
-    def get_reward(coverage_delta, num_test_cases_delta) -> float:
+    def get_reward(self, coverage_delta, num_test_cases_delta) -> float:
         reward: float
         """
         Reward of 1.0 for increasing coverage
@@ -77,7 +78,7 @@ class ReinforcementEnvironment:
         else:
             reward = -1.0
 
-        print(f"Coverage delta reward: {reward}")
+        self.logger.debug(f"Coverage delta reward: {reward}")
 
         """
         If new test cases are added, subtract a small penalty
@@ -86,7 +87,7 @@ class ReinforcementEnvironment:
         """
         test_cases_factor = (num_test_cases_delta * -0.1)
         reward = reward + test_cases_factor
-        print(f"Reward or penalty added to coverage delta reward: {test_cases_factor}")
+        self.logger.debug(f"Reward or penalty added to coverage delta reward: {test_cases_factor}")
 
         print(f"Final reward {reward}")
         return reward
@@ -100,7 +101,7 @@ class ReinforcementEnvironment:
 
         executable_lines = set()
         if not test_cases:
-            print("Warning: No test cases available to determine executable statements")
+            self.logger.debug("Warning: No test cases available to determine executable statements")
             from testgen.util.randomizer import new_random_test_case
             temp_case = new_random_test_case(self.file_name, self.class_name, self.fut)
             analysis = testgen.util.coverage_utils.get_coverage_analysis(self.file_name, self.class_name, self.fut.name, temp_case.inputs)

testgen/reinforcement/statement_coverage_state.py

@@ -1,11 +1,13 @@
 from typing import Tuple
 
+from testgen.service.logging_service import get_logger
 import testgen.util.coverage_utils
 from testgen.reinforcement.abstract_state import AbstractState
 from testgen.util import utils
 
 class StatementCoverageState(AbstractState):
     def __init__(self, environment):
+        self.logger = get_logger()
         self.environment = environment
 
     def get_state(self) -> Tuple[float, int]:
@@ -23,9 +25,9 @@ class StatementCoverageState(AbstractState):
         else:
             calc_coverage: float = (len(all_covered_statements) / len(executable_statements)) * 100
 
-        print(f"GET STATE ALL COVERED STATEMENTS: {all_covered_statements}")
-        print(f"GET STATE ALL EXECUTABLE STATEMENTS: {self.environment.get_all_executable_statements()}")
-        print(f"GET STATE FLOAT COVERAGE: {calc_coverage}")
+        self.logger.debug(f"GET STATE ALL COVERED STATEMENTS: {all_covered_statements}")
+        self.logger.debug(f"GET STATE ALL EXECUTABLE STATEMENTS: {self.environment.get_all_executable_statements()}")
+        self.logger.debug(f"GET STATE FLOAT COVERAGE: {calc_coverage}")
 
         if calc_coverage >= 100:
             print(f"!!!!!!!!FULLY COVERED FUNCTION: {self.environment.fut.name}!!!!!!!!")

testgen/service/analysis_service.py

@@ -5,6 +5,7 @@ from types import ModuleType
 from typing import Dict, List
 
 import testgen
+from testgen.service.logging_service import get_logger
 import testgen.util.file_utils
 import testgen.util.file_utils as file_utils
 import testgen.util.utils
@@ -32,6 +33,7 @@ class AnalysisService:
         self.test_case_analyzer_context = TestCaseAnalyzerContext(None, None)
         self.test_strategy = 0
         self.reinforcement_mode = "train"
+        self.logger = get_logger()
 
     def generate_test_cases(self) -> List[TestCase]:
             """Generate test cases using the current strategy."""
@@ -43,15 +45,15 @@ class AnalysisService:
     
     def create_analysis_context(self, filepath: str) -> AnalysisContext:
         """Create an analysis context for the given file."""
-        print(f"Creating analysis context for {filepath}")
+        self.logger.debug(f"Creating analysis context for {filepath}")
         filename = file_utils.get_filename(filepath)
-        print(f"Filename: {filename}")
+        self.logger.debug(f"Filename: {filename}")
         module = file_utils.load_module(filepath)
-        print(f"Module: {module}")
+        self.logger.debug(f"Module: {module}")
         class_name = self.get_class_name(module)
-        print(f"Class name: {class_name}")
+        self.logger.debug(f"Class name: {class_name}")
         function_data = self.get_function_data(filename, module, class_name)
-        print(f"Function data: {function_data}")
+        self.logger.debug(f"Function data: {function_data}")
         return AnalysisContext(filepath, filename, class_name, module, function_data)
     
     def get_function_data(self, filename: str, module: ModuleType, class_name: str | None) -> List[FunctionMetadata]:
@@ -113,7 +115,7 @@ class AnalysisService:
                 new_test_cases = agent.collect_test_cases()
                 function_test_cases.extend(new_test_cases)
 
-            print(f"\nTest cases for {function.name}: {len(function_test_cases)}")
+            print(f"\nNumber of test cases for {function.name}: {len(function_test_cases)}")
 
             current_coverage: float = environment.run_tests()
             print(f"Current coverage: {function.name}: {current_coverage}")

testgen/service/cfg_service.py

@@ -1,6 +1,7 @@
 import os
 from typing import List
 from testgen.models.test_case import TestCase
+from testgen.service.logging_service import get_logger
 from testgen.util.coverage_visualizer import CoverageVisualizer
 from testgen.service.analysis_service import AnalysisService
 
@@ -10,6 +11,7 @@ class CFGService:
     def __init__(self):
         self.analysis_service = AnalysisService()
         self.visualizer = None
+        self.logger = get_logger()
 
     def initialize_visualizer(self, service):
         self.visualizer = CoverageVisualizer()

testgen/service/generator_service.py

@@ -9,6 +9,7 @@ from testgen.generator.doctest_generator import DocTestGenerator
 from testgen.generator.pytest_generator import PyTestGenerator
 from testgen.generator.unit_test_generator import UnitTestGenerator
 from testgen.inspector.inspector import Inspector
+from testgen.service.logging_service import get_logger
 from testgen.tree.node import Node
 from testgen.tree.tree_utils import build_binary_tree
 from testgen.models.generator_context import GeneratorContext
@@ -26,18 +27,19 @@ class GeneratorService:
         self.code_generator = CodeGenerator()
         self.test_generator = UnitTestGenerator(generator_context=None)
         self.generated_file_path = None
+        self.logger = get_logger()
 
     def set_test_format(self, test_format: int):
         """Set the test generator format."""
         self.test_format = test_format
         if test_format == UNITTEST_FORMAT:
-            print("SETTING TEST FORMAT TO UNITTEST")
+            self.logger.debug("SETTING TEST FORMAT TO UNITTEST")
             self.test_generator = UnitTestGenerator(generator_context=None)
         elif test_format == PYTEST_FORMAT:
-            print("SETTING TEST FORMAT TO PYTEST")
+            self.logger.debug("SETTING TEST FORMAT TO PYTEST")
             self.test_generator = PyTestGenerator(generator_context=None)
         elif test_format == DOCTEST_FORMAT:
-            print("SETTING TEST FORMAT TO DOCTEST")
+            self.logger.debug("SETTING TEST FORMAT TO DOCTEST")
             self.test_generator = DocTestGenerator(generator_context=None)
         else:
             raise NotImplementedError(f"Test format {test_format} not implemented")
@@ -69,16 +71,11 @@ class GeneratorService:
         
         self.test_generator.generate_test_header()
 
-        print("GENERATE TEST FILE: Generated test header")
-
         self.generate_function_tests(test_cases)
 
-        print("GENERATE TEST FILE: Generate function tests")
-
-        print()
 
         if self.test_format == DOCTEST_FORMAT:
-            print("SAVING DOCT TEST FILE")
+            self.logger.debug("SAVING DOCT TEST FILE")
             self.test_generator.save_file()
             return self.filepath
         else:

testgen/service/logging_service.py

@@ -15,7 +15,6 @@ class LogLevel(Enum):
 
 class LoggingService:
     """Centralized logging service for testgen framework"""
-    
     _instance = None
     _initialized = False
     
@@ -42,6 +41,8 @@ class LoggingService:
         """Initialize the logging service"""
         if LoggingService._initialized:
             return
+        
+        self.debug_mode = debug_mode
             
         # Set the base logging level
         level = LogLevel.DEBUG.value if debug_mode else LogLevel.INFO.value
@@ -69,7 +70,8 @@ class LoggingService:
     
     def debug(self, message: str):
         """Log debug message"""
-        self.logger.debug(message)
+        if self.debug_mode:
+            self.logger.debug(message)
     
     def info(self, message: str):
         """Log info message"""

testgen/service/service.py

@@ -36,7 +36,6 @@ DOCTEST_FORMAT = 3
 
 class Service:
     def __init__(self):
-        self.debug_mode: bool = False
         self.test_strategy: int = 0
         self.test_format: int = 0
         self.file_path = None
@@ -78,7 +77,7 @@ class Service:
             test_cases = self.analysis_service.generate_test_cases()
 
         if os.environ.get("RUNNING_IN_DOCKER") is not None:
-            self.debug(f"Serializing test cases {test_cases}")
+            self.logger.debug(f"Serializing test cases {test_cases}")
             self.serialize_test_cases(test_cases)
             return None  # Exit early in analysis-only mode
         
@@ -151,7 +150,7 @@ class Service:
         """Run coverage analysis on the generated tests."""
         Service.wait_for_file(test_file)
         file_path_to_use = self.generated_file_path if self.test_strategy == AST_STRAT else self.file_path
-        print(f"File path to use for coverage: {file_path_to_use}")
+        self.logger.debug(f"File path to use for coverage: {file_path_to_use}")
         coverage_output = ""
         
         try:
@@ -179,7 +178,7 @@ class Service:
         """Parse coverage output and save to database."""
         # Skip if running in Docker or DB service is None
         if os.environ.get("RUNNING_IN_DOCKER") is not None or self.db_service is None:
-            self.debug("Skipping database operations in Docker container")
+            self.logger.debug("Skipping database operations in Docker container")
             return
         
         try:
@@ -370,27 +369,26 @@ class Service:
         functions = inspect.getmembers(cls, inspect.isfunction)
         return functions
 
-    @staticmethod
-    def resolve_module_path(module_name):
+    def resolve_module_path(self, module_name):
         """Resolve a module name to its file path by checking multiple locations."""
         direct_path = f"/controller/{module_name}.py"
         if os.path.exists(direct_path):
-            print(f"Found module at {direct_path}")
+            self.logger.debug(f"Found module at {direct_path}")
             return direct_path
 
         testgen_path = f"/controller/testgen/{module_name}.py"
         if os.path.exists(testgen_path):
-            print(f"Found module at {testgen_path}")
+            self.logger.debug(f"Found module at {testgen_path}")
             return testgen_path
 
         if '.' in module_name:
             parts = module_name.split('.')
             potential_path = os.path.join('/controller', *parts) + '.py'
             if os.path.exists(potential_path):
-                print(f"Found module at {potential_path}")
+                self.logger.debug(f"Found module at {potential_path}")
                 return potential_path
 
-        print(f"Could not find module: {module_name}")
+        self.logger.debug(f"Could not find module: {module_name}")
         return None
 
     def visualize_test_coverage(self):
@@ -408,13 +406,6 @@ class Service:
         if hasattr(self ,'analysis_service'):
             self.analysis_service.set_reinforcement_mode(mode)
 
-    def set_debug_mode(self, debug: bool):
-        self.debug_mode = debug
-
-    def debug(self, message: str):
-        if self.debug_mode:
-            self.logger.debug(message)
-
     def _get_test_case_id(self, test_case_name: str) -> int:
         """
         Retrieve the test case ID from the database based on the test case name.
@@ -464,13 +455,13 @@ class Service:
     def execute_and_store_unittest(self, file_path_to_use, test_file):
         import unittest
         loader = unittest.TestLoader()
-        print(f"Discovering tests in: {os.path.dirname(file_path_to_use)} with pattern: {os.path.basename(test_file)}")
+        self.logger.debug(f"Discovering tests in: {os.path.dirname(file_path_to_use)} with pattern: {os.path.basename(test_file)}")
         test_module = os.path.relpath(test_file,
                                       start=os.getcwd())  # Get relative path from the current working directory
         test_module = test_module.replace("/", ".").replace("\\", ".").rstrip(".py")  # Convert to module name
         if test_module.startswith("."):
             test_module = test_module[1:]  # Remove leading dot if present
-        print(f"Test module: {test_module}")
+        self.logger.debug(f"Test module: {test_module}")
         suite = loader.loadTestsFromName(test_module)
         runner = unittest.TextTestRunner()
         result = runner.run(suite)
@@ -506,7 +497,7 @@ class Service:
 
         results = self.db_service.get_test_file_data(test_file_name)
         if not results:
-            print(f"No data found for file: {test_file_name}")
+            self.logger.debug(f"No data found for file: {test_file_name}")
             return
 
         from tabulate import tabulate

testgen/tests/test_boolean.py

@@ -0,0 +1,81 @@
+import pytest
+
+import testgen.code_to_test.boolean as boolean
+
+def test_bin_and_0():
+   args = (False, False)
+   expected = False
+   result = boolean.bin_and(*args)
+   assert result == expected
+
+def test_bin_and_1():
+   args = (True, True)
+   expected = True
+   result = boolean.bin_and(*args)
+   assert result == expected
+
+def test_bin_and_2():
+   args = (True, False)
+   expected = False
+   result = boolean.bin_and(*args)
+   assert result == expected
+
+def test_bin_xor_3():
+   args = (False, True)
+   expected = True
+   result = boolean.bin_xor(*args)
+   assert result == expected
+
+def test_bin_xor_4():
+   args = (False, False)
+   expected = False
+   result = boolean.bin_xor(*args)
+   assert result == expected
+
+def test_bin_xor_5():
+   args = (True, True)
+   expected = False
+   result = boolean.bin_xor(*args)
+   assert result == expected
+
+def test_bin_xor_6():
+   args = (True, False)
+   expected = True
+   result = boolean.bin_xor(*args)
+   assert result == expected
+
+def test_status_flags_7():
+   args = (True, False, True)
+   expected = 'admin-unverified'
+   result = boolean.status_flags(*args)
+   assert result == expected
+
+def test_status_flags_8():
+   args = (True, True, False)
+   expected = 'user-verified'
+   result = boolean.status_flags(*args)
+   assert result == expected
+
+def test_status_flags_9():
+   args = (False, True, True)
+   expected = 'admin-verified'
+   result = boolean.status_flags(*args)
+   assert result == expected
+
+def test_status_flags_10():
+   args = (True, True, True)
+   expected = 'admin-verified'
+   result = boolean.status_flags(*args)
+   assert result == expected
+
+def test_status_flags_11():
+   args = (True, False, False)
+   expected = 'user-unverified'
+   result = boolean.status_flags(*args)
+   assert result == expected
+
+def test_status_flags_12():
+   args = (False, True, False)
+   expected = 'inactive'
+   result = boolean.status_flags(*args)
+   assert result == expected

testgen/tests/test_generated_boolean.py

@@ -0,0 +1,83 @@
+import unittest
+
+import testgen.generated_boolean as generated_boolean
+
+class TestNone(unittest.TestCase):  
+
+   def test_bin_and_0(self):
+      args = (True, True)
+      expected = True
+      result = generated_boolean.bin_and(*args)
+      self.assertEqual(result, expected)
+
+   def test_bin_and_1(self):
+      args = (True, False)
+      expected = False
+      result = generated_boolean.bin_and(*args)
+      self.assertEqual(result, expected)
+
+   def test_bin_and_2(self):
+      args = (False, True)
+      expected = False
+      result = generated_boolean.bin_and(*args)
+      self.assertEqual(result, expected)
+
+   def test_bin_xor_3(self):
+      args = (True, True)
+      expected = False
+      result = generated_boolean.bin_xor(*args)
+      self.assertEqual(result, expected)
+
+   def test_bin_xor_4(self):
+      args = (True, False)
+      expected = True
+      result = generated_boolean.bin_xor(*args)
+      self.assertEqual(result, expected)
+
+   def test_bin_xor_5(self):
+      args = (False, True)
+      expected = True
+      result = generated_boolean.bin_xor(*args)
+      self.assertEqual(result, expected)
+
+   def test_status_flags_6(self):
+      args = (True, True, True)
+      expected = 'admin-verified'
+      result = generated_boolean.status_flags(*args)
+      self.assertEqual(result, expected)
+
+   def test_status_flags_7(self):
+      args = (True, True, False)
+      expected = 'user-verified'
+      result = generated_boolean.status_flags(*args)
+      self.assertEqual(result, expected)
+
+   def test_status_flags_8(self):
+      args = (True, False, True)
+      expected = 'admin-unverified'
+      result = generated_boolean.status_flags(*args)
+      self.assertEqual(result, expected)
+
+   def test_status_flags_9(self):
+      args = (True, False, False)
+      expected = 'user-unverified'
+      result = generated_boolean.status_flags(*args)
+      self.assertEqual(result, expected)
+
+   def test_status_flags_10(self):
+      args = (False, True, True)
+      expected = 'admin-verified'
+      result = generated_boolean.status_flags(*args)
+      self.assertEqual(result, expected)
+
+   def test_status_flags_11(self):
+      args = (False, True, False)
+      expected = 'inactive'
+      result = generated_boolean.status_flags(*args)
+      self.assertEqual(result, expected)
+
+   def test_status_flags_12(self):
+      args = (False, False, True)
+      expected = 'admin-unverified'
+      result = generated_boolean.status_flags(*args)
+      self.assertEqual(result, expected)

testgen/util/coverage_visualizer.py

@@ -3,6 +3,7 @@ import os
 from typing import Dict, List, Set
 import coverage
 
+from testgen.service.logging_service import get_logger
 import testgen.util.coverage_utils
 from testgen.models.test_case import TestCase
 import pygraphviz as pgv
@@ -12,6 +13,7 @@ class CoverageVisualizer:
         self.service = None
         self.cov = coverage.Coverage(branch=True)
         self.covered_lines: Dict[str, Set[int]] = {}
+        self.logger = get_logger()
 
     def set_service(self, service):
         self.service = service
@@ -27,9 +29,9 @@ class CoverageVisualizer:
                 self.covered_lines[func_def.name].update(covered)
 
         if func_def.name in self.covered_lines:
-            print(f"Covered lines for {func_def.name}: {self.covered_lines[func_def.name]}")
+            self.logger.debug(f"Covered lines for {func_def.name}: {self.covered_lines[func_def.name]}")
         else:
-            print(f"No coverage data found for {func_def.name}")
+            self.logger.debug(f"No coverage data found for {func_def.name}")
 
     def generate_colored_cfg(self, function_name, output_path):
         """Generate colored CFG for a function showing test coverage"""
@@ -54,7 +56,7 @@ class CoverageVisualizer:
         try:
             tree = ast.parse(source_code)
             ast_functions = [node.name for node in ast.walk(tree) if isinstance(node, ast.FunctionDef)]
-            print(f"Functions found by AST: {ast_functions}")
+            self.logger.debug(f"Functions found by AST: {ast_functions}")
 
             return self._create_basic_cfg(source_code, function_name, output_path)
 

testgen/util/file_utils.py

@@ -55,7 +55,7 @@ def get_import_info(filepath: str) -> Dict[str, str]:
         'file_dir': file_dir
     }
     
-    print(f"INFO: {info}")
+    #print(f"INFO: {info}")
     
     return info