# encoding: utf-8 # module PyQt6.QtNetwork # from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\PyQt6\QtNetwork.pyd # by generator 1.147 # no doc # imports import enum as __enum import PyQt6.QtCore as __PyQt6_QtCore import PyQt6.sip as __PyQt6_sip from .QTcpSocket import QTcpSocket class QSslSocket(QTcpSocket): """ QSslSocket(parent: typing.Optional[QObject] = None) """ def activeBackend(self): # real signature unknown; restored from __doc__ """ activeBackend() -> str """ return "" def alertReceived(self, *args, **kwargs): # real signature unknown """ pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL types is normally a sequence of individual types. Each type is either a type object or a string that is the name of a C++ type. Alternatively each type could itself be a sequence of types each describing a different overloaded signal. name is the optional C++ name of the signal. If it is not specified then the name of the class attribute that is bound to the signal is used. revision is the optional revision of the signal that is exported to QML. If it is not specified then 0 is used. arguments is the optional sequence of the names of the signal's arguments. """ pass def alertSent(self, *args, **kwargs): # real signature unknown """ pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL types is normally a sequence of individual types. Each type is either a type object or a string that is the name of a C++ type. Alternatively each type could itself be a sequence of types each describing a different overloaded signal. name is the optional C++ name of the signal. If it is not specified then the name of the class attribute that is bound to the signal is used. revision is the optional revision of the signal that is exported to QML. If it is not specified then 0 is used. arguments is the optional sequence of the names of the signal's arguments. """ pass def atEnd(self): # real signature unknown; restored from __doc__ """ atEnd(self) -> bool """ return False def availableBackends(self): # real signature unknown; restored from __doc__ """ availableBackends() -> List[str] """ return [] def bytesAvailable(self): # real signature unknown; restored from __doc__ """ bytesAvailable(self) -> int """ return 0 def bytesToWrite(self): # real signature unknown; restored from __doc__ """ bytesToWrite(self) -> int """ return 0 def canReadLine(self): # real signature unknown; restored from __doc__ """ canReadLine(self) -> bool """ return False def childEvent(self, *args, **kwargs): # real signature unknown pass def close(self): # real signature unknown; restored from __doc__ """ close(self) """ pass def connectNotify(self, *args, **kwargs): # real signature unknown pass def connectToHost(self, hostName, port, mode=None, protocol=None): # real signature unknown; restored from __doc__ """ connectToHost(self, hostName: str, port: int, mode: QIODeviceBase.OpenModeFlag = QIODeviceBase.ReadWrite, protocol: QAbstractSocket.NetworkLayerProtocol = QAbstractSocket.AnyIPProtocol) """ pass def connectToHostEncrypted(self, hostName, port, *__args): # real signature unknown; restored from __doc__ with multiple overloads """ connectToHostEncrypted(self, hostName: str, port: int, mode: QIODeviceBase.OpenModeFlag = QIODeviceBase.ReadWrite, protocol: QAbstractSocket.NetworkLayerProtocol = QAbstractSocket.AnyIPProtocol) connectToHostEncrypted(self, hostName: str, port: int, sslPeerName: str, mode: QIODeviceBase.OpenModeFlag = QIODeviceBase.ReadWrite, protocol: QAbstractSocket.NetworkLayerProtocol = QAbstractSocket.AnyIPProtocol) """ pass def continueInterruptedHandshake(self): # real signature unknown; restored from __doc__ """ continueInterruptedHandshake(self) """ pass def customEvent(self, *args, **kwargs): # real signature unknown pass def disconnectFromHost(self): # real signature unknown; restored from __doc__ """ disconnectFromHost(self) """ pass def disconnectNotify(self, *args, **kwargs): # real signature unknown pass def encrypted(self, *args, **kwargs): # real signature unknown """ pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL types is normally a sequence of individual types. Each type is either a type object or a string that is the name of a C++ type. Alternatively each type could itself be a sequence of types each describing a different overloaded signal. name is the optional C++ name of the signal. If it is not specified then the name of the class attribute that is bound to the signal is used. revision is the optional revision of the signal that is exported to QML. If it is not specified then 0 is used. arguments is the optional sequence of the names of the signal's arguments. """ pass def encryptedBytesAvailable(self): # real signature unknown; restored from __doc__ """ encryptedBytesAvailable(self) -> int """ return 0 def encryptedBytesToWrite(self): # real signature unknown; restored from __doc__ """ encryptedBytesToWrite(self) -> int """ return 0 def encryptedBytesWritten(self, *args, **kwargs): # real signature unknown """ pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL types is normally a sequence of individual types. Each type is either a type object or a string that is the name of a C++ type. Alternatively each type could itself be a sequence of types each describing a different overloaded signal. name is the optional C++ name of the signal. If it is not specified then the name of the class attribute that is bound to the signal is used. revision is the optional revision of the signal that is exported to QML. If it is not specified then 0 is used. arguments is the optional sequence of the names of the signal's arguments. """ pass def handshakeInterruptedOnError(self, *args, **kwargs): # real signature unknown """ pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL types is normally a sequence of individual types. Each type is either a type object or a string that is the name of a C++ type. Alternatively each type could itself be a sequence of types each describing a different overloaded signal. name is the optional C++ name of the signal. If it is not specified then the name of the class attribute that is bound to the signal is used. revision is the optional revision of the signal that is exported to QML. If it is not specified then 0 is used. arguments is the optional sequence of the names of the signal's arguments. """ pass def ignoreSslErrors(self, errors=None, QSslError=None): # real signature unknown; restored from __doc__ with multiple overloads """ ignoreSslErrors(self) ignoreSslErrors(self, errors: Iterable[QSslError]) """ pass def implementedClasses(self, backendName=''): # real signature unknown; restored from __doc__ """ implementedClasses(backendName: str = '') -> List[QSsl.ImplementedClass] """ return [] def isClassImplemented(self, cl, backendName=''): # real signature unknown; restored from __doc__ """ isClassImplemented(cl: QSsl.ImplementedClass, backendName: str = '') -> bool """ return False def isEncrypted(self): # real signature unknown; restored from __doc__ """ isEncrypted(self) -> bool """ return False def isFeatureSupported(self, feat, backendName=''): # real signature unknown; restored from __doc__ """ isFeatureSupported(feat: QSsl.SupportedFeature, backendName: str = '') -> bool """ return False def isProtocolSupported(self, protocol, backendName=''): # real signature unknown; restored from __doc__ """ isProtocolSupported(protocol: QSsl.SslProtocol, backendName: str = '') -> bool """ return False def isSignalConnected(self, *args, **kwargs): # real signature unknown pass def localCertificate(self): # real signature unknown; restored from __doc__ """ localCertificate(self) -> QSslCertificate """ return QSslCertificate def localCertificateChain(self): # real signature unknown; restored from __doc__ """ localCertificateChain(self) -> List[QSslCertificate] """ return [] def mode(self): # real signature unknown; restored from __doc__ """ mode(self) -> QSslSocket.SslMode """ pass def modeChanged(self, *args, **kwargs): # real signature unknown """ pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL types is normally a sequence of individual types. Each type is either a type object or a string that is the name of a C++ type. Alternatively each type could itself be a sequence of types each describing a different overloaded signal. name is the optional C++ name of the signal. If it is not specified then the name of the class attribute that is bound to the signal is used. revision is the optional revision of the signal that is exported to QML. If it is not specified then 0 is used. arguments is the optional sequence of the names of the signal's arguments. """ pass def newSessionTicketReceived(self, *args, **kwargs): # real signature unknown """ pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL types is normally a sequence of individual types. Each type is either a type object or a string that is the name of a C++ type. Alternatively each type could itself be a sequence of types each describing a different overloaded signal. name is the optional C++ name of the signal. If it is not specified then the name of the class attribute that is bound to the signal is used. revision is the optional revision of the signal that is exported to QML. If it is not specified then 0 is used. arguments is the optional sequence of the names of the signal's arguments. """ pass def ocspResponses(self): # real signature unknown; restored from __doc__ """ ocspResponses(self) -> List[QOcspResponse] """ return [] def peerCertificate(self): # real signature unknown; restored from __doc__ """ peerCertificate(self) -> QSslCertificate """ return QSslCertificate def peerCertificateChain(self): # real signature unknown; restored from __doc__ """ peerCertificateChain(self) -> List[QSslCertificate] """ return [] def peerVerifyDepth(self): # real signature unknown; restored from __doc__ """ peerVerifyDepth(self) -> int """ return 0 def peerVerifyError(self, *args, **kwargs): # real signature unknown """ pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL types is normally a sequence of individual types. Each type is either a type object or a string that is the name of a C++ type. Alternatively each type could itself be a sequence of types each describing a different overloaded signal. name is the optional C++ name of the signal. If it is not specified then the name of the class attribute that is bound to the signal is used. revision is the optional revision of the signal that is exported to QML. If it is not specified then 0 is used. arguments is the optional sequence of the names of the signal's arguments. """ pass def peerVerifyMode(self): # real signature unknown; restored from __doc__ """ peerVerifyMode(self) -> QSslSocket.PeerVerifyMode """ pass def peerVerifyName(self): # real signature unknown; restored from __doc__ """ peerVerifyName(self) -> str """ return "" def preSharedKeyAuthenticationRequired(self, *args, **kwargs): # real signature unknown """ pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL types is normally a sequence of individual types. Each type is either a type object or a string that is the name of a C++ type. Alternatively each type could itself be a sequence of types each describing a different overloaded signal. name is the optional C++ name of the signal. If it is not specified then the name of the class attribute that is bound to the signal is used. revision is the optional revision of the signal that is exported to QML. If it is not specified then 0 is used. arguments is the optional sequence of the names of the signal's arguments. """ pass def privateKey(self): # real signature unknown; restored from __doc__ """ privateKey(self) -> QSslKey """ return QSslKey def protocol(self): # real signature unknown; restored from __doc__ """ protocol(self) -> QSsl.SslProtocol """ pass def readData(self, maxlen): # real signature unknown; restored from __doc__ """ readData(self, maxlen: int) -> bytes """ return b"" def readLineData(self, *args, **kwargs): # real signature unknown pass def receivers(self, *args, **kwargs): # real signature unknown pass def resume(self): # real signature unknown; restored from __doc__ """ resume(self) """ pass def sender(self, *args, **kwargs): # real signature unknown pass def senderSignalIndex(self, *args, **kwargs): # real signature unknown pass def sessionCipher(self): # real signature unknown; restored from __doc__ """ sessionCipher(self) -> QSslCipher """ return QSslCipher def sessionProtocol(self): # real signature unknown; restored from __doc__ """ sessionProtocol(self) -> QSsl.SslProtocol """ pass def setActiveBackend(self, backendName): # real signature unknown; restored from __doc__ """ setActiveBackend(backendName: str) -> bool """ return False def setErrorString(self, *args, **kwargs): # real signature unknown pass def setLocalAddress(self, *args, **kwargs): # real signature unknown pass def setLocalCertificate(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads """ setLocalCertificate(self, certificate: QSslCertificate) setLocalCertificate(self, path: str, format: QSsl.EncodingFormat = QSsl.Pem) """ pass def setLocalCertificateChain(self, localChain, QSslCertificate=None): # real signature unknown; restored from __doc__ """ setLocalCertificateChain(self, localChain: Iterable[QSslCertificate]) """ pass def setLocalPort(self, *args, **kwargs): # real signature unknown pass def setOpenMode(self, *args, **kwargs): # real signature unknown pass def setPeerAddress(self, *args, **kwargs): # real signature unknown pass def setPeerName(self, *args, **kwargs): # real signature unknown pass def setPeerPort(self, *args, **kwargs): # real signature unknown pass def setPeerVerifyDepth(self, depth): # real signature unknown; restored from __doc__ """ setPeerVerifyDepth(self, depth: int) """ pass def setPeerVerifyMode(self, mode): # real signature unknown; restored from __doc__ """ setPeerVerifyMode(self, mode: QSslSocket.PeerVerifyMode) """ pass def setPeerVerifyName(self, hostName): # real signature unknown; restored from __doc__ """ setPeerVerifyName(self, hostName: str) """ pass def setPrivateKey(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads """ setPrivateKey(self, key: QSslKey) setPrivateKey(self, fileName: str, algorithm: QSsl.KeyAlgorithm = QSsl.Rsa, format: QSsl.EncodingFormat = QSsl.Pem, passPhrase: QByteArray = QByteArray()) """ pass def setProtocol(self, protocol): # real signature unknown; restored from __doc__ """ setProtocol(self, protocol: QSsl.SslProtocol) """ pass def setReadBufferSize(self, size): # real signature unknown; restored from __doc__ """ setReadBufferSize(self, size: int) """ pass def setSocketDescriptor(self, socketDescriptor, state=None, mode=None): # real signature unknown; restored from __doc__ """ setSocketDescriptor(self, socketDescriptor: PyQt6.sip.voidptr, state: QAbstractSocket.SocketState = QAbstractSocket.ConnectedState, mode: QIODeviceBase.OpenModeFlag = QIODeviceBase.ReadWrite) -> bool """ return False def setSocketError(self, *args, **kwargs): # real signature unknown pass def setSocketOption(self, option, value): # real signature unknown; restored from __doc__ """ setSocketOption(self, option: QAbstractSocket.SocketOption, value: Any) """ pass def setSocketState(self, *args, **kwargs): # real signature unknown pass def setSslConfiguration(self, config): # real signature unknown; restored from __doc__ """ setSslConfiguration(self, config: QSslConfiguration) """ pass def skipData(self, maxSize): # real signature unknown; restored from __doc__ """ skipData(self, maxSize: int) -> int """ return 0 def socketOption(self, option): # real signature unknown; restored from __doc__ """ socketOption(self, option: QAbstractSocket.SocketOption) -> Any """ pass def sslConfiguration(self): # real signature unknown; restored from __doc__ """ sslConfiguration(self) -> QSslConfiguration """ return QSslConfiguration def sslErrors(self, *args, **kwargs): # real signature unknown """ pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL types is normally a sequence of individual types. Each type is either a type object or a string that is the name of a C++ type. Alternatively each type could itself be a sequence of types each describing a different overloaded signal. name is the optional C++ name of the signal. If it is not specified then the name of the class attribute that is bound to the signal is used. revision is the optional revision of the signal that is exported to QML. If it is not specified then 0 is used. arguments is the optional sequence of the names of the signal's arguments. """ pass def sslHandshakeErrors(self): # real signature unknown; restored from __doc__ """ sslHandshakeErrors(self) -> List[QSslError] """ return [] def sslLibraryBuildVersionNumber(self): # real signature unknown; restored from __doc__ """ sslLibraryBuildVersionNumber() -> int """ return 0 def sslLibraryBuildVersionString(self): # real signature unknown; restored from __doc__ """ sslLibraryBuildVersionString() -> str """ return "" def sslLibraryVersionNumber(self): # real signature unknown; restored from __doc__ """ sslLibraryVersionNumber() -> int """ return 0 def sslLibraryVersionString(self): # real signature unknown; restored from __doc__ """ sslLibraryVersionString() -> str """ return "" def startClientEncryption(self): # real signature unknown; restored from __doc__ """ startClientEncryption(self) """ pass def startServerEncryption(self): # real signature unknown; restored from __doc__ """ startServerEncryption(self) """ pass def supportedFeatures(self, backendName=''): # real signature unknown; restored from __doc__ """ supportedFeatures(backendName: str = '') -> List[QSsl.SupportedFeature] """ return [] def supportedProtocols(self, backendName=''): # real signature unknown; restored from __doc__ """ supportedProtocols(backendName: str = '') -> List[QSsl.SslProtocol] """ return [] def supportsSsl(self): # real signature unknown; restored from __doc__ """ supportsSsl() -> bool """ return False def timerEvent(self, *args, **kwargs): # real signature unknown pass def waitForBytesWritten(self, msecs=30000): # real signature unknown; restored from __doc__ """ waitForBytesWritten(self, msecs: int = 30000) -> bool """ return False def waitForConnected(self, msecs=30000): # real signature unknown; restored from __doc__ """ waitForConnected(self, msecs: int = 30000) -> bool """ return False def waitForDisconnected(self, msecs=30000): # real signature unknown; restored from __doc__ """ waitForDisconnected(self, msecs: int = 30000) -> bool """ return False def waitForEncrypted(self, msecs=30000): # real signature unknown; restored from __doc__ """ waitForEncrypted(self, msecs: int = 30000) -> bool """ return False def waitForReadyRead(self, msecs=30000): # real signature unknown; restored from __doc__ """ waitForReadyRead(self, msecs: int = 30000) -> bool """ return False def writeData(self, a0, bytes=None, bytearray=None, memoryview=None, PyQt6_sip_array=None, PyQt6_sip_voidptr=None): # real signature unknown; restored from __doc__ """ writeData(self, a0: Union[bytes, bytearray, memoryview, PyQt6.sip.array, PyQt6.sip.voidptr]) -> int """ return 0 def __init__(self, parent, QObject=None, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ pass PeerVerifyMode = None # (!) real value is "" SslMode = None # (!) real value is ""