Add files using upload-large-folder tool

parrot/lib/python3.10/site-packages/decord/__init__.py

@@ -0,0 +1,19 @@
+"""Decord python package"""
+from . import function
+
+from ._ffi.runtime_ctypes import TypeCode
+from ._ffi.function import register_func, get_global_func, list_global_func_names, extract_ext_funcs
+from ._ffi.base import DECORDError, DECORDLimitReachedError, __version__
+
+from .base import ALL
+
+from . import ndarray as nd
+from .ndarray import cpu, gpu
+from . import bridge
+from . import logging
+from .video_reader import VideoReader
+from .video_loader import VideoLoader
+from .audio_reader import AudioReader
+from .av_reader import AVReader
+
+logging.set_level(logging.ERROR)

parrot/lib/python3.10/site-packages/decord/_api_internal.py

@@ -0,0 +1 @@
+"""Namespace for internal apis."""

parrot/lib/python3.10/site-packages/decord/_ffi/__init__.py

@@ -0,0 +1,10 @@
+"""C interfacing code.
+
+This namespace contains everything that interacts with C code.
+Most C related object are ctypes compatible, which means
+they contains a handle field that is ctypes.c_void_p and can
+be used via ctypes function calls.
+
+Some performance critical functions are implemented by cython
+and have a ctypes fallback implementation.
+"""

parrot/lib/python3.10/site-packages/decord/_ffi/_ctypes/__init__.py

@@ -0,0 +1 @@
+"""ctypes specific implementation of FFI"""

parrot/lib/python3.10/site-packages/decord/_ffi/_ctypes/function.py

@@ -0,0 +1,233 @@
+# coding: utf-8
+# pylint: disable=invalid-name, protected-access, too-many-branches, global-statement
+"""Function configuration API."""
+from __future__ import absolute_import
+
+import ctypes
+import traceback
+from numbers import Number, Integral
+
+from ..base import _LIB, check_call
+from ..base import c_str, string_types
+from ..runtime_ctypes import DECORDType, DECORDByteArray, DECORDContext
+from . import ndarray as _nd
+from .ndarray import NDArrayBase, _make_array
+from .types import DECORDValue, TypeCode
+from .types import DECORDPackedCFunc, DECORDCFuncFinalizer
+from .types import RETURN_SWITCH, C_TO_PY_ARG_SWITCH, _wrap_arg_func
+
+FunctionHandle = ctypes.c_void_p
+ModuleHandle = ctypes.c_void_p
+DECORDRetValueHandle = ctypes.c_void_p
+
+def _ctypes_free_resource(rhandle):
+    """callback to free resources when it it not needed."""
+    pyobj = ctypes.cast(rhandle, ctypes.py_object)
+    ctypes.pythonapi.Py_DecRef(pyobj)
+
+# Global callback that is always alive
+DECORD_FREE_PYOBJ = DECORDCFuncFinalizer(_ctypes_free_resource)
+ctypes.pythonapi.Py_IncRef(ctypes.py_object(DECORD_FREE_PYOBJ))
+
+def convert_to_decord_func(pyfunc):
+    """Convert a python function to DECORD function
+
+    Parameters
+    ----------
+    pyfunc : python function
+        The python function to be converted.
+
+    Returns
+    -------
+    decordfunc: decord.nd.Function
+        The converted decord function.
+    """
+    local_pyfunc = pyfunc
+    def cfun(args, type_codes, num_args, ret, _):
+        """ ctypes function """
+        num_args = num_args.value if isinstance(num_args, ctypes.c_int) else num_args
+        pyargs = (C_TO_PY_ARG_SWITCH[type_codes[i]](args[i]) for i in range(num_args))
+        # pylint: disable=broad-except
+        try:
+            rv = local_pyfunc(*pyargs)
+        except Exception:
+            msg = traceback.format_exc()
+            _LIB.DECORDAPISetLastError(c_str(msg))
+            return -1
+
+        if rv is not None:
+            if isinstance(rv, tuple):
+                raise ValueError("PackedFunction can only support one return value")
+            temp_args = []
+            values, tcodes, _ = _make_decord_args((rv,), temp_args)
+            if not isinstance(ret, DECORDRetValueHandle):
+                ret = DECORDRetValueHandle(ret)
+            check_call(_LIB.DECORDCFuncSetReturn(ret, values, tcodes, ctypes.c_int(1)))
+            _ = temp_args
+            _ = rv
+        return 0
+
+    handle = FunctionHandle()
+    f = DECORDPackedCFunc(cfun)
+    # NOTE: We will need to use python-api to increase ref count of the f
+    # DECORD_FREE_PYOBJ will be called after it is no longer needed.
+    pyobj = ctypes.py_object(f)
+    ctypes.pythonapi.Py_IncRef(pyobj)
+    check_call(_LIB.DECORDFuncCreateFromCFunc(
+        f, pyobj, DECORD_FREE_PYOBJ, ctypes.byref(handle)))
+    return _CLASS_FUNCTION(handle, False)
+
+
+def _make_decord_args(args, temp_args):
+    """Pack arguments into c args decord call accept"""
+    num_args = len(args)
+    values = (DECORDValue * num_args)()
+    type_codes = (ctypes.c_int * num_args)()
+    for i, arg in enumerate(args):
+        if arg is None:
+            values[i].v_handle = None
+            type_codes[i] = TypeCode.NULL
+        elif isinstance(arg, NDArrayBase):
+            values[i].v_handle = ctypes.cast(arg.handle, ctypes.c_void_p)
+            type_codes[i] = (TypeCode.NDARRAY_CONTAINER
+                             if not arg.is_view else TypeCode.ARRAY_HANDLE)
+        elif isinstance(arg, _nd._DECORD_COMPATS):
+            values[i].v_handle = ctypes.c_void_p(arg._decord_handle)
+            type_codes[i] = arg.__class__._decord_tcode
+        elif isinstance(arg, Integral):
+            values[i].v_int64 = arg
+            type_codes[i] = TypeCode.INT
+        elif isinstance(arg, Number):
+            values[i].v_float64 = arg
+            type_codes[i] = TypeCode.FLOAT
+        elif isinstance(arg, DECORDType):
+            values[i].v_str = c_str(str(arg))
+            type_codes[i] = TypeCode.STR
+        elif isinstance(arg, DECORDContext):
+            values[i].v_ctx = arg
+            type_codes[i] = TypeCode.DECORD_CONTEXT
+        elif isinstance(arg, bytearray):
+            arr = DECORDByteArray()
+            arr.data = ctypes.cast(
+                (ctypes.c_byte * len(arg)).from_buffer(arg),
+                ctypes.POINTER(ctypes.c_byte))
+            arr.size = len(arg)
+            values[i].v_handle = ctypes.c_void_p(ctypes.addressof(arr))
+            temp_args.append(arr)
+            type_codes[i] = TypeCode.BYTES
+        elif isinstance(arg, string_types):
+            values[i].v_str = c_str(arg)
+            type_codes[i] = TypeCode.STR
+        # NOTE(minjie): module is not used in DECORD
+        #elif isinstance(arg, _CLASS_MODULE):
+        #    values[i].v_handle = arg.handle
+        #    type_codes[i] = TypeCode.MODULE_HANDLE
+        elif isinstance(arg, FunctionBase):
+            values[i].v_handle = arg.handle
+            type_codes[i] = TypeCode.FUNC_HANDLE
+        elif isinstance(arg, ctypes.c_void_p):
+            values[i].v_handle = arg
+            type_codes[i] = TypeCode.HANDLE
+        elif callable(arg):
+            arg = convert_to_decord_func(arg)
+            values[i].v_handle = arg.handle
+            type_codes[i] = TypeCode.FUNC_HANDLE
+            temp_args.append(arg)
+        else:
+            raise TypeError("Don't know how to handle type %s" % type(arg))
+    return values, type_codes, num_args
+
+
+class FunctionBase(object):
+    """Function base."""
+    __slots__ = ["handle", "is_global"]
+    # pylint: disable=no-member
+    def __init__(self, handle, is_global):
+        """Initialize the function with handle
+
+        Parameters
+        ----------
+        handle : FunctionHandle
+            the handle to the underlying function.
+
+        is_global : bool
+            Whether this is a global function in python
+        """
+        self.handle = handle
+        self.is_global = is_global
+
+    def __del__(self):
+        if not self.is_global and _LIB is not None:
+            check_call(_LIB.DECORDFuncFree(self.handle))
+
+    def __call__(self, *args):
+        """Call the function with positional arguments
+
+        args : list
+           The positional arguments to the function call.
+        """
+        temp_args = []
+        values, tcodes, num_args = _make_decord_args(args, temp_args)
+        ret_val = DECORDValue()
+        ret_tcode = ctypes.c_int()
+        check_call(_LIB.DECORDFuncCall(
+            self.handle, values, tcodes, ctypes.c_int(num_args),
+            ctypes.byref(ret_val), ctypes.byref(ret_tcode)))
+        _ = temp_args
+        _ = args
+        return RETURN_SWITCH[ret_tcode.value](ret_val)
+
+
+def __init_handle_by_constructor__(fconstructor, args):
+    """Initialize handle by constructor"""
+    temp_args = []
+    values, tcodes, num_args = _make_decord_args(args, temp_args)
+    ret_val = DECORDValue()
+    ret_tcode = ctypes.c_int()
+    check_call(_LIB.DECORDFuncCall(
+        fconstructor.handle, values, tcodes, ctypes.c_int(num_args),
+        ctypes.byref(ret_val), ctypes.byref(ret_tcode)))
+    _ = temp_args
+    _ = args
+    assert ret_tcode.value == TypeCode.NODE_HANDLE
+    handle = ret_val.v_handle
+    return handle
+
+
+def _return_module(x):
+    """Return function"""
+    handle = x.v_handle
+    if not isinstance(handle, ModuleHandle):
+        handle = ModuleHandle(handle)
+    return _CLASS_MODULE(handle)
+
+def _handle_return_func(x):
+    """Return function"""
+    handle = x.v_handle
+    if not isinstance(handle, FunctionHandle):
+        handle = FunctionHandle(handle)
+    return _CLASS_FUNCTION(handle, False)
+
+
+# setup return handle for function type
+RETURN_SWITCH[TypeCode.FUNC_HANDLE] = _handle_return_func
+RETURN_SWITCH[TypeCode.MODULE_HANDLE] = _return_module
+RETURN_SWITCH[TypeCode.NDARRAY_CONTAINER] = lambda x: _make_array(x.v_handle, False)
+C_TO_PY_ARG_SWITCH[TypeCode.FUNC_HANDLE] = _wrap_arg_func(
+    _handle_return_func, TypeCode.FUNC_HANDLE)
+C_TO_PY_ARG_SWITCH[TypeCode.MODULE_HANDLE] = _wrap_arg_func(
+    _return_module, TypeCode.MODULE_HANDLE)
+C_TO_PY_ARG_SWITCH[TypeCode.ARRAY_HANDLE] = lambda x: _make_array(x.v_handle, True)
+C_TO_PY_ARG_SWITCH[TypeCode.NDARRAY_CONTAINER] = lambda x: _make_array(x.v_handle, False)
+
+_CLASS_MODULE = None
+_CLASS_FUNCTION = None
+
+def _set_class_module(module_class):
+    """Initialize the module."""
+    global _CLASS_MODULE
+    _CLASS_MODULE = module_class
+
+def _set_class_function(func_class):
+    global _CLASS_FUNCTION
+    _CLASS_FUNCTION = func_class

parrot/lib/python3.10/site-packages/decord/_ffi/_ctypes/ndarray.py

@@ -0,0 +1,107 @@
+# pylint: disable=invalid-name
+"""Runtime NDArray api"""
+from __future__ import absolute_import
+
+import ctypes
+from ..base import _LIB, check_call, c_str
+from ..runtime_ctypes import DECORDArrayHandle
+from .types import RETURN_SWITCH, C_TO_PY_ARG_SWITCH, _wrap_arg_func, _return_handle
+
+
+DECORDPyCapsuleDestructor = ctypes.CFUNCTYPE(None, ctypes.c_void_p)
+_c_str_dltensor = c_str('dltensor')
+_c_str_used_dltensor = c_str('used_dltensor')
+
+
+# used for PyCapsule manipulation
+if hasattr(ctypes, 'pythonapi'):
+    ctypes.pythonapi.PyCapsule_GetName.restype = ctypes.c_char_p
+    ctypes.pythonapi.PyCapsule_GetPointer.restype = ctypes.c_void_p
+    ctypes.pythonapi.PyCapsule_New.restype = ctypes.py_object
+
+
+def _from_dlpack(dltensor):
+    dltensor = ctypes.py_object(dltensor)
+    if ctypes.pythonapi.PyCapsule_IsValid(dltensor, _c_str_dltensor):
+        ptr = ctypes.pythonapi.PyCapsule_GetPointer(dltensor, _c_str_dltensor)
+        # XXX(minjie): The below cast should be unnecessary given the code to
+        #   set restype of PyCapsule calls. But weirdly, this does not
+        #   work out always.
+        ptr = ctypes.cast(ptr, ctypes.c_void_p)
+        handle = DECORDArrayHandle()
+        check_call(_LIB.DECORDArrayFromDLPack(ptr, ctypes.byref(handle)))
+        ctypes.pythonapi.PyCapsule_SetName(dltensor, _c_str_used_dltensor)
+        ctypes.pythonapi.PyCapsule_SetDestructor(dltensor, DECORDPyCapsuleDestructor(0))
+        return _make_array(handle, False)
+    raise ValueError("Expect a dltensor field, PyCapsule can only be consumed once")
+
+
+def _dlpack_deleter(pycapsule):
+    pycapsule = ctypes.cast(pycapsule, ctypes.py_object)
+    if ctypes.pythonapi.PyCapsule_IsValid(pycapsule, _c_str_dltensor):
+        ptr = ctypes.pythonapi.PyCapsule_GetPointer(pycapsule, _c_str_dltensor)
+        # XXX(minjie): The below cast should be unnecessary given the code to
+        #   set restype of PyCapsule calls. But weirdly, this does not
+        #   work out always.
+        ptr = ctypes.cast(ptr, ctypes.c_void_p)
+        _LIB.DECORDDLManagedTensorCallDeleter(ptr)
+        ctypes.pythonapi.PyCapsule_SetDestructor(pycapsule, DECORDPyCapsuleDestructor(0))
+
+_c_dlpack_deleter = DECORDPyCapsuleDestructor(_dlpack_deleter)
+
+
+class NDArrayBase(object):
+    """A simple Device/CPU Array object in runtime."""
+    __slots__ = ["handle", "is_view"]
+    # pylint: disable=no-member
+    def __init__(self, handle, is_view=False):
+        """Initialize the function with handle
+
+        Parameters
+        ----------
+        handle : DECORDArrayHandle
+            the handle to the underlying C++ DECORDArray
+        """
+        self.handle = handle
+        self.is_view = is_view
+
+    def __del__(self):
+        if not self.is_view and _LIB:
+            check_call(_LIB.DECORDArrayFree(self.handle))
+
+    @property
+    def _decord_handle(self):
+        return ctypes.cast(self.handle, ctypes.c_void_p).value
+
+    def to_dlpack(self):
+        """Produce an array from a DLPack Tensor without copying memory
+
+        Returns
+        -------
+        dlpack : DLPack tensor view of the array data
+        """
+        ptr = ctypes.c_void_p()
+        check_call(_LIB.DECORDArrayToDLPack(self.handle, ctypes.byref(ptr)))
+        return ctypes.pythonapi.PyCapsule_New(ptr, _c_str_dltensor, _c_dlpack_deleter)
+
+
+def _make_array(handle, is_view):
+    handle = ctypes.cast(handle, DECORDArrayHandle)
+    return _CLASS_NDARRAY(handle, is_view)
+
+_DECORD_COMPATS = ()
+
+def _reg_extension(cls, fcreate):
+    global _DECORD_COMPATS
+    _DECORD_COMPATS += (cls,)
+    if fcreate:
+        fret = lambda x: fcreate(_return_handle(x))
+        RETURN_SWITCH[cls._decord_tcode] = fret
+        C_TO_PY_ARG_SWITCH[cls._decord_tcode] = _wrap_arg_func(fret, cls._decord_tcode)
+
+
+_CLASS_NDARRAY = None
+
+def _set_class_ndarray(cls):
+    global _CLASS_NDARRAY
+    _CLASS_NDARRAY = cls

parrot/lib/python3.10/site-packages/decord/_ffi/_ctypes/types.py

@@ -0,0 +1,74 @@
+"""The C Types used in API."""
+# pylint: disable=invalid-name
+from __future__ import absolute_import as _abs
+
+import ctypes
+from ..base import py_str, check_call, _LIB
+from ..runtime_ctypes import DECORDByteArray, TypeCode
+
+class DECORDValue(ctypes.Union):
+    """DECORDValue in C API"""
+    _fields_ = [("v_int64", ctypes.c_int64),
+                ("v_float64", ctypes.c_double),
+                ("v_handle", ctypes.c_void_p),
+                ("v_str", ctypes.c_char_p)]
+
+
+DECORDPackedCFunc = ctypes.CFUNCTYPE(
+    ctypes.c_int,
+    ctypes.POINTER(DECORDValue),
+    ctypes.POINTER(ctypes.c_int),
+    ctypes.c_int,
+    ctypes.c_void_p,
+    ctypes.c_void_p)
+
+
+DECORDCFuncFinalizer = ctypes.CFUNCTYPE(
+    None,
+    ctypes.c_void_p)
+
+
+def _return_handle(x):
+    """return handle"""
+    handle = x.v_handle
+    if not isinstance(handle, ctypes.c_void_p):
+        handle = ctypes.c_void_p(handle)
+    return handle
+
+def _return_bytes(x):
+    """return handle"""
+    handle = x.v_handle
+    if not isinstance(handle, ctypes.c_void_p):
+        handle = ctypes.c_void_p(handle)
+    arr = ctypes.cast(handle, ctypes.POINTER(DECORDByteArray))[0]
+    size = arr.size
+    res = bytearray(size)
+    rptr = (ctypes.c_byte * size).from_buffer(res)
+    if not ctypes.memmove(rptr, arr.data, size):
+        raise RuntimeError('memmove failed')
+    return res
+
+def _wrap_arg_func(return_f, type_code):
+    tcode = ctypes.c_int(type_code)
+    def _wrap_func(x):
+        check_call(_LIB.DECORDCbArgToReturn(ctypes.byref(x), tcode))
+        return return_f(x)
+    return _wrap_func
+
+RETURN_SWITCH = {
+    TypeCode.INT: lambda x: x.v_int64,
+    TypeCode.FLOAT: lambda x: x.v_float64,
+    TypeCode.HANDLE: _return_handle,
+    TypeCode.NULL: lambda x: None,
+    TypeCode.STR: lambda x: py_str(x.v_str),
+    TypeCode.BYTES: _return_bytes
+}
+
+C_TO_PY_ARG_SWITCH = {
+    TypeCode.INT: lambda x: x.v_int64,
+    TypeCode.FLOAT: lambda x: x.v_float64,
+    TypeCode.HANDLE: _return_handle,
+    TypeCode.NULL: lambda x: None,
+    TypeCode.STR: lambda x: py_str(x.v_str),
+    TypeCode.BYTES: _return_bytes
+}

parrot/lib/python3.10/site-packages/decord/_ffi/_cy2/__init__.py

@@ -0,0 +1 @@
+"""cython2 namespace"""

parrot/lib/python3.10/site-packages/decord/_ffi/_cy3/__init__.py

@@ -0,0 +1 @@
+"""cython3 namespace"""

parrot/lib/python3.10/site-packages/decord/_ffi/base.py

@@ -0,0 +1,127 @@
+# coding: utf-8
+# pylint: disable=invalid-name
+"""ctypes library and helper functions """
+from __future__ import absolute_import
+
+import sys
+import os
+import ctypes
+import numpy as np
+from . import libinfo
+
+#----------------------------
+# library loading
+#----------------------------
+if sys.version_info[0] == 3:
+    string_types = (str,)
+    numeric_types = (float, int, np.float32, np.int32)
+    # this function is needed for python3
+    # to convert ctypes.char_p .value back to python str
+    py_str = lambda x: x.decode('utf-8')
+else:
+    string_types = (basestring,)
+    numeric_types = (float, int, long, np.float32, np.int32)
+    py_str = lambda x: x
+
+
+class DECORDError(Exception):
+    """Error thrown by DECORD function"""
+    pass  # pylint: disable=unnecessary-pass
+
+class DECORDLimitReachedError(Exception):
+    """Limit Reached Error thrown by DECORD function"""
+    pass  # pylint: disable=unnecessary-pass
+
+def _load_lib():
+    """Load libary by searching possible path."""
+    lib_path = libinfo.find_lib_path()
+    os.environ['PATH'] += os.pathsep + os.path.dirname(lib_path[0])
+    lib = ctypes.CDLL(lib_path[0], ctypes.RTLD_GLOBAL)
+    # DMatrix functions
+    lib.DECORDGetLastError.restype = ctypes.c_char_p
+    return lib, os.path.basename(lib_path[0])
+
+# version number
+__version__ = libinfo.__version__
+# library instance of nnvm
+_LIB, _LIB_NAME = _load_lib()
+
+# The FFI mode of DECORD
+_FFI_MODE = os.environ.get("DECORD_FFI", "auto")
+
+# enable stack trace or not
+_ENABLE_STACK_TRACE = int(os.environ.get("DECORD_ENABLE_STACK_TRACE", "0"))
+
+#----------------------------
+# helper function in ctypes.
+#----------------------------
+def check_call(ret):
+    """Check the return value of C API call
+
+    This function will raise exception when error occurs.
+    Wrap every API call with this function
+
+    Parameters
+    ----------
+    ret : int
+        return value from API calls
+    """
+    if ret != 0:
+        err_str = py_str(_LIB.DECORDGetLastError())
+        if not _ENABLE_STACK_TRACE:
+            if 'Stack trace' in err_str:
+                err_str = err_str.split('Stack trace')[0].strip()
+        if 'recovered from nearest frames' in err_str:
+            if 'Stack trace' in err_str:
+                err_str = err_str.split('Stack trace')[0].strip()
+            raise DECORDLimitReachedError(err_str)
+        raise DECORDError(err_str)
+
+
+def c_str(string):
+    """Create ctypes char * from a python string
+    Parameters
+    ----------
+    string : string type
+        python string
+
+    Returns
+    -------
+    str : c_char_p
+        A char pointer that can be passed to C API
+    """
+    return ctypes.c_char_p(string.encode('utf-8'))
+
+
+def c_array(ctype, values):
+    """Create ctypes array from a python array
+
+    Parameters
+    ----------
+    ctype : ctypes data type
+        data type of the array we want to convert to
+
+    values : tuple or list
+        data content
+
+    Returns
+    -------
+    out : ctypes array
+        Created ctypes array
+    """
+    return (ctype * len(values))(*values)
+
+
+def decorate(func, fwrapped):
+    """A wrapper call of decorator package, differs to call time
+
+    Parameters
+    ----------
+    func : function
+        The original function
+
+    fwrapped : function
+        The wrapped function
+    """
+    import decorator
+    return decorator.decorate(func, fwrapped)

parrot/lib/python3.10/site-packages/decord/_ffi/function.py

@@ -0,0 +1,318 @@
+# pylint: disable=invalid-name, unused-import
+"""Function namespace."""
+from __future__ import absolute_import
+
+import sys
+import ctypes
+from .base import _LIB, check_call, py_str, c_str, string_types, _FFI_MODE
+
+IMPORT_EXCEPT = RuntimeError if _FFI_MODE == "cython" else ImportError
+
+try:
+    # pylint: disable=wrong-import-position
+    if _FFI_MODE == "ctypes":
+        raise ImportError()
+    if sys.version_info >= (3, 0):
+        from ._cy3.core import _set_class_function, _set_class_module
+        from ._cy3.core import FunctionBase as _FunctionBase
+        from ._cy3.core import convert_to_decord_func
+    else:
+        from ._cy2.core import _set_class_function, _set_class_module
+        from ._cy2.core import FunctionBase as _FunctionBase
+        from ._cy2.core import convert_to_decord_func
+except IMPORT_EXCEPT:
+    # pylint: disable=wrong-import-position
+    from ._ctypes.function import _set_class_function, _set_class_module
+    from ._ctypes.function import FunctionBase as _FunctionBase
+    from ._ctypes.function import convert_to_decord_func
+
+FunctionHandle = ctypes.c_void_p
+
+class Function(_FunctionBase):
+    """The PackedFunc object.
+
+    Function plays an key role to bridge front and backend in DECORD.
+    Function provide a type-erased interface, you can call function with positional arguments.
+
+    The compiled module returns Function.
+    DECORD backend also registers and exposes its API as Functions.
+    For example, the developer function exposed in decord.ir_pass are actually
+    C++ functions that are registered as PackedFunc
+
+    The following are list of common usage scenario of decord.Function.
+
+    - Automatic exposure of C++ API into python
+    - To call PackedFunc from python side
+    - To call python callbacks to inspect results in generated code
+    - Bring python hook into C++ backend
+
+    See Also
+    --------
+    decord.register_func: How to register global function.
+    decord.get_global_func: How to get global function.
+    """
+    pass  # pylint: disable=unnecessary-pass
+
+
+class ModuleBase(object):
+    """Base class for module"""
+    __slots__ = ["handle", "_entry", "entry_name"]
+
+    def __init__(self, handle):
+        self.handle = handle
+        self._entry = None
+        self.entry_name = "__decord_main__"
+
+    def __del__(self):
+        check_call(_LIB.DECORDModFree(self.handle))
+
+    @property
+    def entry_func(self):
+        """Get the entry function
+
+        Returns
+        -------
+        f : Function
+            The entry function if exist
+        """
+        if self._entry:
+            return self._entry
+        self._entry = self.get_function(self.entry_name)
+        return self._entry
+
+    def get_function(self, name, query_imports=False):
+        """Get function from the module.
+
+        Parameters
+        ----------
+        name : str
+            The name of the function
+
+        query_imports : bool
+            Whether also query modules imported by this module.
+
+        Returns
+        -------
+        f : Function
+            The result function.
+        """
+        ret_handle = FunctionHandle()
+        check_call(_LIB.DECORDModGetFunction(
+            self.handle, c_str(name),
+            ctypes.c_int(query_imports),
+            ctypes.byref(ret_handle)))
+        if not ret_handle.value:
+            raise AttributeError(
+                "Module has no function '%s'" %  name)
+        return Function(ret_handle, False)
+
+    def import_module(self, module):
+        """Add module to the import list of current one.
+
+        Parameters
+        ----------
+        module : Module
+            The other module.
+        """
+        check_call(_LIB.DECORDModImport(self.handle, module.handle))
+
+    def __getitem__(self, name):
+        if not isinstance(name, string_types):
+            raise ValueError("Can only take string as function name")
+        return self.get_function(name)
+
+    def __call__(self, *args):
+        if self._entry:
+            return self._entry(*args)
+        f = self.entry_func
+        return f(*args)
+
+
+def register_func(func_name, f=None, override=False):
+    """Register global function
+
+    Parameters
+    ----------
+    func_name : str or function
+        The function name
+
+    f : function, optional
+        The function to be registered.
+
+    override: boolean optional
+        Whether override existing entry.
+
+    Returns
+    -------
+    fregister : function
+        Register function if f is not specified.
+
+    Examples
+    --------
+    The following code registers my_packed_func as global function.
+    Note that we simply get it back from global function table to invoke
+    it from python side. However, we can also invoke the same function
+    from C++ backend, or in the compiled DECORD code.
+
+    .. code-block:: python
+
+      targs = (10, 10.0, "hello")
+      @decord.register_func
+      def my_packed_func(*args):
+          assert(tuple(args) == targs)
+          return 10
+      # Get it out from global function table
+      f = decord.get_global_func("my_packed_func")
+      assert isinstance(f, decord.nd.Function)
+      y = f(*targs)
+      assert y == 10
+    """
+    if callable(func_name):
+        f = func_name
+        func_name = f.__name__
+
+    if not isinstance(func_name, str):
+        raise ValueError("expect string function name")
+
+    ioverride = ctypes.c_int(override)
+    def register(myf):
+        """internal register function"""
+        if not isinstance(myf, Function):
+            myf = convert_to_decord_func(myf)
+        check_call(_LIB.DECORDFuncRegisterGlobal(
+            c_str(func_name), myf.handle, ioverride))
+        return myf
+    if f:
+        return register(f)
+    return register
+
+
+def get_global_func(name, allow_missing=False):
+    """Get a global function by name
+
+    Parameters
+    ----------
+    name : str
+        The name of the global function
+
+    allow_missing : bool
+        Whether allow missing function or raise an error.
+
+    Returns
+    -------
+    func : decord.Function
+        The function to be returned, None if function is missing.
+    """
+    handle = FunctionHandle()
+    check_call(_LIB.DECORDFuncGetGlobal(c_str(name), ctypes.byref(handle)))
+    if handle.value:
+        return Function(handle, False)
+    else:
+        if allow_missing:
+            return None
+        else:
+            raise ValueError("Cannot find global function %s" % name)
+
+
+
+def list_global_func_names():
+    """Get list of global functions registered.
+
+    Returns
+    -------
+    names : list
+       List of global functions names.
+    """
+    plist = ctypes.POINTER(ctypes.c_char_p)()
+    size = ctypes.c_uint()
+
+    check_call(_LIB.DECORDFuncListGlobalNames(ctypes.byref(size),
+                                           ctypes.byref(plist)))
+    fnames = []
+    for i in range(size.value):
+        fnames.append(py_str(plist[i]))
+    return fnames
+
+
+def extract_ext_funcs(finit):
+    """
+    Extract the extension PackedFuncs from a C module.
+
+    Parameters
+    ----------
+    finit : ctypes function
+        a ctypes that takes signature of DECORDExtensionDeclarer
+
+    Returns
+    -------
+    fdict : dict of str to Function
+        The extracted functions
+    """
+    fdict = {}
+    def _list(name, func):
+        fdict[name] = func
+    myf = convert_to_decord_func(_list)
+    ret = finit(myf.handle)
+    _ = myf
+    if ret != 0:
+        raise RuntimeError("cannot initialize with %s" % finit)
+    return fdict
+
+def _get_api(f):
+    flocal = f
+    flocal.is_global = True
+    return flocal
+
+def _init_api(namespace, target_module_name=None):
+    """Initialize api for a given module name
+
+    namespace : str
+       The namespace of the source registry
+
+    target_module_name : str
+       The target module name if different from namespace
+    """
+    target_module_name = (
+        target_module_name if target_module_name else namespace)
+    if namespace.startswith("decord."):
+        _init_api_prefix(target_module_name, namespace[7:])
+    else:
+        _init_api_prefix(target_module_name, namespace)
+
+
+def _init_api_prefix(module_name, prefix):
+    module = sys.modules[module_name]
+
+    for name in list_global_func_names():
+        if name.startswith("_"):
+            continue
+        if not name.startswith(prefix):
+            continue
+        fname = name[len(prefix)+1:]
+        target_module = module
+
+        if fname.find(".") != -1:
+            print('Warning: invalid API name "%s".' % fname)
+            continue
+        f = get_global_func(name)
+        ff = _get_api(f)
+        ff.__name__ = fname
+        ff.__doc__ = ("DECORD PackedFunc %s. " % fname)
+        setattr(target_module, ff.__name__, ff)
+
+def _init_internal_api():
+    for name in list_global_func_names():
+        if not name.startswith("_"):
+            continue
+        target_module = sys.modules["decord._api_internal"]
+        fname = name
+        if fname.find(".") != -1:
+            print('Warning: invalid API name "%s".' % fname)
+            continue
+        f = get_global_func(name)
+        ff = _get_api(f)
+        ff.__name__ = fname
+        ff.__doc__ = ("DECORD PackedFunc %s. " % fname)
+        setattr(target_module, ff.__name__, ff)
+
+_set_class_function(Function)

parrot/lib/python3.10/site-packages/decord/_ffi/libinfo.py

@@ -0,0 +1,90 @@
+"""Library information."""
+from __future__ import absolute_import
+import sys
+import os
+
+
+def find_lib_path(name=None, search_path=None, optional=False):
+    """Find dynamic library files.
+
+    Parameters
+    ----------
+    name : list of str
+        List of names to be found.
+
+    Returns
+    -------
+    lib_path : list(string)
+        List of all found path to the libraries
+    """
+    # See https://github.com/dmlc/tvm/issues/281 for some background.
+
+    # NB: This will either be the source directory (if DECORD is run
+    # inplace) or the install directory (if DECORD is installed).
+    # An installed DECORD's curr_path will look something like:
+    #   $PREFIX/lib/python3.6/site-packages/decord/_ffi
+    ffi_dir = os.path.dirname(os.path.abspath(os.path.expanduser(__file__)))
+    source_dir = os.path.join(ffi_dir, "..", "..", "..")
+    install_lib_dir = os.path.join(ffi_dir, "..", "..", "..", "..")
+
+    dll_path = []
+
+    if os.environ.get('DECORD_LIBRARY_PATH', None):
+        dll_path.append(os.environ['DECORD_LIBRARY_PATH'])
+
+    if sys.platform.startswith('linux') and os.environ.get('LD_LIBRARY_PATH', None):
+        dll_path.extend([p.strip() for p in os.environ['LD_LIBRARY_PATH'].split(":")])
+    elif sys.platform.startswith('darwin') and os.environ.get('DYLD_LIBRARY_PATH', None):
+        dll_path.extend([p.strip() for p in os.environ['DYLD_LIBRARY_PATH'].split(":")])
+
+    # Pip lib directory
+    dll_path.append(os.path.join(ffi_dir, ".."))
+    # Default cmake build directory
+    dll_path.append(os.path.join(source_dir, "build"))
+    dll_path.append(os.path.join(source_dir, "build", "Release"))
+    # Default make build directory
+    dll_path.append(os.path.join(source_dir, "lib"))
+
+    dll_path.append(install_lib_dir)
+
+    dll_path = [os.path.abspath(x) for x in dll_path]
+    if search_path is not None:
+        if search_path is list:
+            dll_path = dll_path + search_path
+        else:
+            dll_path.append(search_path)
+    if name is not None:
+        if isinstance(name, list):
+            lib_dll_path = []
+            for n in name:
+                lib_dll_path += [os.path.join(p, n) for p in dll_path]
+        else:
+            lib_dll_path = [os.path.join(p, name) for p in dll_path]
+    else:
+        if sys.platform.startswith('win32'):
+            lib_dll_path = [os.path.join(p, 'libdecord.dll') for p in dll_path] +\
+                           [os.path.join(p, 'decord.dll') for p in dll_path]
+        elif sys.platform.startswith('darwin'):
+            lib_dll_path = [os.path.join(p, 'libdecord.dylib') for p in dll_path]
+        else:
+            lib_dll_path = [os.path.join(p, 'libdecord.so') for p in dll_path]
+
+    # try to find lib_dll_path
+    lib_found = [p for p in lib_dll_path if os.path.exists(p) and os.path.isfile(p)]
+
+    if not lib_found:
+        message = ('Cannot find the files.\n' +
+                   'List of candidates:\n' +
+                   str('\n'.join(lib_dll_path)))
+        if not optional:
+            raise RuntimeError(message)
+        return None
+
+    return lib_found
+
+
+# current version
+# We use the version of the incoming release for code
+# that is under development.
+# The following line is set by decord/python/update_version.py
+__version__ = "0.6.0"

parrot/lib/python3.10/site-packages/decord/_ffi/ndarray.py

@@ -0,0 +1,344 @@
+# pylint: disable=invalid-name, unused-import
+"""Runtime NDArray api"""
+from __future__ import absolute_import
+
+import sys
+import ctypes
+import numpy as np
+from .base import _LIB, check_call, c_array, string_types, _FFI_MODE, c_str
+from .runtime_ctypes import DECORDType, DECORDContext, DECORDArray, DECORDArrayHandle
+from .runtime_ctypes import TypeCode, decord_shape_index_t
+
+
+IMPORT_EXCEPT = RuntimeError if _FFI_MODE == "cython" else ImportError
+
+try:
+    # pylint: disable=wrong-import-position
+    if _FFI_MODE == "ctypes":
+        raise ImportError()
+    if sys.version_info >= (3, 0):
+        from ._cy3.core import _set_class_ndarray, _reg_extension, _make_array, _from_dlpack
+        from ._cy3.core import NDArrayBase as _NDArrayBase
+    else:
+        from ._cy2.core import _set_class_ndarray, _reg_extension, _make_array, _from_dlpack
+        from ._cy2.core import NDArrayBase as _NDArrayBase
+except IMPORT_EXCEPT:
+    # pylint: disable=wrong-import-position
+    from ._ctypes.ndarray import _set_class_ndarray, _reg_extension, _make_array, _from_dlpack
+    from ._ctypes.ndarray import NDArrayBase as _NDArrayBase
+
+def context(dev_type, dev_id=0):
+    """Construct a DECORD context with given device type and id.
+
+    Parameters
+    ----------
+    dev_type: int or str
+        The device type mask or name of the device.
+
+    dev_id : int, optional
+        The integer device id
+
+    Returns
+    -------
+    ctx: DECORDContext
+        The corresponding context.
+
+    Examples
+    --------
+    Context can be used to create reflection of context by
+    string representation of the device type.
+
+    .. code-block:: python
+
+      assert decord.context("cpu", 1) == decord.cpu(1)
+      assert decord.context("gpu", 0) == decord.gpu(0)
+      assert decord.context("cuda", 0) == decord.gpu(0)
+    """
+    if isinstance(dev_type, string_types):
+        dev_type = dev_type.split()[0]
+        if dev_type not in DECORDContext.STR2MASK:
+            raise ValueError("Unknown device type %s" % dev_type)
+        dev_type = DECORDContext.STR2MASK[dev_type]
+    return DECORDContext(dev_type, dev_id)
+
+
+def numpyasarray(np_data):
+    """Return a DECORDArray representation of a numpy array.
+    """
+    data = np_data
+    assert data.flags['C_CONTIGUOUS']
+    arr = DECORDArray()
+    shape = c_array(decord_shape_index_t, data.shape)
+    arr.data = data.ctypes.data_as(ctypes.c_void_p)
+    arr.shape = shape
+    arr.strides = None
+    arr.dtype = DECORDType(np.dtype(data.dtype).name)
+    arr.ndim = data.ndim
+    # CPU device
+    arr.ctx = context(1, 0)
+    return arr, shape
+
+
+def empty(shape, dtype="float32", ctx=context(1, 0)):
+    """Create an empty array given shape and device
+
+    Parameters
+    ----------
+    shape : tuple of int
+        The shape of the array
+
+    dtype : type or str
+        The data type of the array.
+
+    ctx : DECORDContext
+        The context of the array
+
+    Returns
+    -------
+    arr : decord.nd.NDArray
+        The array decord supported.
+    """
+    shape = c_array(decord_shape_index_t, shape)
+    ndim = ctypes.c_int(len(shape))
+    handle = DECORDArrayHandle()
+    dtype = DECORDType(dtype)
+    check_call(_LIB.DECORDArrayAlloc(
+        shape, ndim,
+        ctypes.c_int(dtype.type_code),
+        ctypes.c_int(dtype.bits),
+        ctypes.c_int(dtype.lanes),
+        ctx.device_type,
+        ctx.device_id,
+        ctypes.byref(handle)))
+    return _make_array(handle, False)
+
+
+def from_dlpack(dltensor):
+    """Produce an array from a DLPack tensor without memory copy.
+    Retrieves the underlying DLPack tensor's pointer to create an array from the
+    data. Removes the original DLPack tensor's destructor as now the array is
+    responsible for destruction.
+
+    Parameters
+    ----------
+    dltensor : DLPack tensor
+        Input DLManagedTensor, can only be consumed once.
+
+    Returns
+    -------
+    arr: decord.nd.NDArray
+        The array view of the tensor data.
+    """
+    return _from_dlpack(dltensor)
+
+
+class NDArrayBase(_NDArrayBase):
+    """A simple Device/CPU Array object in runtime."""
+    @property
+    def shape(self):
+        """Shape of this array"""
+        return tuple(self.handle.contents.shape[i] for i in range(self.handle.contents.ndim))
+
+    @property
+    def dtype(self):
+        """Type of this array"""
+        return str(self.handle.contents.dtype)
+
+    @property
+    def ctx(self):
+        """context of this array"""
+        return self.handle.contents.ctx
+
+    @property
+    def context(self):
+        """context of this array"""
+        return self.ctx
+
+    def __hash__(self):
+        return ctypes.cast(self.handle, ctypes.c_void_p).value
+
+    def __eq__(self, other):
+        return self.same_as(other)
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def same_as(self, other):
+        """Check object identity equality
+
+        Parameters
+        ----------
+        other : object
+            The other object to compare to
+
+        Returns
+        -------
+        same : bool
+            Whether other is same as self.
+        """
+        if not isinstance(other, NDArrayBase):
+            return False
+        return self.__hash__() == other.__hash__()
+
+    def __setitem__(self, in_slice, value):
+        """Set ndarray value"""
+        if (not isinstance(in_slice, slice) or
+                in_slice.start is not None
+                or in_slice.stop is not None):
+            raise ValueError('Array only support set from numpy array')
+        if isinstance(value, NDArrayBase):
+            if value.handle is not self.handle:
+                value.copyto(self)
+        elif isinstance(value, (np.ndarray, np.generic)):
+            self.copyfrom(value)
+        else:
+            raise TypeError('type %s not supported' % str(type(value)))
+
+    def copyfrom(self, source_array):
+        """Perform a synchronized copy from the array.
+
+        Parameters
+        ----------
+        source_array : array_like
+            The data source we should like to copy from.
+
+        Returns
+        -------
+        arr : NDArray
+            Reference to self.
+        """
+        if isinstance(source_array, NDArrayBase):
+            source_array.copyto(self)
+            return self
+
+        if not isinstance(source_array, np.ndarray):
+            try:
+                source_array = np.array(source_array, dtype=self.dtype)
+            except:
+                raise TypeError('array must be an array_like data,' +
+                                'type %s is not supported' % str(type(source_array)))
+        t = DECORDType(self.dtype)
+        shape, dtype = self.shape, self.dtype
+        if t.lanes > 1:
+            shape = shape + (t.lanes,)
+            t.lanes = 1
+            dtype = str(t)
+
+        if source_array.shape != shape:
+            raise ValueError("array shape do not match the shape of NDArray {0} vs {1}".format(
+                source_array.shape, shape))
+        source_array = np.ascontiguousarray(source_array, dtype=dtype)
+        assert source_array.flags['C_CONTIGUOUS']
+        data = source_array.ctypes.data_as(ctypes.c_void_p)
+        nbytes = ctypes.c_size_t(source_array.size * source_array.dtype.itemsize)
+        check_call(_LIB.DECORDArrayCopyFromBytes(self.handle, data, nbytes))
+        return self
+
+    def __repr__(self):
+        res = "<decord.NDArray shape={0}, {1}>\n".format(self.shape, self.context)
+        res += self.asnumpy().__repr__()
+        return res
+
+    def __str__(self):
+        return str(self.asnumpy())
+
+    def asnumpy(self):
+        """Convert this array to numpy array
+
+        Returns
+        -------
+        np_arr : numpy.ndarray
+            The corresponding numpy array.
+        """
+        t = DECORDType(self.dtype)
+        shape, dtype = self.shape, self.dtype
+        if t.lanes > 1:
+            shape = shape + (t.lanes,)
+            t.lanes = 1
+            dtype = str(t)
+        np_arr = np.empty(shape, dtype=dtype)
+        assert np_arr.flags['C_CONTIGUOUS']
+        data = np_arr.ctypes.data_as(ctypes.c_void_p)
+        nbytes = ctypes.c_size_t(np_arr.size * np_arr.dtype.itemsize)
+        check_call(_LIB.DECORDArrayCopyToBytes(self.handle, data, nbytes))
+        return np_arr
+
+    def copyto(self, target):
+        """Copy array to target
+
+        Parameters
+        ----------
+        target : NDArray
+            The target array to be copied, must have same shape as this array.
+        """
+        if isinstance(target, DECORDContext):
+            target = empty(self.shape, self.dtype, target)
+        if isinstance(target, NDArrayBase):
+            check_call(_LIB.DECORDArrayCopyFromTo(
+                self.handle, target.handle, None))
+        else:
+            raise ValueError("Unsupported target type %s" % str(type(target)))
+        return target
+
+
+def free_extension_handle(handle, type_code):
+    """Free c++ extension type handle
+
+    Parameters
+    ----------
+    handle : ctypes.c_void_p
+        The handle to the extension type.
+
+    type_code : int
+         The tyoe code
+    """
+    check_call(_LIB.DECORDExtTypeFree(handle, ctypes.c_int(type_code)))
+
+def register_extension(cls, fcreate=None):
+    """Register a extension class to DECORD.
+
+    After the class is registered, the class will be able
+    to directly pass as Function argument generated by DECORD.
+
+    Parameters
+    ----------
+    cls : class
+        The class object to be registered as extension.
+
+    Note
+    ----
+    The registered class is requires one property: _decord_handle and a class attribute _decord_tcode.
+
+    - ```_decord_handle``` returns integer represents the address of the handle.
+    - ```_decord_tcode``` gives integer represents type code of the class.
+
+    Returns
+    -------
+    cls : class
+        The class being registered.
+
+    fcreate : function, optional
+        The creation function to create a class object given handle value.
+
+    Example
+    -------
+    The following code registers user defined class
+    MyTensor to be DLTensor compatible.
+
+    .. code-block:: python
+
+       @decord.register_extension
+       class MyTensor(object):
+           _decord_tcode = decord.TypeCode.ARRAY_HANDLE
+
+           def __init__(self):
+               self.handle = _LIB.NewDLTensor()
+
+           @property
+           def _decord_handle(self):
+               return self.handle.value
+    """
+    if fcreate and cls._decord_tcode < TypeCode.EXT_BEGIN:
+        raise ValueError("Cannot register create when extension tcode is same as buildin")
+    _reg_extension(cls, fcreate)
+    return cls

parrot/lib/python3.10/site-packages/decord/_ffi/runtime_ctypes.py

@@ -0,0 +1,258 @@
+"""Common runtime ctypes."""
+# pylint: disable=invalid-name, super-init-not-called
+from __future__ import absolute_import
+
+import ctypes
+import json
+import numpy as np
+from .base import _LIB, check_call
+from .. import _api_internal
+
+decord_shape_index_t = ctypes.c_int64
+
+class TypeCode(object):
+    """Type code used in API calls"""
+    INT = 0
+    UINT = 1
+    FLOAT = 2
+    HANDLE = 3
+    NULL = 4
+    DECORD_TYPE = 5
+    DECORD_CONTEXT = 6
+    ARRAY_HANDLE = 7
+    NODE_HANDLE = 8
+    MODULE_HANDLE = 9
+    FUNC_HANDLE = 10
+    STR = 11
+    BYTES = 12
+    NDARRAY_CONTAINER = 13
+    EXT_BEGIN = 15
+
+class DECORDByteArray(ctypes.Structure):
+    """Temp data structure for byte array."""
+    _fields_ = [("data", ctypes.POINTER(ctypes.c_byte)),
+                ("size", ctypes.c_size_t)]
+
+class DECORDType(ctypes.Structure):
+    """DECORD datatype structure"""
+    _fields_ = [("type_code", ctypes.c_uint8),
+                ("bits", ctypes.c_uint8),
+                ("lanes", ctypes.c_uint16)]
+    CODE2STR = {
+        0 : 'int',
+        1 : 'uint',
+        2 : 'float',
+        4 : 'handle'
+    }
+    _cache = {}
+
+    def __new__(cls, type_str):
+        if type_str in cls._cache:
+            return cls._cache[type_str]
+
+        inst = super(DECORDType, cls).__new__(DECORDType)
+
+        if isinstance(type_str, np.dtype):
+            type_str = str(type_str)
+        arr = type_str.split("x")
+        head = arr[0]
+        inst.lanes = int(arr[1]) if len(arr) > 1 else 1
+        bits = 32
+
+        if head.startswith("int"):
+            inst.type_code = 0
+            head = head[3:]
+        elif head.startswith("uint"):
+            inst.type_code = 1
+            head = head[4:]
+        elif head.startswith("float"):
+            inst.type_code = 2
+            head = head[5:]
+        elif head.startswith("handle"):
+            inst.type_code = 4
+            bits = 64
+            head = ""
+        else:
+            raise ValueError("Do not know how to handle type %s" % type_str)
+        bits = int(head) if head else bits
+        inst.bits = bits
+
+        cls._cache[type_str] = inst
+        return inst
+
+    def __init__(self, type_str):
+        pass
+
+    def __repr__(self):
+        x = "%s%d" % (DECORDType.CODE2STR[self.type_code], self.bits)
+        if self.lanes != 1:
+            x += "x%d" % self.lanes
+        return x
+
+    def __eq__(self, other):
+        return (self.bits == other.bits and
+                self.type_code == other.type_code and
+                self.lanes == other.lanes)
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+RPC_SESS_MASK = 128
+
+class DECORDContext(ctypes.Structure):
+    """DECORD context strucure."""
+    _fields_ = [("device_type", ctypes.c_int),
+                ("device_id", ctypes.c_int)]
+    MASK2STR = {
+        1 : 'cpu',
+        2 : 'gpu',
+        4 : 'opencl',
+        5 : 'aocl',
+        6 : 'sdaccel',
+        7 : 'vulkan',
+        8 : 'metal',
+        9 : 'vpi',
+        10: 'rocm',
+        11: 'opengl',
+        12: 'ext_dev',
+    }
+    STR2MASK = {
+        'llvm': 1,
+        'stackvm': 1,
+        'cpu': 1,
+        'gpu': 2,
+        'cuda': 2,
+        'nvptx': 2,
+        'cl': 4,
+        'opencl': 4,
+        'aocl' : 5,
+        'aocl_sw_emu' : 5,
+        'sdaccel': 6,
+        'vulkan': 7,
+        'metal': 8,
+        'vpi': 9,
+        'rocm': 10,
+        'opengl': 11,
+        'ext_dev': 12,
+    }
+    _cache = {}
+
+    def __new__(cls, device_type, device_id):
+        if (device_type, device_id) in cls._cache:
+            return cls._cache[(device_type, device_id)]
+
+        inst = super(DECORDContext, cls).__new__(DECORDContext)
+
+        inst.device_type = device_type
+        inst.device_id = device_id
+
+        cls._cache[(device_type, device_id)] = inst
+        return inst
+
+    def __init__(self, device_type, device_id):
+        pass
+
+    @property
+    def exist(self):
+        """Whether this device exist."""
+        return _api_internal._GetDeviceAttr(
+            self.device_type, self.device_id, 0) != 0
+
+    @property
+    def max_threads_per_block(self):
+        """Maximum number of threads on each block."""
+        return _api_internal._GetDeviceAttr(
+            self.device_type, self.device_id, 1)
+
+    @property
+    def warp_size(self):
+        """Number of threads that executes in concurrent."""
+        return _api_internal._GetDeviceAttr(
+            self.device_type, self.device_id, 2)
+
+    @property
+    def max_shared_memory_per_block(self):
+        """Total amount of shared memory per block in bytes."""
+        return _api_internal._GetDeviceAttr(
+            self.device_type, self.device_id, 3)
+
+    @property
+    def compute_version(self):
+        """Get compute verison number in string.
+
+        Currently used to get compute capability of CUDA device.
+
+        Returns
+        -------
+        version : str
+            The version string in `major.minor` format.
+        """
+        return _api_internal._GetDeviceAttr(
+            self.device_type, self.device_id, 4)
+
+    @property
+    def device_name(self):
+        """Return the string name of device."""
+        return _api_internal._GetDeviceAttr(
+            self.device_type, self.device_id, 5)
+
+    @property
+    def max_clock_rate(self):
+        """Return the max clock frequency of device."""
+        return _api_internal._GetDeviceAttr(
+            self.device_type, self.device_id, 6)
+
+    @property
+    def multi_processor_count(self):
+        """Return the number of compute units of device."""
+        return _api_internal._GetDeviceAttr(
+            self.device_type, self.device_id, 7)
+
+    @property
+    def max_thread_dimensions(self):
+        """Return the maximum size of each thread axis
+
+        Returns
+        -------
+        dims: List of int
+            The maximum length of threadIdx.x, threadIdx.y, threadIdx.z
+        """
+        return json.loads(_api_internal._GetDeviceAttr(
+            self.device_type, self.device_id, 8))
+
+    def sync(self):
+        """Synchronize until jobs finished at the context."""
+        check_call(_LIB.DECORDSynchronize(self.device_type, self.device_id, None))
+
+    def __eq__(self, other):
+        return (isinstance(other, DECORDContext) and
+                self.device_id == other.device_id and
+                self.device_type == other.device_type)
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __repr__(self):
+        if self.device_type >= RPC_SESS_MASK:
+            tbl_id = self.device_type / RPC_SESS_MASK - 1
+            dev_type = self.device_type % RPC_SESS_MASK
+            return "remote[%d]:%s(%d)" % (
+                tbl_id, DECORDContext.MASK2STR[dev_type], self.device_id)
+        return "%s(%d)" % (
+            DECORDContext.MASK2STR[self.device_type], self.device_id)
+
+    def __hash__(self):
+        return hash((self.device_type, self.device_id))
+
+
+class DECORDArray(ctypes.Structure):
+    """DECORDValue in C API"""
+    _fields_ = [("data", ctypes.c_void_p),
+                ("ctx", DECORDContext),
+                ("ndim", ctypes.c_int),
+                ("dtype", DECORDType),
+                ("shape", ctypes.POINTER(decord_shape_index_t)),
+                ("strides", ctypes.POINTER(decord_shape_index_t)),
+                ("byte_offset", ctypes.c_uint64)]
+
+DECORDArrayHandle = ctypes.POINTER(DECORDArray)

parrot/lib/python3.10/site-packages/decord/audio_reader.py

@@ -0,0 +1,182 @@
+"""Audio Reader."""
+from __future__ import absolute_import
+
+import ctypes
+import numpy as np
+import math
+
+from ._ffi.base import c_array, c_str
+from ._ffi.function import _init_api
+from ._ffi.ndarray import DECORDContext
+from .base import DECORDError
+from . import ndarray as _nd
+from .ndarray import cpu, gpu
+from .bridge import bridge_out
+
+AudioReaderHandle = ctypes.c_void_p
+
+class AudioReader(object):
+    """Individual audio reader with convenient indexing function.
+
+    Parameters
+    ----------
+    uri: str
+        Path of file.
+    ctx: decord.Context
+        The context to decode the file, can be decord.cpu() or decord.gpu().
+    sample_rate: int, default is -1
+        Desired output sample rate of the audio, unchanged if `-1` is specified.
+    mono: bool, default is True
+        Desired output channel layout of the audio. 
+        Setting `True` will return the audio as mono layout. 
+        Setting `False` will return the audio channel layout intact.
+
+    """
+
+    def __init__(self, uri, ctx=cpu(0), sample_rate=-1, mono=True):
+        self._handle = None
+        assert isinstance(ctx, DECORDContext)
+        is_mono = 1 if mono else 0
+        if hasattr(uri, 'read'):
+            ba = bytearray(uri.read())
+            uri = '{} bytes'.format(len(ba))
+            self._handle = _CAPI_AudioReaderGetAudioReader(
+                ba, ctx.device_type, ctx.device_id, sample_rate, 2, is_mono)
+        else:
+            self._handle = _CAPI_AudioReaderGetAudioReader(
+                uri, ctx.device_type, ctx.device_id, sample_rate, 0, is_mono)
+        if self._handle is None:
+            raise RuntimeError("Error reading " + uri + "...")
+        self._array = _CAPI_AudioReaderGetNDArray(self._handle)
+        self._array = self._array.asnumpy()
+        self._duration = _CAPI_AudioReaderGetDuration(self._handle)
+        self._num_samples_per_channel = _CAPI_AudioReaderGetNumSamplesPerChannel(self._handle)
+        self._num_channels = _CAPI_AudioReaderGetNumChannels(self._handle)
+        self.sample_rate = sample_rate
+        self._num_padding = None
+
+    def __len__(self):
+        """Get length of the audio. The length refer to the shape's first dimension. In this case,
+        the length is the number of channels.
+        Returns
+        -------
+        int
+            The number of channels in the audio track.
+        """
+        return self.shape[0]
+
+    def __del__(self):
+        if self._handle:
+            _CAPI_AudioReaderFree(self._handle)
+
+    def __getitem__(self, idx):
+        """Get sample at `idx`. idx is the index of resampled audio, unit is sample.
+
+        Parameters
+        ----------
+        idx : int or slice
+            The sample index, can be negative which means it will index backwards,
+            or slice of sample indices.
+
+        Returns
+        -------
+        ndarray
+            Samples of shape CxS,
+            where C is the number of channels, S is the number of samples of the index or slice.
+        """
+        assert self._handle is not None
+        if isinstance(idx, slice):
+            return self.get_batch(range(*idx.indices(self._num_samples_per_channel)))
+        if idx < 0:
+            idx += self._num_samples_per_channel
+        if idx >= self._num_samples_per_channel or idx < 0:
+            raise IndexError("Index: {} out of bound: {}".format(idx, self._num_samples_per_channel))
+        return bridge_out(_nd.array(self._array[:, idx]))
+        
+    def get_batch(self, indices):
+        """Get entire batch of samples.
+
+        Parameters
+        ----------
+        indices : list of integers
+            A list of frame indices. If negative indices detected, the indices will be indexed from backward
+        Returns
+        -------
+        ndarray
+            Samples of shape CxS,
+            where C is the number of channels, S is the number of samples of the slice.
+
+        """
+        assert self._handle is not None
+        indices = self._validate_indices(indices)
+        indices = list(indices)
+        return bridge_out(_nd.array(self._array[:, indices]))
+
+    @property
+    def shape(self):
+        """Get shape of the entire audio samples.
+
+        Returns
+        -------
+        (int, int)
+            The number of channels, and the number of samples in each channel.
+
+        """
+        return (self._num_channels, self._num_samples_per_channel)
+
+    def duration(self):
+        """Get duration of the audio.
+
+        Returns
+        -------
+        double
+            Duration of the audio in secs.
+
+        """
+        return self._duration
+
+    def __get_num_padding(self):
+        """Get number of samples needed to pad the audio to start at time 0."""
+        if self._num_padding is None:
+            self._num_padding = _CAPI_AudioReaderGetNumPaddingSamples(self._handle)
+        return self._num_padding
+
+    def add_padding(self):
+        """Pad the audio samples so that it starts at time 0.
+
+        Returns
+        -------
+        int
+            Number of samples padded
+
+        """
+        self._array = np.pad(self._array, ((0, 0), (self.__get_num_padding(), 0)), 'constant', constant_values=0)
+        self._duration += self.__get_num_padding() * self.sample_rate
+        return self.__get_num_padding()
+
+    def get_info(self):
+        """Log out the basic info about the audio stream."""
+        _CAPI_AudioReaderGetInfo(self._handle)
+
+    def _time_to_sample(self, timestamp):
+        """Convert time in seconds to sample index"""
+        return math.ceil(timestamp * self.sample_rate)
+        
+    def _times_to_samples(self, timestamps):
+        """Convert times in seconds to sample indices"""
+        return [self._time_to_sample(timestamp) for timestamp in timestamps]
+
+    def _validate_indices(self, indices):
+        """Validate int64 integers and convert negative integers to positive by backward search"""
+        assert self._handle is not None
+        indices = np.array(indices, dtype=np.int64)
+        # process negative indices
+        indices[indices < 0] += self._num_samples_per_channel
+        if not (indices >= 0).all():
+            raise IndexError(
+                'Invalid negative indices: {}'.format(indices[indices < 0] + self._num_samples_per_channel))
+        if not (indices < self._num_samples_per_channel).all():
+            raise IndexError('Out of bound indices: {}'.format(indices[indices >= self._num_samples_per_channel]))
+        return indices
+
+_init_api("decord.audio_reader")

parrot/lib/python3.10/site-packages/decord/av_reader.py

@@ -0,0 +1,149 @@
+"""AV Reader."""
+from __future__ import absolute_import
+
+import ctypes
+import numpy as np
+import math
+from .video_reader import VideoReader
+from .audio_reader import AudioReader
+
+from .ndarray import cpu, gpu
+from . import ndarray as _nd
+from .bridge import bridge_out
+
+class AVReader(object):
+    """Individual audio video reader with convenient indexing function.
+
+    Parameters
+    ----------
+    uri: str
+        Path of file.
+    ctx: decord.Context
+        The context to decode the file, can be decord.cpu() or decord.gpu().
+    sample_rate: int, default is -1
+        Desired output sample rate of the audio, unchanged if `-1` is specified.
+    mono: bool, default is True
+        Desired output channel layout of the audio. `True` is mono layout. `False` is unchanged.
+    width : int, default is -1
+        Desired output width of the video, unchanged if `-1` is specified.
+    height : int, default is -1
+        Desired output height of the video, unchanged if `-1` is specified.
+    num_threads : int, default is 0
+        Number of decoding thread, auto if `0` is specified.
+    fault_tol : int, default is -1
+        The threshold of corupted and recovered frames. This is to prevent silent fault
+        tolerance when for example 50% frames of a video cannot be decoded and duplicate
+        frames are returned. You may find the fault tolerant feature sweet in many cases,
+        but not for training models. Say `N = # recovered frames`
+        If `fault_tol` < 0, nothing will happen.
+        If 0 < `fault_tol` < 1.0, if N > `fault_tol * len(video)`, raise `DECORDLimitReachedError`.
+        If 1 < `fault_tol`, if N > `fault_tol`, raise `DECORDLimitReachedError`.
+
+    """
+
+    def __init__(self, uri, ctx=cpu(0), sample_rate=44100, mono=True, width=-1, height=-1, num_threads=0, fault_tol=-1):
+        self.__audio_reader = AudioReader(uri, ctx, sample_rate, mono)
+        self.__audio_reader.add_padding()
+        if hasattr(uri, 'read'):
+            uri.seek(0)
+        self.__video_reader = VideoReader(uri, ctx, width, height, num_threads, fault_tol)
+
+    def __len__(self):
+        """Get length of the video. Note that sometimes FFMPEG reports inaccurate number of frames,
+        we always follow what FFMPEG reports.
+        Returns
+        -------
+        int
+            The number of frames in the video file.
+        """
+        return len(self.__video_reader)
+
+    def __getitem__(self, idx):
+        """Get audio samples and video frame at `idx`.
+
+        Parameters
+        ----------
+        idx : int or slice
+            The frame index, can be negative which means it will index backwards,
+            or slice of frame indices.
+
+        Returns
+        -------
+        (ndarray/list of ndarray, ndarray)
+            First element is samples of shape CxS or a list of length N containing samples of shape CxS,
+            where N is the number of frames, C is the number of channels, 
+            S is the number of samples of the corresponding frame.
+
+            Second element is Frame of shape HxWx3 or batch of image frames with shape NxHxWx3,
+            where N is the length of the slice.
+        """
+        assert self.__video_reader is not None and self.__audio_reader is not None
+        if isinstance(idx, slice):
+            return self.get_batch(range(*idx.indices(len(self.__video_reader))))
+        if idx < 0:
+            idx += len(self.__video_reader)
+        if idx >= len(self.__video_reader) or idx < 0:
+            raise IndexError("Index: {} out of bound: {}".format(idx, len(self.__video_reader)))
+        audio_start_idx, audio_end_idx = self.__video_reader.get_frame_timestamp(idx)
+        audio_start_idx = self.__audio_reader._time_to_sample(audio_start_idx)
+        audio_end_idx = self.__audio_reader._time_to_sample(audio_end_idx)
+        return (self.__audio_reader[audio_start_idx:audio_end_idx], self.__video_reader[idx])
+        
+    def get_batch(self, indices):
+        """Get entire batch of audio samples and video frames.
+
+        Parameters
+        ----------
+        indices : list of integers
+            A list of frame indices. If negative indices detected, the indices will be indexed from backward
+        Returns
+        -------
+        (list of ndarray, ndarray)
+            First element is a list of length N containing samples of shape CxS,
+            where N is the number of frames, C is the number of channels, 
+            S is the number of samples of the corresponding frame.
+
+            Second element is Frame of shape HxWx3 or batch of image frames with shape NxHxWx3,
+            where N is the length of the slice.
+
+        """
+        assert self.__video_reader is not None and self.__audio_reader is not None
+        indices = self._validate_indices(indices)
+        audio_arr = []
+        prev_video_idx = None
+        prev_audio_end_idx = None
+        for idx in list(indices):
+            frame_start_time, frame_end_time = self.__video_reader.get_frame_timestamp(idx)
+            # timestamp and sample conversion could have some error that could cause non-continuous audio
+            # we detect if retrieving continuous frame and make the audio continuous
+            if prev_video_idx and idx == prev_video_idx+1:
+                audio_start_idx = prev_audio_end_idx
+            else:
+                audio_start_idx = self.__audio_reader._time_to_sample(frame_start_time)
+            audio_end_idx = self.__audio_reader._time_to_sample(frame_end_time)
+            audio_arr.append(self.__audio_reader[audio_start_idx:audio_end_idx])
+            prev_video_idx = idx
+            prev_audio_end_idx = audio_end_idx
+        return (audio_arr, self.__video_reader.get_batch(indices))
+
+    def _get_slice(self, sl):
+        audio_arr = np.empty(shape=(self.__audio_reader.shape()[0], 0), dtype='float32')
+        for idx in list(sl):
+            audio_start_idx, audio_end_idx = self.__video_reader.get_frame_timestamp(idx)
+            audio_start_idx = self.__audio_reader._time_to_sample(audio_start_idx)
+            audio_end_idx = self.__audio_reader._time_to_sample(audio_end_idx)
+            audio_arr = np.concatenate((audio_arr, self.__audio_reader[audio_start_idx:audio_end_idx].asnumpy()), axis=1)
+        return (bridge_out(_nd.array(audio_arr)), self.__video_reader.get_batch(sl))
+
+    def _validate_indices(self, indices):
+        """Validate int64 integers and convert negative integers to positive by backward search"""
+        assert self.__video_reader is not None and self.__audio_reader is not None
+        indices = np.array(indices, dtype=np.int64)
+        # process negative indices
+        indices[indices < 0] += len(self.__video_reader)
+        if not (indices >= 0).all():
+            raise IndexError(
+                'Invalid negative indices: {}'.format(indices[indices < 0] + len(self.__video_reader)))
+        if not (indices < len(self.__video_reader)).all():
+            raise IndexError('Out of bound indices: {}'.format(indices[indices >= len(self.__video_reader)]))
+        return indices

parrot/lib/python3.10/site-packages/decord/base.py

@@ -0,0 +1,20 @@
+"""Module for base types and utilities."""
+from __future__ import absolute_import
+
+import warnings
+
+from ._ffi.base import DECORDError  # pylint: disable=unused-import
+from ._ffi.function import _init_internal_api
+
+# A special symbol for selecting all nodes or edges.
+ALL = "__ALL__"
+
+def is_all(arg):
+    """Return true if the argument is a special symbol for all nodes or edges."""
+    return isinstance(arg, str) and arg == ALL
+
+def decord_warning(msg):
+    """Print out warning messages."""
+    warnings.warn(msg)
+
+_init_internal_api()

parrot/lib/python3.10/site-packages/decord/bridge/__init__.py

@@ -0,0 +1,76 @@
+"""Deep Learning Framework bridges."""
+from __future__ import absolute_import
+import threading
+
+from .mxnet import to_mxnet, from_mxnet
+from .torchdl import to_torch, from_torch
+from .tf import to_tensorflow, from_tensorflow
+from .tvm import to_tvm, from_tvm
+
+_BRIDGE_TYPES = {
+    'native': (lambda x: x, lambda x: x),
+    'mxnet': (to_mxnet, from_mxnet),
+    'torch': (to_torch, from_torch),
+    'tensorflow': (to_tensorflow, from_tensorflow),
+    'tvm': (to_tvm, from_tvm),
+}
+
+_CURRENT_BRIDGE = threading.local()
+_CURRENT_BRIDGE.type = 'native'
+_GLOBAL_BRIDGE_TYPE = 'native'  # child threads will derive from the global type but not overwrite
+
+def reset_bridge():
+    _CURRENT_BRIDGE.type = 'native'
+    if threading.current_thread().name == 'MainThread':
+        _GLOBAL_BRIDGE_TYPE = 'native'
+
+def set_bridge(new_bridge):
+    assert isinstance(new_bridge, str), (
+        "New bridge type must be str. Choices: {}".format(_BRIDGE_TYPES.keys()))
+    assert new_bridge in _BRIDGE_TYPES.keys(), (
+        "valid bridges: {}".format(_BRIDGE_TYPES.keys()))
+    global _CURRENT_BRIDGE
+    _CURRENT_BRIDGE.type = new_bridge
+    if threading.current_thread().name == 'MainThread':
+        _GLOBAL_BRIDGE_TYPE = new_bridge
+
+def bridge_out(native_arr):
+    if not hasattr(_CURRENT_BRIDGE, 'type'):
+        _CURRENT_BRIDGE.type = _GLOBAL_BRIDGE_TYPE
+    return _BRIDGE_TYPES[_CURRENT_BRIDGE.type][0](native_arr)
+
+def bridge_in(arr):
+    if not hasattr(_CURRENT_BRIDGE, 'type'):
+        _CURRENT_BRIDGE.type = _GLOBAL_BRIDGE_TYPE
+    return _BRIDGE_TYPES[_CURRENT_BRIDGE.type][1](arr)
+
+class _BridgeScope(object):
+    def __init__(self, bridge_type='native'):
+        self._type = bridge_type
+        self._prev = None
+
+    def __enter__(self):
+        global _CURRENT_BRIDGE
+        if not hasattr(_CURRENT_BRIDGE, 'type'):
+            _CURRENT_BRIDGE.type = _GLOBAL_BRIDGE_TYPE
+        try:
+            self._prev = _CURRENT_BRIDGE.type
+        except AttributeError:
+            self._prev = 'native'
+        set_bridge(self._type)
+
+    def __exit__(self, type, value, traceback):
+        if self._prev != self._type:
+            set_bridge(self._prev)
+
+def use_mxnet():
+    return _BridgeScope('mxnet')
+
+def use_torch():
+    return _BridgeScope('torch')
+
+def use_tensorflow():
+    return _BridgeScope('tensorflow')
+
+def use_tvm():
+    return _BridgeScope('tvm')

parrot/lib/python3.10/site-packages/decord/bridge/mxnet.py

@@ -0,0 +1,25 @@
+"""DECORD MXNet bridge"""
+from __future__ import absolute_import
+
+from .._ffi._ctypes.ndarray import _from_dlpack
+from .utils import try_import
+
+def try_import_mxnet():
+    """Try import mxnet at runtime.
+
+    Returns
+    -------
+    mxnet module if found. Raise ImportError otherwise
+    """
+    msg = "mxnet is required, you can install by pip.\n \
+        CPU: `pip install mxnet-mkl`, GPU: `pip install mxnet-cu100mkl`"
+    return try_import('mxnet', msg)
+
+def to_mxnet(decord_arr):
+    """from decord to mxnet, no copy"""
+    mx = try_import_mxnet()
+    return mx.nd.from_dlpack(decord_arr.to_dlpack())
+
+def from_mxnet(mxnet_arr):
+    """from mxnet to decord, no copy"""
+    return _from_dlpack(mxnet_arr.to_dlpack_for_read())

parrot/lib/python3.10/site-packages/decord/bridge/tf.py

@@ -0,0 +1,30 @@
+"""DECORD tensorflow bridge"""
+from __future__ import absolute_import
+
+from .._ffi._ctypes.ndarray import _from_dlpack
+
+def try_import_tfdl():
+    """Try to import tensorflow dlpack at runtime.
+
+    Returns
+    -------
+    tensorflow dlpack module if found. Raise ImportError otherwise
+    """
+    try:
+        return __import__('tensorflow.experimental.dlpack', fromlist=[''])
+    except ImportError as e:
+        raise ImportError("tensorflow >= 2.2.0 is required.")
+
+def to_tensorflow(decord_arr):
+    """from decord to tensorflow, no copy"""
+    tfdl = try_import_tfdl()
+    from tensorflow.python import pywrap_tfe
+    from tensorflow.python.eager import context
+    ctx = context.context()
+    ctx.ensure_initialized()
+    return pywrap_tfe.TFE_FromDlpackCapsule(decord_arr.to_dlpack(), ctx._handle)
+
+def from_tensorflow(tf_tensor):
+    """from tensorflow to decord, no copy"""
+    tfdl = try_import_tfdl()
+    return _from_dlpack(tfdl.to_dlpack(tf_tensor))

parrot/lib/python3.10/site-packages/decord/bridge/torchdl.py

@@ -0,0 +1,33 @@
+"""DECORD Pytorch bridge"""
+from __future__ import absolute_import
+
+from .._ffi._ctypes.ndarray import _from_dlpack
+
+def try_import_torch():
+    """Try import torch at runtime.
+
+    Returns
+    -------
+    torch module if found. Raise ImportError otherwise
+    """
+    message = "torch is required, you can install by pip: `pip install torch`"
+    try:
+        return __import__('torch.utils.dlpack', fromlist=['object'])
+    except ImportError as e:
+        if not message:
+            raise e
+        raise ImportError(message)
+
+def to_torch(decord_arr):
+    """From decord to torch.
+    The tensor will share the memory with the object represented in the dlpack.
+    Note that each dlpack can only be consumed once."""
+    dlpack = try_import_torch()
+    return dlpack.from_dlpack(decord_arr.to_dlpack())
+
+def from_torch(tensor):
+    """From torch to decord.
+    The dlpack shares the tensors memory.
+    Note that each dlpack can only be consumed once."""
+    dlpack = try_import_torch()
+    return _from_dlpack(dlpack.to_dlpack(tensor))

parrot/lib/python3.10/site-packages/decord/bridge/tvm.py

@@ -0,0 +1,25 @@
+"""DECORD TVM bridge"""
+from __future__ import absolute_import
+
+from .._ffi._ctypes.ndarray import _from_dlpack
+from .utils import try_import
+
+def try_import_tvm():
+    """Try import tvm at runtime.
+
+    Returns
+    -------
+    tvm module if found. Raise ImportError otherwise
+    """
+    msg = "tvm is required, for installation guide, please checkout:\n \
+        https://tvm.apache.org/docs/install/index.html"
+    return try_import('tvm', msg)
+
+def to_tvm(decord_arr):
+    """from decord to tvm, no copy"""
+    tvm = try_import_tvm()
+    return tvm.nd.from_dlpack(decord_arr.to_dlpack())
+
+def from_tvm(tvm_arr):
+    """from tvm to decord, no copy"""
+    return _from_dlpack(tvm_arr.to_dlpack())

parrot/lib/python3.10/site-packages/decord/bridge/utils.py

@@ -0,0 +1,21 @@
+"""Bridge utils."""
+from __future__ import absolute_import
+
+def try_import(package, message=None):
+    """Try import specified package, with custom message support.
+    Parameters
+    ----------
+    package : str
+        The name of the targeting package.
+    message : str, default is None
+        If not None, this function will raise customized error message when import error is found.
+    Returns
+    -------
+    module if found, raise ImportError otherwise
+    """
+    try:
+        return __import__(package)
+    except ImportError as e:
+        if not message:
+            raise e
+        raise ImportError(message)

parrot/lib/python3.10/site-packages/decord/data/base_action.py

@@ -0,0 +1,346 @@
+"""Customized dataloader for general video classification tasks.
+Code adapted from https://github.com/dmlc/gluon-cv"""
+import os
+from ..bridge import use_mxnet
+from ..bridge.mxnet import try_import_mxnet
+from ..video_reader import VideoReader
+from ..ndarray import cpu, gpu
+
+try_import_mxnet()
+from mxnet import numpy as np
+from mxnet.util import use_np
+
+__all__ = ['VideoClsCustom']
+
+
+@use_np
+class VideoClsCustom(object):
+    """Load your own video classification dataset.
+
+    Parameters
+    ----------
+    root : str, required.
+        Path to the root folder storing the dataset.
+    setting : str, required.
+        A text file describing the dataset, each line per video sample.
+        There are three items in each line: (1) video path; (2) video length and (3) video label.
+    train : bool, default True.
+        Whether to load the training or validation set.
+    test_mode : bool, default False.
+        Whether to perform evaluation on the test set.
+        Usually there is three-crop or ten-crop evaluation strategy involved.
+    name_pattern : str, default None.
+        The naming pattern of the decoded video frames.
+        For example, img_00012.jpg.
+    video_ext : str, default 'mp4'.
+        Please specify the video format accordinly.
+    is_color : bool, default True.
+        Whether the loaded image is color or grayscale.
+    modality : str, default 'rgb'.
+        Input modalities, we support only rgb video frames for now.
+        Will add support for rgb difference image and optical flow image later.
+    num_segments : int, default 1.
+        Number of segments to evenly divide the video into clips.
+        A useful technique to obtain global video-level information.
+        Limin Wang, etal, Temporal Segment Networks: Towards Good Practices for Deep Action Recognition, ECCV 2016.
+    num_crop : int, default 1.
+        Number of crops for each image. default is 1.
+        Common choices are three crops and ten crops during evaluation.
+    new_length : int, default 1.
+        The length of input video clip. Default is a single image, but it can be multiple video frames.
+        For example, new_length=16 means we will extract a video clip of consecutive 16 frames.
+    new_step : int, default 1.
+        Temporal sampling rate. For example, new_step=1 means we will extract a video clip of consecutive frames.
+        new_step=2 means we will extract a video clip of every other frame.
+    new_width : int, default 340.
+        Scale the width of loaded image to 'new_width' for later multiscale cropping and resizing.
+    new_height : int, default 256.
+        Scale the height of loaded image to 'new_height' for later multiscale cropping and resizing.
+    target_width : int, default 224.
+        Scale the width of transformed image to the same 'target_width' for batch forwarding.
+    target_height : int, default 224.
+        Scale the height of transformed image to the same 'target_height' for batch forwarding.
+    temporal_jitter : bool, default False.
+        Whether to temporally jitter if new_step > 1.
+    transform : function, default None.
+        A function that takes data and label and transforms them.
+    slowfast : bool, default False.
+        If set to True, use data loader designed for SlowFast network.
+        Christoph Feichtenhofer, etal, SlowFast Networks for Video Recognition, ICCV 2019.
+    slow_temporal_stride : int, default 16.
+        The temporal stride for sparse sampling of video frames in slow branch of a SlowFast network.
+    fast_temporal_stride : int, default 2.
+        The temporal stride for sparse sampling of video frames in fast branch of a SlowFast network.
+    lazy_init : bool, default False.
+        If set to True, build a dataset instance without loading any dataset.
+    ctx : decord.Context, default is cpu(0)
+        Set the context used to load the video. Can be cpu() or gpu(xx)
+    """
+    def __init__(self,
+                 root,
+                 setting,
+                 train=True,
+                 test_mode=False,
+                 name_pattern='img_%05d.jpg',
+                 video_ext='mp4',
+                 is_color=True,
+                 modality='rgb',
+                 num_segments=1,
+                 num_crop=1,
+                 new_length=1,
+                 new_step=1,
+                 new_width=340,
+                 new_height=256,
+                 target_width=224,
+                 target_height=224,
+                 temporal_jitter=False,
+                 slowfast=False,
+                 slow_temporal_stride=16,
+                 fast_temporal_stride=2,
+                 lazy_init=False,
+                 transform=None,
+                 ctx=cpu(0)):
+        super(VideoClsCustom, self).__init__()
+        self.root = root
+        self.setting = setting
+        self.train = train
+        self.test_mode = test_mode
+        self.is_color = is_color
+        self.modality = modality
+        self.num_segments = num_segments
+        self.num_crop = num_crop
+        self.new_height = new_height
+        self.new_width = new_width
+        self.new_length = new_length
+        self.new_step = new_step
+        self.skip_length = self.new_length * self.new_step
+        self.target_height = target_height
+        self.target_width = target_width
+        self.transform = transform
+        self.temporal_jitter = temporal_jitter
+        self.name_pattern = name_pattern
+        self.video_ext = video_ext
+        self.slowfast = slowfast
+        self.slow_temporal_stride = slow_temporal_stride
+        self.fast_temporal_stride = fast_temporal_stride
+        self.lazy_init = lazy_init
+        self.ctx = ctx
+
+        if self.slowfast:
+            assert slow_temporal_stride % fast_temporal_stride == 0, 'slow_temporal_stride needs to be multiples of slow_temporal_stride, please set it accordinly.'
+            assert not temporal_jitter, 'Slowfast dataloader does not support temporal jitter. Please set temporal_jitter=False.'
+            assert new_step == 1, 'Slowfast dataloader only support consecutive frames reading, please set new_step=1.'
+
+        if not self.lazy_init:
+            self.clips = self._make_dataset(root, setting)
+            if len(self.clips) == 0:
+                raise(RuntimeError("Found 0 video clips in subfolders of: " + root + "\n"
+                                   "Check your data directory (opt.data-dir)."))
+
+    def __getitem__(self, index):
+        if isinstance(index, tuple):
+            index, ctx = index
+        else:
+            ctx = None
+        directory, duration, target = self.clips[index]
+        if '.' in directory.split('/')[-1]:
+            # data in the "setting" file already have extension, e.g., demo.mp4
+            video_name = directory
+        else:
+            # data in the "setting" file do not have extension, e.g., demo
+            # So we need to provide extension (i.e., .mp4) to complete the file name.
+            video_name = '{}.{}'.format(directory, self.video_ext)
+        decord_vr = VideoReader(video_name, width=self.new_width, height=self.new_height, ctx=self.ctx if ctx is None else ctx)
+        duration = len(decord_vr)
+
+        if self.train and not self.test_mode:
+            segment_indices, skip_offsets = self._sample_train_indices(duration)
+        elif not self.train and not self.test_mode:
+            segment_indices, skip_offsets = self._sample_val_indices(duration)
+        else:
+            segment_indices, skip_offsets = self._sample_test_indices(duration)
+
+        # N frames of shape H x W x C, where N = num_oversample * num_segments * new_length
+        if self.slowfast:
+            clip_input = self._video_TSN_decord_slowfast_loader(directory, decord_vr, duration, segment_indices, skip_offsets)
+        else:
+            clip_input = self._video_TSN_decord_batch_loader(directory, decord_vr, duration, segment_indices, skip_offsets)
+
+        if self.transform is not None:
+            clip_input = self.transform(clip_input)
+
+        if self.slowfast:
+            sparse_sampels = len(clip_input) // (self.num_segments * self.num_crop)
+            clip_input = np.stack(clip_input, axis=0)
+            clip_input = clip_input.reshape((-1,) + (sparse_sampels, 3, self.target_height, self.target_width))
+            clip_input = np.transpose(clip_input, (0, 2, 1, 3, 4))
+        else:
+            clip_input = np.stack(clip_input, axis=0)
+            clip_input = clip_input.reshape((-1,) + (self.new_length, 3, self.target_height, self.target_width))
+            clip_input = np.transpose(clip_input, (0, 2, 1, 3, 4))
+
+        if self.new_length == 1:
+            clip_input = np.squeeze(clip_input, axis=2)    # this is for 2D input case
+
+        return clip_input.as_nd_ndarray(), target
+
+    def __len__(self):
+        return len(self.clips)
+
+    def _find_classes(self, directory):
+        classes = [d for d in os.listdir(directory) if os.path.isdir(os.path.join(directory, d))]
+        classes.sort()
+        class_to_idx = {classes[i]: i for i in range(len(classes))}
+        return classes, class_to_idx
+
+    def _make_dataset(self, directory, setting):
+        if not os.path.exists(setting):
+            raise(RuntimeError("Setting file %s doesn't exist. Check opt.train-list and opt.val-list. " % (setting)))
+        clips = []
+        with open(setting) as split_f:
+            data = split_f.readlines()
+            for line in data:
+                line_info = line.split()
+                # line format: video_path, video_duration, video_label
+                if len(line_info) < 3:
+                    raise(RuntimeError('Video input format is not correct, missing one or more element. %s' % line))
+                clip_path = os.path.join(directory, line_info[0])
+                duration = int(line_info[1])
+                target = int(line_info[2])
+                item = (clip_path, duration, target)
+                clips.append(item)
+        return clips
+
+    def _sample_train_indices(self, num_frames):
+        average_duration = (num_frames - self.skip_length + 1) // self.num_segments
+        if average_duration > 0:
+            offsets = np.multiply(np.array(list(range(self.num_segments))),
+                                  average_duration)
+            offsets = offsets + np.random.randint(average_duration,
+                                                  size=self.num_segments)
+        elif num_frames > max(self.num_segments, self.skip_length):
+            offsets = np.sort(np.random.randint(
+                num_frames - self.skip_length + 1,
+                size=self.num_segments))
+        else:
+            offsets = np.zeros((self.num_segments,))
+
+        if self.temporal_jitter:
+            skip_offsets = np.random.randint(
+                self.new_step, size=self.skip_length // self.new_step)
+        else:
+            skip_offsets = np.zeros(
+                self.skip_length // self.new_step, dtype=int)
+        return offsets + 1, skip_offsets
+
+    def _sample_val_indices(self, num_frames):
+        if num_frames > self.num_segments + self.skip_length - 1:
+            tick = (num_frames - self.skip_length + 1) / \
+                float(self.num_segments)
+            offsets = np.array([int(tick / 2.0 + tick * x)
+                                for x in range(self.num_segments)])
+        else:
+            offsets = np.zeros((self.num_segments,))
+
+        if self.temporal_jitter:
+            skip_offsets = np.random.randint(
+                self.new_step, size=self.skip_length // self.new_step)
+        else:
+            skip_offsets = np.zeros(
+                self.skip_length // self.new_step, dtype=int)
+        return offsets + 1, skip_offsets
+
+    def _sample_test_indices(self, num_frames):
+        if num_frames > self.skip_length - 1:
+            tick = (num_frames - self.skip_length + 1) / \
+                float(self.num_segments)
+            offsets = np.array([int(tick / 2.0 + tick * x)
+                                for x in range(self.num_segments)])
+        else:
+            offsets = np.zeros((self.num_segments,))
+
+        if self.temporal_jitter:
+            skip_offsets = np.random.randint(
+                self.new_step, size=self.skip_length // self.new_step)
+        else:
+            skip_offsets = np.zeros(
+                self.skip_length // self.new_step, dtype=int)
+        return offsets + 1, skip_offsets
+
+    def _video_TSN_decord_loader(self, directory, video_reader, duration, indices, skip_offsets):
+        sampled_list = []
+        for seg_ind in indices:
+            offset = int(seg_ind)
+            for i, _ in enumerate(range(0, self.skip_length, self.new_step)):
+                try:
+                    if offset + skip_offsets[i] <= duration:
+                        with use_mxnet():
+                            vid_frame = video_reader[offset + skip_offsets[i] - 1].as_np_ndarray()
+                    else:
+                        with use_mxnet():
+                            vid_frame = video_reader[offset - 1].as_np_ndarray()
+                except KeyboardInterrupt:
+                    raise
+                except:
+                    raise RuntimeError('Error occured in reading frames from video {} of duration {}.'.format(directory, duration))
+                sampled_list.append(vid_frame)
+                if offset + self.new_step < duration:
+                    offset += self.new_step
+        return sampled_list
+
+    def _video_TSN_decord_batch_loader(self, directory, video_reader, duration, indices, skip_offsets):
+        sampled_list = []
+        frame_id_list = []
+        for seg_ind in indices:
+            offset = int(seg_ind)
+            for i, _ in enumerate(range(0, self.skip_length, self.new_step)):
+                if offset + skip_offsets[i] <= duration:
+                    frame_id = offset + skip_offsets[i] - 1
+                else:
+                    frame_id = offset - 1
+                frame_id_list.append(frame_id)
+                if offset + self.new_step < duration:
+                    offset += self.new_step
+        try:
+            with use_mxnet():
+                video_data = video_reader.get_batch(frame_id_list).as_np_ndarray()
+            sampled_list = [video_data[vid, :, :, :] for vid, _ in enumerate(frame_id_list)]
+        except KeyboardInterrupt:
+            raise
+        except:
+            raise RuntimeError('Error occured in reading frames {} from video {} of duration {}.'.format(frame_id_list, directory, duration))
+        return sampled_list
+
+    def _video_TSN_decord_slowfast_loader(self, directory, video_reader, duration, indices, skip_offsets):
+        sampled_list = []
+        frame_id_list = []
+        for seg_ind in indices:
+            fast_id_list = []
+            slow_id_list = []
+            offset = int(seg_ind)
+            for i, _ in enumerate(range(0, self.skip_length, self.new_step)):
+                if offset + skip_offsets[i] <= duration:
+                    frame_id = offset + skip_offsets[i] - 1
+                else:
+                    frame_id = offset - 1
+
+                if (i + 1) % self.fast_temporal_stride == 0:
+                    fast_id_list.append(frame_id)
+
+                    if (i + 1) % self.slow_temporal_stride == 0:
+                        slow_id_list.append(frame_id)
+
+                if offset + self.new_step < duration:
+                    offset += self.new_step
+
+            fast_id_list.extend(slow_id_list)
+            frame_id_list.extend(fast_id_list)
+        try:
+            with use_mxnet():
+                video_data = video_reader.get_batch(frame_id_list).as_np_ndarray()
+            sampled_list = [video_data[vid, :, :, :] for vid, _ in enumerate(frame_id_list)]
+        except KeyboardInterrupt:
+            raise
+        except:
+            raise RuntimeError('Error occured in reading frames {} from video {} of duration {}.'.format(frame_id_list, directory, duration))
+        return sampled_list

parrot/lib/python3.10/site-packages/decord/logging.py

@@ -0,0 +1,23 @@
+"""DECORD logging module.
+
+You can adjust the logging level for ffmpeg.
+"""
+from ._ffi.function import _init_api
+
+QUIET = -8
+PANIC = 0
+FATAL = 8
+ERROR = 16
+WARNING = 24
+INFO = 32
+VERBOSE = 40
+DEBUG = 48
+TRACE = 56
+
+# Mimicking stdlib.
+CRITICAL = FATAL
+
+def set_level(lvl=ERROR):
+    _CAPI_SetLoggingLevel(lvl)
+
+_init_api("decord.logging")

parrot/lib/python3.10/site-packages/decord/ndarray.py

@@ -0,0 +1,90 @@
+"""DECORD Runtime NDArray API.
+
+decord.ndarray provides a minimum runtime array structure to be
+used with C++ library.
+"""
+# pylint: disable=invalid-name,unused-import
+from __future__ import absolute_import as _abs
+
+import ctypes
+import functools
+import operator
+import numpy as _np
+
+from ._ffi.ndarray import DECORDContext, DECORDType, NDArrayBase
+from ._ffi.ndarray import context, empty, from_dlpack, numpyasarray
+from ._ffi.ndarray import _set_class_ndarray
+
+class NDArray(NDArrayBase):
+    """Lightweight NDArray class for DECORD framework."""
+    def __len__(self):
+        return functools.reduce(operator.mul, self.shape, 1)
+
+def cpu(dev_id=0):
+    """Construct a CPU device
+
+    Parameters
+    ----------
+    dev_id : int, optional
+        The integer device id
+
+    Returns
+    -------
+    ctx : DECORDContext
+        The created context
+    """
+    return DECORDContext(1, dev_id)
+
+def gpu(dev_id=0):
+    """Construct a CPU device
+
+    Parameters
+    ----------
+    dev_id : int, optional
+        The integer device id
+
+    Returns
+    -------
+    ctx : DECORDContext
+        The created context
+    """
+    return DECORDContext(2, dev_id)
+
+def array(arr, ctx=cpu(0)):
+    """Create an array from source arr.
+
+    Parameters
+    ----------
+    arr : numpy.ndarray
+        The array to be copied from
+
+    ctx : DECORDContext, optional
+        The device context to create the array
+
+    Returns
+    -------
+    ret : NDArray
+        The created array
+    """
+    if not isinstance(arr, (_np.ndarray, NDArray)):
+        arr = _np.array(arr)
+    return empty(arr.shape, arr.dtype, ctx).copyfrom(arr)
+
+def zerocopy_from_numpy(np_data):
+    """Create an array that shares the given numpy data.
+
+    Parameters
+    ----------
+    np_data : numpy.ndarray
+        The numpy data
+
+    Returns
+    -------
+    NDArray
+        The array
+    """
+    arr, _ = numpyasarray(np_data)
+    handle = ctypes.pointer(arr)
+    return NDArray(handle, is_view=True)
+
+_set_class_ndarray(NDArray)

parrot/lib/python3.10/site-packages/decord/video_loader.py

@@ -0,0 +1,121 @@
+"""Video Loader."""
+from __future__ import absolute_import
+
+import ctypes
+import numpy as np
+
+from ._ffi.base import c_array, c_str
+from ._ffi.function import _init_api
+from .base import DECORDError
+from . import ndarray as _nd
+from .ndarray import DECORDContext
+from .bridge import bridge_out
+
+VideoLoaderHandle = ctypes.c_void_p
+
+
+class VideoLoader(object):
+    """Multiple video loader with advanced shuffling and batching methods.
+
+    Parameters
+    ----------
+    uris : list of str
+        List of video paths.
+    ctx : decord.Context or list of Context
+        The context to decode the video file, can be decord.cpu() or decord.gpu().
+        If ctx is a list, videos will be evenly split over many ctxs.
+    shape : tuple
+        Returned shape of the batch images, e.g., (2, 320, 240, 3) as (Batch, H, W, 3)
+    interval : int
+        Intra-batch frame interval.
+    skip : int
+        Inter-batch frame interval.
+    shuffle : int
+        Shuffling strategy. Can be
+        `0`:  all sequential, no seeking, following initial filename order
+        `1`:  random filename order, no random access for each video, very efficient
+        `2`:  random order
+        `3`:  random frame access in each video only.
+
+    """
+    def __init__(self, uris, ctx, shape, interval, skip, shuffle, prefetch=0):
+        self._handle = None
+        assert isinstance(uris, (list, tuple))
+        assert (len(uris) > 0)
+        uri = ','.join([x.strip() for x in uris])
+        if isinstance(ctx, DECORDContext):
+            ctx = [ctx]
+        for _ctx in ctx:
+            assert isinstance(_ctx, DECORDContext)
+        device_types = _nd.array([x.device_type for x in ctx])
+        device_ids = _nd.array([x.device_id for x in ctx])
+        assert isinstance(shape, (list, tuple))
+        assert len(shape) == 4, "expected shape: [bs, height, width, 3], given {}".format(shape)
+        self._handle = _CAPI_VideoLoaderGetVideoLoader(
+            uri, device_types, device_ids, shape[0], shape[1], shape[2], shape[3], interval, skip, shuffle, prefetch)
+        assert self._handle is not None
+        self._len = _CAPI_VideoLoaderLength(self._handle)
+        self._curr = 0
+
+    def __del__(self):
+        if self._handle:
+            _CAPI_VideoLoaderFree(self._handle)
+
+    def __len__(self):
+        """Get number of batches in each epoch.
+
+        Returns
+        -------
+        int
+            number of batches in each epoch.
+
+        """
+        return self._len
+
+    def reset(self):
+        """Reset loader for next epoch.
+
+        """
+        assert self._handle is not None
+        self._curr = 0
+        _CAPI_VideoLoaderReset(self._handle)
+
+    def __next__(self):
+        """Get the next batch.
+
+        Returns
+        -------
+        ndarray, ndarray
+            Frame data and corresponding indices in videos.
+            Indices are [(n0, k0), (n1, k1)...] where n0 is the index of video, k0 is the index
+            of frame in video n0.
+
+        """
+        assert self._handle is not None
+        # avoid calling CAPI HasNext
+        if self._curr >= self._len:
+            raise StopIteration
+        _CAPI_VideoLoaderNext(self._handle)
+        data = _CAPI_VideoLoaderNextData(self._handle)
+        indices = _CAPI_VideoLoaderNextIndices(self._handle)
+        self._curr += 1
+        return bridge_out(data), bridge_out(indices)
+
+    def next(self):
+        """Alias of __next__ for python2.
+
+        """
+        return self.__next__()
+
+    def __iter__(self):
+        assert self._handle is not None
+        # if (self._curr >= self._len):
+        #     self.reset()
+        # else:
+        #     err_msg = "Call __iter__ of VideoLoader during previous iteration is forbidden. \
+        #         Consider using cached iterator by 'vl = iter(video_loader)' and reuse it."
+        #     raise RuntimeError(err_msg)
+        return self
+
+
+_init_api("decord.video_loader")

parrot/lib/python3.10/site-packages/decord/video_reader.py

@@ -0,0 +1,251 @@
+"""Video Reader."""
+from __future__ import absolute_import
+
+import ctypes
+import numpy as np
+
+from ._ffi.base import c_array, c_str
+from ._ffi.function import _init_api
+from ._ffi.ndarray import DECORDContext
+from .base import DECORDError
+from . import ndarray as _nd
+from .ndarray import cpu, gpu
+from .bridge import bridge_out
+
+VideoReaderHandle = ctypes.c_void_p
+
+
+class VideoReader(object):
+    """Individual video reader with convenient indexing and seeking functions.
+
+    Parameters
+    ----------
+    uri : str
+        Path of video file.
+    ctx : decord.Context
+        The context to decode the video file, can be decord.cpu() or decord.gpu().
+    width : int, default is -1
+        Desired output width of the video, unchanged if `-1` is specified.
+    height : int, default is -1
+        Desired output height of the video, unchanged if `-1` is specified.
+    num_threads : int, default is 0
+        Number of decoding thread, auto if `0` is specified.
+    fault_tol : int, default is -1
+        The threshold of corupted and recovered frames. This is to prevent silent fault
+        tolerance when for example 50% frames of a video cannot be decoded and duplicate
+        frames are returned. You may find the fault tolerant feature sweet in many cases,
+        but not for training models. Say `N = # recovered frames`
+        If `fault_tol` < 0, nothing will happen.
+        If 0 < `fault_tol` < 1.0, if N > `fault_tol * len(video)`, raise `DECORDLimitReachedError`.
+        If 1 < `fault_tol`, if N > `fault_tol`, raise `DECORDLimitReachedError`.
+
+
+    """
+    def __init__(self, uri, ctx=cpu(0), width=-1, height=-1, num_threads=0, fault_tol=-1):
+        self._handle = None
+        assert isinstance(ctx, DECORDContext)
+        fault_tol = str(fault_tol)
+        if hasattr(uri, 'read'):
+            ba = bytearray(uri.read())
+            uri = '{} bytes'.format(len(ba))
+            self._handle = _CAPI_VideoReaderGetVideoReader(
+                ba, ctx.device_type, ctx.device_id, width, height, num_threads, 2, fault_tol)
+        else:
+            self._handle = _CAPI_VideoReaderGetVideoReader(
+                uri, ctx.device_type, ctx.device_id, width, height, num_threads, 0, fault_tol)
+        if self._handle is None:
+            raise RuntimeError("Error reading " + uri + "...")
+        self._num_frame = _CAPI_VideoReaderGetFrameCount(self._handle)
+        assert self._num_frame > 0, "Invalid frame count: {}".format(self._num_frame)
+        self._key_indices = None
+        self._frame_pts = None
+        self._avg_fps = None
+
+    def __del__(self):
+        try:
+            if self._handle is not None:
+                _CAPI_VideoReaderFree(self._handle)
+        except TypeError:
+            pass
+
+    def __len__(self):
+        """Get length of the video. Note that sometimes FFMPEG reports inaccurate number of frames,
+        we always follow what FFMPEG reports.
+
+        Returns
+        -------
+        int
+            The number of frames in the video file.
+
+        """
+        return self._num_frame
+
+    def __getitem__(self, idx):
+        """Get frame at `idx`.
+
+        Parameters
+        ----------
+        idx : int or slice
+            The frame index, can be negative which means it will index backwards,
+            or slice of frame indices.
+
+        Returns
+        -------
+        ndarray
+            Frame of shape HxWx3 or batch of image frames with shape NxHxWx3,
+            where N is the length of the slice.
+        """
+        if isinstance(idx, slice):
+            return self.get_batch(range(*idx.indices(len(self))))
+        if idx < 0:
+            idx += self._num_frame
+        if idx >= self._num_frame or idx < 0:
+            raise IndexError("Index: {} out of bound: {}".format(idx, self._num_frame))
+        self.seek_accurate(idx)
+        return self.next()
+
+    def next(self):
+        """Grab the next frame.
+
+        Returns
+        -------
+        ndarray
+            Frame with shape HxWx3.
+
+        """
+        assert self._handle is not None
+        arr = _CAPI_VideoReaderNextFrame(self._handle)
+        if not arr.shape:
+            raise StopIteration()
+        return bridge_out(arr)
+
+    def _validate_indices(self, indices):
+        """Validate int64 integers and convert negative integers to positive by backward search"""
+        assert self._handle is not None
+        indices = np.array(indices, dtype=np.int64)
+        # process negative indices
+        indices[indices < 0] += self._num_frame
+        if not (indices >= 0).all():
+            raise IndexError(
+                'Invalid negative indices: {}'.format(indices[indices < 0] + self._num_frame))
+        if not (indices < self._num_frame).all():
+            raise IndexError('Out of bound indices: {}'.format(indices[indices >= self._num_frame]))
+        return indices
+
+    def get_frame_timestamp(self, idx):
+        """Get frame playback timestamp in unit(second).
+
+        Parameters
+        ----------
+        indices: list of integers or slice
+            A list of frame indices. If negative indices detected, the indices will be indexed from backward.
+
+        Returns
+        -------
+        numpy.ndarray
+            numpy.ndarray of shape (N, 2), where N is the size of indices. The format is `(start_second, end_second)`.
+        """
+        assert self._handle is not None
+        if isinstance(idx, slice):
+            idx = self.get_batch(range(*idx.indices(len(self))))
+        idx = self._validate_indices(idx)
+        if self._frame_pts is None:
+            self._frame_pts = _CAPI_VideoReaderGetFramePTS(self._handle).asnumpy()
+        return self._frame_pts[idx, :]
+
+
+    def get_batch(self, indices):
+        """Get entire batch of images. `get_batch` is optimized to handle seeking internally.
+        Duplicate frame indices will be optmized by copying existing frames rather than decode
+        from video again.
+
+        Parameters
+        ----------
+        indices : list of integers
+            A list of frame indices. If negative indices detected, the indices will be indexed from backward
+
+        Returns
+        -------
+        ndarray
+            An entire batch of image frames with shape NxHxWx3, where N is the length of `indices`.
+
+        """
+        assert self._handle is not None
+        indices = _nd.array(self._validate_indices(indices))
+        arr = _CAPI_VideoReaderGetBatch(self._handle, indices)
+        return bridge_out(arr)
+
+    def get_key_indices(self):
+        """Get list of key frame indices.
+
+        Returns
+        -------
+        list
+            List of key frame indices.
+
+        """
+        if self._key_indices is None:
+            self._key_indices = _CAPI_VideoReaderGetKeyIndices(self._handle).asnumpy().tolist()
+        return self._key_indices
+
+    def get_avg_fps(self):
+        """Get average FPS(frame per second).
+
+        Returns
+        -------
+        float
+            Average FPS.
+
+        """
+        if self._avg_fps is None:
+            self._avg_fps = _CAPI_VideoReaderGetAverageFPS(self._handle)
+        return self._avg_fps
+
+    def seek(self, pos):
+        """Fast seek to frame position, this does not guarantee accurate position.
+        To obtain accurate seeking, see `accurate_seek`.
+
+        Parameters
+        ----------
+        pos : integer
+            Non negative seeking position.
+
+        """
+        assert self._handle is not None
+        assert pos >= 0 and pos < self._num_frame
+        success = _CAPI_VideoReaderSeek(self._handle, pos)
+        if not success:
+            raise RuntimeError("Failed to seek to frame {}".format(pos))
+
+    def seek_accurate(self, pos):
+        """Accurately seek to frame position, this is slower than `seek`
+        but guarantees accurate position.
+
+        Parameters
+        ----------
+        pos : integer
+            Non negative seeking position.
+
+        """
+        assert self._handle is not None
+        assert pos >= 0 and pos < self._num_frame
+        success = _CAPI_VideoReaderSeekAccurate(self._handle, pos)
+        if not success:
+            raise RuntimeError("Failed to seek_accurate to frame {}".format(pos))
+
+    def skip_frames(self, num=1):
+        """Skip reading multiple frames. Skipped frames will still be decoded
+        (required by following frames) but it can save image resize/copy operations.
+
+
+        Parameters
+        ----------
+        num : int, default is 1
+            The number of frames to be skipped.
+
+        """
+        assert self._handle is not None
+        assert num > 0
+        _CAPI_VideoReaderSkipFrames(self._handle, num)
+
+_init_api("decord.video_reader")