At least for GCC enum is just a simple numeric type. It can be 8-, 16-, 32-, 64-bit or whatever (I have tested it with 64-bit values) as well as signed or unsigned. I guess it cannot exceed long long int, but practically you should check the range of your enums and choose something like c_uint.

Here is an example. The C program:

enum batch_op {
    OP1 = 2,
    OP2 = 3,
    OP3 = -1,
};

struct attrl {
    char *name;
    struct attrl *next;
    enum batch_op op;
};

void f(struct attrl *x) {
    x->op = OP3;
}

and the Python one:

from ctypes import (Structure, c_char_p, c_uint, c_int,
    POINTER, CDLL)

class AttrList(Structure): pass
AttrList._fields_ = [
    ('name', c_char_p),
    ('next', POINTER(AttrList)),
    ('op', c_int),
]

(OP1, OP2, OP3) = (2, 3, -1)

enum = CDLL('./libenum.so')
enum.f.argtypes = [POINTER(AttrList)]
enum.f.restype = None

a = AttrList(name=None, next=None, op=OP2)
assert a.op == OP2
enum.f(a)
assert a.op == OP3

There are a couple issues here:

• the return value of pyfunc is going back to a C routine, so must be a standard ctypes type (E is not a ctype type)

• neither from_param nor _as_parameter_ appear to be called for a return type

To address these problems you must

• change the E in @ct.CFUNCTYPE to ct.c_int

and one of the following:

• use IntEnum instead of Enum

or

• return E(a).value

or

• add __int__ and __index__ to your enum (which makes it int-like enough for ctypes):

    class E(enum.Enum):
        A = 10
        #
        def __int__(self):
            return self.value
        __index__ = __int__

If you read the enum docs on pip you'll see:

Python 3 now has in its standard library an enum implementation (also available for older Python versions as the third-party flufl.enum distribution) that supersedes this library.

You actually want enum34.

I made a small demo of some C code that looks similar to your API below, and show how to handle an enum and callback nicely:

test.c

#include <memory.h>

#ifdef _WIN32
#   define API __declspec(dllexport)
#else
#   define API
#endif

typedef enum _gsmEvent_e {
    GSM_NO_SIGNAL = 0,
    GSM_RING_VOICE,
    GSM_RING_DATA,
    GSM_NEW_SMS,
    GSM_CALL_RELEASED,
    GSM_RECEIVED_DATA,
    GSM_FAILURE,
    GSM_COVERAGE,
} gsmEvent_e;

#define EVENTS_BUFFER_SIZE 1024

typedef struct _gsmEvents_s {
   gsmEvent_e gsmEventType;
   char evBuffer[ EVENTS_BUFFER_SIZE];
   int evHandled;
}gsmEvents_s;

typedef struct _TGSM_MODULE_CONFIGURATION {
   unsigned char wCode[9];
   unsigned char wMECode[9];
   void (*gsm_action)(gsmEvents_s*);
} TGSM_MODULE_CONFIGURATION;

TGSM_MODULE_CONFIGURATION* g_conf;

API int GSM_Initialize(TGSM_MODULE_CONFIGURATION* pgsmconf) {
    // Save off the configuration so the callback can be called by start.
    g_conf = pgsmconf;
    return 1;
}

API void GSM_Start() {
    // Hard-code some event response and call the callback.
    gsmEvents_s event;
    event.gsmEventType = GSM_FAILURE;
    memset(event.evBuffer, 'A', EVENTS_BUFFER_SIZE);
    event.evHandled = 1;
    g_conf->gsm_action(&event);
}

test.py

import ctypes as ct
from enum import Enum,auto

class gsmEvent_e(Enum):
    GSM_NO_SIGNAL = 0
    GSM_RING_VOICE = auto()
    GSM_RING_DATA = auto()
    GSM_NEW_SMS = auto()
    GSM_CALL_RELEASED = auto()
    GSM_RECEIVED_DATA = auto()
    GSM_FAILURE = auto()
    GSM_COVERAGE = auto()

    @classmethod
    def from_param(obj): # allows enum to be used in .argtypes
        if not isinstance(cls, obj):
            raise TypeError('not a gsmEvent_e enumeration')
        return obj.value

class gsmEvents_s(ct.Structure):

    _fields_ = (("_gsmEventType",  ct.c_int),
                ("evBuffer", ct.c_char * 1024),
                ("evHandled", ct.c_int))

    @property
    def gsmEventType(self): # wrapper to return the enum when referenced.
        return gsmEvent_e(self._gsmEventType)

    # allows structure to print itself
    def __repr__(self):
        return f'gsm_Events_s(type={self.gsmEventType.name}, handled={self.evHandled})'

# callback type
GSM_ACTION = ct.CFUNCTYPE(None, ct.POINTER(gsmEvents_s))

class TGSM_MODULE_CONFIGURATION(ct.Structure):
    _fields_ = (("wCode", ct.c_char * 9),
                ("wMECode", ct.c_char * 9),
                ("gsm_action", GSM_ACTION))

# To define a Python callback function, decorate with the callback type
@GSM_ACTION
def gsm_action_callback(gsm_event):
    # callback pointer is dereferenced with .contents
    # __repr__ defined above allows event to print itself
    print(gsm_event.contents)

dll = ct.CDLL('./test')
dll.GSM_Initialize.argtypes = ct.POINTER(TGSM_MODULE_CONFIGURATION),
dll.GSM_Initialize.restype = ct.c_int
dll.GSM_Start.argtypes = ()
dll.GSM_Start.restype = None

gsmconf = TGSM_MODULE_CONFIGURATION(b'code', b'mecode', gsm_action_callback)
dll.GSM_Initialize(gsmconf)
dll.GSM_Start()

Output:

gsm_Events_s(type=GSM_FAILURE, handled=1)

The Enumeration class suggested by Raj Kumar was broken in that it required the __init__ to be run to set a new value in a variable, and thus unusable if the value was changed on C side. Here is a fixed version thereof:

class EnumerationType(type(c_uint)):
    def __new__(metacls, name, bases, dict):
        if not "_members_" in dict:
            _members_ = {}
            for key, value in dict.items():
                if not key.startswith("_"):
                    _members_[key] = value

            dict["_members_"] = _members_
        else:
            _members_ = dict["_members_"]

        dict["_reverse_map_"] = { v: k for k, v in _members_.items() }
        cls = type(c_uint).__new__(metacls, name, bases, dict)
        for key,value in cls._members_.items():
            globals()[key] = value
        return cls

    def __repr__(self):
        return "<Enumeration %s>" % self.__name__

class CEnumeration(c_uint):
    __metaclass__ = EnumerationType
    _members_     = {}

    def __repr__(self):
        value = self.value
        return "<%s.%s: %d>" % (
            self.__class__.__name__,
            self._reverse_map_.get(value, '(unknown)'),
            value
        )

    def __eq__(self, other):
        if isinstance(other, (int, long)):
            return self.value == other

        return type(self) == type(other) and self.value == other.value

Now one can declare a CEnumeration:

class EBoolean(CEnumeration):
    FALSE = 0
    TRUE = 1

and use it:

class HeaderStruct(Structure):
    _fields_ = [("param1", EBoolean), 
                ("param2", c_uint)]

Examples:

>>> header = HeaderStruct()
>>> header.param1
<EBoolean.FALSE: 0>
>>> memmove(addressof(header), b'\x01', 1)  # write LSB 0x01 in the boolean
>>> header.param1
<EBoolean.TRUE: 1>
>>> header.param1 == EBoolean.TRUE
True
>>> header.param1 == 1   # as a special case compare against ints
True
>>> header.param1.value
1L

I'm a bit disappointed to answer to this question myself. Especially since I found it all from the f* manual.

http://docs.python.org/library/ctypes.html#calling-functions-with-your-own-custom-data-types

To complete my answer, I'll write some code that does wrap an item.

from ctypes import CDLL, c_uint, c_char_p

class Flag(object):
    flags = [(0x1, 'fun'), (0x2, 'toy')]
    @classmethod
    def from_param(cls, data):
        return c_uint(encode_flags(self.flags, data))

libc = CDLL('libc.so.6')
printf = libc.printf
printf.argtypes = [c_char_p, Flag]

printf("hello %d\n", ["fun", "toy"])

encode_flags transforms that nifty list into an integer.