Take a look at the ctypes tutorial. You use the ctypes.Union class:

class test(ctypes.Structure):
    # ...
class test2(ctypes.Structure):
    # ...

class tests(ctypes.Union):
    _fields_ = [("a", test),
                ("b", test2)]

state_struct.loc0 is an array of length 3. You need to index into its elements if you want to assign integers to them.

For example:

l = [1,2,3]
for index, value in enumerate(l):
    u.state_struct.loc0[index] = value

or you could assign the whole list in one go using slice indexing:

u.state_struct.loc0[:] = l

The fields of your union are declared incorrectly. You've declared an attribute named "ch[2]".

To demonstrate this, have a look at this variant of your program:

#Demo of union at work
from ctypes import *
class a(Union):
    _fields_= [("i", c_int, 16),
               ("ch[2]",c_char)]
key=a()
key.i = 65
print getattr(key, "ch[2]")

Output

A

You probably meant to write code like this:

_fields_= [("i", c_int, 16),
           ("ch", c_byte*2)]

This declares ch to be an array of c_byte, with length 2.

Note that I use c_byte in place of c_char because you expect an integral type rather than a character.

So, here's the corrected program:

#Demo of union at work
from ctypes import *
class a(Union):
    _fields_= [("i", c_int, 16),
               ("ch",c_byte*2)]
key=a()
key.i=512
print key.i
print key.ch[0]
print key.ch[1]

Output

512
0
2

Installing libffi-dev and re-installing python3.7 fixed the problem for me.

to cleanly build py 3.7 libffi-dev is required or else later stuff will fail

If using RHEL/Fedora:

sudo yum install libffi-devel

or

sudo dnf install libffi-devel

If using Debian/Ubuntu:

sudo apt-get install libffi-dev

What about ctypes?

from ctypes import (
        Union, Array, 
        c_uint8, c_uint32, 
        cdll, CDLL
) 

class uint8_array(Array):
    _type_ = c_uint8
    _length_ = 4

class u_type(Union):
    _fields_ = ("data", c_uint32), ("chunk", uint8_array)

# load printf function from Dynamic Linked Libary libc.so.6 (I'm using linux)
libc = CDLL(cdll.LoadLibrary('libc.so.6')._name)
printf = libc.printf

if __name__ == "__main__":
    # initialize union
    _32bitsdata = u_type()
    # set values to chunk
    _32bitsdata.chunk[:] = (1, 2, 3, 4)
    # and print it
    printf(b"Data in 32 bits: %d\n", _32bitsdata.data)

c_bool is one byte in size and prints 0 for zero and 1 for non-zero. You can see that the size in bytes for the structures are incorrect:

>>> sizeof(Bits)
32
>>> sizeof(Int)
4
>>> sizeof(union)
32

Since Value is a 4-byte integer and all four bytes are non-zero the first four byte-sized c_bool fields in the union print 1.

To specify bit fields correctly, specify a 3rd parameter with the number of bits to use. See Bit fields in structures and unions in the ctypes documentation.

from ctypes import *

class Bits(Structure):
    _fields_ = [('Bit_0', c_uint32, 1),  # Use 1 bit of an unsigned 32-bit integer.
                ('Bit_1', c_uint32, 1),  # etc.
                ('Bit_2', c_uint32, 1),
                ('Bit_3', c_uint32, 1),
                ('Bit_4', c_uint32, 1),
                ('Bit_5', c_uint32, 1),
                ('Bit_6', c_uint32, 1),
                ('Bit_7', c_uint32, 1),
                ('Bit_8', c_uint32, 1),
                ('Bit_9', c_uint32, 1),
                ('Bit_10', c_uint32, 1),
                ('Bit_11', c_uint32, 1),
                ('Bit_12', c_uint32, 1),
                ('Bit_13', c_uint32, 1),
                ('Bit_14', c_uint32, 1),
                ('Bit_15', c_uint32, 1),
                ('Bit_16', c_uint32, 1),
                ('Bit_17', c_uint32, 1),
                ('Bit_18', c_uint32, 1),
                ('Bit_19', c_uint32, 1),
                ('Bit_20', c_uint32, 1),
                ('Bit_21', c_uint32, 1),
                ('Bit_22', c_uint32, 1),
                ('Bit_23', c_uint32, 1),
                ('Bit_24', c_uint32, 1),
                ('Bit_25', c_uint32, 1),
                ('Bit_26', c_uint32, 1),
                ('Bit_27', c_uint32, 1),
                ('Bit_28', c_uint32, 1),
                ('Bit_29', c_uint32, 1),
                ('Bit_30', c_uint32, 1),
                ('Bit_31', c_uint32, 1)]

    def return_dic(self):
        dic = {}
        for field in self._fields_:
            dic[field[0]] = getattr(self, field[0])
        return(dic)

class Int(Structure):
    _fields_ = [('Value', c_uint32)]

class union(Union):
    _fields_ = [('Descriptor', Int),('Bits', Bits)]
        
test = union(Int(0x87654321))
print('{0:b}'.format(test.Descriptor.Value))
dic = test.Bits.return_dic()
for x in dic.keys():
    print('{0} : {1:b}'.format(x,dic[x]))

Output:

10000111011001010100001100100001
Bit_0 : 1
Bit_1 : 0
Bit_2 : 0
Bit_3 : 0
Bit_4 : 0
Bit_5 : 1
Bit_6 : 0
Bit_7 : 0
Bit_8 : 1
Bit_9 : 1
Bit_10 : 0
Bit_11 : 0
Bit_12 : 0
Bit_13 : 0
Bit_14 : 1
Bit_15 : 0
Bit_16 : 1
Bit_17 : 0
Bit_18 : 1
Bit_19 : 0
Bit_20 : 0
Bit_21 : 1
Bit_22 : 1
Bit_23 : 0
Bit_24 : 1
Bit_25 : 1
Bit_26 : 1
Bit_27 : 0
Bit_28 : 0
Bit_29 : 0
Bit_30 : 0
Bit_31 : 1

Your Structure syntax isn't valid:

AttributeError: '_fields_' must be a sequence of pairs

I believe you want to use the anonymous attribute in your ctypes.Structure. It looks like the ctypes documentation creates a TYPEDESC structure (which is very similar in construction to the tagINPUT).

Also note that you'll have to define DWORD as a base type for your platform.