WIP: generator accepts NdArray attribute

forte/data/ontology/code_generation_objects.py

@@ -17,6 +17,7 @@
 from abc import ABC
 from pathlib import Path
 from typing import Optional, Any, List, Dict, Set, Tuple
+from numpy import ndarray
 
 from forte.data.ontology.code_generation_exceptions import (
     CodeGenerationException,
@@ -382,6 +383,51 @@ def to_field_value(self):
         return self.name
 
 
+class NdArrayProperty(Property):
+    """
+    NdArrayProperty accepts parsed properties of NdArray and
+    instructs import manager to import and instanciate FNdArray
+    as default value in the generated code.
+    """
+
+    def __init__(
+        self,
+        import_manager: ImportManager,
+        name: str,
+        ndarray_dtype: Optional[str] = None,
+        ndarray_shape: Optional[List[int]] = None,
+        description: Optional[str] = None,
+        default_val: Optional[ndarray] = None,
+    ):
+        self.type_str = "forte.data.ontology.core.FNdArray"
+        super().__init__(
+            import_manager,
+            name,
+            self.type_str,
+            description=description,
+            default_val=default_val,
+        )
+        self.ndarray_dtype: Optional[str] = ndarray_dtype
+        self.ndarray_shape: Optional[List[int]] = ndarray_shape
+
+    def internal_type_str(self) -> str:
+        type_str = self.import_manager.get_name_to_use(self.type_str)
+        return f"{type_str}"
+
+    def default_value(self) -> str:
+        if self.ndarray_dtype is None:
+            return f"FNdArray(shape={self.ndarray_shape}, dtype={self.ndarray_dtype})"
+        else:
+            return f"FNdArray(shape={self.ndarray_shape}, dtype='{self.ndarray_dtype}')"
+
+    def _full_class(self):
+        item_type = self.import_manager.get_name_to_use(self.type_str)
+        return item_type
+
+    def to_field_value(self):
+        return self.name
+
+
 class DictProperty(Property):
     def __init__(
         self,

forte/data/ontology/core.py

@@ -598,6 +598,73 @@ def __iter__(self) -> Iterator[KeyType]:
         yield from self.__data
 
 
+class FNdArray:
+    """
+    FNdArray is a wrapper of a NumPy array that stores shape and data type
+    of the array if they are specified. Only when both shape and data type
+    are provided, will FNdArray initialize a placeholder array through
+    np.ndarray(shape, dtype=dtype).
+    More details about np.ndarray(...):
+    https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html
+    """
+
+    def __init__(
+        self, dtype: Optional[str] = None, shape: Optional[Iterable[int]] = None
+    ):
+        super().__init__()
+        self._dtype: Optional[np.dtype] = (
+            np.dtype(dtype) if dtype is not None else dtype
+        )
+        self._shape: Optional[tuple] = (
+            tuple(shape) if shape is not None else shape
+        )
+        self._data: Optional[np.ndarray] = None
+        if dtype and shape:
+            self._data = np.ndarray(shape, dtype=dtype)
+
+    @property
+    def dtype(self):
+        return self._dtype
+
+    @property
+    def shape(self):
+        return self._shape
+
+    @property
+    def data(self):
+        return self._data
+
+    @data.setter
+    def data(self, array: Union[np.ndarray, List]):
+        if isinstance(array, np.ndarray):
+            if self.dtype and not np.issubdtype(array.dtype, self.dtype):
+                raise TypeError(
+                    f"Expecting type or subtype of {self.dtype}, but got {array.dtype}."
+                )
+            if self.shape and self.shape != array.shape:
+                raise AttributeError(
+                    f"Expecting shape {self.shape}, but got {array.shape}."
+                )
+            self._data = array
+
+        elif isinstance(array, list):
+            array_np = np.array(array, dtype=self.dtype)
+            if self.shape and self.shape != array_np.shape:
+                raise AttributeError(
+                    f"Expecting shape {self.shape}, but got {array_np.shape}."
+                )
+            self._data = array_np
+
+        else:
+            raise ValueError(
+                f"Can only accept numpy array or python list, but got {type(array)}"
+            )
+
+        # Stored dtype and shape should match to the provided array's.
+        self._dtype = self._data.dtype
+        self._shape = self._data.shape
+
+
 class Pointer(BasePointer):
     """
     A pointer that points to an entry in the current pack, this is basically

forte/data/ontology/ontology_code_const.py

@@ -28,6 +28,8 @@ class SchemaKeywords:
     element_type = "item_type"
     dict_key_type = "key_type"
     dict_value_type = "value_type"
+    ndarray_dtype = "ndarray_dtype"
+    ndarray_shape = "ndarray_shape"
 
 
 # Some names are used as properties by the core types, they should not be
@@ -83,7 +85,7 @@ def get_ignore_error_lines(json_filepath: str) -> List[str]:
 
 SUPPORTED_PRIMITIVES = {"int", "float", "str", "bool"}
 NON_COMPOSITES = {key: key for key in SUPPORTED_PRIMITIVES}
-COMPOSITES = {"List", "Dict"}
+COMPOSITES = {"List", "Dict", "NdArray"}
 
 ALL_INBUILT_TYPES = set(list(NON_COMPOSITES.keys()) + list(COMPOSITES))
 

forte/data/ontology/ontology_code_generator.py

@@ -32,6 +32,7 @@
 import jsonschema
 import typed_ast.ast3 as ast
 import typed_astunparse as ast_unparse
+from numpy import ndarray
 
 from forte.data.ontology import top, utils
 from forte.data.ontology.code_generation_exceptions import (
@@ -48,6 +49,7 @@
     OntologySourceNotFoundException,
 )
 from forte.data.ontology.code_generation_objects import (
+    NdArrayProperty,
     NonCompositeProperty,
     ListProperty,
     ClassTypeDefinition,
@@ -1078,6 +1080,40 @@ def parse_entry(
 
         return entry_item, property_names
 
+    def parse_ndarray(
+        self,
+        manager: ImportManager,
+        schema: Dict,
+        att_name: str,
+        desc: str,
+    ):
+        ndarray_dtype = None
+        if SchemaKeywords.ndarray_dtype in schema:
+            ndarray_dtype = schema[SchemaKeywords.ndarray_dtype]
+
+        ndarray_shape = None
+        if SchemaKeywords.ndarray_shape in schema:
+            ndarray_shape = schema[SchemaKeywords.ndarray_shape]
+
+        if ndarray_dtype is None or ndarray_shape is None:
+            warnings.warn(
+                "Either dtype or shape is not specified."
+                " It is recommended to specify both of them."
+            )
+
+        default_val = None
+        if ndarray_dtype and ndarray_shape:
+            default_val = ndarray(ndarray_shape, dtype=ndarray_dtype)
+
+        return NdArrayProperty(
+            manager,
+            att_name,
+            ndarray_dtype,
+            ndarray_shape,
+            description=desc,
+            default_val=default_val,
+        )
+
     def parse_dict(
         self,
         manager: ImportManager,
@@ -1250,6 +1286,8 @@ def parse_property(self, entry_name: EntryName, schema: Dict) -> Property:
                 return self.parse_dict(
                     manager, schema, entry_name, att_name, att_type, desc
                 )
+            elif att_type == "NdArray":
+                return self.parse_ndarray(manager, schema, att_name, desc)
         elif att_type in NON_COMPOSITES or manager.is_imported(att_type):
             self_ref = entry_name.class_name == att_type
             return self.parse_non_composite(

forte/data/ontology/validation_schema.json

@@ -95,6 +95,34 @@
                 "value_type": {
                   "description": "Item type for the case of Dice attributes",
                   "type": "string"
+                },
+                "ndarray_dtype": {
+                  "description": "Data type for the case of NdArray attributes. Allow a subset of NumPy supported data types",
+                  "type": "string",
+                  "enum": [
+                    "bool",
+                    "bool8",
+                    "int",
+                    "int8",
+                    "int32",
+                    "int64",
+                    "uint8",
+                    "uint32",
+                    "uint64",
+                    "float",
+                    "float32",
+                    "float64",
+                    "float96",
+                    "float128",
+                    "complex",
+                    "complex128",
+                    "complex192",
+                    "complex256"
+                  ]
+                },
+                "ndarray_shape": {
+                  "description": "Shape of N-dimensional array for the case of NdArray attributes",
+                  "type": "array"
                 }
               },
               "anyOf": [
@@ -135,6 +163,23 @@
                     }
                   ]
                 },
+                {
+                  "allOf": [
+                    {
+                      "properties": {
+                        "name": {
+                          "enum": [
+                            "NdArray"
+                          ]
+                        }
+                      },
+                      "required": [
+                        "name",
+                        "type"
+                      ]
+                    }
+                  ]
+                },
                 {
                   "allOf": [
                     {