Update python unit test generation

.gitignore

@@ -8,4 +8,6 @@ target/
 .gradle/
 *.log
 *.rdgen
-utbot-intellij/src/main/resources/settings.properties
+utbot-intellij/src/main/resources/settings.properties
+__pycache__
+.dmypy.json

settings.gradle.kts

@@ -53,6 +53,7 @@ if (pythonIde.split(",").contains(ideType)) {
     include("utbot-python")
     include("utbot-cli-python")
     include("utbot-intellij-python")
+    include("utbot-python-parser")
 }
 
 if (jsIde.split(",").contains(ideType)) {

utbot-cli-python/src/main/kotlin/org/utbot/cli/language/python/Application.kt

@@ -26,7 +26,8 @@ class UtBotPythonCli : CliktCommand(name = "UnitTestBot Python Command Line Inte
 fun main(args: Array<String>) = try {
     UtBotPythonCli().subcommands(
         PythonGenerateTestsCommand(),
-        PythonRunTestsCommand()
+        PythonRunTestsCommand(),
+        PythonTypeInferenceCommand()
     ).main(args)
 } catch (ex: Throwable) {
     ex.printStackTrace()

utbot-cli-python/src/main/kotlin/org/utbot/cli/language/python/PythonGenerateTestsCommand.kt

@@ -6,17 +6,20 @@ import com.github.ajalt.clikt.parameters.options.*
 import com.github.ajalt.clikt.parameters.types.choice
 import com.github.ajalt.clikt.parameters.types.long
 import mu.KotlinLogging
+import org.parsers.python.PythonParser
 import org.utbot.framework.codegen.domain.TestFramework
-import org.utbot.python.PythonMethod
+import org.utbot.python.PythonMethodHeader
 import org.utbot.python.PythonTestGenerationProcessor
 import org.utbot.python.PythonTestGenerationProcessor.processTestGeneration
-import org.utbot.python.code.PythonClass
 import org.utbot.python.code.PythonCode
+import org.utbot.python.framework.api.python.PythonClassId
 import org.utbot.python.framework.codegen.model.Pytest
 import org.utbot.python.framework.codegen.model.Unittest
+import org.utbot.python.newtyping.ast.parseClassDefinition
+import org.utbot.python.newtyping.ast.parseFunctionDefinition
+import org.utbot.python.utils.*
 import org.utbot.python.utils.RequirementsUtils.installRequirements
 import org.utbot.python.utils.RequirementsUtils.requirements
-import org.utbot.python.utils.getModuleName
 import java.io.File
 import java.nio.file.Paths
 
@@ -80,11 +83,6 @@ class PythonGenerateTestsCommand : CliktCommand(
         help = "Turn off Python requirements check (to speed up)."
     ).flag(default = false)
 
-    private val visitOnlySpecifiedSource by option(
-        "--visit-only-specified-source",
-        help = "Do not search for classes and imported modules in other Python files from sys.path."
-    ).flag(default = false)
-
     private val timeout by option(
         "-t", "--timeout",
         help = "Specify the maximum time in milliseconds to spend on generating tests ($DEFAULT_TIMEOUT_IN_MILLIS by default)."
@@ -107,36 +105,33 @@ class PythonGenerateTestsCommand : CliktCommand(
                 else -> error("Not reachable")
             }
 
-    private fun findCurrentPythonModule(): Optional<String> {
-        directoriesForSysPath.forEach { path ->
-            val module = getModuleName(path.toAbsolutePath(), sourceFile.toAbsolutePath())
-            if (module != null)
-                return Success(module)
-        }
-        return Fail("Couldn't find path for $sourceFile in --sys-path option. Please, specify it.")
-    }
-
     private val forbiddenMethods = listOf("__init__", "__new__")
 
-    private fun getClassMethods(pythonClassFromSources: PythonClass): List<PythonMethod> =
-        pythonClassFromSources.methods.filter { method -> method.name !in forbiddenMethods }
+    private fun getPythonMethods(): Optional<List<PythonMethodHeader>> {
+        val parsedModule = PythonParser(sourceFileContent).Module()
 
-    private fun getPythonMethods(sourceCodeContent: String, currentModule: String): Optional<List<PythonMethod>> {
-        val code = PythonCode.getFromString(
-            sourceCodeContent,
-            sourceFile.toAbsolutePath(),
-            pythonModule = currentModule
-        )
-            ?: return Fail("Couldn't parse source file. Maybe it contains syntax error?")
+        val topLevelFunctions = PythonCode.getTopLevelFunctions(parsedModule)
+        val topLevelClasses = PythonCode.getTopLevelClasses(parsedModule)
 
-        val topLevelFunctions = code.getToplevelFunctions()
-        val topLevelClasses = code.getToplevelClasses()
         val selectedMethods = methods
         if (pythonClass == null && methods == null) {
             return if (topLevelFunctions.isNotEmpty())
-                Success(topLevelFunctions)
+                Success(
+                    topLevelFunctions
+                        .mapNotNull { parseFunctionDefinition(it) }
+                        .map { PythonMethodHeader(it.name.toString(), sourceFile, null) }
+                )
             else {
-                val topLevelClassMethods = topLevelClasses.flatMap { getClassMethods(it) }
+                val topLevelClassMethods = topLevelClasses
+                    .mapNotNull { parseClassDefinition(it) }
+                    .flatMap { cls ->
+                        PythonCode.getClassMethods(cls.body)
+                            .mapNotNull { parseFunctionDefinition(it) }
+                            .map { function ->
+                                val parsedClassName = PythonClassId(cls.name.toString())
+                                PythonMethodHeader(function.name.toString(), sourceFile, parsedClassName)
+                            }
+                    }
                 if (topLevelClassMethods.isNotEmpty()) {
                     Success(topLevelClassMethods)
                 } else
@@ -145,19 +140,29 @@ class PythonGenerateTestsCommand : CliktCommand(
         } else if (pythonClass == null && selectedMethods != null) {
             val pythonMethodsOpt = selectedMethods.map { functionName ->
                 topLevelFunctions
+                    .mapNotNull { parseFunctionDefinition(it) }
+                    .map { PythonMethodHeader(it.name.toString(), sourceFile, null) }
                     .find { it.name == functionName }
                     ?.let { Success(it) }
                     ?: Fail("Couldn't find top-level function $functionName in the source file.")
             }
             return pack(*pythonMethodsOpt.toTypedArray())
         }
 
-        val pythonClassFromSources = code.getToplevelClasses().find { it.name == pythonClass }
+        val pythonClassFromSources = topLevelClasses
+            .mapNotNull { parseClassDefinition(it) }
+            .find { it.name.toString() == pythonClass }
             ?.let { Success(it) }
             ?: Fail("Couldn't find class $pythonClass in the source file.")
 
-        val methods = bind(pythonClassFromSources) {
-            val fineMethods: List<PythonMethod> = it.methods.filter { method -> method.name !in forbiddenMethods }
+        val methods = bind(pythonClassFromSources) { parsedClass ->
+            val parsedClassId = PythonClassId(parsedClass.name.toString())
+            val methods = PythonCode.getClassMethods(parsedClass.body).mapNotNull { parseFunctionDefinition(it) }
+            val fineMethods = methods
+                .filter { !forbiddenMethods.contains(it.name.toString()) }
+                .map {
+                    PythonMethodHeader(it.name.toString(), sourceFile, parsedClassId)
+                }
             if (fineMethods.isNotEmpty())
                 Success(fineMethods)
             else
@@ -178,18 +183,18 @@ class PythonGenerateTestsCommand : CliktCommand(
     }
 
     private lateinit var currentPythonModule: String
-    private lateinit var pythonMethods: List<PythonMethod>
+    private lateinit var pythonMethods: List<PythonMethodHeader>
     private lateinit var sourceFileContent: String
 
     @Suppress("UNCHECKED_CAST")
     private fun calculateValues(): Optional<Unit> {
-        val currentPythonModuleOpt = findCurrentPythonModule()
+        val currentPythonModuleOpt = findCurrentPythonModule(directoriesForSysPath, sourceFile)
         sourceFileContent = File(sourceFile).readText()
-        val pythonMethodsOpt = bind(currentPythonModuleOpt) { getPythonMethods(sourceFileContent, it) }
+        val pythonMethodsOpt = bind(currentPythonModuleOpt) { getPythonMethods() }
 
         return bind(pack(currentPythonModuleOpt, pythonMethodsOpt)) {
             currentPythonModule = it[0] as String
-            pythonMethods = it[1] as List<PythonMethod>
+            pythonMethods = it[1] as List<PythonMethodHeader>
             Success(Unit)
         }
     }
@@ -235,12 +240,12 @@ class PythonGenerateTestsCommand : CliktCommand(
             timeout = timeout,
             testFramework = testFramework,
             timeoutForRun = timeoutForRun,
-            withMinimization = !doNotMinimize,
-            doNotCheckRequirements = doNotCheckRequirements,
-            visitOnlySpecifiedSource = visitOnlySpecifiedSource,
             writeTestTextToFile = { generatedCode ->
                 writeToFileAndSave(output, generatedCode)
             },
+            pythonRunRoot = Paths.get("").toAbsolutePath(),
+            doNotCheckRequirements = doNotCheckRequirements,
+            withMinimization = !doNotMinimize,
             checkingRequirementsAction = {
                 logger.info("Checking requirements...")
             },
@@ -263,17 +268,12 @@ class PythonGenerateTestsCommand : CliktCommand(
                 )
             },
             processMypyWarnings = { messages -> messages.forEach { println(it) } },
-            finishedAction = {
-                logger.info("Finished test generation for the following functions: ${it.joinToString()}")
-            },
             processCoverageInfo = { coverageReport ->
                 val output = coverageOutput ?: return@processTestGeneration
                 writeToFileAndSave(output, coverageReport)
-            },
-            pythonRunRoot = Paths.get("").toAbsolutePath()
-        )
+            }
+        ) {
+            logger.info("Finished test generation for the following functions: ${it.joinToString()}")
+        }
     }
-
-    private fun String.toAbsolutePath(): String =
-        File(this).canonicalPath
 }

utbot-cli-python/src/main/kotlin/org/utbot/cli/language/python/PythonTypeInferenceCommand.kt

@@ -0,0 +1,89 @@
+package org.utbot.cli.language.python
+
+import com.github.ajalt.clikt.core.CliktCommand
+import com.github.ajalt.clikt.parameters.arguments.argument
+import com.github.ajalt.clikt.parameters.options.option
+import com.github.ajalt.clikt.parameters.options.required
+import com.github.ajalt.clikt.parameters.options.split
+import com.github.ajalt.clikt.parameters.types.long
+import mu.KotlinLogging
+import org.utbot.python.newtyping.inference.TypeInferenceProcessor
+import org.utbot.python.newtyping.pythonTypeRepresentation
+import org.utbot.python.utils.Fail
+import org.utbot.python.utils.RequirementsUtils.requirements
+import org.utbot.python.utils.Success
+
+private val logger = KotlinLogging.logger {}
+
+class PythonTypeInferenceCommand : CliktCommand(
+    name = "infer_types",
+    help = "Infer types for the specified Python top-level function."
+) {
+    private val sourceFile by argument(
+        help = "File with Python code."
+    )
+
+    private val function by argument(
+        help = "Function to infer types for."
+    )
+
+    private val className by option(
+        "-c", "--class",
+        help = "Class of the function"
+    )
+
+    private val pythonPath by option(
+        "-p", "--python-path",
+        help = "(required) Path to Python interpreter. Use only UNC format on Windows."
+    ).required()
+
+    private val timeout by option(
+        "-t", "--timout",
+        help = "(required) Timeout in milliseconds for type inference."
+    ).long().required()
+
+    private val directoriesForSysPath by option(
+        "-s", "--sys-path",
+        help = "(required) Directories to add to sys.path. Use only UNC format on Windows. " +
+                "One of directories must contain the file with the methods under test."
+    ).split(",").required()
+
+    private var startTime: Long = 0
+
+    override fun run() {
+        val moduleOpt = findCurrentPythonModule(
+            directoriesForSysPath.map { it.toAbsolutePath() },
+            sourceFile.toAbsolutePath()
+        )
+        if (moduleOpt is Fail) {
+            logger.error(moduleOpt.message)
+        }
+        val module = (moduleOpt as Success).value
+
+        val result = TypeInferenceProcessor(
+            pythonPath,
+            directoriesForSysPath.map{ it.toAbsolutePath() }.toSet(),
+            sourceFile,
+            module,
+            function,
+            className
+        ).inferTypes(
+            startingTypeInferenceAction = {
+                startTime = System.currentTimeMillis()
+                logger.info("Starting type inference...")
+            },
+            processSignature = { logger.info("Found signature: " + it.pythonTypeRepresentation()) },
+            cancel = { System.currentTimeMillis() - startTime > timeout },
+            checkRequirementsAction = { logger.info("Checking Python requirements...") },
+            missingRequirementsAction = {
+                logger.error("Some of the following Python requirements are missing: " +
+                        "${requirements.joinToString()}. Please install them.")
+            },
+            loadingInfoAboutTypesAction = { logger.info("Loading information about types...") },
+            analyzingCodeAction = { logger.info("Analyzing code...") },
+            pythonMethodExtractionFailAction = { logger.error(it) }
+        )
+
+        result.forEach { println(it.pythonTypeRepresentation()) }
+    }
+}

utbot-cli-python/src/main/kotlin/org/utbot/cli/language/python/Utils.kt

@@ -0,0 +1,22 @@
+package org.utbot.cli.language.python
+
+import org.utbot.python.utils.Fail
+import org.utbot.python.utils.Optional
+import org.utbot.python.utils.Success
+import org.utbot.python.utils.getModuleName
+import java.io.File
+
+fun findCurrentPythonModule(
+    directoriesForSysPath: Collection<String>,
+    sourceFile: String
+): Optional<String> {
+    directoriesForSysPath.forEach { path ->
+        val module = getModuleName(path.toAbsolutePath(), sourceFile.toAbsolutePath())
+        if (module != null)
+            return Success(module)
+    }
+    return Fail("Couldn't find path for $sourceFile in --sys-path option. Please, specify it.")
+}
+
+fun String.toAbsolutePath(): String =
+    File(this).canonicalPath

utbot-fuzzing/src/main/kotlin/org/utbot/fuzzing/seeds/BitVectorValue.kt

@@ -101,12 +101,7 @@ class BitVectorValue : KnownValue {
 
     @Suppress("MemberVisibilityCanBePrivate")
     fun toString(radix: Int, isUnsigned: Boolean = false): String {
-        val size = if (isUnsigned) size + 1 else size
-        val array = ByteArray(size / 8 + if (size % 8 != 0) 1 else 0) { index ->
-            toLong(bits = 8, shift = index * 8).toByte()
-        }
-        array.reverse()
-        return BigInteger(array).toString(radix)
+        return toBigInteger(isUnsigned).toString(radix)
     }
 
     override fun toString() = toString(10)
@@ -126,6 +121,17 @@ class BitVectorValue : KnownValue {
         return result
     }
 
+    private fun toBigInteger(isUnsigned: Boolean): BigInteger {
+        val size = if (isUnsigned) size + 1 else size
+        val array = ByteArray(size / 8 + if (size % 8 != 0) 1 else 0) { index ->
+            toLong(bits = 8, shift = index * 8).toByte()
+        }
+        array.reverse()
+        return BigInteger(array)
+    }
+
+    fun toBigInteger() = toBigInteger(false)
+
     fun toBoolean() = vector[0]
 
     fun toByte() = toLong(8).toByte()
@@ -155,6 +161,7 @@ class BitVectorValue : KnownValue {
                 is Short -> fromShort(value)
                 is Int -> fromInt(value)
                 is Long -> fromLong(value)
+                is BigInteger -> fromBigInteger(value)
                 else -> error("unknown type of value $value (${value::class})")
             }
         }
@@ -190,6 +197,17 @@ class BitVectorValue : KnownValue {
             }
             return BitVectorValue(size, vector)
         }
+
+        fun  fromBigInteger(value: BigInteger): BitVectorValue {
+            val size = 128
+            val bits = value.bitCount()
+            assert(bits <= size) { "This value $value is too big. Max value is 2^$bits." }
+            val vector = BitSet(size)
+            for (i in 0 until size) {
+                vector[i] = value.testBit(i)
+            }
+            return BitVectorValue(size, vector)
+        }
     }
 }