testgenie-py 0.3.6__py3-none-any.whl → 0.3.8__py3-none-any.whl

testgen/controller/cli_controller.py

@@ -1,5 +1,4 @@
 import argparse
-import inspect
 import os
 import sys
 
@@ -10,8 +9,7 @@ from testgen.service.logging_service import LoggingService, get_logger
 from testgen.util.file_utils import adjust_file_path_for_docker, get_project_root_in_docker
 from testgen.controller.docker_controller import DockerController
 from testgen.service.service import Service
-from testgen.presentation.cli_view import CLIView
-from testgen.sqlite.db_service import DBService
+from testgen.service.db_service import DBService
 
 AST_STRAT = 1
 FUZZ_STRAT = 2
@@ -24,9 +22,9 @@ DOCTEST_FORMAT = 3
 
 class CLIController:
     #TODO: Possibly create a view 'interface' and use dependency injection to extend other views
-    def __init__(self, service: Service, view: CLIView):
+    def __init__(self, service: Service):
         self.service = service
-        self.view = view
+        self.logger = None
 
     def run(self):
 
@@ -35,12 +33,16 @@ class CLIController:
         args = parser.parse_args()
 
         LoggingService.get_instance().initialize(
-            debug_mode=args.debug if hasattr(args, 'debug') else False,
+            debug_mode=args.debug if args.debug else False,
             log_file=args.log_file if hasattr(args, 'log_file') else None,
             console_output=True
         )
 
-        logger = get_logger()
+        self.logger = get_logger()
+
+        if args.functions:
+            self.service.get_all_functions(args.file_path)
+            return
 
         if args.query:
             print(f"Querying database for file: {args.file_path}")
@@ -48,7 +50,7 @@ class CLIController:
             return
         
         if args.coverage:
-            self.service.get_coverage(args.file_path)
+            self.service.run_coverage(args.file_path)
             return
             
         running_in_docker = os.environ.get("RUNNING_IN_DOCKER") is not None
@@ -59,7 +61,7 @@ class CLIController:
             client = self.docker_available()
             # Skip Docker-dependent operations if client is None
             if client is None and args.safe:
-                self.view.display_message("Running with --safe flag requires Docker. Continuing without safe mode.")
+                self.logger.debug("Running with --safe flag requires Docker. Continuing without safe mode.")
                 args.safe = False
                 self.execute_generation(args)
             else:
@@ -69,15 +71,13 @@ class CLIController:
                 if not successful:
                     if hasattr(args, 'db') and args.db:
                         self.service.db_service = DBService(args.db)
-                        self.view.display_message(f"Using database: {args.db}")
+                        self.logger.debug(f"Using database: {args.db}")
                     self.execute_generation(args)
-                # Else successful, do nothing - we're done
         else:
-            # Initialize database service with specified path
             if hasattr(args, 'db') and args.db:
                 self.service.db_service = DBService(args.db)
-                self.view.display_message(f"Using database: {args.db}")
-            self.view.display_message("Running in local mode...")
+                self.logger.debug(f"Using database: {args.db}")
+            self.logger.debug("Running in local mode...")
             self.execute_generation(args)
 
     def execute_generation(self, args: argparse.Namespace, running_in_docker: bool = False):
@@ -85,22 +85,23 @@ class CLIController:
             self.set_service_args(args)
 
             if running_in_docker:
-                self.view.display_message("Running in Docker mode...")
+                self.logger.debug("Running in Docker mode...")
                 self.service.generate_test_cases()
 
             else:
                 test_file = self.service.generate_tests(args.output)
-                self.view.display_message(f"Unit tests saved to: {test_file}")
-                self.view.display_message("Running coverage...")
+                self.logger.debug(f"Unit tests saved to: {test_file}")
+                print("Executing tests...")
+                self.service.run_tests(test_file)
+                print("Running coverage...")
                 self.service.run_coverage(test_file)
-                self.view.display_message("Tests and coverage data saved to database.")
+                self.logger.debug("Tests and coverage data saved to database.")
 
                 if args.visualize:
                     self.service.visualize_test_coverage()
 
         except Exception as e:
-            self.view.display_error(f"An error occurred: {e}")
-            # Make sure to close the DB connection on error
+            self.logger.error(f"An error occurred: {e}")
             if hasattr(self.service, 'db_service'):
                 self.service.db_service.close()
 
@@ -168,6 +169,11 @@ class CLIController:
             action="store_true",
             help="Run coverage analysis on the generated tests"
         )
+        parser.add_argument(
+            "-f", "--functions",
+            action="store_true",
+            help="List all functions in file"
+        )
         return parser
 
     def set_test_format(self, args: argparse.Namespace):
@@ -180,32 +186,32 @@ class CLIController:
 
     def set_test_strategy(self, args: argparse.Namespace):
         if args.test_mode == "random":
-            self.view.display_message("Using Random Feedback-Directed Test Generation Strategy.")
+            print("Using Random Feedback-Directed Test Generation Strategy.")
             self.service.set_test_analysis_strategy(RANDOM_STRAT)
         elif args.test_mode == "fuzz":
-            self.view.display_message("Using Fuzz Test Generation Strategy...")
+            print("Using Fuzz Test Generation Strategy...")
             self.service.set_test_analysis_strategy(FUZZ_STRAT)
         elif args.test_mode == "reinforce":
-            self.view.display_message("Using Reinforcement Learning Test Generation Strategy...")
+            print("Using Reinforcement Learning Test Generation Strategy...")
             if args.reinforce_mode == "train":
-                self.view.display_message("Training mode enabled - will update Q-table")
+                print("Training mode enabled - will update Q-table")
             else:
-                self.view.display_message("Training mode disabled - will use existing Q-table")
+                print("Training mode disabled - will use existing Q-table")
             self.service.set_test_analysis_strategy(REINFORCE_STRAT)
             self.service.set_reinforcement_mode(args.reinforce_mode)
         else:
-            self.view.display_message("Generating function code using AST analysis...")
+            print("Generating function code using AST analysis...")
             generated_file_path = self.service.generate_function_code()
-            self.view.display_message(f"Generated code saved to: {generated_file_path}")
+            print(f"Generated code saved to: {generated_file_path}")
             if not args.generate_only:
-                self.view.display_message("Using Simple AST Traversal Test Generation Strategy...")
+                print("Using Simple AST Traversal Test Generation Strategy...")
                 self.service.set_test_analysis_strategy(AST_STRAT)
 
     def docker_available(self) -> DockerClient | None:
         try:
             client = docker.from_env()
             client.ping()
-            self.view.display_message("Docker daemon is running and connected.")
+            print("Docker daemon is running and connected.")
             return client
         except docker.errors.DockerException as err:
             print(f"Docker is not available: {err}")

testgen/controller/docker_controller.py

@@ -59,10 +59,10 @@ class DockerController:
             self.debug(f"project_root: {project_root}")
             container = self.run_container(docker_client, image_name, docker_args, project_root)
 
-            self.clean_up(dest_path)
-
             # Stream the logs to the console
             logs_output = self.get_logs(container)
+
+            self.clean_up(dest_path)
             self.debug(logs_output)
 
         except Exception as e:
@@ -98,6 +98,7 @@ class DockerController:
 
         if not args.generate_only:
             print("Running coverage...")
+            self.service.run_tests(test_file)
             self.service.run_coverage(test_file)
             
         # Add explicit return True here

testgen/db/dao.py

@@ -0,0 +1,68 @@
+from abc import ABC, abstractmethod
+from typing import List, Tuple, Any
+
+from testgen.models.function import Function
+
+
+class Dao(ABC):
+    @abstractmethod
+    def insert_test_suite(self, name: str) -> int:
+        pass
+
+    @abstractmethod
+    def insert_source_file(self, path: str, lines_of_code: int, last_modified) -> int:
+        pass
+
+    @abstractmethod
+    def insert_function(self, name: str, params, start_line: int, end_line: int, source_file_id: int) -> int:
+        pass
+
+    @abstractmethod
+    def insert_test_case(self, test_case: Any, test_suite_id: int, function_id: int, test_method_type: int) -> int:
+        pass
+
+    @abstractmethod
+    def insert_test_result(self, test_case_id: int, status: bool, error: str = None) -> int:
+        pass
+
+    @abstractmethod
+    def insert_coverage_data(self, file_name: str, executed_lines: int, missed_lines: int,
+                             branch_coverage: float, source_file_id: int, function_id: int = None) -> int:
+        pass
+
+    @abstractmethod
+    def get_test_suites(self) -> List[Any]:
+        pass
+
+    @abstractmethod
+    def get_test_cases_by_function(self, function_name: str) -> List[Any]:
+        pass
+
+    @abstractmethod
+    def get_source_file_id_by_path(self, filepath: str) -> int:
+        pass
+
+    @abstractmethod
+    def get_coverage_by_file(self, file_path: str) -> List[Any]:
+        pass
+
+    @abstractmethod
+    def get_test_file_data(self, file_path: str) -> List[Any]:
+        pass
+
+    @abstractmethod
+    def get_function_by_name_file_id_start(self, name: str, source_file_id: int, start_line: int)-> int:
+        pass
+
+    @abstractmethod
+    def get_functions_by_file(self, filepath: str) -> List[Function]:
+        pass
+
+    @abstractmethod
+    def get_test_suite_id_by_name(self, name: str) -> int:
+        pass
+
+    @abstractmethod
+    def get_test_case_id_by_func_id_input_expected(self, function_id: int, inputs: str, expected: str) -> int:
+        pass
+

testgen/db/dao_impl.py

@@ -0,0 +1,226 @@
+import os
+import sqlite3
+import json
+from typing import List, Tuple, Any
+from datetime import datetime
+
+from testgen.db.dao import Dao
+from testgen.models.function import Function
+from testgen.models.test_case import TestCase
+from testgen.db.db import create_database
+
+class DaoImpl(Dao):
+    def __init__(self, db_name="testgen.db"):
+        self.db_name = db_name
+        self.conn = None
+        self.cursor = None
+        self._connect()
+
+    def _connect(self):
+        if not os.path.exists(self.db_name):
+            create_database(self.db_name)
+        self.conn = sqlite3.connect(self.db_name)
+        self.conn.row_factory = sqlite3.Row
+        self.cursor = self.conn.cursor()
+        self.cursor.execute("PRAGMA foreign_keys = ON;")
+
+    def close(self):
+        if self.conn:
+            self.conn.close()
+            self.conn = None
+            self.cursor = None
+
+    def insert_test_suite(self, name: str) -> int:
+        self.cursor.execute(
+            "INSERT INTO TestSuite (name, creation_date) VALUES (?, ?)",
+            (name, datetime.now())
+        )
+        self.conn.commit()
+        return self.cursor.lastrowid
+
+    def insert_source_file(self, path: str, lines_of_code: int, last_modified) -> int:
+        self.cursor.execute("SELECT id FROM SourceFile WHERE path = ?", (path,))
+        existing = self.cursor.fetchone()
+        if existing:
+            return existing[0]
+        self.cursor.execute(
+            "INSERT INTO SourceFile (path, lines_of_code, last_modified) VALUES (?, ?, ?)",
+            (path, lines_of_code, last_modified)
+        )
+        self.conn.commit()
+        return self.cursor.lastrowid
+
+    def insert_function(self, name: str, params, start_line: int, end_line: int, source_file_id: int) -> int:
+        print(f"INSERTING FUNCTION: {name}, {params}, {start_line}, {end_line}, {source_file_id}")
+
+        num_lines = end_line - start_line + 1
+        self.cursor.execute(
+            "SELECT id FROM Function WHERE name = ? AND source_file_id = ? AND params = ?",
+            (name, source_file_id, params)
+        )
+        existing = self.cursor.fetchone()
+        if existing:
+            return existing[0]
+        self.cursor.execute(
+            "INSERT INTO Function (name, params, start_line, end_line, num_lines, source_file_id) VALUES (?, ?, ?, ?, ?, ?)",
+            (name, params, start_line, end_line, num_lines, source_file_id)
+        )
+        self.conn.commit()
+        return self.cursor.lastrowid
+
+    def insert_test_case(self, test_case: TestCase, test_suite_id: int, function_id: int, test_method_type: int) -> int:
+        inputs_json = json.dumps(test_case.inputs, sort_keys=True)
+        expected_json = json.dumps(test_case.expected, sort_keys=True)
+
+        print(f"INSERTING TEST CASE: {test_case.func_name}, {test_case.inputs}, {test_case.expected}, {test_suite_id}, {function_id}, {test_method_type}")
+
+        # Check for existing test case with same function_id, inputs, and expected_output
+        self.cursor.execute(
+            "SELECT id FROM TestCase WHERE function_id = ? AND input = ? AND expected_output = ?",
+            (function_id, inputs_json, expected_json)
+        )
+        existing = self.cursor.fetchone()
+        if existing:
+            return existing[0]
+
+        self.cursor.execute(
+            "INSERT INTO TestCase (expected_output, input, test_function, last_run_time, test_method_type, test_suite_id, function_id) "
+            "VALUES (?, ?, ?, ?, ?, ?, ?)",
+            (
+                expected_json,
+                inputs_json,
+                test_case.func_name,
+                datetime.now(),
+                test_method_type,
+                test_suite_id,
+                function_id
+            )
+        )
+        self.conn.commit()
+        return self.cursor.lastrowid
+
+    def insert_test_result(self, test_case_id: int, status: bool, error: str = None) -> int:
+        self.cursor.execute(
+            "INSERT INTO TestResult (test_case_id, status, error, execution_time) VALUES (?, ?, ?, ?)",
+            (test_case_id, status, error, datetime.now())
+        )
+        self.conn.commit()
+        return self.cursor.lastrowid
+
+    def insert_coverage_data(self, file_name: str, executed_lines: int, missed_lines: int,
+                             branch_coverage: float, source_file_id: int, function_id: int | None) -> int:
+        coverage_type = "file" if function_id is None else "function"
+        self.cursor.execute(
+            "INSERT INTO CoverageData (coverage_type, executed_lines, missed_lines, branch_coverage, source_file_id, function_id) "
+            "VALUES (?, ?, ?, ?, ?, ?)",
+            (coverage_type, executed_lines, missed_lines, branch_coverage, source_file_id, function_id)
+        )
+        self.conn.commit()
+        return self.cursor.lastrowid
+
+    def get_test_suites(self) -> List[Any]:
+        self.cursor.execute("SELECT * FROM TestSuite ORDER BY creation_date DESC")
+        return self.cursor.fetchall()
+
+    def get_test_cases_by_function(self, function_name: str) -> List[Any]:
+        self.cursor.execute(
+            "SELECT tc.* FROM TestCase tc JOIN Function f ON tc.function_id = f.id WHERE f.name = ?",
+            (function_name,)
+        )
+        return self.cursor.fetchall()
+
+    def get_coverage_by_file(self, file_path: str) -> List[Any]:
+        self.cursor.execute(
+            "SELECT cd.* FROM CoverageData cd JOIN SourceFile sf ON cd.source_file_id = sf.id WHERE sf.path = ?",
+            (file_path,)
+        )
+        return self.cursor.fetchall()
+
+    def get_test_file_data(self, file_path: str) -> List[Any]:
+        query = """
+            SELECT
+                tc.id AS test_case_id,
+                tc.name AS test_case_name,
+                tc.test_function AS test_case_test_function,
+                tc.test_method_type AS test_case_method_type,
+                COALESCE(cd.missed_lines, 'None') AS coverage_data_missed_lines
+            FROM SourceFile sf
+            LEFT JOIN Function f ON sf.id = f.source_file_id
+            LEFT JOIN TestCase tc ON f.id = tc.function_id
+            LEFT JOIN TestResult tr ON tc.id = tr.test_case_id
+            LEFT JOIN CoverageData cd ON sf.id = cd.source_file_id
+            WHERE sf.path = ?;
+        """
+        self.cursor.execute(query, (file_path,))
+        return self.cursor.fetchall()
+
+    def get_function_by_name_file_id_start(self, name: str, source_file_id: int, start_line: int) -> int:
+        print(f"GETTING FUNCTION ID FOR {name}, {source_file_id}, {start_line}")
+        self.cursor.execute(
+            """
+            SELECT id FROM Function
+            WHERE name = ? AND source_file_id = ? AND start_line = ?
+            """,
+            (name, source_file_id, start_line)
+        )
+        result = self.cursor.fetchone()
+        return result["id"] if result else -1
+
+    def get_functions_by_file(self, filepath: str) -> List[Function]:
+        self.cursor.execute(
+            """
+            SELECT id, name, params, start_line, end_line, num_lines, source_file_id
+            FROM Function
+            WHERE source_file_id = (
+                SELECT id FROM SourceFile WHERE path = ?
+            )
+            """,
+            (filepath,)
+        )
+        rows = self.cursor.fetchall()
+        return [
+            Function(
+                name=row["name"],
+                params=row["params"],
+                start_line=row["start_line"],
+                end_line=row["end_line"],
+                num_lines=row["num_lines"],
+                source_file_id=row["source_file_id"]
+            )
+            for row in rows
+        ]
+
+    def get_test_suite_id_by_name(self, name: str) -> int:
+        self.cursor.execute(
+            """
+            SELECT id FROM TestSuite
+            WHERE name = ?
+            """,
+            (name,)
+        )
+        result = self.cursor.fetchone()
+        return result["id"] if result else -1
+
+    def get_source_file_id_by_path(self, filepath: str) -> int:
+        self.cursor.execute(
+            """
+            SELECT id FROM SourceFile
+            WHERE path = ?
+            """,
+            (filepath,)
+        )
+        result = self.cursor.fetchone()
+        return result["id"] if result else -1
+
+    def get_test_case_id_by_func_id_input_expected(self, function_id: int, inputs: str, expected: str) -> int:
+        self.cursor.execute(
+            """
+            SELECT id FROM TestCase
+            WHERE function_id = ? 
+            AND input = ? 
+            AND expected_output = ?
+            """,
+            (function_id, inputs, expected)
+        )
+        result = self.cursor.fetchone()
+        return result["id"] if result else -1

testgen/{sqlite → db}/db.py

@@ -29,10 +29,12 @@ def create_database(db_name="testgen.db"):
         CREATE TABLE IF NOT EXISTS Function (
             id INTEGER PRIMARY KEY,
             name TEXT,
+            params TEXT,
             start_line INTEGER,
             end_line INTEGER,
             num_lines INTEGER,
             source_file_id INTEGER,
+            UNIQUE(name, params, source_file_id),
             FOREIGN KEY (source_file_id) REFERENCES SourceFile(id)
         );
     """)
@@ -40,16 +42,16 @@ def create_database(db_name="testgen.db"):
     cursor.execute("""
         CREATE TABLE IF NOT EXISTS TestCase (
             id INTEGER PRIMARY KEY,
-            name TEXT,
-            expected_output TEXT,  -- storing JSON as TEXT
-            input TEXT,            -- storing JSON as TEXT
+            expected_output TEXT,
+            input TEXT,
             test_function TEXT,
             last_run_time TIMESTAMP,
             test_method_type INTEGER,
             test_suite_id INTEGER,
             function_id INTEGER,
             FOREIGN KEY (test_suite_id) REFERENCES TestSuite(id),
-            FOREIGN KEY (function_id) REFERENCES Function(id)
+            FOREIGN KEY (function_id) REFERENCES Function(id),
+            UNIQUE(function_id, input, expected_output)
         );
     """)
 
@@ -67,12 +69,19 @@ def create_database(db_name="testgen.db"):
     cursor.execute("""
         CREATE TABLE IF NOT EXISTS CoverageData (
             id INTEGER PRIMARY KEY,
-            file_name TEXT,
+            coverage_type TEXT CHECK(coverage_type IN ('file', 'function')),
             executed_lines INTEGER,
             missed_lines INTEGER,
             branch_coverage REAL,
             source_file_id INTEGER,
-            FOREIGN KEY (source_file_id) REFERENCES SourceFile(id)
+            function_id INTEGER,
+            FOREIGN KEY (source_file_id) REFERENCES SourceFile(id),
+            FOREIGN KEY (function_id) REFERENCES Function(id),
+            CHECK (
+                -- Only one of source_file_id or function_id is required based on coverage_type
+                (coverage_type = 'file' AND source_file_id IS NOT NULL AND function_id IS NULL) OR
+                (coverage_type = 'function' AND function_id IS NOT NULL)
+            )
         );
     """)
 

testgen/generator/pytest_generator.py

@@ -1,5 +1,4 @@
 from testgen.generator.test_generator import TestGenerator
-from testgen.util.file_utils import get_import_info
 from testgen.models.generator_context import GeneratorContext
 
 
@@ -10,17 +9,10 @@ class PyTestGenerator(TestGenerator):
 
     def generate_test_header(self):
         self.test_code.append("import pytest\n")
-        import_info = get_import_info(self._generator_context.filepath)
         if self._generator_context.class_name == "" or self._generator_context.class_name is None:
-            if import_info['is_package']:
-                self.test_code.append(f"import {import_info['import_path']} as {self._generator_context.module.__name__}\n")
-            else:
-                self.test_code.append(f"import {import_info['import_path']} as {self._generator_context.module.__name__}\n")
+            self.test_code.append(f"import {self._generator_context.import_path} as {self._generator_context.module.__name__}\n")
         else:
-            if import_info['is_package']:
-                self.test_code.append(f"from {import_info['import_path']} import {self._generator_context.class_name}\n")
-            else:
-                self.test_code.append(f"from {import_info['import_path']} import {self._generator_context.class_name}\n")
+            self.test_code.append(f"from {self._generator_context.import_path} import {self._generator_context.class_name}\n")
 
     def generate_test_function(self, unique_func_name, func_name, cases):
         self.test_code.append(f"def test_{unique_func_name}():")

testgen/generator/unit_test_generator.py

@@ -1,4 +1,3 @@
-from testgen.util.file_utils import get_import_info
 from testgen.generator.test_generator import TestGenerator
 from testgen.models.generator_context import GeneratorContext
 
@@ -13,19 +12,11 @@ class UnitTestGenerator(TestGenerator):
 
     def generate_test_header(self):
 
-        import_info = get_import_info(self._generator_context.filepath)
-
         self.test_code.append("import unittest\n")
         if self._generator_context.class_name == "" or self._generator_context.class_name is None:
-            if import_info['is_package']:
-                self.test_code.append(f"import {import_info['import_path']} as {self._generator_context.module.__name__}\n")
-            else:
-                self.test_code.append(f"import {import_info['import_path']} as {self._generator_context.module.__name__}\n")
+            self.test_code.append(f"import {self._generator_context.import_path} as {self._generator_context.module.__name__}\n")
         else:
-            if import_info['is_package']:
-                self.test_code.append(f"from {import_info['import_path']} import {self._generator_context.class_name}\n")
-            else:
-                self.test_code.append(f"from {import_info['import_path']} import {self._generator_context.class_name}\n")
+            self.test_code.append(f"from {self._generator_context.import_path} import {self._generator_context.class_name}\n")
         self.test_code.append(f"class Test{self._generator_context.class_name}(unittest.TestCase):  \n")
 
     def generate_test_function(self, unique_func_name, func_name, cases):

testgen/main.py

@@ -1,12 +1,10 @@
 from testgen.service.service import Service
 from testgen.controller.cli_controller import CLIController
 from testgen.generator.unit_test_generator import UnitTestGenerator
-from testgen.presentation.cli_view import CLIView
 
 def main():
     service = Service()
-    view = CLIView()
-    controller = CLIController(service, view)
+    controller = CLIController(service)
     controller.run()
 
 if __name__ == '__main__':

testgen/models/coverage_data.py

@@ -0,0 +1,56 @@
+class CoverageData:
+    def __init__(self, coverage_type: str, executed_lines: int, missed_lines: int, branch_coverage: float, source_file_id: int, function_id: int):
+        self._coverage_type: str = coverage_type
+        self._executed_lines: int = executed_lines
+        self._missed_lines: int = missed_lines
+        self._branch_coverage: float = branch_coverage
+        self._source_file_id: int = source_file_id
+        self._function_id: int = function_id
+
+    @property
+    def coverage_type(self) -> str:
+        return self._coverage_type
+
+    @coverage_type.setter
+    def coverage_type(self, value: str) -> None:
+        self._coverage_type = value
+
+    @property
+    def executed_lines(self) -> int:
+        return self._executed_lines
+
+    @executed_lines.setter
+    def executed_lines(self, value: int) -> None:
+        self._executed_lines = value
+
+    @property
+    def missed_lines(self) -> int:
+        return self._missed_lines
+
+    @missed_lines.setter
+    def missed_lines(self, value: int) -> None:
+        self._missed_lines = value
+
+    @property
+    def branch_coverage(self) -> float:
+        return self._branch_coverage
+
+    @branch_coverage.setter
+    def branch_coverage(self, value: float) -> None:
+        self._branch_coverage = value
+
+    @property
+    def source_file_id(self) -> int:
+        return self._source_file_id
+
+    @source_file_id.setter
+    def source_file_id(self, value: int) -> None:
+        self._source_file_id = value
+
+    @property
+    def function_id(self) -> int:
+        return self._function_id
+
+    @function_id.setter
+    def function_id(self, value: int) -> None:
+        self._function_id = value