import struct

def preargs(cls):
    def _pre_init(*args1, **kwargs1):
        def _my_init(*args2, **kwargs2):
            args = args1 + args2
            kwargs1.update(kwargs2)
            return cls(*args, **kwargs1)
        return _my_init
    return _pre_init

class BinaryMetaType(type):
    def __getitem__(self, val):
        return array(self, val)

class BinaryType(metaclass=BinaryMetaType):
    def __init__(self, **kwargs):
        self._kwargs = kwargs

    def to_binary(self, val):
        pass

    def from_binary(self, binary):
        pass

class SimpleBinaryType(BinaryType):
    def __init__(self, fmt):
        self._struct = struct.Struct(fmt)

    def to_binary(self, val):
        return self._struct.pack(val)

    def from_binary(self, binary):
        return (self._struct.size,
                self._struct.unpack(binary[:self._struct.size])[0])

@preargs
class array(BinaryType):
    def __init__(self, arrtype, arrlen, **kwargs):
        super().__init__(**kwargs)
        self._arrtype, self._arrlen = arrtype(**kwargs), arrlen

    def to_binary(self, val):
        res = []
        for i,v in enumerate(val):
            res.append(self._arrtype.to_binary(v))
            if i+1 == self._arrlen: break
        return b''.join(res)

    def from_binary(self, binary):
        res = []
        ssum = 0
        for i in range(self._arrlen):
            s,v = self._arrtype.from_binary(binary[ssum:])
            ssum += s
            res.append(v)
        return ssum, res

class dword(SimpleBinaryType):
    def __init__(self, **kwargs):
        super().__init__('I', **kwargs)

class char(SimpleBinaryType):
    def __init__(self, **kwargs):
        super().__init__('c', **kwargs)

class BinaryBuilder(dict):
    def __init__(self, **kwargs):
        self.members = []
        self._kwargs = kwargs

    def __setitem__(self, key, value):
        if key ==  '__module__': return
        if key not in self:
            self.members.append((key, value(**self._kwargs)))
        super().__setitem__(key, value)

class Binary(type):
    @classmethod
    def __prepare__(*bases, **kwargs):
        # In the future kwargs can contain things such as endianity
        # and alignment
        return BinaryBuilder(**kwargs)

    def __new__(cls, name, bases, classdict):
        # There are nicer ways of doing this, but as a hack it works
        def fixupdict(d):
            @classmethod
            def to_binary(clas, datadict):
                res = []
                for k,v in clas.members:
                    res.append(v.to_binary(datadict[k]))
                return b''.join(res)

            @classmethod
            def from_binary(cls, bytesin):
                res = {}
                ssum = 0
                for k,v in cls.members:
                    i, d = v.from_binary(bytesin[ssum:])
                    ssum += i
                    res[k] = d
                return ssum, res

            nd = {'to_binary': to_binary,
              'from_binary': from_binary,
              'members': d.members}
            return nd

        return super().__new__(cls, name, bases, fixupdict(classdict))


#### How one would use the above module

class BMP(metaclass=Binary):
    # The point was to try and get this C-like syntax
    bfType = char[2]
    bfSize = dword
    bfReserved = dword
    bfOffBits = dword

print(BMP.from_binary(b'BM6\x00$\x00\x00\x00\x00\x006\x00\x00\x00'))
print(BMP.to_binary(
    {'bfType': 'BM',
     'bfSize': 2359350,
     'bfReserved': 0,
     'bfOffBits': 54}))