For m68k-micropython I want to wrap a large set of Macintosh APIs. Many of these APIs operate via structures, such as struct { INTEGER top, left, right, bottom; } Rect;.

In Python code I'd like to be able to "construct a Rect object" and then pass it to a function which can type check that it actually received a Rect Python object. The object would of course have an internal buffer with the layout of a Rect struct.

To do this, I've made some enhancements to the uctypes module:

• uctypes.struct can take a buffer as the first argument in addition to an address
• core code can specify "named struct" types.
  • Calling the type object Rect() allocates storage and returns a Rect instance that points to it. This object has a repr like <Rect STRUCT address>.
    • structs can be initialized by positional or named args to the constructor
    • arrays can be initialized by positional args to the constructor
  • calling uctypes.struct(address, Rect) returns a Rect instance pointing at the given address. (also works for buffers)
  • uctypes.sizeof and other stuff that looks at sub-structures can accept a type object as a descriptor, in addition to dict or tuple
  • since these have distinct Python types, the binding code is free to check that the type matches what is required.
• whole-object assignment is lhs[:] = rhs
• object duplication (shallow copy) is rhs[:]
• struct objects track the "GC base address", similar to how memoryview objects do it now, so that you can retain only a reference to a substructure without having GC think the outer object may be freed
• the above item necessitated a change to mp_get_buffer: there's a new field void *base in mp_buffer_info_t which is populated by memoryview & ctypes and which mp_get_buffer ensures is populated (with buf) if it was not otherwise set to non-NULL.
  • similar to memoryview, the offset from the base pointer is stored in the ctypes structure using bits not required for flags, rather than growing the structure
• possible future enhancements I'm considering:
  • ctypes.desc() to get the actual descriptor of a type or object
  • improved repr() that will print structs & arrays
  • runtime creation of "named structure types" is not hard but I don't have a use-case so I didn't

Needless to say this probably all grows the struct module by a fair amount (I haven't measured). And worse, it contains an incompatible ABI change. (hmm I wonder if the ABI change could be avoided by doing crimes to the field called int typecode...)

I'm not sure, but ulab might benefit from the mp_get_buffer change or something that makes it possible for more types than memoryview to correctly track gc base pointers; at least at one point it had a similar GC problem to memoryview with slicing views.

Is there any interest in seeing uctypes in micropython improved along these lines? The module does not seem to see a lot of development activity and so new features are likely to be little used. In short, I'm guessing not. But I wanted to make the offer and give a brief description of what I've done and what I have in mind.