[Andrew Polyakov] Add dimension parameter to NDArrayValueProvider

Author: AndrewPolyakov1

utbot-python/src/main/kotlin/org/utbot/python/evaluation/serialization/PythonObjectParser.kt

@@ -321,8 +321,8 @@ fun MemoryObject.toPythonTree(
 
             is NdarrayMemoryObject -> {
                 val draft = when (this.qualname) {
-                    "np.ndarray" -> PythonTree.NdarrayNode(id, mutableMapOf())
-                    "numpy.ndarray" -> PythonTree.NdarrayNode(id, mutableMapOf())
+                    "np.ndarray" -> PythonTree.NdarrayNode(id, mutableMapOf(), listOf())
+                    "numpy.ndarray" -> PythonTree.NdarrayNode(id, mutableMapOf(), listOf())
                     else -> PythonTree.ListNode(id, mutableMapOf())
                 }
                 visited[this.id] = draft

utbot-python/src/main/kotlin/org/utbot/python/framework/api/python/PythonTree.kt

@@ -157,9 +157,10 @@ object PythonTree {
     }
     class NdarrayNode(
         id: Long,
-        val items: MutableMap<Int, PythonTreeNode>
+        val items: MutableMap<Int, PythonTreeNode>,
+        val dimention: List<Int>
     ) : PythonTreeNode(id, pythonNdarrayClassId) {
-        constructor(items: MutableMap<Int, PythonTreeNode>) : this(PythonIdGenerator.createId(), items)
+        constructor(items: MutableMap<Int, PythonTreeNode>, dimention: List<Int>) : this(PythonIdGenerator.createId(), items, dimention)
 
         override val children: List<PythonTreeNode>
             get() = items.values.toList()

utbot-python/src/main/kotlin/org/utbot/python/fuzzing/PythonApi.kt

@@ -141,7 +141,7 @@ fun pythonDefaultValueProviders(typeStorage: PythonTypeHintsStorage) = listOf(
     ConstantValueProvider,
     TypeAliasValueProvider,
     IteratorValueProvider,
-    NDArrayValueProvider,
+    NDArrayValueProvider(typeStorage),
     SubtypeValueProvider(typeStorage)
 )
 

utbot-python/src/main/kotlin/org/utbot/python/fuzzing/provider/NDArrayValueProvider.kt

@@ -6,35 +6,63 @@ import org.utbot.fuzzing.Seed
 import org.utbot.python.framework.api.python.PythonTree
 import org.utbot.python.framework.api.python.util.pythonNdarrayClassId
 import org.utbot.python.fuzzing.FuzzedUtType
-import org.utbot.python.fuzzing.FuzzedUtType.Companion.activateAnyIf
 import org.utbot.python.fuzzing.FuzzedUtType.Companion.toFuzzed
 import org.utbot.python.fuzzing.PythonFuzzedValue
 import org.utbot.python.fuzzing.PythonMethodDescription
 import org.utbot.python.fuzzing.PythonValueProvider
-import org.utpython.types.pythonAnnotationParameters
+import org.utbot.python.fuzzing.provider.utils.*
+import org.utpython.types.*
+import kotlin.math.abs
 
 
 private val logger = KotlinLogging.logger {}
 
-object NDArrayValueProvider : PythonValueProvider {
+class NDArrayValueProvider(
+    private val typeStorage: PythonTypeHintsStorage
+) : PythonValueProvider {
     override fun accept(type: FuzzedUtType): Boolean {
         return type.pythonTypeName() == pythonNdarrayClassId.canonicalName
     }
 
+    @Suppress("UNCHECKED_CAST")
     override fun generate(
         description: PythonMethodDescription, type: FuzzedUtType
     ) = sequence {
         val param = type.utType.pythonAnnotationParameters()
-        yield(Seed.Collection( //TODO: Rewrite to construct NDArray objects
-            construct = Routine.Collection {
+        val intType = typeStorage.pythonInt
+        val listType = typeStorage.pythonList
+
+        yield(Seed.Recursive(
+            construct = Routine.Create(
+                listOf(
+                    listType
+                        .pythonDescription()
+                        .createTypeWithNewAnnotationParameters(listType, listOf(intType)).toFuzzed()
+                )
+            ) {
                 PythonFuzzedValue(
+
                     PythonTree.NdarrayNode(
-                        emptyMap<Int, PythonTree.PythonTreeNode>().toMutableMap(),
+                        emptyMap<Int, PythonTree.PythonTreeNode>().toMutableMap(), // Generate new Python IntNode
+                        ((it.first().tree as PythonTree.ListNode).items as Map<Int, PythonTree.PrimitiveNode>).values.map { node ->
+                            abs(node.repr.take(3).toInt()) % 10
+                        }
                     ), "%var% = ${type.pythonTypeRepresentation()}"
                 )
             },
-            modify = Routine.ForEach(param.toFuzzed().activateAnyIf(type)) { self, i, values ->
-                (self.tree as PythonTree.NdarrayNode).items[i] = values.first().tree
-            }))
+            // TODO: Call to modify
+            modify = sequence {
+                yield(Routine.Call((0 until 10000). map{param[1]}.toFuzzed()) { instance, arguments ->
+                    val obj = instance.tree as PythonTree.NdarrayNode
+                    (0 until obj.dimention.fold(1, Int::times)).map {
+                        obj.items[it] = arguments.get(it).tree
+                    }
+
+                })
+            },
+            empty = Routine.Empty { PythonFuzzedValue(PythonTree.FakeNode) }
+        )
+
+        )
     }
 }