Coverage for cuda / bindings / cufile.pyx: 32.40%

1# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. (empty)

2# 

3# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE 

4# 

5# This code was automatically generated across versions from 12.9.1 to 13.1.1, generator version 0.3.1.dev1322+g646ce84ec. Do not modify it directly. 

6  

7cimport cython # NOQA 

8from libc cimport errno 

9from ._internal.utils cimport (get_buffer_pointer, get_nested_resource_ptr, 

10 nested_resource) 

11from cuda.bindings._internal._fast_enum import FastEnum as _FastEnum (empty)

12  

13import cython 

14  

15from cuda.bindings.driver import CUresult as pyCUresult (empty)

16  

17from libc.stdlib cimport calloc, free, malloc 

18from cython cimport view 

19cimport cpython.buffer 

20cimport cpython.memoryview 

21cimport cpython 

22from libc.string cimport memcmp, memcpy 

23import numpy as _numpy (empty)

24  

25  

26cdef __from_data(data, dtype_name, expected_dtype, lowpp_type): (empty)

27 # _numpy.recarray is a subclass of _numpy.ndarray, so implicitly handled here. 

28 if isinstance(data, lowpp_type): 

29 return data 

30 if not isinstance(data, _numpy.ndarray): 

31 raise TypeError("data argument must be a NumPy ndarray") 

32 if data.size != 1: 

33 raise ValueError("data array must have a size of 1") 

34 if data.dtype != expected_dtype: 

35 raise ValueError(f"data array must be of dtype {dtype_name}") 

36 return lowpp_type.from_ptr(data.ctypes.data, not data.flags.writeable, data) 

37  

38  

39cdef __from_buffer(buffer, size, lowpp_type): (empty)

40 cdef Py_buffer view 

41 if cpython.PyObject_GetBuffer(buffer, &view, cpython.PyBUF_SIMPLE) != 0: 

42 raise TypeError("buffer argument does not support the buffer protocol") 

43 try: 

44 if view.itemsize != 1: 

45 raise ValueError("buffer itemsize must be 1 byte") 

46 if view.len != size: 

47 raise ValueError(f"buffer length must be {size} bytes") 

48 return lowpp_type.from_ptr(<intptr_t><void *>view.buf, not view.readonly, buffer) 

49 finally: 

50 cpython.PyBuffer_Release(&view) 

51  

52  

53cdef __getbuffer(object self, cpython.Py_buffer *buffer, void *ptr, int size, bint readonly): (empty)

54 buffer.buf = <char *>ptr 

55 buffer.format = 'b' 

56 buffer.internal = NULL 

57 buffer.itemsize = 1 

58 buffer.len = size 

59 buffer.ndim = 1 

60 buffer.obj = self 

61 buffer.readonly = readonly 

62 buffer.shape = &buffer.len 

63 buffer.strides = &buffer.itemsize 

64 buffer.suboffsets = NULL 

65  

66############################################################################### 

67# POD 

68############################################################################### 

69  

70_py_anon_pod1_dtype = _numpy.dtype(( (empty)

71 _numpy.dtype((_numpy.void, sizeof((<CUfileDescr_t*>NULL).handle))), (empty)

72 { 

73 "fd": (_numpy.int32, 0), (empty)

74 "handle": (_numpy.intp, 0), (empty)

75 } 

76 )) 

77  

78  

79cdef class _py_anon_pod1: 

80 """Empty-initialize an instance of `_anon_pod1`. 

81  

82  

83 .. seealso:: `_anon_pod1` 

84 """ 

85 cdef: 

86 _anon_pod1 *_ptr 

87 object _owner 

88 bint _owned 

89 bint _readonly 

90  

91 def __init__(self): 

92 self._ptr = <_anon_pod1 *>calloc(1, sizeof((<CUfileDescr_t*>NULL).handle)) 

93 if self._ptr == NULL: 

94 raise MemoryError("Error allocating _py_anon_pod1") 

95 self._owner = None 

96 self._owned = True 

97 self._readonly = False 

98  

99 def __dealloc__(self): 

100 cdef _anon_pod1 *ptr 

101 if self._owned and self._ptr != NULL: 

102 ptr = self._ptr 

103 self._ptr = NULL 

104 free(ptr) 

105  

106 def __repr__(self): 

107 return f"<{__name__}._py_anon_pod1 object at {hex(id(self))}>" 

108  

109 @property 

110 def ptr(self): 

111 """Get the pointer address to the data as Python :class:`int`.""" 

112 return <intptr_t>(self._ptr) 

113  

114 cdef intptr_t _get_ptr(self): (empty)

115 return <intptr_t>(self._ptr) (empty)

116  

117 def __int__(self): 

118 return <intptr_t>(self._ptr) 

119  

120 def __eq__(self, other): 

121 cdef _py_anon_pod1 other_ 

122 if not isinstance(other, _py_anon_pod1): 

123 return False 

124 other_ = other 

125 return (memcmp(<void *><intptr_t>(self._ptr), <void *><intptr_t>(other_._ptr), sizeof((<CUfileDescr_t*>NULL).handle)) == 0) 

126  

127 def __getbuffer__(self, Py_buffer *buffer, int flags): 

128 __getbuffer(self, buffer, <void *>self._ptr, sizeof((<CUfileDescr_t*>NULL).handle), self._readonly) 

129  

130 def __releasebuffer__(self, Py_buffer *buffer): 

131 pass 

132  

133 def __setitem__(self, key, val): 

134 if key == 0 and isinstance(val, _numpy.ndarray): 

135 self._ptr = <_anon_pod1 *>malloc(sizeof((<CUfileDescr_t*>NULL).handle)) 

136 if self._ptr == NULL: 

137 raise MemoryError("Error allocating _py_anon_pod1") 

138 memcpy(<void*>self._ptr, <void*><intptr_t>val.ctypes.data, sizeof((<CUfileDescr_t*>NULL).handle)) 

139 self._owner = None 

140 self._owned = True 

141 self._readonly = not val.flags.writeable 

142 else: 

143 setattr(self, key, val) 

144  

145 @property 

146 def fd(self): 

147 """int: """ 

148 return self._ptr[0].fd 

149  

150 @fd.setter 

151 def fd(self, val): 

152 if self._readonly: 

153 raise ValueError("This _py_anon_pod1 instance is read-only") 

154 self._ptr[0].fd = val 

155  

156 @property 

157 def handle(self): 

158 """int: """ 

159 return <intptr_t>(self._ptr[0].handle) 

160  

161 @handle.setter 

162 def handle(self, val): 

163 if self._readonly: 

164 raise ValueError("This _py_anon_pod1 instance is read-only") 

165 self._ptr[0].handle = <void *><intptr_t>val 

166  

167 @staticmethod (empty)

168 def from_buffer(buffer): 

169 """Create an _py_anon_pod1 instance with the memory from the given buffer.""" 

170 return __from_buffer(buffer, sizeof((<CUfileDescr_t*>NULL).handle), _py_anon_pod1) 

171  

172 @staticmethod (empty)

173 def from_data(data): 

174 """Create an _py_anon_pod1 instance wrapping the given NumPy array. 

175  

176 Args: 

177 data (_numpy.ndarray): a single-element array of dtype `_py_anon_pod1_dtype` holding the data. 

178 """ 

179 return __from_data(data, "_py_anon_pod1_dtype", _py_anon_pod1_dtype, _py_anon_pod1) 

180  

181 @staticmethod (empty)

182 def from_ptr(intptr_t ptr, bint readonly=False, object owner=None): 

183 """Create an _py_anon_pod1 instance wrapping the given pointer. 

184  

185 Args: 

186 ptr (intptr_t): pointer address as Python :class:`int` to the data. 

187 owner (object): The Python object that owns the pointer. If not provided, data will be copied. 

188 readonly (bool): whether the data is read-only (to the user). default is `False`. 

189 """ 

190 if ptr == 0: 

191 raise ValueError("ptr must not be null (0)") 

192 cdef _py_anon_pod1 obj = _py_anon_pod1.__new__(_py_anon_pod1) 

193 if owner is None: 

194 obj._ptr = <_anon_pod1 *>malloc(sizeof((<CUfileDescr_t*>NULL).handle)) 

195 if obj._ptr == NULL: 

196 raise MemoryError("Error allocating _py_anon_pod1") 

197 memcpy(<void*>(obj._ptr), <void*>ptr, sizeof((<CUfileDescr_t*>NULL).handle)) 

198 obj._owner = None 

199 obj._owned = True 

200 else: 

201 obj._ptr = <_anon_pod1 *>ptr 

202 obj._owner = owner 

203 obj._owned = False 

204 obj._readonly = readonly 

205 return obj 

206  

207  

208cdef _get__py_anon_pod3_dtype_offsets(): (empty)

209 cdef _anon_pod3 pod = _anon_pod3() (empty)

210 return _numpy.dtype({ (empty)

211 'names': ['dev_ptr_base', 'file_offset', 'dev_ptr_offset', 'size_'], (empty)

212 'formats': [_numpy.intp, _numpy.int64, _numpy.int64, _numpy.uint64], (empty)

213 'offsets': [ (empty)

214 (<intptr_t>&(pod.devPtr_base)) - (<intptr_t>&pod), (empty)

215 (<intptr_t>&(pod.file_offset)) - (<intptr_t>&pod), (empty)

216 (<intptr_t>&(pod.devPtr_offset)) - (<intptr_t>&pod), (empty)

217 (<intptr_t>&(pod.size)) - (<intptr_t>&pod), (empty)

218 ], 

219 'itemsize': sizeof((<CUfileIOParams_t*>NULL).u.batch), (empty)

220 }) 

221  

222_py_anon_pod3_dtype = _get__py_anon_pod3_dtype_offsets() (empty)

223  

224cdef class _py_anon_pod3: 

225 """Empty-initialize an instance of `_anon_pod3`. 

226  

227  

228 .. seealso:: `_anon_pod3` 

229 """ 

230 cdef: 

231 _anon_pod3 *_ptr 

232 object _owner 

233 bint _owned 

234 bint _readonly 

235  

236 def __init__(self): 

237 self._ptr = <_anon_pod3 *>calloc(1, sizeof((<CUfileIOParams_t*>NULL).u.batch)) 

238 if self._ptr == NULL: 

239 raise MemoryError("Error allocating _py_anon_pod3") 

240 self._owner = None 

241 self._owned = True 

242 self._readonly = False 

243  

244 def __dealloc__(self): 

245 cdef _anon_pod3 *ptr 

246 if self._owned and self._ptr != NULL: 

247 ptr = self._ptr 

248 self._ptr = NULL 

249 free(ptr) 

250  

251 def __repr__(self): 

252 return f"<{__name__}._py_anon_pod3 object at {hex(id(self))}>" 

253  

254 @property 

255 def ptr(self): 

256 """Get the pointer address to the data as Python :class:`int`.""" 

257 return <intptr_t>(self._ptr) 

258  

259 cdef intptr_t _get_ptr(self): (empty)

260 return <intptr_t>(self._ptr) 

261  

262 def __int__(self): 

263 return <intptr_t>(self._ptr) 

264  

265 def __eq__(self, other): 

266 cdef _py_anon_pod3 other_ 

267 if not isinstance(other, _py_anon_pod3): 

268 return False 

269 other_ = other 

270 return (memcmp(<void *><intptr_t>(self._ptr), <void *><intptr_t>(other_._ptr), sizeof((<CUfileIOParams_t*>NULL).u.batch)) == 0) 

271  

272 def __getbuffer__(self, Py_buffer *buffer, int flags): 

273 __getbuffer(self, buffer, <void *>self._ptr, sizeof((<CUfileIOParams_t*>NULL).u.batch), self._readonly) 

274  

275 def __releasebuffer__(self, Py_buffer *buffer): 

276 pass 

277  

278 def __setitem__(self, key, val): 

279 if key == 0 and isinstance(val, _numpy.ndarray): 

280 self._ptr = <_anon_pod3 *>malloc(sizeof((<CUfileIOParams_t*>NULL).u.batch)) 

281 if self._ptr == NULL: 

282 raise MemoryError("Error allocating _py_anon_pod3") 

283 memcpy(<void*>self._ptr, <void*><intptr_t>val.ctypes.data, sizeof((<CUfileIOParams_t*>NULL).u.batch)) 

284 self._owner = None 

285 self._owned = True 

286 self._readonly = not val.flags.writeable 

287 else: 

288 setattr(self, key, val) 

289  

290 @property 

291 def dev_ptr_base(self): 

292 """int: """ 

293 return <intptr_t>(self._ptr[0].devPtr_base) 

294  

295 @dev_ptr_base.setter 

296 def dev_ptr_base(self, val): 

297 if self._readonly: 

298 raise ValueError("This _py_anon_pod3 instance is read-only") 

299 self._ptr[0].devPtr_base = <void *><intptr_t>val 

300  

301 @property 

302 def file_offset(self): 

303 """int: """ 

304 return self._ptr[0].file_offset 

305  

306 @file_offset.setter 

307 def file_offset(self, val): 

308 if self._readonly: 

309 raise ValueError("This _py_anon_pod3 instance is read-only") 

310 self._ptr[0].file_offset = val 

311  

312 @property 

313 def dev_ptr_offset(self): 

314 """int: """ 

315 return self._ptr[0].devPtr_offset 

316  

317 @dev_ptr_offset.setter 

318 def dev_ptr_offset(self, val): 

319 if self._readonly: 

320 raise ValueError("This _py_anon_pod3 instance is read-only") 

321 self._ptr[0].devPtr_offset = val 

322  

323 @property 

324 def size_(self): 

325 """int: """ 

326 return self._ptr[0].size 

327  

328 @size_.setter 

329 def size_(self, val): 

330 if self._readonly: 

331 raise ValueError("This _py_anon_pod3 instance is read-only") 

332 self._ptr[0].size = val 

333  

334 @staticmethod (empty)

335 def from_buffer(buffer): 

336 """Create an _py_anon_pod3 instance with the memory from the given buffer.""" 

337 return __from_buffer(buffer, sizeof((<CUfileIOParams_t*>NULL).u.batch), _py_anon_pod3) 

338  

339 @staticmethod (empty)

340 def from_data(data): 

341 """Create an _py_anon_pod3 instance wrapping the given NumPy array. 

342  

343 Args: 

344 data (_numpy.ndarray): a single-element array of dtype `_py_anon_pod3_dtype` holding the data. 

345 """ 

346 return __from_data(data, "_py_anon_pod3_dtype", _py_anon_pod3_dtype, _py_anon_pod3) 

347  

348 @staticmethod (empty)

349 def from_ptr(intptr_t ptr, bint readonly=False, object owner=None): 

350 """Create an _py_anon_pod3 instance wrapping the given pointer. 

351  

352 Args: 

353 ptr (intptr_t): pointer address as Python :class:`int` to the data. 

354 owner (object): The Python object that owns the pointer. If not provided, data will be copied. 

355 readonly (bool): whether the data is read-only (to the user). default is `False`. 

356 """ 

357 if ptr == 0: 

358 raise ValueError("ptr must not be null (0)") 

359 cdef _py_anon_pod3 obj = _py_anon_pod3.__new__(_py_anon_pod3) 

360 if owner is None: 

361 obj._ptr = <_anon_pod3 *>malloc(sizeof((<CUfileIOParams_t*>NULL).u.batch)) 

362 if obj._ptr == NULL: 

363 raise MemoryError("Error allocating _py_anon_pod3") 

364 memcpy(<void*>(obj._ptr), <void*>ptr, sizeof((<CUfileIOParams_t*>NULL).u.batch)) 

365 obj._owner = None 

366 obj._owned = True 

367 else: 

368 obj._ptr = <_anon_pod3 *>ptr 

369 obj._owner = owner 

370 obj._owned = False 

371 obj._readonly = readonly 

372 return obj 

373  

374  

375cdef _get_io_events_dtype_offsets(): (empty)

376 cdef CUfileIOEvents_t pod = CUfileIOEvents_t() (empty)

377 return _numpy.dtype({ (empty)

378 'names': ['cookie', 'status', 'ret'], (empty)

379 'formats': [_numpy.intp, _numpy.int32, _numpy.uint64], (empty)

380 'offsets': [ (empty)

381 (<intptr_t>&(pod.cookie)) - (<intptr_t>&pod), (empty)

382 (<intptr_t>&(pod.status)) - (<intptr_t>&pod), (empty)

383 (<intptr_t>&(pod.ret)) - (<intptr_t>&pod), (empty)

384 ], 

385 'itemsize': sizeof(CUfileIOEvents_t), (empty)

386 }) 

387  

388io_events_dtype = _get_io_events_dtype_offsets() (empty)

389  

390cdef class IOEvents: 

391 """Empty-initialize an array of `CUfileIOEvents_t`. 

392  

393 The resulting object is of length `size` and of dtype `io_events_dtype`. 

394 If default-constructed, the instance represents a single struct. 

395  

396 Args: 

397 size (int): number of structs, default=1. 

398  

399  

400 .. seealso:: `CUfileIOEvents_t` 

401 """ 

402 cdef: 

403 readonly object _data 

404  

405  

406  

407 def __init__(self, size=1): 

408 arr = _numpy.empty(size, dtype=io_events_dtype) 

409 self._data = arr.view(_numpy.recarray) 

410 assert self._data.itemsize == sizeof(CUfileIOEvents_t), \ 

411 f"itemsize {self._data.itemsize} mismatches struct size { sizeof(CUfileIOEvents_t) }" 

412  

413 def __repr__(self): 

414 if self._data.size > 1: 

415 return f"<{__name__}.IOEvents_Array_{self._data.size} object at {hex(id(self))}>" 

416 else: 

417 return f"<{__name__}.IOEvents object at {hex(id(self))}>" 

418  

419 @property 

420 def ptr(self): 

421 """Get the pointer address to the data as Python :class:`int`.""" 

422 return self._data.ctypes.data 

423  

424 cdef intptr_t _get_ptr(self): (empty)

425 return self._data.ctypes.data 

426  

427 def __int__(self): 

428 if self._data.size > 1: 

429 raise TypeError("int() argument must be a bytes-like object of size 1. " 

430 "To get the pointer address of an array, use .ptr") 

431 return self._data.ctypes.data 

432  

433 def __len__(self): 

434 return self._data.size 

435  

436 def __eq__(self, other): 

437 cdef object self_data = self._data 

438 if (not isinstance(other, IOEvents)) or self_data.size != other._data.size or self_data.dtype != other._data.dtype: 

439 return False 

440 return bool((self_data == other._data).all()) 

441  

442 def __getbuffer__(self, Py_buffer *buffer, int flags): 

443 cpython.PyObject_GetBuffer(self._data, buffer, flags) 

444  

445 def __releasebuffer__(self, Py_buffer *buffer): 

446 cpython.PyBuffer_Release(buffer) 

447  

448 @property 

449 def cookie(self): 

450 """Union[~_numpy.intp, int]: """ 

451 if self._data.size == 1: 

452 return int(self._data.cookie[0]) 

453 return self._data.cookie 

454  

455 @cookie.setter 

456 def cookie(self, val): 

457 self._data.cookie = val 

458  

459 @property 

460 def status(self): 

461 """Union[~_numpy.int32, int]: """ 

462 if self._data.size == 1: 

463 return int(self._data.status[0]) 

464 return self._data.status 

465  

466 @status.setter 

467 def status(self, val): 

468 self._data.status = val 

469  

470 @property 

471 def ret(self): 

472 """Union[~_numpy.uint64, int]: """ 

473 if self._data.size == 1: 

474 return int(self._data.ret[0]) 

475 return self._data.ret 

476  

477 @ret.setter 

478 def ret(self, val): 

479 self._data.ret = val 

480  

481 def __getitem__(self, key): 

482 cdef ssize_t key_ 

483 cdef ssize_t size 

484 if isinstance(key, int): 

485 key_ = key 

486 size = self._data.size 

487 if key_ >= size or key_ <= -(size+1): 

488 raise IndexError("index is out of bounds") 

489 if key_ < 0: 

490 key_ += size 

491 return IOEvents.from_data(self._data[key_:key_+1]) 

492 out = self._data[key] 

493 if isinstance(out, _numpy.recarray) and out.dtype == io_events_dtype: 

494 return IOEvents.from_data(out) 

495 return out 

496  

497 def __setitem__(self, key, val): 

498 self._data[key] = val 

499  

500 @staticmethod (empty)

501 def from_buffer(buffer): 

502 """Create an IOEvents instance with the memory from the given buffer.""" 

503 return IOEvents.from_data(_numpy.frombuffer(buffer, dtype=io_events_dtype)) 

504  

505 @staticmethod (empty)

506 def from_data(data): 

507 """Create an IOEvents instance wrapping the given NumPy array. 

508  

509 Args: 

510 data (_numpy.ndarray): a 1D array of dtype `io_events_dtype` holding the data. 

511 """ 

512 cdef IOEvents obj = IOEvents.__new__(IOEvents) 

513 if not isinstance(data, _numpy.ndarray): 

514 raise TypeError("data argument must be a NumPy ndarray") 

515 if data.ndim != 1: 

516 raise ValueError("data array must be 1D") 

517 if data.dtype != io_events_dtype: 

518 raise ValueError("data array must be of dtype io_events_dtype") 

519 obj._data = data.view(_numpy.recarray) 

520  

521 return obj 

522  

523 @staticmethod (empty)

524 def from_ptr(intptr_t ptr, size_t size=1, bint readonly=False): 

525 """Create an IOEvents instance wrapping the given pointer. 

526  

527 Args: 

528 ptr (intptr_t): pointer address as Python :class:`int` to the data. 

529 size (int): number of structs, default=1. 

530 readonly (bool): whether the data is read-only (to the user). default is `False`. 

531 """ 

532 if ptr == 0: 

533 raise ValueError("ptr must not be null (0)") 

534 cdef IOEvents obj = IOEvents.__new__(IOEvents) 

535 cdef flag = cpython.buffer.PyBUF_READ if readonly else cpython.buffer.PyBUF_WRITE 

536 cdef object buf = cpython.memoryview.PyMemoryView_FromMemory( 

537 <char*>ptr, sizeof(CUfileIOEvents_t) * size, flag) 

538 data = _numpy.ndarray(size, buffer=buf, dtype=io_events_dtype) 

539 obj._data = data.view(_numpy.recarray) 

540  

541 return obj 

542  

543  

544cdef _get_op_counter_dtype_offsets(): (empty)

545 cdef CUfileOpCounter_t pod = CUfileOpCounter_t() (empty)

546 return _numpy.dtype({ (empty)

547 'names': ['ok', 'err'], (empty)

548 'formats': [_numpy.uint64, _numpy.uint64], (empty)

549 'offsets': [ (empty)

550 (<intptr_t>&(pod.ok)) - (<intptr_t>&pod), (empty)

551 (<intptr_t>&(pod.err)) - (<intptr_t>&pod), (empty)

552 ], 

553 'itemsize': sizeof(CUfileOpCounter_t), (empty)

554 }) 

555  

556op_counter_dtype = _get_op_counter_dtype_offsets() (empty)

557  

558cdef class OpCounter: 

559 """Empty-initialize an instance of `CUfileOpCounter_t`. 

560  

561  

562 .. seealso:: `CUfileOpCounter_t` 

563 """ 

564 cdef: 

565 CUfileOpCounter_t *_ptr 

566 object _owner 

567 bint _owned 

568 bint _readonly 

569  

570 def __init__(self): 

571 self._ptr = <CUfileOpCounter_t *>calloc(1, sizeof(CUfileOpCounter_t)) 

572 if self._ptr == NULL: 

573 raise MemoryError("Error allocating OpCounter") 

574 self._owner = None 

575 self._owned = True 

576 self._readonly = False 

577  

578 def __dealloc__(self): 

579 cdef CUfileOpCounter_t *ptr 

580 if self._owned and self._ptr != NULL: 

581 ptr = self._ptr 

582 self._ptr = NULL 

583 free(ptr) 

584  

585 def __repr__(self): 

586 return f"<{__name__}.OpCounter object at {hex(id(self))}>" 

587  

588 @property 

589 def ptr(self): 

590 """Get the pointer address to the data as Python :class:`int`.""" 

591 return <intptr_t>(self._ptr) 

592  

593 cdef intptr_t _get_ptr(self): (empty)

594 return <intptr_t>(self._ptr) 

595  

596 def __int__(self): 

597 return <intptr_t>(self._ptr) 

598  

599 def __eq__(self, other): 

600 cdef OpCounter other_ 

601 if not isinstance(other, OpCounter): 

602 return False 

603 other_ = other 

604 return (memcmp(<void *><intptr_t>(self._ptr), <void *><intptr_t>(other_._ptr), sizeof(CUfileOpCounter_t)) == 0) 

605  

606 def __getbuffer__(self, Py_buffer *buffer, int flags): 

607 __getbuffer(self, buffer, <void *>self._ptr, sizeof(CUfileOpCounter_t), self._readonly) 

608  

609 def __releasebuffer__(self, Py_buffer *buffer): 

610 pass 

611  

612 def __setitem__(self, key, val): 

613 if key == 0 and isinstance(val, _numpy.ndarray): 

614 self._ptr = <CUfileOpCounter_t *>malloc(sizeof(CUfileOpCounter_t)) 

615 if self._ptr == NULL: 

616 raise MemoryError("Error allocating OpCounter") 

617 memcpy(<void*>self._ptr, <void*><intptr_t>val.ctypes.data, sizeof(CUfileOpCounter_t)) 

618 self._owner = None 

619 self._owned = True 

620 self._readonly = not val.flags.writeable 

621 else: 

622 setattr(self, key, val) 

623  

624 @property 

625 def ok(self): 

626 """int: """ 

627 return self._ptr[0].ok 

628  

629 @ok.setter 

630 def ok(self, val): 

631 if self._readonly: 

632 raise ValueError("This OpCounter instance is read-only") 

633 self._ptr[0].ok = val 

634  

635 @property 

636 def err(self): 

637 """int: """ 

638 return self._ptr[0].err 

639  

640 @err.setter 

641 def err(self, val): 

642 if self._readonly: 

643 raise ValueError("This OpCounter instance is read-only") 

644 self._ptr[0].err = val 

645  

646 @staticmethod (empty)

647 def from_buffer(buffer): 

648 """Create an OpCounter instance with the memory from the given buffer.""" 

649 return __from_buffer(buffer, sizeof(CUfileOpCounter_t), OpCounter) 

650  

651 @staticmethod (empty)

652 def from_data(data): 

653 """Create an OpCounter instance wrapping the given NumPy array. 

654  

655 Args: 

656 data (_numpy.ndarray): a single-element array of dtype `op_counter_dtype` holding the data. 

657 """ 

658 return __from_data(data, "op_counter_dtype", op_counter_dtype, OpCounter) 

659  

660 @staticmethod (empty)

661 def from_ptr(intptr_t ptr, bint readonly=False, object owner=None): 

662 """Create an OpCounter instance wrapping the given pointer. 

663  

664 Args: 

665 ptr (intptr_t): pointer address as Python :class:`int` to the data. 

666 owner (object): The Python object that owns the pointer. If not provided, data will be copied. 

667 readonly (bool): whether the data is read-only (to the user). default is `False`. 

668 """ 

669 if ptr == 0: 

670 raise ValueError("ptr must not be null (0)") 

671 cdef OpCounter obj = OpCounter.__new__(OpCounter) 

672 if owner is None: 

673 obj._ptr = <CUfileOpCounter_t *>malloc(sizeof(CUfileOpCounter_t)) 

674 if obj._ptr == NULL: 

675 raise MemoryError("Error allocating OpCounter") 

676 memcpy(<void*>(obj._ptr), <void*>ptr, sizeof(CUfileOpCounter_t)) 

677 obj._owner = None 

678 obj._owned = True 

679 else: 

680 obj._ptr = <CUfileOpCounter_t *>ptr 

681 obj._owner = owner 

682 obj._owned = False 

683 obj._readonly = readonly 

684 return obj 

685  

686  

687cdef _get_per_gpu_stats_dtype_offsets(): (empty)

688 cdef CUfilePerGpuStats_t pod = CUfilePerGpuStats_t() (empty)

689 return _numpy.dtype({ (empty)

690 'names': ['uuid', 'read_bytes', 'read_bw_bytes_per_sec', 'read_utilization', 'read_duration_us', 'n_total_reads', 'n_p2p_reads', 'n_nvfs_reads', 'n_posix_reads', 'n_unaligned_reads', 'n_dr_reads', 'n_sparse_regions', 'n_inline_regions', 'n_reads_err', 'writes_bytes', 'write_bw_bytes_per_sec', 'write_utilization', 'write_duration_us', 'n_total_writes', 'n_p2p_writes', 'n_nvfs_writes', 'n_posix_writes', 'n_unaligned_writes', 'n_dr_writes', 'n_writes_err', 'n_mmap', 'n_mmap_ok', 'n_mmap_err', 'n_mmap_free', 'reg_bytes'], (empty)

691 'formats': [(_numpy.int8, 16), _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64, _numpy.uint64], (empty)

692 'offsets': [ (empty)

693 (<intptr_t>&(pod.uuid)) - (<intptr_t>&pod), (empty)

694 (<intptr_t>&(pod.read_bytes)) - (<intptr_t>&pod), (empty)

695 (<intptr_t>&(pod.read_bw_bytes_per_sec)) - (<intptr_t>&pod), (empty)

696 (<intptr_t>&(pod.read_utilization)) - (<intptr_t>&pod), (empty)

697 (<intptr_t>&(pod.read_duration_us)) - (<intptr_t>&pod), (empty)

698 (<intptr_t>&(pod.n_total_reads)) - (<intptr_t>&pod), (empty)

699 (<intptr_t>&(pod.n_p2p_reads)) - (<intptr_t>&pod), (empty)

700 (<intptr_t>&(pod.n_nvfs_reads)) - (<intptr_t>&pod), (empty)

701 (<intptr_t>&(pod.n_posix_reads)) - (<intptr_t>&pod), (empty)

702 (<intptr_t>&(pod.n_unaligned_reads)) - (<intptr_t>&pod), (empty)

703 (<intptr_t>&(pod.n_dr_reads)) - (<intptr_t>&pod), (empty)

704 (<intptr_t>&(pod.n_sparse_regions)) - (<intptr_t>&pod), (empty)

705 (<intptr_t>&(pod.n_inline_regions)) - (<intptr_t>&pod), (empty)

706 (<intptr_t>&(pod.n_reads_err)) - (<intptr_t>&pod), (empty)

707 (<intptr_t>&(pod.writes_bytes)) - (<intptr_t>&pod), (empty)

708 (<intptr_t>&(pod.write_bw_bytes_per_sec)) - (<intptr_t>&pod), (empty)

709 (<intptr_t>&(pod.write_utilization)) - (<intptr_t>&pod), (empty)

710 (<intptr_t>&(pod.write_duration_us)) - (<intptr_t>&pod), (empty)

711 (<intptr_t>&(pod.n_total_writes)) - (<intptr_t>&pod), (empty)

712 (<intptr_t>&(pod.n_p2p_writes)) - (<intptr_t>&pod), (empty)

713 (<intptr_t>&(pod.n_nvfs_writes)) - (<intptr_t>&pod), (empty)

714 (<intptr_t>&(pod.n_posix_writes)) - (<intptr_t>&pod), (empty)

715 (<intptr_t>&(pod.n_unaligned_writes)) - (<intptr_t>&pod), (empty)

716 (<intptr_t>&(pod.n_dr_writes)) - (<intptr_t>&pod), (empty)

717 (<intptr_t>&(pod.n_writes_err)) - (<intptr_t>&pod), (empty)

718 (<intptr_t>&(pod.n_mmap)) - (<intptr_t>&pod), (empty)

719 (<intptr_t>&(pod.n_mmap_ok)) - (<intptr_t>&pod), (empty)

720 (<intptr_t>&(pod.n_mmap_err)) - (<intptr_t>&pod), (empty)

721 (<intptr_t>&(pod.n_mmap_free)) - (<intptr_t>&pod), (empty)

722 (<intptr_t>&(pod.reg_bytes)) - (<intptr_t>&pod), (empty)

723 ], 

724 'itemsize': sizeof(CUfilePerGpuStats_t), (empty)

725 }) 

726  

727per_gpu_stats_dtype = _get_per_gpu_stats_dtype_offsets() (empty)

728  

729cdef class PerGpuStats: 

730 """Empty-initialize an array of `CUfilePerGpuStats_t`. 

731  

732 The resulting object is of length `size` and of dtype `per_gpu_stats_dtype`. 

733 If default-constructed, the instance represents a single struct. 

734  

735 Args: 

736 size (int): number of structs, default=1. 

737  

738  

739 .. seealso:: `CUfilePerGpuStats_t` 

740 """ 

741 cdef: 

742 readonly object _data 

743  

744  

745  

746 def __init__(self, size=1): 

747 arr = _numpy.empty(size, dtype=per_gpu_stats_dtype) 

748 self._data = arr.view(_numpy.recarray) 

749 assert self._data.itemsize == sizeof(CUfilePerGpuStats_t), \ 

750 f"itemsize {self._data.itemsize} mismatches struct size { sizeof(CUfilePerGpuStats_t) }" 

751  

752 def __repr__(self): 

753 if self._data.size > 1: 

754 return f"<{__name__}.PerGpuStats_Array_{self._data.size} object at {hex(id(self))}>" 

755 else: 

756 return f"<{__name__}.PerGpuStats object at {hex(id(self))}>" 

757  

758 @property 

759 def ptr(self): 

760 """Get the pointer address to the data as Python :class:`int`.""" 

761 return self._data.ctypes.data 

762  

763 cdef intptr_t _get_ptr(self): (empty)

764 return self._data.ctypes.data 

765  

766 def __int__(self): 

767 if self._data.size > 1: 

768 raise TypeError("int() argument must be a bytes-like object of size 1. " 

769 "To get the pointer address of an array, use .ptr") 

770 return self._data.ctypes.data 

771  

772 def __len__(self): 

773 return self._data.size 

774  

775 def __eq__(self, other): 

776 cdef object self_data = self._data 

777 if (not isinstance(other, PerGpuStats)) or self_data.size != other._data.size or self_data.dtype != other._data.dtype: 

778 return False 

779 return bool((self_data == other._data).all()) 

780  

781 def __getbuffer__(self, Py_buffer *buffer, int flags): 

782 cpython.PyObject_GetBuffer(self._data, buffer, flags) 

783  

784 def __releasebuffer__(self, Py_buffer *buffer): 

785 cpython.PyBuffer_Release(buffer) 

786  

787 @property 

788 def uuid(self): 

789 """~_numpy.int8: (array of length 16).""" 

790 return self._data.uuid 

791  

792 @uuid.setter 

793 def uuid(self, val): 

794 self._data.uuid = val 

795  

796 @property 

797 def read_bytes(self): 

798 """Union[~_numpy.uint64, int]: """ 

799 if self._data.size == 1: 

800 return int(self._data.read_bytes[0]) 

801 return self._data.read_bytes 

802  

803 @read_bytes.setter 

804 def read_bytes(self, val): 

805 self._data.read_bytes = val 

806  

807 @property 

808 def read_bw_bytes_per_sec(self): 

809 """Union[~_numpy.uint64, int]: """ 

810 if self._data.size == 1: 

811 return int(self._data.read_bw_bytes_per_sec[0]) 

812 return self._data.read_bw_bytes_per_sec 

813  

814 @read_bw_bytes_per_sec.setter 

815 def read_bw_bytes_per_sec(self, val): 

816 self._data.read_bw_bytes_per_sec = val 

817  

818 @property 

819 def read_utilization(self): 

820 """Union[~_numpy.uint64, int]: """ 

821 if self._data.size == 1: 

822 return int(self._data.read_utilization[0]) 

823 return self._data.read_utilization 

824  

825 @read_utilization.setter 

826 def read_utilization(self, val): 

827 self._data.read_utilization = val 

828  

829 @property 

830 def read_duration_us(self): 

831 """Union[~_numpy.uint64, int]: """ 

832 if self._data.size == 1: 

833 return int(self._data.read_duration_us[0]) 

834 return self._data.read_duration_us 

835  

836 @read_duration_us.setter 

837 def read_duration_us(self, val): 

838 self._data.read_duration_us = val 

839  

840 @property 

841 def n_total_reads(self): 

842 """Union[~_numpy.uint64, int]: """ 

843 if self._data.size == 1: 

844 return int(self._data.n_total_reads[0]) 

845 return self._data.n_total_reads 

846  

847 @n_total_reads.setter 

848 def n_total_reads(self, val): 

849 self._data.n_total_reads = val 

850  

851 @property 

852 def n_p2p_reads(self): 

853 """Union[~_numpy.uint64, int]: """ 

854 if self._data.size == 1: 

855 return int(self._data.n_p2p_reads[0]) 

856 return self._data.n_p2p_reads 

857  

858 @n_p2p_reads.setter 

859 def n_p2p_reads(self, val): 

860 self._data.n_p2p_reads = val 

861  

862 @property 

863 def n_nvfs_reads(self): 

864 """Union[~_numpy.uint64, int]: """ 

865 if self._data.size == 1: 

866 return int(self._data.n_nvfs_reads[0]) 

867 return self._data.n_nvfs_reads 

868  

869 @n_nvfs_reads.setter 

870 def n_nvfs_reads(self, val): 

871 self._data.n_nvfs_reads = val 

872  

873 @property 

874 def n_posix_reads(self): 

875 """Union[~_numpy.uint64, int]: """ 

876 if self._data.size == 1: 

877 return int(self._data.n_posix_reads[0]) 

878 return self._data.n_posix_reads 

879  

880 @n_posix_reads.setter 

881 def n_posix_reads(self, val): 

882 self._data.n_posix_reads = val 

883  

884 @property 

885 def n_unaligned_reads(self): 

886 """Union[~_numpy.uint64, int]: """ 

887 if self._data.size == 1: 

888 return int(self._data.n_unaligned_reads[0]) 

889 return self._data.n_unaligned_reads 

890  

891 @n_unaligned_reads.setter 

892 def n_unaligned_reads(self, val): 

893 self._data.n_unaligned_reads = val 

894  

895 @property 

896 def n_dr_reads(self): 

897 """Union[~_numpy.uint64, int]: """ 

898 if self._data.size == 1: 

899 return int(self._data.n_dr_reads[0]) 

900 return self._data.n_dr_reads 

901  

902 @n_dr_reads.setter 

903 def n_dr_reads(self, val): 

904 self._data.n_dr_reads = val 

905  

906 @property 

907 def n_sparse_regions(self): 

908 """Union[~_numpy.uint64, int]: """ 

909 if self._data.size == 1: 

910 return int(self._data.n_sparse_regions[0]) 

911 return self._data.n_sparse_regions 

912  

913 @n_sparse_regions.setter 

914 def n_sparse_regions(self, val): 

915 self._data.n_sparse_regions = val 

916  

917 @property 

918 def n_inline_regions(self): 

919 """Union[~_numpy.uint64, int]: """ 

920 if self._data.size == 1: 

921 return int(self._data.n_inline_regions[0]) 

922 return self._data.n_inline_regions 

923  

924 @n_inline_regions.setter 

925 def n_inline_regions(self, val): 

926 self._data.n_inline_regions = val 

927  

928 @property 

929 def n_reads_err(self): 

930 """Union[~_numpy.uint64, int]: """ 

931 if self._data.size == 1: 

932 return int(self._data.n_reads_err[0]) 

933 return self._data.n_reads_err 

934  

935 @n_reads_err.setter 

936 def n_reads_err(self, val): 

937 self._data.n_reads_err = val 

938  

939 @property 

940 def writes_bytes(self): 

941 """Union[~_numpy.uint64, int]: """ 

942 if self._data.size == 1: 

943 return int(self._data.writes_bytes[0]) 

944 return self._data.writes_bytes 

945  

946 @writes_bytes.setter 

947 def writes_bytes(self, val): 

948 self._data.writes_bytes = val 

949  

950 @property 

951 def write_bw_bytes_per_sec(self): 

952 """Union[~_numpy.uint64, int]: """ 

953 if self._data.size == 1: 

954 return int(self._data.write_bw_bytes_per_sec[0]) 

955 return self._data.write_bw_bytes_per_sec 

956  

957 @write_bw_bytes_per_sec.setter 

958 def write_bw_bytes_per_sec(self, val): 

959 self._data.write_bw_bytes_per_sec = val 

960  

961 @property 

962 def write_utilization(self): 

963 """Union[~_numpy.uint64, int]: """ 

964 if self._data.size == 1: 

965 return int(self._data.write_utilization[0]) 

966 return self._data.write_utilization 

967  

968 @write_utilization.setter 

969 def write_utilization(self, val): 

970 self._data.write_utilization = val 

971  

972 @property 

973 def write_duration_us(self): 

974 """Union[~_numpy.uint64, int]: """ 

975 if self._data.size == 1: 

976 return int(self._data.write_duration_us[0]) 

977 return self._data.write_duration_us 

978  

979 @write_duration_us.setter 

980 def write_duration_us(self, val): 

981 self._data.write_duration_us = val 

982  

983 @property 

984 def n_total_writes(self): 

985 """Union[~_numpy.uint64, int]: """ 

986 if self._data.size == 1: 

987 return int(self._data.n_total_writes[0]) 

988 return self._data.n_total_writes 

989  

990 @n_total_writes.setter 

991 def n_total_writes(self, val): 

992 self._data.n_total_writes = val 

993  

994 @property 

995 def n_p2p_writes(self): 

996 """Union[~_numpy.uint64, int]: """ 

997 if self._data.size == 1: 

998 return int(self._data.n_p2p_writes[0]) 

999 return self._data.n_p2p_writes 

1000  

1001 @n_p2p_writes.setter 

1002 def n_p2p_writes(self, val): 

1003 self._data.n_p2p_writes = val 

1004  

1005 @property 

1006 def n_nvfs_writes(self): 

1007 """Union[~_numpy.uint64, int]: """ 

1008 if self._data.size == 1: 

1009 return int(self._data.n_nvfs_writes[0]) 

1010 return self._data.n_nvfs_writes 

1011  

1012 @n_nvfs_writes.setter 

1013 def n_nvfs_writes(self, val): 

1014 self._data.n_nvfs_writes = val 

1015  

1016 @property 

1017 def n_posix_writes(self): 

1018 """Union[~_numpy.uint64, int]: """ 

1019 if self._data.size == 1: 

1020 return int(self._data.n_posix_writes[0]) 

1021 return self._data.n_posix_writes 

1022  

1023 @n_posix_writes.setter 

1024 def n_posix_writes(self, val): 

1025 self._data.n_posix_writes = val 

1026  

1027 @property 

1028 def n_unaligned_writes(self): 

1029 """Union[~_numpy.uint64, int]: """ 

1030 if self._data.size == 1: 

1031 return int(self._data.n_unaligned_writes[0]) 

1032 return self._data.n_unaligned_writes 

1033  

1034 @n_unaligned_writes.setter 

1035 def n_unaligned_writes(self, val): 

1036 self._data.n_unaligned_writes = val 

1037  

1038 @property 

1039 def n_dr_writes(self): 

1040 """Union[~_numpy.uint64, int]: """ 

1041 if self._data.size == 1: 

1042 return int(self._data.n_dr_writes[0]) 

1043 return self._data.n_dr_writes 

1044  

1045 @n_dr_writes.setter 

1046 def n_dr_writes(self, val): 

1047 self._data.n_dr_writes = val 

1048  

1049 @property 

1050 def n_writes_err(self): 

1051 """Union[~_numpy.uint64, int]: """ 

1052 if self._data.size == 1: 

1053 return int(self._data.n_writes_err[0]) 

1054 return self._data.n_writes_err 

1055  

1056 @n_writes_err.setter 

1057 def n_writes_err(self, val): 

1058 self._data.n_writes_err = val 

1059  

1060 @property 

1061 def n_mmap(self): 

1062 """Union[~_numpy.uint64, int]: """ 

1063 if self._data.size == 1: 

1064 return int(self._data.n_mmap[0]) 

1065 return self._data.n_mmap 

1066  

1067 @n_mmap.setter 

1068 def n_mmap(self, val): 

1069 self._data.n_mmap = val 

1070  

1071 @property 

1072 def n_mmap_ok(self): 

1073 """Union[~_numpy.uint64, int]: """ 

1074 if self._data.size == 1: 

1075 return int(self._data.n_mmap_ok[0]) 

1076 return self._data.n_mmap_ok 

1077  

1078 @n_mmap_ok.setter 

1079 def n_mmap_ok(self, val): 

1080 self._data.n_mmap_ok = val 

1081  

1082 @property 

1083 def n_mmap_err(self): 

1084 """Union[~_numpy.uint64, int]: """ 

1085 if self._data.size == 1: 

1086 return int(self._data.n_mmap_err[0]) 

1087 return self._data.n_mmap_err 

1088  

1089 @n_mmap_err.setter 

1090 def n_mmap_err(self, val): 

1091 self._data.n_mmap_err = val 

1092  

1093 @property 

1094 def n_mmap_free(self): 

1095 """Union[~_numpy.uint64, int]: """ 

1096 if self._data.size == 1: 

1097 return int(self._data.n_mmap_free[0]) 

1098 return self._data.n_mmap_free 

1099  

1100 @n_mmap_free.setter 

1101 def n_mmap_free(self, val): 

1102 self._data.n_mmap_free = val 

1103  

1104 @property 

1105 def reg_bytes(self): 

1106 """Union[~_numpy.uint64, int]: """ 

1107 if self._data.size == 1: 

1108 return int(self._data.reg_bytes[0]) 

1109 return self._data.reg_bytes 

1110  

1111 @reg_bytes.setter 

1112 def reg_bytes(self, val): 

1113 self._data.reg_bytes = val 

1114  

1115 def __getitem__(self, key): 

1116 cdef ssize_t key_ 

1117 cdef ssize_t size 

1118 if isinstance(key, int): 

1119 key_ = key 

1120 size = self._data.size 

1121 if key_ >= size or key_ <= -(size+1): 

1122 raise IndexError("index is out of bounds") 

1123 if key_ < 0: 

1124 key_ += size 

1125 return PerGpuStats.from_data(self._data[key_:key_+1]) 

1126 out = self._data[key] 

1127 if isinstance(out, _numpy.recarray) and out.dtype == per_gpu_stats_dtype: 

1128 return PerGpuStats.from_data(out) 

1129 return out 

1130  

1131 def __setitem__(self, key, val): 

1132 self._data[key] = val 

1133  

1134 @staticmethod (empty)

1135 def from_buffer(buffer): 

1136 """Create an PerGpuStats instance with the memory from the given buffer.""" 

1137 return PerGpuStats.from_data(_numpy.frombuffer(buffer, dtype=per_gpu_stats_dtype)) 

1138  

1139 @staticmethod (empty)

1140 def from_data(data): 

1141 """Create an PerGpuStats instance wrapping the given NumPy array. 

1142  

1143 Args: 

1144 data (_numpy.ndarray): a 1D array of dtype `per_gpu_stats_dtype` holding the data. 

1145 """ 

1146 cdef PerGpuStats obj = PerGpuStats.__new__(PerGpuStats) 

1147 if not isinstance(data, _numpy.ndarray): 

1148 raise TypeError("data argument must be a NumPy ndarray") 

1149 if data.ndim != 1: 

1150 raise ValueError("data array must be 1D") 

1151 if data.dtype != per_gpu_stats_dtype: 

1152 raise ValueError("data array must be of dtype per_gpu_stats_dtype") 

1153 obj._data = data.view(_numpy.recarray) 

1154  

1155 return obj 

1156  

1157 @staticmethod (empty)

1158 def from_ptr(intptr_t ptr, size_t size=1, bint readonly=False): 

1159 """Create an PerGpuStats instance wrapping the given pointer. 

1160  

1161 Args: 

1162 ptr (intptr_t): pointer address as Python :class:`int` to the data. 

1163 size (int): number of structs, default=1. 

1164 readonly (bool): whether the data is read-only (to the user). default is `False`. 

1165 """ 

1166 if ptr == 0: 

1167 raise ValueError("ptr must not be null (0)") 

1168 cdef PerGpuStats obj = PerGpuStats.__new__(PerGpuStats) 

1169 cdef flag = cpython.buffer.PyBUF_READ if readonly else cpython.buffer.PyBUF_WRITE 

1170 cdef object buf = cpython.memoryview.PyMemoryView_FromMemory( 

1171 <char*>ptr, sizeof(CUfilePerGpuStats_t) * size, flag) 

1172 data = _numpy.ndarray(size, buffer=buf, dtype=per_gpu_stats_dtype) 

1173 obj._data = data.view(_numpy.recarray) 

1174  

1175 return obj 

1176  

1177  

1178cdef _get_descr_dtype_offsets(): (empty)

1179 cdef CUfileDescr_t pod = CUfileDescr_t() (empty)

1180 return _numpy.dtype({ (empty)

1181 'names': ['type', 'handle', 'fs_ops'], (empty)

1182 'formats': [_numpy.int32, _py_anon_pod1_dtype, _numpy.intp], (empty)

1183 'offsets': [ (empty)

1184 (<intptr_t>&(pod.type)) - (<intptr_t>&pod), (empty)

1185 (<intptr_t>&(pod.handle)) - (<intptr_t>&pod), (empty)

1186 (<intptr_t>&(pod.fs_ops)) - (<intptr_t>&pod), (empty)

1187 ], 

1188 'itemsize': sizeof(CUfileDescr_t), (empty)

1189 }) 

1190  

1191descr_dtype = _get_descr_dtype_offsets() (empty)

1192  

1193cdef class Descr: 

1194 """Empty-initialize an array of `CUfileDescr_t`. 

1195  

1196 The resulting object is of length `size` and of dtype `descr_dtype`. 

1197 If default-constructed, the instance represents a single struct. 

1198  

1199 Args: 

1200 size (int): number of structs, default=1. 

1201  

1202  

1203 .. seealso:: `CUfileDescr_t` 

1204 """ 

1205 cdef: 

1206 readonly object _data 

1207  

1208  

1209  

1210 def __init__(self, size=1): 

1211 arr = _numpy.empty(size, dtype=descr_dtype) 13 ctx1efgklhijmbcdn

1212 self._data = arr.view(_numpy.recarray) 13 ctx1efgklhijmbcdn

1213 assert self._data.itemsize == sizeof(CUfileDescr_t), \ 13 ctx1efgklhijmbcdn

1214 f"itemsize {self._data.itemsize} mismatches struct size { sizeof(CUfileDescr_t) }" 

1215  

1216 def __repr__(self): 

1217 if self._data.size > 1: 13 ctx1efgklhijmbcdn

1218 return f"<{__name__}.Descr_Array_{self._data.size} object at {hex(id(self))}>" 

1219 else: 

1220 return f"<{__name__}.Descr object at {hex(id(self))}>" 13 ctx1efgklhijmbcdn

1221  

1222 @property 

1223 def ptr(self): 

1224 """Get the pointer address to the data as Python :class:`int`.""" 

1225 return self._data.ctypes.data 13 ctx1efgklhijmbcdn

1226  

1227 cdef intptr_t _get_ptr(self): (empty)

1228 return self._data.ctypes.data 

1229  

1230 def __int__(self): 

1231 if self._data.size > 1: 

1232 raise TypeError("int() argument must be a bytes-like object of size 1. " 

1233 "To get the pointer address of an array, use .ptr") 

1234 return self._data.ctypes.data 

1235  

1236 def __len__(self): 

1237 return self._data.size 

1238  

1239 def __eq__(self, other): 

1240 cdef object self_data = self._data 

1241 if (not isinstance(other, Descr)) or self_data.size != other._data.size or self_data.dtype != other._data.dtype: 

1242 return False 

1243 return bool((self_data == other._data).all()) 

1244  

1245 def __getbuffer__(self, Py_buffer *buffer, int flags): 

1246 cpython.PyObject_GetBuffer(self._data, buffer, flags) 

1247  

1248 def __releasebuffer__(self, Py_buffer *buffer): 

1249 cpython.PyBuffer_Release(buffer) 

1250  

1251 @property 

1252 def type(self): 

1253 """Union[~_numpy.int32, int]: """ 

1254 if self._data.size == 1: 

1255 return int(self._data.type[0]) 

1256 return self._data.type 

1257  

1258 @type.setter 

1259 def type(self, val): 

1260 self._data.type = val 13 ctx1efgklhijmbcdn

1261  

1262 @property 

1263 def handle(self): 

1264 """_py_anon_pod1_dtype: """ 

1265 return self._data.handle 13 ctx1efgklhijmbcdn

1266  

1267 @handle.setter 

1268 def handle(self, val): 

1269 self._data.handle = val 

1270  

1271 @property 

1272 def fs_ops(self): 

1273 """Union[~_numpy.intp, int]: """ 

1274 if self._data.size == 1: 

1275 return int(self._data.fs_ops[0]) 

1276 return self._data.fs_ops 

1277  

1278 @fs_ops.setter 

1279 def fs_ops(self, val): 

1280 self._data.fs_ops = val 13 ctx1efgklhijmbcdn

1281  

1282 def __getitem__(self, key): 

1283 cdef ssize_t key_ 

1284 cdef ssize_t size 

1285 if isinstance(key, int): 

1286 key_ = key 

1287 size = self._data.size 

1288 if key_ >= size or key_ <= -(size+1): 

1289 raise IndexError("index is out of bounds") 

1290 if key_ < 0: 

1291 key_ += size 

1292 return Descr.from_data(self._data[key_:key_+1]) 

1293 out = self._data[key] 

1294 if isinstance(out, _numpy.recarray) and out.dtype == descr_dtype: 

1295 return Descr.from_data(out) 

1296 return out 

1297  

1298 def __setitem__(self, key, val): 

1299 self._data[key] = val 

1300  

1301 @staticmethod (empty)

1302 def from_buffer(buffer): 

1303 """Create an Descr instance with the memory from the given buffer.""" 

1304 return Descr.from_data(_numpy.frombuffer(buffer, dtype=descr_dtype)) 

1305  

1306 @staticmethod (empty)

1307 def from_data(data): 

1308 """Create an Descr instance wrapping the given NumPy array. 

1309  

1310 Args: