hyb
2026-01-09 4cb426cb3ae31e772a09d4ade5b2f0242aaeefa0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
# SPDX-License-Identifier: BSD-2-Clause
 
# Copyright (c) 2024 Phil Thompson <phil@riverbankcomputing.com>
 
 
from typing import Any, Generic, Iterable, overload, Sequence, TypeVar, Union
 
 
# PEP 484 has no explicit support for the buffer protocol so we just name types
# we know that implement it.
Buffer = Union[bytes, bytearray, memoryview, 'array', 'voidptr']
 
 
# Constants.
SIP_VERSION = ...       # type: int
SIP_VERSION_STR = ...   # type: str
 
 
# The bases for SIP generated types.
class wrappertype:
    def __init__(self, *args, **kwargs) -> None: ...
 
class simplewrapper:
    def __init__(self, *args, **kwargs) -> None: ...
 
class wrapper(simplewrapper): ...
 
 
# The array type.
_T = TypeVar('_T')
 
class array(Sequence[_T], Generic[_T]):
 
    @overload
    def __getitem__(self, key: int) -> _T: ...
    @overload
    def __getitem__(self, key: slice) -> 'array[_T]': ...
 
    @overload
    def __setitem__(self, key: int, value: _T) -> None: ...
    @overload
    def __setitem__(self, key: slice, value: Iterable[_T]) -> None: ...
 
    @overload
    def __delitem__(self, key: int) -> None: ...
    @overload
    def __delitem__(self, key: slice) -> None: ...
 
    def __len__(self) -> int: ...
 
 
# The voidptr type.
class voidptr:
 
    def __init__(self, addr: Union[int, Buffer], size: int = -1, writeable: bool = True) -> None: ...
 
    def __int__(self) -> int: ...
 
    @overload
    def __getitem__(self, i: int) -> bytes: ...
 
    @overload
    def __getitem__(self, s: slice) -> 'voidptr': ...
 
    def __len__(self) -> int: ...
 
    def __setitem__(self, i: Union[int, slice], v: Buffer) -> None: ...
 
    def asarray(self, size: int = -1) -> array[int]: ...
 
    # Python doesn't expose the capsule type.
    def ascapsule(self) -> Any: ...
 
    def asstring(self, size: int = -1) -> bytes: ...
 
    def getsize(self) -> int: ...
 
    def getwriteable(self) -> bool: ...
 
    def setsize(self, size: int) -> None: ...
 
    def setwriteable(self, writeable: bool) -> None: ...
 
 
# Remaining functions.
def assign(obj: simplewrapper, other: simplewrapper) -> None: ...
def cast(obj: simplewrapper, type: wrappertype) -> simplewrapper: ...
def delete(obj: simplewrapper) -> None: ...
def dump(obj: simplewrapper) -> None: ...
def enableautoconversion(type: wrappertype, enable: bool) -> bool: ...
def enableoverflowchecking(enable: bool) -> bool: ...
def getapi(name: str) -> int: ...
def isdeleted(obj: simplewrapper) -> bool: ...
def ispycreated(obj: simplewrapper) -> bool: ...
def ispyowned(obj: simplewrapper) -> bool: ...
def setapi(name: str, version: int) -> None: ...
def setdeleted(obj: simplewrapper) -> None: ...
def setdestroyonexit(destroy: bool) -> None: ...
def settracemask(mask: int) -> None: ...
def transferback(obj: wrapper) -> None: ...
def transferto(obj: wrapper, owner: wrapper) -> None: ...
def unwrapinstance(obj: simplewrapper) -> None: ...
def wrapinstance(addr: int, type: wrappertype) -> simplewrapper: ...