pyverbs: Align code to support Cython 3.1.0 format

In Cython 3.1.0 named cpdef enums no longer copy their item names into
the global module namespace. This means each named enum must be imported
explicitly to be used in a file or else an import exception will be
raised. Align pyverbs code to explicitly import enums so it will be able
to execute on relatively new distributions that cython version in them
is newer than 3.1.0: Ubuntu 22.04/24.04, Debian 12, RHEL 9, Rocky Linux
9 and AL2023.

This change was also tested on cython 3.0.12 to verify it works on older
versions.

Link: https://cython.readthedocs.io/en/latest/src/changes.html#id10
Signed-off-by: Yonatan Nachum <[email protected]>

Author: YonatanNachum

Documentation/pyverbs.md

@@ -164,12 +164,12 @@ device must be opened prior to creation and a PD has to be allocated.
 import pyverbs.device as d
 from pyverbs.pd import PD
 from pyverbs.mr import MR
-import pyverbs.enums as e
+from pyverbs.libibverbs_enums import ibv_access_flags
 
 with d.Context(name='mlx5_0') as ctx:
     with PD(ctx) as pd:
         mr_len = 1000
-        flags = e.IBV_ACCESS_LOCAL_WRITE
+        flags = ibv_access_flags.IBV_ACCESS_LOCAL_WRITE
         mr = MR(pd, mr_len, flags)
 ```
 ##### Memory window
@@ -181,11 +181,11 @@ deregister an MR that the MW is bound to.
 import pyverbs.device as d
 from pyverbs.pd import PD
 from pyverbs.mr import MW
-import pyverbs.enums as e
+from pyverbs.libibverbs_enums import ibv_mw_type
 
 with d.Context(name='mlx5_0') as ctx:
     with PD(ctx) as pd:
-        mw = MW(pd, e.IBV_MW_TYPE_1)
+        mw = MW(pd, ibv_mw_type.IBV_MW_TYPE_1)
 ```
 ##### Device memory
 The following snippet shows how to allocate a DM - a direct memory object,
@@ -214,7 +214,7 @@ from pyverbs.device import DM, AllocDmAttr
 from pyverbs.mr import DMMR
 import pyverbs.device as d
 from pyverbs.pd import PD
-import pyverbs.enums as e
+from pyverbs.libibverbs_enums import ibv_access_flags
 
 with d.Context(name='mlx5_0') as ctx:
     attr = ctx.query_device_ex()
@@ -224,7 +224,7 @@ with d.Context(name='mlx5_0') as ctx:
         dm_mr_len = random.randint(4, dm_len)
         with DM(ctx, dm_attrs) as dm:
             with PD(ctx) as pd:
-                dm_mr = DMMR(pd, dm_mr_len, e.IBV_ACCESS_ZERO_BASED, dm=dm,
+                dm_mr = DMMR(pd, dm_mr_len, ibv_access_flags.IBV_ACCESS_ZERO_BASED, dm=dm,
                              offset=0)
 ```
 
@@ -262,11 +262,11 @@ import random
 
 from pyverbs.cq import CqInitAttrEx, CQEX
 import pyverbs.device as d
-import pyverbs.enums as e
+from pyverbs.libibverbs_enums import ibv_create_cq_wc_flags
 
 with d.Context(name='mlx5_0') as ctx:
     num_cqe = random.randint(0, 200)
-    wc_flags = e.IBV_WC_EX_WITH_CVLAN
+    wc_flags = ibv_create_cq_wc_flags.IBV_WC_EX_WITH_CVLAN
     comp_mask = 0 # Not using flags in this example
     # completion channel is not used in this example
     attrs = CqInitAttrEx(cqe=num_cqe, wc_flags=wc_flags, comp_mask=comp_mask,
@@ -318,7 +318,7 @@ from pyverbs.qp import QPCap, QPInitAttr, QPAttr, QP
 from pyverbs.addr import GlobalRoute
 from pyverbs.addr import AH, AHAttr
 import pyverbs.device as d
-import pyverbs.enums as e
+from pyverbs.libibverbs_enums import ibv_qp_type
 from pyverbs.pd import PD
 from pyverbs.cq import CQ
 import pyverbs.wr as pwr
@@ -328,7 +328,7 @@ ctx = d.Context(name='mlx5_0')
 pd = PD(ctx)
 cq = CQ(ctx, 100, None, None, 0)
 cap = QPCap(100, 10, 1, 1, 0)
-qia = QPInitAttr(cap=cap, qp_type = e.IBV_QPT_UD, scq=cq, rcq=cq)
+qia = QPInitAttr(cap=cap, qp_type = ibv_qp_type.IBV_QPT_UD, scq=cq, rcq=cq)
 # A UD QP will be in RTS if a QPAttr object is provided
 udqp = QP(pd, qia, QPAttr())
 port_num = 1
@@ -351,7 +351,7 @@ when using the extended QP's new post send mechanism.
 ```python
 from pyverbs.qp import QPCap, QPInitAttrEx, QPAttr, QPEx
 import pyverbs.device as d
-import pyverbs.enums as e
+from pyverbs.libibverbs_enums import ibv_qp_type, ibv_qp_init_attr_mask
 from pyverbs.pd import PD
 from pyverbs.cq import CQ
 
@@ -360,9 +360,9 @@ ctx = d.Context(name='mlx5_0')
 pd = PD(ctx)
 cq = CQ(ctx, 100)
 cap = QPCap(100, 10, 1, 1, 0)
-qia = QPInitAttrEx(qp_type=e.IBV_QPT_UD, scq=cq, rcq=cq, cap=cap, pd=pd,
-                   comp_mask=e.IBV_QP_INIT_ATTR_SEND_OPS_FLAGS| \
-                   e.IBV_QP_INIT_ATTR_PD)
+qia = QPInitAttrEx(qp_type=ibv_qp_type.IBV_QPT_UD, scq=cq, rcq=cq, cap=cap, pd=pd,
+                   comp_mask=ibv_qp_init_attr_mask.IBV_QP_INIT_ATTR_SEND_OPS_FLAGS| \
+                   ibv_qp_init_attr_mask.IBV_QP_INIT_ATTR_PD)
 qp = QPEx(ctx, qia)
 ```
 
@@ -371,15 +371,15 @@ The following code demonstrates creation of an XRCD object.
 ```python
 from pyverbs.xrcd import XRCD, XRCDInitAttr
 import pyverbs.device as d
-import pyverbs.enums as e
+from pyverbs.libibverbs_enums import ibv_xrcd_init_attr_mask
 import stat
 import os
 
 
 ctx = d.Context(name='ibp0s8f0')
 xrcd_fd = os.open('/tmp/xrcd', os.O_RDONLY | os.O_CREAT,
                   stat.S_IRUSR | stat.S_IRGRP)
-init = XRCDInitAttr(e.IBV_XRCD_INIT_ATTR_FD | e.IBV_XRCD_INIT_ATTR_OFLAGS,
+init = XRCDInitAttr(ibv_xrcd_init_attr_mask.IBV_XRCD_INIT_ATTR_FD | ibv_xrcd_init_attr_mask.IBV_XRCD_INIT_ATTR_OFLAGS,
                     os.O_CREAT, xrcd_fd)
 xrcd = XRCD(ctx, init)
 ```
@@ -391,7 +391,7 @@ For more complex examples, please see pyverbs/tests/test_odp.
 from pyverbs.xrcd import XRCD, XRCDInitAttr
 from pyverbs.srq import SRQ, SrqInitAttrEx
 import pyverbs.device as d
-import pyverbs.enums as e
+from pyverbs.libibverbs_enums import ibv_xrcd_init_attr_mask, ibv_srq_type, ibv_srq_init_attr_mask
 from pyverbs.cq import CQ
 from pyverbs.pd import PD
 import stat
@@ -403,17 +403,17 @@ pd = PD(ctx)
 cq = CQ(ctx, 100, None, None, 0)
 xrcd_fd = os.open('/tmp/xrcd', os.O_RDONLY | os.O_CREAT,
                   stat.S_IRUSR | stat.S_IRGRP)
-init = XRCDInitAttr(e.IBV_XRCD_INIT_ATTR_FD | e.IBV_XRCD_INIT_ATTR_OFLAGS,
+init = XRCDInitAttr(ibv_xrcd_init_attr_mask.IBV_XRCD_INIT_ATTR_FD | ibv_xrcd_init_attr_mask.IBV_XRCD_INIT_ATTR_OFLAGS,
                     os.O_CREAT, xrcd_fd)
 xrcd = XRCD(ctx, init)
 
 srq_attr = SrqInitAttrEx(max_wr=10)
-srq_attr.srq_type = e.IBV_SRQT_XRC
+srq_attr.srq_type = ibv_srq_type.IBV_SRQT_XRC
 srq_attr.pd = pd
 srq_attr.xrcd = xrcd
 srq_attr.cq = cq
-srq_attr.comp_mask = e.IBV_SRQ_INIT_ATTR_TYPE | e.IBV_SRQ_INIT_ATTR_PD | \
-                     e.IBV_SRQ_INIT_ATTR_CQ | e.IBV_SRQ_INIT_ATTR_XRCD
+srq_attr.comp_mask = ibv_srq_init_attr_mask.IBV_SRQ_INIT_ATTR_TYPE | ibv_srq_init_attr_mask.IBV_SRQ_INIT_ATTR_PD | \
+                     ibv_srq_init_attr_mask.IBV_SRQ_INIT_ATTR_CQ | ibv_srq_init_attr_mask.IBV_SRQ_INIT_ATTR_XRCD
 srq = SRQ(ctx, srq_attr)
 ```
 
@@ -476,9 +476,9 @@ following PRs.
 ```python
 from pyverbs.providers.mlx5.mlx5dv import Mlx5Context, Mlx5DVContextAttr
 from pyverbs.providers.mlx5.mlx5dv import Mlx5DVQPInitAttr, Mlx5QP
-import pyverbs.providers.mlx5.mlx5_enums as me
+from pyverbs.providers.mlx5.mlx5_enums import mlx5dv_qp_init_attr_mask, mlx5dv_dc_type, mlx5dv_qp_create_flags
 from pyverbs.qp import QPInitAttrEx, QPCap
-import pyverbs.enums as e
+from pyverbs.libibverbs_enums import ibv_qp_type, ibv_qp_init_attr_mask, ibv_qp_type
 from pyverbs.cq import CQ
 from pyverbs.pd import PD
 
@@ -487,19 +487,19 @@ with Mlx5Context(name='rocep0s8f0', attr=Mlx5DVContextAttr()) as ctx:
         with CQ(ctx, 100) as cq:
             cap = QPCap(100, 0, 1, 0)
             # Create a DC QP of type DCI
-            qia = QPInitAttrEx(cap=cap, pd=pd, scq=cq, qp_type=e.IBV_QPT_DRIVER,
-                               comp_mask=e.IBV_QP_INIT_ATTR_PD, rcq=cq)
-            attr = Mlx5DVQPInitAttr(comp_mask=me.MLX5DV_QP_INIT_ATTR_MASK_DC)
-            attr.dc_type = me.MLX5DV_DCTYPE_DCI
+            qia = QPInitAttrEx(cap=cap, pd=pd, scq=cq, qp_type=ibv_qp_type.IBV_QPT_DRIVER,
+                               comp_mask=ibv_qp_init_attr_mask.IBV_QP_INIT_ATTR_PD, rcq=cq)
+            attr = Mlx5DVQPInitAttr(comp_mask=mlx5dv_qp_init_attr_mask.MLX5DV_QP_INIT_ATTR_MASK_DC)
+            attr.dc_type = mlx5dv_dc_type.MLX5DV_DCTYPE_DCI
 
             dci = Mlx5QP(ctx, qia, dv_init_attr=attr)
 
             # Create a Raw Packet QP using mlx5-specific capabilities
-            qia.qp_type = e.IBV_QPT_RAW_PACKET
-            attr.comp_mask = me.MLX5DV_QP_INIT_ATTR_MASK_QP_CREATE_FLAGS
-            attr.create_flags = me.MLX5DV_QP_CREATE_ALLOW_SCATTER_TO_CQE |\
-                                me.MLX5DV_QP_CREATE_TIR_ALLOW_SELF_LOOPBACK_UC |\
-                                me.MLX5DV_QP_CREATE_TUNNEL_OFFLOADS
+            qia.qp_type = ibv_qp_type.IBV_QPT_RAW_PACKET
+            attr.comp_mask = mlx5dv_qp_init_attr_mask.MLX5DV_QP_INIT_ATTR_MASK_QP_CREATE_FLAGS
+            attr.create_flags = mlx5dv_qp_create_flags.MLX5DV_QP_CREATE_ALLOW_SCATTER_TO_CQE | \
+                                mlx5dv_qp_create_flags.MLX5DV_QP_CREATE_TIR_ALLOW_SELF_LOOPBACK_UC | \
+                                mlx5dv_qp_create_flags.MLX5DV_QP_CREATE_TUNNEL_OFFLOADS
             qp = Mlx5QP(ctx, qia, dv_init_attr=attr)
 ```
 
@@ -512,13 +512,13 @@ The following snippet shows this simple creation process.
 ```python
 from pyverbs.providers.mlx5.mlx5dv import Mlx5Context, Mlx5DVContextAttr
 from pyverbs.providers.mlx5.mlx5dv import Mlx5DVCQInitAttr, Mlx5CQ
-import pyverbs.providers.mlx5.mlx5_enums as me
+from pyverbs.providers.mlx5.mlx5_enums import mlx5dv_cq_init_attr_mask, mlx5dv_cqe_comp_res_format
 from pyverbs.cq import CqInitAttrEx
 
 with Mlx5Context(name='rocep0s8f0', attr=Mlx5DVContextAttr()) as ctx:
     cqia = CqInitAttrEx()
-    mlx5_cqia = Mlx5DVCQInitAttr(comp_mask=me.MLX5DV_CQ_INIT_ATTR_MASK_COMPRESSED_CQE,
-                                 cqe_comp_res_format=me.MLX5DV_CQE_RES_FORMAT_CSUM)
+    mlx5_cqia = Mlx5DVCQInitAttr(comp_mask=mlx5dv_cq_init_attr_mask.MLX5DV_CQ_INIT_ATTR_MASK_COMPRESSED_CQE,
+                                 cqe_comp_res_format=mlx5dv_cqe_comp_res_format.MLX5DV_CQE_RES_FORMAT_CSUM)
     cq = Mlx5CQ(ctx, cqia, dv_init_attr=mlx5_cqia)
 ```
 
@@ -530,8 +530,7 @@ For more complex examples, please see tests/test_rdmacm.
 ```python
 from pyverbs.qp import QPInitAttr, QPCap
 from pyverbs.cmid import CMID, AddrInfo
-import pyverbs.cm_enums as ce
-
+from pyverbs.librdmacm_enums import rdma_port_space, RAI_PASSIVE
 
 cap = QPCap(max_recv_wr=1)
 qp_init_attr = QPInitAttr(cap=cap)
@@ -540,15 +539,15 @@ port = '7471'
 
 # Passive side
 
-sai = AddrInfo(src=addr, src_service=port, port_space=ce.RDMA_PS_TCP, flags=ce.RAI_PASSIVE)
+sai = AddrInfo(src=addr, src_service=port, port_space=rdma_port_space.RDMA_PS_TCP, flags=RAI_PASSIVE)
 sid = CMID(creator=sai, qp_init_attr=qp_init_attr)
 sid.listen()  # listen for incoming connection requests
 new_id = sid.get_request()  # check if there are any connection requests
 new_id.accept()  # new_id is connected to remote peer and ready to communicate
 
 # Active side
 
-cai = AddrInfo(src=addr, dst=addr, dst_service=port, port_space=ce.RDMA_PS_TCP)
+cai = AddrInfo(src=addr, dst=addr, dst_service=port, port_space=rdma_port_space.RDMA_PS_TCP)
 cid = CMID(creator=cai, qp_init_attr=qp_init_attr)
 cid.connect()  # send connection request to passive addr
 ```
@@ -604,10 +603,10 @@ The following code snippet demonstrates how to allocate an mlx5dv_pp with rate
 limit value of 5, then frees the entry.
 ```python
 from pyverbs.providers.mlx5.mlx5dv import Mlx5Context, Mlx5DVContextAttr, Mlx5PP
-import pyverbs.providers.mlx5.mlx5_enums as e
+from pyverbs.providers.mlx5.mlx5_enums import mlx5dv_context_attr_flags
 
 # The device must be opened as DEVX context
-mlx5dv_attr = Mlx5DVContextAttr(e.MLX5DV_CONTEXT_FLAGS_DEVX)
+mlx5dv_attr = Mlx5DVContextAttr(mlx5dv_context_attr_flags.MLX5DV_CONTEXT_FLAGS_DEVX)
 ctx = Mlx5Context(attr=mlx5dv_attr, name='rocep0s8f0')
 rate_limit_inbox = (5).to_bytes(length=4, byteorder='big', signed=True)
 pp = Mlx5PP(ctx, rate_limit_inbox)
@@ -650,18 +649,18 @@ Here is a demonstration of importing a device, PD and MR in one process.
 from pyverbs.device import Context
 from pyverbs.pd import PD
 from pyverbs.mr import MR
-import pyverbs.enums as e
+from pyverbs.libibverbs_enums import ibv_access_flags
 import os
 
 ctx = Context(name='ibp0s8f0')
 pd = PD(ctx)
-mr = MR(pd, 100, e.IBV_ACCESS_LOCAL_WRITE)
+mr = MR(pd, 100, ibv_access_flags.IBV_ACCESS_LOCAL_WRITE)
 cmd_fd_dup = os.dup(ctx.cmd_fd)
 imported_ctx = Context(cmd_fd=cmd_fd_dup)
 imported_pd = PD(imported_ctx, handle=pd.handle)
 imported_mr = MR(imported_pd, handle=mr.handle)
 # MRs can be created as usual on the imported PD
-secondary_mr = MR(imported_pd, 100, e.IBV_ACCESS_REMOTE_READ)
+secondary_mr = MR(imported_pd, 100, ibv_access_flags.IBV_ACCESS_REMOTE_READ)
 # Must manually unimport the imported objects (which close the object and frees
 # other resources that use them) before closing the "original" objects.
 # This prevents unexpected behaviours caused by the GC.
@@ -683,7 +682,7 @@ from pyverbs.qp import QPCap, QPInitAttr, QPAttr, QP
 from pyverbs.flow import FlowAttr, Flow
 from pyverbs.spec import EthSpec
 import pyverbs.device as d
-import pyverbs.enums as e
+from pyverbs.libibverbs_enums import ibv_qp_type
 from pyverbs.pd import PD
 from pyverbs.cq import CQ
 
@@ -692,7 +691,7 @@ ctx = d.Context(name='rocep0s8f0')
 pd = PD(ctx)
 cq = CQ(ctx, 100, None, None, 0)
 cap = QPCap(100, 10, 1, 1, 0)
-qia = QPInitAttr(cap=cap, qp_type = e.IBV_QPT_UD, scq=cq, rcq=cq)
+qia = QPInitAttr(cap=cap, qp_type = ibv_qp_type.IBV_QPT_UD, scq=cq, rcq=cq)
 qp = QP(pd, qia, QPAttr())
 
 # Create Eth spec

pyverbs/CMakeLists.txt

@@ -21,14 +21,12 @@ endif()
 rdma_cython_module(pyverbs ""
   addr.pyx
   base.pyx
-  cm_enums.pyx
   cmid.pyx
   cq.pyx
   device.pyx
   ${DMA_UTIL}
   dmabuf.pyx
   ${DMABUF_ALLOC}
-  enums.pyx
   flow.pyx
   fork.pyx
   libibverbs.pyx

pyverbs/cm_enums.pyx

@@ -510,16 +510,6 @@ cdef extern from "<infiniband/verbs_api.h>":
     cdef unsigned long long IBV_ADVISE_MR_FLAG_FLUSH
     cdef unsigned long long IBV_ADVISE_MR_ADVICE_PREFETCH_NO_FAULT
 
-
-_IBV_DEVICE_RAW_SCATTER_FCS = IBV_DEVICE_RAW_SCATTER_FCS
-_IBV_DEVICE_PCI_WRITE_END_PADDING = IBV_DEVICE_PCI_WRITE_END_PADDING
-_IBV_ALLOCATOR_USE_DEFAULT = <size_t>IBV_ALLOCATOR_USE_DEFAULT
-_IBV_ADVISE_MR_ADVICE_PREFETCH = IBV_ADVISE_MR_ADVICE_PREFETCH
-_IBV_ADVISE_MR_ADVICE_PREFETCH_WRITE = IBV_ADVISE_MR_ADVICE_PREFETCH_WRITE
-_IBV_ADVISE_MR_FLAG_FLUSH = IBV_ADVISE_MR_FLAG_FLUSH
-_IBV_ADVISE_MR_ADVICE_PREFETCH_NO_FAULT = IBV_ADVISE_MR_ADVICE_PREFETCH_NO_FAULT
-
-
 cdef extern from '<infiniband/driver.h>':
     cpdef enum ibv_gid_type_sysfs:
         IBV_GID_TYPE_SYSFS_IB_ROCE_V1

pyverbs/enums.pyx

@@ -0,0 +1,19 @@
+from pyverbs.libibverbs_enums cimport (
+    IBV_DEVICE_RAW_SCATTER_FCS,
+    IBV_DEVICE_PCI_WRITE_END_PADDING,
+    IBV_ADVISE_MR_ADVICE_PREFETCH,
+    IBV_ADVISE_MR_ADVICE_PREFETCH_WRITE,
+    IBV_ADVISE_MR_FLAG_FLUSH,
+    IBV_ADVISE_MR_ADVICE_PREFETCH_NO_FAULT,
+    IBV_ALLOCATOR_USE_DEFAULT,
+)
+
+from libc.stddef cimport size_t
+
+_IBV_DEVICE_RAW_SCATTER_FCS = IBV_DEVICE_RAW_SCATTER_FCS
+_IBV_DEVICE_PCI_WRITE_END_PADDING = IBV_DEVICE_PCI_WRITE_END_PADDING
+_IBV_ALLOCATOR_USE_DEFAULT = <size_t>IBV_ALLOCATOR_USE_DEFAULT
+_IBV_ADVISE_MR_ADVICE_PREFETCH = IBV_ADVISE_MR_ADVICE_PREFETCH
+_IBV_ADVISE_MR_ADVICE_PREFETCH_WRITE = IBV_ADVISE_MR_ADVICE_PREFETCH_WRITE
+_IBV_ADVISE_MR_FLAG_FLUSH = IBV_ADVISE_MR_FLAG_FLUSH
+_IBV_ADVISE_MR_ADVICE_PREFETCH_NO_FAULT = IBV_ADVISE_MR_ADVICE_PREFETCH_NO_FAULT

pyverbs/libibverbs_enums.pxd

@@ -7,7 +7,7 @@ cimport pyverbs.providers.efa.libefa as dv
 from pyverbs.addr cimport GID
 from pyverbs.base import PyverbsRDMAErrno, PyverbsRDMAError
 from pyverbs.cq cimport CQEX, CqInitAttrEx
-import pyverbs.enums as e
+from pyverbs.libibverbs_enums import ibv_qp_attr_mask
 cimport pyverbs.libibverbs as v
 from pyverbs.pd cimport PD
 from pyverbs.qp cimport QP, QPEx, QPInitAttr, QPInitAttrEx
@@ -212,10 +212,10 @@ cdef class SRDQPEx(QPEx):
         super().__init__(ctx, attr_ex)
 
     def _get_comp_mask(self, dst):
-        srd_mask = {'INIT': e.IBV_QP_PKEY_INDEX | e.IBV_QP_PORT | e.IBV_QP_QKEY,
+        srd_mask = {'INIT': ibv_qp_attr_mask.IBV_QP_PKEY_INDEX | ibv_qp_attr_mask.IBV_QP_PORT | ibv_qp_attr_mask.IBV_QP_QKEY,
                     'RTR': 0,
-                    'RTS': e.IBV_QP_SQ_PSN}
-        return srd_mask [dst] | e.IBV_QP_STATE
+                    'RTS': ibv_qp_attr_mask.IBV_QP_SQ_PSN}
+        return srd_mask [dst] | ibv_qp_attr_mask.IBV_QP_STATE
 
 
 cdef class EfaDVCQInitAttr(PyverbsObject):

pyverbs/libibverbs_enums.pyx

@@ -5,7 +5,7 @@ from pyverbs.base import PyverbsRDMAErrno, PyverbsRDMAError
 from pyverbs.providers.mlx5.dr_domain cimport DrDomain
 from pyverbs.providers.mlx5.mlx5dv cimport Mlx5DevxObj
 from pyverbs.providers.mlx5.dr_rule cimport DrRule
-import pyverbs.providers.mlx5.mlx5_enums as dve
+from pyverbs.providers.mlx5.mlx5_enums import mlx5dv_dr_action_dest_type
 from pyverbs.pyverbs_error import PyverbsError
 from pyverbs.base cimport close_weakrefs
 from libc.stdlib cimport calloc, free
@@ -216,15 +216,15 @@ cdef class DrActionDestAttr(PyverbsCM):
         super().__init__()
         self.dest_reformat = NULL
         self.action_dest_attr = NULL
-        if action_type == dve.MLX5DV_DR_ACTION_DEST:
+        if action_type == mlx5dv_dr_action_dest_type.MLX5DV_DR_ACTION_DEST:
             self.action_dest_attr = <dv.mlx5dv_dr_action_dest_attr *> calloc(
                 1, sizeof(dv.mlx5dv_dr_action_dest_attr))
             if self.action_dest_attr == NULL:
                 raise PyverbsRDMAErrno('Memory allocation for DrActionDestAttr failed.')
             self.action_dest_attr.type = action_type
             self.action_dest_attr.dest = dest.action
             self.dest = dest
-        elif action_type == dve.MLX5DV_DR_ACTION_DEST_REFORMAT:
+        elif action_type == mlx5dv_dr_action_dest_type.MLX5DV_DR_ACTION_DEST_REFORMAT:
             self.dest_reformat = <dv.mlx5dv_dr_action_dest_reformat *> calloc(
                 1, sizeof(dv.mlx5dv_dr_action_dest_reformat))
             if self.dest_reformat == NULL: