[('John', 25, 180.5) ('',  0,   0. )]
[('John', 25, 180.5) ('John', 25, 180.5)]

import numpy as np
import operator
from numba import cuda
from numba.core import types
from numba.core.extending import lower_cast
from numba.core.typeconv import Conversion
from numba.core.typing.templates import (AbstractTemplate, infer_global,
                                         signature)


@lower_cast(types.UniTuple, types.Record)
@lower_cast(types.Tuple, types.Record)
def tuple_to_record(context, builder, fromty, toty, val):
    breakpoint()


possible_conversions = (
    Conversion.exact,
    Conversion.promote,
    Conversion.safe,
    Conversion.unsafe
)


@infer_global(operator.setitem)
class SetItemRecordArray(AbstractTemplate):
    def generic(self, args, kws):
        assert not kws
        ary, idx, val = args
        for a, b in zip(ary.dtype.fields.values(), val.types):
            conv = self.context.can_convert(b, a.type)

            if conv not in possible_conversions:
                return

        return signature(types.none, ary, idx, val)


def test():

    dt = np.dtype([('x', np.float32), ('y', np.float32)], align=True)

    @cuda.jit
    def f(input, output):
        # v = input[0]
        # x, y = v.x, v.y
        # output[0] = v # works
        #output[0] = np.record((3.14, 2.71), dtype=dt)  # nope
        # output[0].x = 3.14 # OK
        # output[0].y = 2.71 # OK
        output[0] = (3.14, 2.71)

    input = np.array([(3.14, 2.71)], dtype=dt)
    output = np.zeros_like(input)

    f[1, 1](input, output)
    cuda.synchronize()

    print(input, output)
    assert np.allclose(input.view(dtype=np.float32),
                       output.view(dtype=np.float32))


test()