# encoding: utf-8 # module PyQt6.QtMultimedia # from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\PyQt6\QtMultimedia.pyd # by generator 1.147 # no doc # imports import PyQt6.QtCore as __PyQt6_QtCore import PyQt6.sip as __PyQt6_sip # no functions # classes class QAudio(__PyQt6_sip.simplewrapper): # no doc def convertVolume(self, volume, from_, to): # real signature unknown; restored from __doc__ """ convertVolume(volume: float, from_: QAudio.VolumeScale, to: QAudio.VolumeScale) -> float """ return 0.0 def __init__(self, *args, **kwargs): # real signature unknown pass __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """list of weak references to the object (if defined)""" Error = None # (!) real value is "" State = None # (!) real value is "" VolumeScale = None # (!) real value is "" class QAudioBuffer(__PyQt6_sip.simplewrapper): """ QAudioBuffer() QAudioBuffer(data: QByteArray, format: QAudioFormat, startTime: int = -1) QAudioBuffer(numFrames: int, format: QAudioFormat, startTime: int = -1) QAudioBuffer(other: QAudioBuffer) """ def byteCount(self): # real signature unknown; restored from __doc__ """ byteCount(self) -> int """ return 0 def constData(self): # real signature unknown; restored from __doc__ """ constData(self) -> PyQt6.sip.voidptr """ pass def data(self): # real signature unknown; restored from __doc__ """ data(self) -> PyQt6.sip.voidptr """ pass def detach(self): # real signature unknown; restored from __doc__ """ detach(self) """ pass def duration(self): # real signature unknown; restored from __doc__ """ duration(self) -> int """ return 0 def format(self): # real signature unknown; restored from __doc__ """ format(self) -> QAudioFormat """ return QAudioFormat def frameCount(self): # real signature unknown; restored from __doc__ """ frameCount(self) -> int """ return 0 def isValid(self): # real signature unknown; restored from __doc__ """ isValid(self) -> bool """ return False def sampleCount(self): # real signature unknown; restored from __doc__ """ sampleCount(self) -> int """ return 0 def startTime(self): # real signature unknown; restored from __doc__ """ startTime(self) -> int """ return 0 def swap(self, other): # real signature unknown; restored from __doc__ """ swap(self, other: QAudioBuffer) """ pass def __init__(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads pass __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """list of weak references to the object (if defined)""" class QAudioDecoder(__PyQt6_QtCore.QObject): """ QAudioDecoder(parent: typing.Optional[QObject] = None) """ def audioFormat(self): # real signature unknown; restored from __doc__ """ audioFormat(self) -> QAudioFormat """ return QAudioFormat def bufferAvailable(self): # real signature unknown; restored from __doc__ """ bufferAvailable(self) -> bool """ return False def bufferAvailableChanged(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 bufferReady(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 childEvent(self, *args, **kwargs): # real signature unknown pass def connectNotify(self, *args, **kwargs): # real signature unknown pass def customEvent(self, *args, **kwargs): # real signature unknown pass def disconnectNotify(self, *args, **kwargs): # real signature unknown pass def duration(self): # real signature unknown; restored from __doc__ """ duration(self) -> int """ return 0 def durationChanged(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 error(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 errorString(self): # real signature unknown; restored from __doc__ """ errorString(self) -> str """ return "" def finished(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 formatChanged(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 isDecoding(self): # real signature unknown; restored from __doc__ """ isDecoding(self) -> bool """ return False def isDecodingChanged(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 isSignalConnected(self, *args, **kwargs): # real signature unknown pass def isSupported(self): # real signature unknown; restored from __doc__ """ isSupported(self) -> bool """ return False def position(self): # real signature unknown; restored from __doc__ """ position(self) -> int """ return 0 def positionChanged(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 read(self): # real signature unknown; restored from __doc__ """ read(self) -> QAudioBuffer """ return QAudioBuffer def receivers(self, *args, **kwargs): # real signature unknown pass def sender(self, *args, **kwargs): # real signature unknown pass def senderSignalIndex(self, *args, **kwargs): # real signature unknown pass def setAudioFormat(self, format): # real signature unknown; restored from __doc__ """ setAudioFormat(self, format: QAudioFormat) """ pass def setSource(self, fileName): # real signature unknown; restored from __doc__ """ setSource(self, fileName: QUrl) """ pass def setSourceDevice(self, device): # real signature unknown; restored from __doc__ """ setSourceDevice(self, device: QIODevice) """ pass def source(self): # real signature unknown; restored from __doc__ """ source(self) -> QUrl """ pass def sourceChanged(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 sourceDevice(self): # real signature unknown; restored from __doc__ """ sourceDevice(self) -> QIODevice """ pass def start(self): # real signature unknown; restored from __doc__ """ start(self) """ pass def stop(self): # real signature unknown; restored from __doc__ """ stop(self) """ pass def timerEvent(self, *args, **kwargs): # real signature unknown pass def __init__(self, parent, QObject=None, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ pass Error = None # (!) real value is "" class QAudioDevice(__PyQt6_sip.simplewrapper): """ QAudioDevice() QAudioDevice(other: QAudioDevice) """ def channelConfiguration(self): # real signature unknown; restored from __doc__ """ channelConfiguration(self) -> QAudioFormat.ChannelConfig """ pass def description(self): # real signature unknown; restored from __doc__ """ description(self) -> str """ return "" def id(self): # real signature unknown; restored from __doc__ """ id(self) -> QByteArray """ pass def isDefault(self): # real signature unknown; restored from __doc__ """ isDefault(self) -> bool """ return False def isFormatSupported(self, format): # real signature unknown; restored from __doc__ """ isFormatSupported(self, format: QAudioFormat) -> bool """ return False def isNull(self): # real signature unknown; restored from __doc__ """ isNull(self) -> bool """ return False def maximumChannelCount(self): # real signature unknown; restored from __doc__ """ maximumChannelCount(self) -> int """ return 0 def maximumSampleRate(self): # real signature unknown; restored from __doc__ """ maximumSampleRate(self) -> int """ return 0 def minimumChannelCount(self): # real signature unknown; restored from __doc__ """ minimumChannelCount(self) -> int """ return 0 def minimumSampleRate(self): # real signature unknown; restored from __doc__ """ minimumSampleRate(self) -> int """ return 0 def mode(self): # real signature unknown; restored from __doc__ """ mode(self) -> QAudioDevice.Mode """ pass def preferredFormat(self): # real signature unknown; restored from __doc__ """ preferredFormat(self) -> QAudioFormat """ return QAudioFormat def supportedSampleFormats(self): # real signature unknown; restored from __doc__ """ supportedSampleFormats(self) -> List[QAudioFormat.SampleFormat] """ return [] def swap(self, other): # real signature unknown; restored from __doc__ """ swap(self, other: QAudioDevice) """ pass def __eq__(self, *args, **kwargs): # real signature unknown """ Return self==value. """ pass def __ge__(self, *args, **kwargs): # real signature unknown """ Return self>=value. """ pass def __gt__(self, *args, **kwargs): # real signature unknown """ Return self>value. """ pass def __init__(self, other=None): # real signature unknown; restored from __doc__ with multiple overloads pass def __le__(self, *args, **kwargs): # real signature unknown """ Return self<=value. """ pass def __lt__(self, *args, **kwargs): # real signature unknown """ Return self" __hash__ = None class QAudioFormat(__PyQt6_sip.simplewrapper): """ QAudioFormat() QAudioFormat(a0: QAudioFormat) """ def bytesForDuration(self, duration): # real signature unknown; restored from __doc__ """ bytesForDuration(self, duration: int) -> int """ return 0 def bytesForFrames(self, frameCount): # real signature unknown; restored from __doc__ """ bytesForFrames(self, frameCount: int) -> int """ return 0 def bytesPerFrame(self): # real signature unknown; restored from __doc__ """ bytesPerFrame(self) -> int """ return 0 def bytesPerSample(self): # real signature unknown; restored from __doc__ """ bytesPerSample(self) -> int """ return 0 def channelConfig(self): # real signature unknown; restored from __doc__ """ channelConfig(self) -> QAudioFormat.ChannelConfig """ pass def channelCount(self): # real signature unknown; restored from __doc__ """ channelCount(self) -> int """ return 0 def channelOffset(self, channel): # real signature unknown; restored from __doc__ """ channelOffset(self, channel: QAudioFormat.AudioChannelPosition) -> int """ return 0 def defaultChannelConfigForChannelCount(self, channelCount): # real signature unknown; restored from __doc__ """ defaultChannelConfigForChannelCount(channelCount: int) -> QAudioFormat.ChannelConfig """ pass def durationForBytes(self, byteCount): # real signature unknown; restored from __doc__ """ durationForBytes(self, byteCount: int) -> int """ return 0 def durationForFrames(self, frameCount): # real signature unknown; restored from __doc__ """ durationForFrames(self, frameCount: int) -> int """ return 0 def framesForBytes(self, byteCount): # real signature unknown; restored from __doc__ """ framesForBytes(self, byteCount: int) -> int """ return 0 def framesForDuration(self, duration): # real signature unknown; restored from __doc__ """ framesForDuration(self, duration: int) -> int """ return 0 def isValid(self): # real signature unknown; restored from __doc__ """ isValid(self) -> bool """ return False def normalizedSampleValue(self, sample): # real signature unknown; restored from __doc__ """ normalizedSampleValue(self, sample: PyQt6.sip.voidptr) -> float """ return 0.0 def sampleFormat(self): # real signature unknown; restored from __doc__ """ sampleFormat(self) -> QAudioFormat.SampleFormat """ pass def sampleRate(self): # real signature unknown; restored from __doc__ """ sampleRate(self) -> int """ return 0 def setChannelConfig(self, config): # real signature unknown; restored from __doc__ """ setChannelConfig(self, config: QAudioFormat.ChannelConfig) """ pass def setChannelCount(self, channelCount): # real signature unknown; restored from __doc__ """ setChannelCount(self, channelCount: int) """ pass def setSampleFormat(self, f): # real signature unknown; restored from __doc__ """ setSampleFormat(self, f: QAudioFormat.SampleFormat) """ pass def setSampleRate(self, sampleRate): # real signature unknown; restored from __doc__ """ setSampleRate(self, sampleRate: int) """ pass def __eq__(self, *args, **kwargs): # real signature unknown """ Return self==value. """ pass def __ge__(self, *args, **kwargs): # real signature unknown """ Return self>=value. """ pass def __gt__(self, *args, **kwargs): # real signature unknown """ Return self>value. """ pass def __init__(self, a0=None): # real signature unknown; restored from __doc__ with multiple overloads pass def __le__(self, *args, **kwargs): # real signature unknown """ Return self<=value. """ pass def __lt__(self, *args, **kwargs): # real signature unknown """ Return self" ChannelConfig = None # (!) real value is "" SampleFormat = None # (!) real value is "" __hash__ = None class QAudioInput(__PyQt6_QtCore.QObject): """ QAudioInput(deviceInfo: QAudioDevice, parent: typing.Optional[QObject] = None) QAudioInput(parent: typing.Optional[QObject] = None) """ def childEvent(self, *args, **kwargs): # real signature unknown pass def connectNotify(self, *args, **kwargs): # real signature unknown pass def customEvent(self, *args, **kwargs): # real signature unknown pass def device(self): # real signature unknown; restored from __doc__ """ device(self) -> QAudioDevice """ return QAudioDevice def deviceChanged(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 disconnectNotify(self, *args, **kwargs): # real signature unknown pass def isMuted(self): # real signature unknown; restored from __doc__ """ isMuted(self) -> bool """ return False def isSignalConnected(self, *args, **kwargs): # real signature unknown pass def mutedChanged(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 receivers(self, *args, **kwargs): # real signature unknown pass def sender(self, *args, **kwargs): # real signature unknown pass def senderSignalIndex(self, *args, **kwargs): # real signature unknown pass def setDevice(self, device): # real signature unknown; restored from __doc__ """ setDevice(self, device: QAudioDevice) """ pass def setMuted(self, muted): # real signature unknown; restored from __doc__ """ setMuted(self, muted: bool) """ pass def setVolume(self, volume): # real signature unknown; restored from __doc__ """ setVolume(self, volume: float) """ pass def timerEvent(self, *args, **kwargs): # real signature unknown pass def volume(self): # real signature unknown; restored from __doc__ """ volume(self) -> float """ return 0.0 def volumeChanged(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 __init__(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads pass class QAudioOutput(__PyQt6_QtCore.QObject): """ QAudioOutput(device: QAudioDevice, parent: typing.Optional[QObject] = None) QAudioOutput(parent: typing.Optional[QObject] = None) """ def childEvent(self, *args, **kwargs): # real signature unknown pass def connectNotify(self, *args, **kwargs): # real signature unknown pass def customEvent(self, *args, **kwargs): # real signature unknown pass def device(self): # real signature unknown; restored from __doc__ """ device(self) -> QAudioDevice """ return QAudioDevice def deviceChanged(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 disconnectNotify(self, *args, **kwargs): # real signature unknown pass def isMuted(self): # real signature unknown; restored from __doc__ """ isMuted(self) -> bool """ return False def isSignalConnected(self, *args, **kwargs): # real signature unknown pass def mutedChanged(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 receivers(self, *args, **kwargs): # real signature unknown pass def sender(self, *args, **kwargs): # real signature unknown pass def senderSignalIndex(self, *args, **kwargs): # real signature unknown pass def setDevice(self, device): # real signature unknown; restored from __doc__ """ setDevice(self, device: QAudioDevice) """ pass def setMuted(self, muted): # real signature unknown; restored from __doc__ """ setMuted(self, muted: bool) """ pass def setVolume(self, volume): # real signature unknown; restored from __doc__ """ setVolume(self, volume: float) """ pass def timerEvent(self, *args, **kwargs): # real signature unknown pass def volume(self): # real signature unknown; restored from __doc__ """ volume(self) -> float """ return 0.0 def volumeChanged(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 __init__(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads pass class QAudioSink(__PyQt6_QtCore.QObject): """ QAudioSink(audioDeviceInfo: QAudioDevice, format: QAudioFormat = QAudioFormat(), parent: typing.Optional[QObject] = None) QAudioSink(format: QAudioFormat = QAudioFormat(), parent: typing.Optional[QObject] = None) """ def bufferSize(self): # real signature unknown; restored from __doc__ """ bufferSize(self) -> int """ return 0 def bytesFree(self): # real signature unknown; restored from __doc__ """ bytesFree(self) -> int """ return 0 def childEvent(self, *args, **kwargs): # real signature unknown pass def connectNotify(self, *args, **kwargs): # real signature unknown pass def customEvent(self, *args, **kwargs): # real signature unknown pass def disconnectNotify(self, *args, **kwargs): # real signature unknown pass def elapsedUSecs(self): # real signature unknown; restored from __doc__ """ elapsedUSecs(self) -> int """ return 0 def error(self): # real signature unknown; restored from __doc__ """ error(self) -> QAudio.Error """ pass def format(self): # real signature unknown; restored from __doc__ """ format(self) -> QAudioFormat """ return QAudioFormat def isSignalConnected(self, *args, **kwargs): # real signature unknown pass def processedUSecs(self): # real signature unknown; restored from __doc__ """ processedUSecs(self) -> int """ return 0 def receivers(self, *args, **kwargs): # real signature unknown pass def reset(self): # real signature unknown; restored from __doc__ """ reset(self) """ 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 setBufferSize(self, bytes): # real signature unknown; restored from __doc__ """ setBufferSize(self, bytes: int) """ pass def setVolume(self, a0): # real signature unknown; restored from __doc__ """ setVolume(self, a0: float) """ pass def start(self, device=None): # real signature unknown; restored from __doc__ with multiple overloads """ start(self, device: QIODevice) start(self) -> QIODevice """ pass def state(self): # real signature unknown; restored from __doc__ """ state(self) -> QAudio.State """ pass def stateChanged(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 stop(self): # real signature unknown; restored from __doc__ """ stop(self) """ pass def suspend(self): # real signature unknown; restored from __doc__ """ suspend(self) """ pass def timerEvent(self, *args, **kwargs): # real signature unknown pass def volume(self): # real signature unknown; restored from __doc__ """ volume(self) -> float """ return 0.0 def __init__(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads pass class QAudioSource(__PyQt6_QtCore.QObject): """ QAudioSource(audioDeviceInfo: QAudioDevice, format: QAudioFormat = QAudioFormat(), parent: typing.Optional[QObject] = None) QAudioSource(format: QAudioFormat = QAudioFormat(), parent: typing.Optional[QObject] = None) """ def bufferSize(self): # real signature unknown; restored from __doc__ """ bufferSize(self) -> int """ return 0 def bytesAvailable(self): # real signature unknown; restored from __doc__ """ bytesAvailable(self) -> int """ return 0 def childEvent(self, *args, **kwargs): # real signature unknown pass def connectNotify(self, *args, **kwargs): # real signature unknown pass def customEvent(self, *args, **kwargs): # real signature unknown pass def disconnectNotify(self, *args, **kwargs): # real signature unknown pass def elapsedUSecs(self): # real signature unknown; restored from __doc__ """ elapsedUSecs(self) -> int """ return 0 def error(self): # real signature unknown; restored from __doc__ """ error(self) -> QAudio.Error """ pass def format(self): # real signature unknown; restored from __doc__ """ format(self) -> QAudioFormat """ return QAudioFormat def isSignalConnected(self, *args, **kwargs): # real signature unknown pass def processedUSecs(self): # real signature unknown; restored from __doc__ """ processedUSecs(self) -> int """ return 0 def receivers(self, *args, **kwargs): # real signature unknown pass def reset(self): # real signature unknown; restored from __doc__ """ reset(self) """ 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 setBufferSize(self, bytes): # real signature unknown; restored from __doc__ """ setBufferSize(self, bytes: int) """ pass def setVolume(self, volume): # real signature unknown; restored from __doc__ """ setVolume(self, volume: float) """ pass def start(self, device=None): # real signature unknown; restored from __doc__ with multiple overloads """ start(self, device: QIODevice) start(self) -> QIODevice """ pass def state(self): # real signature unknown; restored from __doc__ """ state(self) -> QAudio.State """ pass def stateChanged(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 stop(self): # real signature unknown; restored from __doc__ """ stop(self) """ pass def suspend(self): # real signature unknown; restored from __doc__ """ suspend(self) """ pass def timerEvent(self, *args, **kwargs): # real signature unknown pass def volume(self): # real signature unknown; restored from __doc__ """ volume(self) -> float """ return 0.0 def __init__(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads pass class QCamera(__PyQt6_QtCore.QObject): """ QCamera(cameraDevice: QCameraDevice, parent: typing.Optional[QObject] = None) QCamera(position: QCameraDevice.Position, parent: typing.Optional[QObject] = None) QCamera(parent: typing.Optional[QObject] = None) """ def activeChanged(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 cameraDevice(self): # real signature unknown; restored from __doc__ """ cameraDevice(self) -> QCameraDevice """ return QCameraDevice def cameraDeviceChanged(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 cameraFormat(self): # real signature unknown; restored from __doc__ """ cameraFormat(self) -> QCameraFormat """ return QCameraFormat def cameraFormatChanged(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 captureSession(self): # real signature unknown; restored from __doc__ """ captureSession(self) -> QMediaCaptureSession """ return QMediaCaptureSession def childEvent(self, *args, **kwargs): # real signature unknown pass def colorTemperature(self): # real signature unknown; restored from __doc__ """ colorTemperature(self) -> int """ return 0 def colorTemperatureChanged(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 connectNotify(self, *args, **kwargs): # real signature unknown pass def customEvent(self, *args, **kwargs): # real signature unknown pass def customFocusPoint(self): # real signature unknown; restored from __doc__ """ customFocusPoint(self) -> QPointF """ pass def customFocusPointChanged(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 disconnectNotify(self, *args, **kwargs): # real signature unknown pass def error(self): # real signature unknown; restored from __doc__ """ error(self) -> QCamera.Error """ pass def errorChanged(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 errorOccurred(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 errorString(self): # real signature unknown; restored from __doc__ """ errorString(self) -> str """ return "" def exposureCompensation(self): # real signature unknown; restored from __doc__ """ exposureCompensation(self) -> float """ return 0.0 def exposureCompensationChanged(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 exposureMode(self): # real signature unknown; restored from __doc__ """ exposureMode(self) -> QCamera.ExposureMode """ pass def exposureModeChanged(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 exposureTime(self): # real signature unknown; restored from __doc__ """ exposureTime(self) -> float """ return 0.0 def exposureTimeChanged(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 flashMode(self): # real signature unknown; restored from __doc__ """ flashMode(self) -> QCamera.FlashMode """ pass def flashModeChanged(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 flashReady(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 focusDistance(self): # real signature unknown; restored from __doc__ """ focusDistance(self) -> float """ return 0.0 def focusDistanceChanged(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 focusMode(self): # real signature unknown; restored from __doc__ """ focusMode(self) -> QCamera.FocusMode """ pass def focusModeChanged(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 focusPoint(self): # real signature unknown; restored from __doc__ """ focusPoint(self) -> QPointF """ pass def focusPointChanged(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 isActive(self): # real signature unknown; restored from __doc__ """ isActive(self) -> bool """ return False def isAvailable(self): # real signature unknown; restored from __doc__ """ isAvailable(self) -> bool """ return False def isExposureModeSupported(self, mode): # real signature unknown; restored from __doc__ """ isExposureModeSupported(self, mode: QCamera.ExposureMode) -> bool """ return False def isFlashModeSupported(self, mode): # real signature unknown; restored from __doc__ """ isFlashModeSupported(self, mode: QCamera.FlashMode) -> bool """ return False def isFlashReady(self): # real signature unknown; restored from __doc__ """ isFlashReady(self) -> bool """ return False def isFocusModeSupported(self, mode): # real signature unknown; restored from __doc__ """ isFocusModeSupported(self, mode: QCamera.FocusMode) -> bool """ return False def isoSensitivity(self): # real signature unknown; restored from __doc__ """ isoSensitivity(self) -> int """ return 0 def isoSensitivityChanged(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 isSignalConnected(self, *args, **kwargs): # real signature unknown pass def isTorchModeSupported(self, mode): # real signature unknown; restored from __doc__ """ isTorchModeSupported(self, mode: QCamera.TorchMode) -> bool """ return False def isWhiteBalanceModeSupported(self, mode): # real signature unknown; restored from __doc__ """ isWhiteBalanceModeSupported(self, mode: QCamera.WhiteBalanceMode) -> bool """ return False def manualExposureTime(self): # real signature unknown; restored from __doc__ """ manualExposureTime(self) -> float """ return 0.0 def manualExposureTimeChanged(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 manualIsoSensitivity(self): # real signature unknown; restored from __doc__ """ manualIsoSensitivity(self) -> int """ return 0 def manualIsoSensitivityChanged(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 maximumExposureTime(self): # real signature unknown; restored from __doc__ """ maximumExposureTime(self) -> float """ return 0.0 def maximumIsoSensitivity(self): # real signature unknown; restored from __doc__ """ maximumIsoSensitivity(self) -> int """ return 0 def maximumZoomFactor(self): # real signature unknown; restored from __doc__ """ maximumZoomFactor(self) -> float """ return 0.0 def maximumZoomFactorChanged(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 minimumExposureTime(self): # real signature unknown; restored from __doc__ """ minimumExposureTime(self) -> float """ return 0.0 def minimumIsoSensitivity(self): # real signature unknown; restored from __doc__ """ minimumIsoSensitivity(self) -> int """ return 0 def minimumZoomFactor(self): # real signature unknown; restored from __doc__ """ minimumZoomFactor(self) -> float """ return 0.0 def minimumZoomFactorChanged(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 receivers(self, *args, **kwargs): # real signature unknown pass def sender(self, *args, **kwargs): # real signature unknown pass def senderSignalIndex(self, *args, **kwargs): # real signature unknown pass def setActive(self, active): # real signature unknown; restored from __doc__ """ setActive(self, active: bool) """ pass def setAutoExposureTime(self): # real signature unknown; restored from __doc__ """ setAutoExposureTime(self) """ pass def setAutoIsoSensitivity(self): # real signature unknown; restored from __doc__ """ setAutoIsoSensitivity(self) """ pass def setCameraDevice(self, cameraDevice): # real signature unknown; restored from __doc__ """ setCameraDevice(self, cameraDevice: QCameraDevice) """ pass def setCameraFormat(self, format): # real signature unknown; restored from __doc__ """ setCameraFormat(self, format: QCameraFormat) """ pass def setColorTemperature(self, colorTemperature): # real signature unknown; restored from __doc__ """ setColorTemperature(self, colorTemperature: int) """ pass def setCustomFocusPoint(self, point): # real signature unknown; restored from __doc__ """ setCustomFocusPoint(self, point: QPointF) """ pass def setExposureCompensation(self, ev): # real signature unknown; restored from __doc__ """ setExposureCompensation(self, ev: float) """ pass def setExposureMode(self, mode): # real signature unknown; restored from __doc__ """ setExposureMode(self, mode: QCamera.ExposureMode) """ pass def setFlashMode(self, mode): # real signature unknown; restored from __doc__ """ setFlashMode(self, mode: QCamera.FlashMode) """ pass def setFocusDistance(self, d): # real signature unknown; restored from __doc__ """ setFocusDistance(self, d: float) """ pass def setFocusMode(self, mode): # real signature unknown; restored from __doc__ """ setFocusMode(self, mode: QCamera.FocusMode) """ pass def setManualExposureTime(self, seconds): # real signature unknown; restored from __doc__ """ setManualExposureTime(self, seconds: float) """ pass def setManualIsoSensitivity(self, iso): # real signature unknown; restored from __doc__ """ setManualIsoSensitivity(self, iso: int) """ pass def setTorchMode(self, mode): # real signature unknown; restored from __doc__ """ setTorchMode(self, mode: QCamera.TorchMode) """ pass def setWhiteBalanceMode(self, mode): # real signature unknown; restored from __doc__ """ setWhiteBalanceMode(self, mode: QCamera.WhiteBalanceMode) """ pass def setZoomFactor(self, factor): # real signature unknown; restored from __doc__ """ setZoomFactor(self, factor: float) """ pass def start(self): # real signature unknown; restored from __doc__ """ start(self) """ pass def stop(self): # real signature unknown; restored from __doc__ """ stop(self) """ pass def supportedFeatures(self): # real signature unknown; restored from __doc__ """ supportedFeatures(self) -> QCamera.Feature """ pass def supportedFeaturesChanged(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 timerEvent(self, *args, **kwargs): # real signature unknown pass def torchMode(self): # real signature unknown; restored from __doc__ """ torchMode(self) -> QCamera.TorchMode """ pass def torchModeChanged(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 whiteBalanceMode(self): # real signature unknown; restored from __doc__ """ whiteBalanceMode(self) -> QCamera.WhiteBalanceMode """ pass def whiteBalanceModeChanged(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 zoomFactor(self): # real signature unknown; restored from __doc__ """ zoomFactor(self) -> float """ return 0.0 def zoomFactorChanged(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 zoomTo(self, zoom, rate): # real signature unknown; restored from __doc__ """ zoomTo(self, zoom: float, rate: float) """ pass def __init__(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads pass Error = None # (!) real value is "" ExposureMode = None # (!) real value is "" Feature = None # (!) real value is "" FlashMode = None # (!) real value is "" FocusMode = None # (!) real value is "" TorchMode = None # (!) real value is "" WhiteBalanceMode = None # (!) real value is "" class QCameraDevice(__PyQt6_sip.simplewrapper): """ QCameraDevice() QCameraDevice(other: QCameraDevice) """ def description(self): # real signature unknown; restored from __doc__ """ description(self) -> str """ return "" def id(self): # real signature unknown; restored from __doc__ """ id(self) -> QByteArray """ pass def isDefault(self): # real signature unknown; restored from __doc__ """ isDefault(self) -> bool """ return False def isNull(self): # real signature unknown; restored from __doc__ """ isNull(self) -> bool """ return False def photoResolutions(self): # real signature unknown; restored from __doc__ """ photoResolutions(self) -> List[QSize] """ return [] def position(self): # real signature unknown; restored from __doc__ """ position(self) -> QCameraDevice.Position """ pass def videoFormats(self): # real signature unknown; restored from __doc__ """ videoFormats(self) -> List[QCameraFormat] """ return [] def __eq__(self, *args, **kwargs): # real signature unknown """ Return self==value. """ pass def __ge__(self, *args, **kwargs): # real signature unknown """ Return self>=value. """ pass def __gt__(self, *args, **kwargs): # real signature unknown """ Return self>value. """ pass def __init__(self, other=None): # real signature unknown; restored from __doc__ with multiple overloads pass def __le__(self, *args, **kwargs): # real signature unknown """ Return self<=value. """ pass def __lt__(self, *args, **kwargs): # real signature unknown """ Return self" __hash__ = None class QCameraFormat(__PyQt6_sip.simplewrapper): """ QCameraFormat() QCameraFormat(other: QCameraFormat) """ def isNull(self): # real signature unknown; restored from __doc__ """ isNull(self) -> bool """ return False def maxFrameRate(self): # real signature unknown; restored from __doc__ """ maxFrameRate(self) -> float """ return 0.0 def minFrameRate(self): # real signature unknown; restored from __doc__ """ minFrameRate(self) -> float """ return 0.0 def pixelFormat(self): # real signature unknown; restored from __doc__ """ pixelFormat(self) -> QVideoFrameFormat.PixelFormat """ pass def resolution(self): # real signature unknown; restored from __doc__ """ resolution(self) -> QSize """ pass def __eq__(self, *args, **kwargs): # real signature unknown """ Return self==value. """ pass def __ge__(self, *args, **kwargs): # real signature unknown """ Return self>=value. """ pass def __gt__(self, *args, **kwargs): # real signature unknown """ Return self>value. """ pass def __init__(self, other=None): # real signature unknown; restored from __doc__ with multiple overloads pass def __le__(self, *args, **kwargs): # real signature unknown """ Return self<=value. """ pass def __lt__(self, *args, **kwargs): # real signature unknown """ Return self int """ return 0 def captureSession(self): # real signature unknown; restored from __doc__ """ captureSession(self) -> QMediaCaptureSession """ return QMediaCaptureSession def captureToFile(self, location=''): # real signature unknown; restored from __doc__ """ captureToFile(self, location: str = '') -> int """ return 0 def childEvent(self, *args, **kwargs): # real signature unknown pass def connectNotify(self, *args, **kwargs): # real signature unknown pass def customEvent(self, *args, **kwargs): # real signature unknown pass def disconnectNotify(self, *args, **kwargs): # real signature unknown pass def error(self): # real signature unknown; restored from __doc__ """ error(self) -> QImageCapture.Error """ pass def errorChanged(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 errorOccurred(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 errorString(self): # real signature unknown; restored from __doc__ """ errorString(self) -> str """ return "" def fileFormat(self): # real signature unknown; restored from __doc__ """ fileFormat(self) -> QImageCapture.FileFormat """ pass def fileFormatChanged(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 fileFormatDescription(self, c): # real signature unknown; restored from __doc__ """ fileFormatDescription(c: QImageCapture.FileFormat) -> str """ return "" def fileFormatName(self, c): # real signature unknown; restored from __doc__ """ fileFormatName(c: QImageCapture.FileFormat) -> str """ return "" def imageAvailable(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 imageCaptured(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 imageExposed(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 imageSaved(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 isAvailable(self): # real signature unknown; restored from __doc__ """ isAvailable(self) -> bool """ return False def isReadyForCapture(self): # real signature unknown; restored from __doc__ """ isReadyForCapture(self) -> bool """ return False def isSignalConnected(self, *args, **kwargs): # real signature unknown pass def metaData(self): # real signature unknown; restored from __doc__ """ metaData(self) -> QMediaMetaData """ return QMediaMetaData def metaDataChanged(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 quality(self): # real signature unknown; restored from __doc__ """ quality(self) -> QImageCapture.Quality """ pass def qualityChanged(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 readyForCaptureChanged(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 receivers(self, *args, **kwargs): # real signature unknown pass def resolution(self): # real signature unknown; restored from __doc__ """ resolution(self) -> QSize """ pass def resolutionChanged(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 sender(self, *args, **kwargs): # real signature unknown pass def senderSignalIndex(self, *args, **kwargs): # real signature unknown pass def setFileFormat(self, format): # real signature unknown; restored from __doc__ """ setFileFormat(self, format: QImageCapture.FileFormat) """ pass def setMetaData(self, metaData): # real signature unknown; restored from __doc__ """ setMetaData(self, metaData: QMediaMetaData) """ pass def setQuality(self, quality): # real signature unknown; restored from __doc__ """ setQuality(self, quality: QImageCapture.Quality) """ pass def setResolution(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads """ setResolution(self, a0: QSize) setResolution(self, width: int, height: int) """ pass def supportedFormats(self): # real signature unknown; restored from __doc__ """ supportedFormats() -> List[QImageCapture.FileFormat] """ return [] def timerEvent(self, *args, **kwargs): # real signature unknown pass def __init__(self, parent, QObject=None, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ pass Error = None # (!) real value is "" FileFormat = None # (!) real value is "" Quality = None # (!) real value is "" class QMediaCaptureSession(__PyQt6_QtCore.QObject): """ QMediaCaptureSession(parent: typing.Optional[QObject] = None) """ def audioInput(self): # real signature unknown; restored from __doc__ """ audioInput(self) -> QAudioInput """ return QAudioInput def audioInputChanged(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 audioOutput(self): # real signature unknown; restored from __doc__ """ audioOutput(self) -> QAudioOutput """ return QAudioOutput def audioOutputChanged(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 camera(self): # real signature unknown; restored from __doc__ """ camera(self) -> QCamera """ return QCamera def cameraChanged(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 childEvent(self, *args, **kwargs): # real signature unknown pass def connectNotify(self, *args, **kwargs): # real signature unknown pass def customEvent(self, *args, **kwargs): # real signature unknown pass def disconnectNotify(self, *args, **kwargs): # real signature unknown pass def imageCapture(self): # real signature unknown; restored from __doc__ """ imageCapture(self) -> QImageCapture """ return QImageCapture def imageCaptureChanged(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 isSignalConnected(self, *args, **kwargs): # real signature unknown pass def receivers(self, *args, **kwargs): # real signature unknown pass def recorder(self): # real signature unknown; restored from __doc__ """ recorder(self) -> QMediaRecorder """ return QMediaRecorder def recorderChanged(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 sender(self, *args, **kwargs): # real signature unknown pass def senderSignalIndex(self, *args, **kwargs): # real signature unknown pass def setAudioInput(self, device): # real signature unknown; restored from __doc__ """ setAudioInput(self, device: QAudioInput) """ pass def setAudioOutput(self, output): # real signature unknown; restored from __doc__ """ setAudioOutput(self, output: QAudioOutput) """ pass def setCamera(self, camera): # real signature unknown; restored from __doc__ """ setCamera(self, camera: QCamera) """ pass def setImageCapture(self, imageCapture): # real signature unknown; restored from __doc__ """ setImageCapture(self, imageCapture: QImageCapture) """ pass def setRecorder(self, recorder): # real signature unknown; restored from __doc__ """ setRecorder(self, recorder: QMediaRecorder) """ pass def setVideoOutput(self, output): # real signature unknown; restored from __doc__ """ setVideoOutput(self, output: QObject) """ pass def setVideoSink(self, sink): # real signature unknown; restored from __doc__ """ setVideoSink(self, sink: QVideoSink) """ pass def timerEvent(self, *args, **kwargs): # real signature unknown pass def videoOutput(self): # real signature unknown; restored from __doc__ """ videoOutput(self) -> QObject """ pass def videoOutputChanged(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 videoSink(self): # real signature unknown; restored from __doc__ """ videoSink(self) -> QVideoSink """ return QVideoSink def __init__(self, parent, QObject=None, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ pass class QMediaDevices(__PyQt6_QtCore.QObject): """ QMediaDevices(parent: typing.Optional[QObject] = None) """ def audioInputs(self): # real signature unknown; restored from __doc__ """ audioInputs() -> List[QAudioDevice] """ return [] def audioInputsChanged(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 audioOutputs(self): # real signature unknown; restored from __doc__ """ audioOutputs() -> List[QAudioDevice] """ return [] def audioOutputsChanged(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 childEvent(self, *args, **kwargs): # real signature unknown pass def connectNotify(self, *args, **kwargs): # real signature unknown pass def customEvent(self, *args, **kwargs): # real signature unknown pass def defaultAudioInput(self): # real signature unknown; restored from __doc__ """ defaultAudioInput() -> QAudioDevice """ return QAudioDevice def defaultAudioOutput(self): # real signature unknown; restored from __doc__ """ defaultAudioOutput() -> QAudioDevice """ return QAudioDevice def defaultVideoInput(self): # real signature unknown; restored from __doc__ """ defaultVideoInput() -> QCameraDevice """ return QCameraDevice def disconnectNotify(self, *args, **kwargs): # real signature unknown pass def isSignalConnected(self, *args, **kwargs): # real signature unknown pass def receivers(self, *args, **kwargs): # real signature unknown pass def sender(self, *args, **kwargs): # real signature unknown pass def senderSignalIndex(self, *args, **kwargs): # real signature unknown pass def timerEvent(self, *args, **kwargs): # real signature unknown pass def videoInputs(self): # real signature unknown; restored from __doc__ """ videoInputs() -> List[QCameraDevice] """ return [] def videoInputsChanged(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 __init__(self, parent, QObject=None, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ pass class QMediaFormat(__PyQt6_sip.simplewrapper): """ QMediaFormat(format: QMediaFormat.FileFormat = QMediaFormat.UnspecifiedFormat) QMediaFormat(other: QMediaFormat) """ def audioCodec(self): # real signature unknown; restored from __doc__ """ audioCodec(self) -> QMediaFormat.AudioCodec """ pass def audioCodecDescription(self, c): # real signature unknown; restored from __doc__ """ audioCodecDescription(c: QMediaFormat.AudioCodec) -> str """ return "" def audioCodecName(self, c): # real signature unknown; restored from __doc__ """ audioCodecName(c: QMediaFormat.AudioCodec) -> str """ return "" def fileFormat(self): # real signature unknown; restored from __doc__ """ fileFormat(self) -> QMediaFormat.FileFormat """ pass def fileFormatDescription(self, c): # real signature unknown; restored from __doc__ """ fileFormatDescription(c: QMediaFormat.FileFormat) -> str """ return "" def fileFormatName(self, c): # real signature unknown; restored from __doc__ """ fileFormatName(c: QMediaFormat.FileFormat) -> str """ return "" def isSupported(self, mode): # real signature unknown; restored from __doc__ """ isSupported(self, mode: QMediaFormat.ConversionMode) -> bool """ return False def mimeType(self): # real signature unknown; restored from __doc__ """ mimeType(self) -> QMimeType """ pass def resolveForEncoding(self, flags): # real signature unknown; restored from __doc__ """ resolveForEncoding(self, flags: QMediaFormat.ResolveFlags) """ pass def setAudioCodec(self, codec): # real signature unknown; restored from __doc__ """ setAudioCodec(self, codec: QMediaFormat.AudioCodec) """ pass def setFileFormat(self, f): # real signature unknown; restored from __doc__ """ setFileFormat(self, f: QMediaFormat.FileFormat) """ pass def setVideoCodec(self, codec): # real signature unknown; restored from __doc__ """ setVideoCodec(self, codec: QMediaFormat.VideoCodec) """ pass def supportedAudioCodecs(self, m): # real signature unknown; restored from __doc__ """ supportedAudioCodecs(self, m: QMediaFormat.ConversionMode) -> List[QMediaFormat.AudioCodec] """ return [] def supportedFileFormats(self, m): # real signature unknown; restored from __doc__ """ supportedFileFormats(self, m: QMediaFormat.ConversionMode) -> List[QMediaFormat.FileFormat] """ return [] def supportedVideoCodecs(self, m): # real signature unknown; restored from __doc__ """ supportedVideoCodecs(self, m: QMediaFormat.ConversionMode) -> List[QMediaFormat.VideoCodec] """ return [] def swap(self, other): # real signature unknown; restored from __doc__ """ swap(self, other: QMediaFormat) """ pass def videoCodec(self): # real signature unknown; restored from __doc__ """ videoCodec(self) -> QMediaFormat.VideoCodec """ pass def videoCodecDescription(self, c): # real signature unknown; restored from __doc__ """ videoCodecDescription(c: QMediaFormat.VideoCodec) -> str """ return "" def videoCodecName(self, c): # real signature unknown; restored from __doc__ """ videoCodecName(c: QMediaFormat.VideoCodec) -> str """ return "" def __eq__(self, *args, **kwargs): # real signature unknown """ Return self==value. """ pass def __ge__(self, *args, **kwargs): # real signature unknown """ Return self>=value. """ pass def __gt__(self, *args, **kwargs): # real signature unknown """ Return self>value. """ pass def __init__(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads pass def __le__(self, *args, **kwargs): # real signature unknown """ Return self<=value. """ pass def __lt__(self, *args, **kwargs): # real signature unknown """ Return self" ConversionMode = None # (!) real value is "" FileFormat = None # (!) real value is "" ResolveFlags = None # (!) real value is "" VideoCodec = None # (!) real value is "" __hash__ = None class QMediaMetaData(__PyQt6_sip.simplewrapper): """ QMediaMetaData() QMediaMetaData(a0: QMediaMetaData) """ def insert(self, k, value): # real signature unknown; restored from __doc__ """ insert(self, k: QMediaMetaData.Key, value: Any) """ pass def keys(self): # real signature unknown; restored from __doc__ """ keys(self) -> List[QMediaMetaData.Key] """ return [] def keyType(self, key): # real signature unknown; restored from __doc__ """ keyType(key: QMediaMetaData.Key) -> QMetaType """ pass def metaDataKeyToString(self, k): # real signature unknown; restored from __doc__ """ metaDataKeyToString(k: QMediaMetaData.Key) -> str """ return "" def stringValue(self, k): # real signature unknown; restored from __doc__ """ stringValue(self, k: QMediaMetaData.Key) -> str """ return "" def value(self, k): # real signature unknown; restored from __doc__ """ value(self, k: QMediaMetaData.Key) -> Any """ pass def __eq__(self, *args, **kwargs): # real signature unknown """ Return self==value. """ pass def __ge__(self, *args, **kwargs): # real signature unknown """ Return self>=value. """ pass def __gt__(self, *args, **kwargs): # real signature unknown """ Return self>value. """ pass def __init__(self, a0=None): # real signature unknown; restored from __doc__ with multiple overloads pass def __le__(self, *args, **kwargs): # real signature unknown """ Return self<=value. """ pass def __lt__(self, *args, **kwargs): # real signature unknown """ Return self" __hash__ = None class QMediaPlayer(__PyQt6_QtCore.QObject): """ QMediaPlayer(parent: typing.Optional[QObject] = None) """ def activeAudioTrack(self): # real signature unknown; restored from __doc__ """ activeAudioTrack(self) -> int """ return 0 def activeSubtitleTrack(self): # real signature unknown; restored from __doc__ """ activeSubtitleTrack(self) -> int """ return 0 def activeTracksChanged(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 activeVideoTrack(self): # real signature unknown; restored from __doc__ """ activeVideoTrack(self) -> int """ return 0 def audioOutput(self): # real signature unknown; restored from __doc__ """ audioOutput(self) -> QAudioOutput """ return QAudioOutput def audioOutputChanged(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 audioTracks(self): # real signature unknown; restored from __doc__ """ audioTracks(self) -> List[QMediaMetaData] """ return [] def bufferedTimeRange(self): # real signature unknown; restored from __doc__ """ bufferedTimeRange(self) -> QMediaTimeRange """ return QMediaTimeRange def bufferProgress(self): # real signature unknown; restored from __doc__ """ bufferProgress(self) -> float """ return 0.0 def bufferProgressChanged(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 childEvent(self, *args, **kwargs): # real signature unknown pass def connectNotify(self, *args, **kwargs): # real signature unknown pass def customEvent(self, *args, **kwargs): # real signature unknown pass def disconnectNotify(self, *args, **kwargs): # real signature unknown pass def duration(self): # real signature unknown; restored from __doc__ """ duration(self) -> int """ return 0 def durationChanged(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 error(self): # real signature unknown; restored from __doc__ """ error(self) -> QMediaPlayer.Error """ pass def errorChanged(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 errorOccurred(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 errorString(self): # real signature unknown; restored from __doc__ """ errorString(self) -> str """ return "" def hasAudio(self): # real signature unknown; restored from __doc__ """ hasAudio(self) -> bool """ return False def hasAudioChanged(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 hasVideo(self): # real signature unknown; restored from __doc__ """ hasVideo(self) -> bool """ return False def hasVideoChanged(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 isAvailable(self): # real signature unknown; restored from __doc__ """ isAvailable(self) -> bool """ return False def isSeekable(self): # real signature unknown; restored from __doc__ """ isSeekable(self) -> bool """ return False def isSignalConnected(self, *args, **kwargs): # real signature unknown pass def loops(self): # real signature unknown; restored from __doc__ """ loops(self) -> int """ return 0 def loopsChanged(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 mediaStatus(self): # real signature unknown; restored from __doc__ """ mediaStatus(self) -> QMediaPlayer.MediaStatus """ pass def mediaStatusChanged(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 metaData(self): # real signature unknown; restored from __doc__ """ metaData(self) -> QMediaMetaData """ return QMediaMetaData def metaDataChanged(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 pause(self): # real signature unknown; restored from __doc__ """ pause(self) """ pass def play(self): # real signature unknown; restored from __doc__ """ play(self) """ pass def playbackRate(self): # real signature unknown; restored from __doc__ """ playbackRate(self) -> float """ return 0.0 def playbackRateChanged(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 playbackState(self): # real signature unknown; restored from __doc__ """ playbackState(self) -> QMediaPlayer.PlaybackState """ pass def playbackStateChanged(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 position(self): # real signature unknown; restored from __doc__ """ position(self) -> int """ return 0 def positionChanged(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 receivers(self, *args, **kwargs): # real signature unknown pass def seekableChanged(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 sender(self, *args, **kwargs): # real signature unknown pass def senderSignalIndex(self, *args, **kwargs): # real signature unknown pass def setActiveAudioTrack(self, index): # real signature unknown; restored from __doc__ """ setActiveAudioTrack(self, index: int) """ pass def setActiveSubtitleTrack(self, index): # real signature unknown; restored from __doc__ """ setActiveSubtitleTrack(self, index: int) """ pass def setActiveVideoTrack(self, index): # real signature unknown; restored from __doc__ """ setActiveVideoTrack(self, index: int) """ pass def setAudioOutput(self, output): # real signature unknown; restored from __doc__ """ setAudioOutput(self, output: QAudioOutput) """ pass def setLoops(self, loops): # real signature unknown; restored from __doc__ """ setLoops(self, loops: int) """ pass def setPlaybackRate(self, rate): # real signature unknown; restored from __doc__ """ setPlaybackRate(self, rate: float) """ pass def setPosition(self, position): # real signature unknown; restored from __doc__ """ setPosition(self, position: int) """ pass def setSource(self, source): # real signature unknown; restored from __doc__ """ setSource(self, source: QUrl) """ pass def setSourceDevice(self, device, sourceUrl=None, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ setSourceDevice(self, device: QIODevice, sourceUrl: QUrl = QUrl()) """ pass def setVideoOutput(self, a0): # real signature unknown; restored from __doc__ """ setVideoOutput(self, a0: QObject) """ pass def setVideoSink(self, sink): # real signature unknown; restored from __doc__ """ setVideoSink(self, sink: QVideoSink) """ pass def source(self): # real signature unknown; restored from __doc__ """ source(self) -> QUrl """ pass def sourceChanged(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 sourceDevice(self): # real signature unknown; restored from __doc__ """ sourceDevice(self) -> QIODevice """ pass def stop(self): # real signature unknown; restored from __doc__ """ stop(self) """ pass def subtitleTracks(self): # real signature unknown; restored from __doc__ """ subtitleTracks(self) -> List[QMediaMetaData] """ return [] def timerEvent(self, *args, **kwargs): # real signature unknown pass def tracksChanged(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 videoOutput(self): # real signature unknown; restored from __doc__ """ videoOutput(self) -> QObject """ pass def videoOutputChanged(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 videoSink(self): # real signature unknown; restored from __doc__ """ videoSink(self) -> QVideoSink """ return QVideoSink def videoTracks(self): # real signature unknown; restored from __doc__ """ videoTracks(self) -> List[QMediaMetaData] """ return [] def __init__(self, parent, QObject=None, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ pass Error = None # (!) real value is "" Loops = None # (!) real value is "" MediaStatus = None # (!) real value is "" PlaybackState = None # (!) real value is "" class QMediaRecorder(__PyQt6_QtCore.QObject): """ QMediaRecorder(parent: typing.Optional[QObject] = None) """ def actualLocation(self): # real signature unknown; restored from __doc__ """ actualLocation(self) -> QUrl """ pass def actualLocationChanged(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 audioBitRate(self): # real signature unknown; restored from __doc__ """ audioBitRate(self) -> int """ return 0 def audioBitRateChanged(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 audioChannelCount(self): # real signature unknown; restored from __doc__ """ audioChannelCount(self) -> int """ return 0 def audioChannelCountChanged(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 audioSampleRate(self): # real signature unknown; restored from __doc__ """ audioSampleRate(self) -> int """ return 0 def audioSampleRateChanged(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 captureSession(self): # real signature unknown; restored from __doc__ """ captureSession(self) -> QMediaCaptureSession """ return QMediaCaptureSession def childEvent(self, *args, **kwargs): # real signature unknown pass def connectNotify(self, *args, **kwargs): # real signature unknown pass def customEvent(self, *args, **kwargs): # real signature unknown pass def disconnectNotify(self, *args, **kwargs): # real signature unknown pass def duration(self): # real signature unknown; restored from __doc__ """ duration(self) -> int """ return 0 def durationChanged(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 encodingMode(self): # real signature unknown; restored from __doc__ """ encodingMode(self) -> QMediaRecorder.EncodingMode """ pass def encodingModeChanged(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 error(self): # real signature unknown; restored from __doc__ """ error(self) -> QMediaRecorder.Error """ pass def errorChanged(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 errorOccurred(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 errorString(self): # real signature unknown; restored from __doc__ """ errorString(self) -> str """ return "" def isAvailable(self): # real signature unknown; restored from __doc__ """ isAvailable(self) -> bool """ return False def isSignalConnected(self, *args, **kwargs): # real signature unknown pass def mediaFormat(self): # real signature unknown; restored from __doc__ """ mediaFormat(self) -> QMediaFormat """ return QMediaFormat def mediaFormatChanged(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 metaData(self): # real signature unknown; restored from __doc__ """ metaData(self) -> QMediaMetaData """ return QMediaMetaData def metaDataChanged(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 outputLocation(self): # real signature unknown; restored from __doc__ """ outputLocation(self) -> QUrl """ pass def pause(self): # real signature unknown; restored from __doc__ """ pause(self) """ pass def quality(self): # real signature unknown; restored from __doc__ """ quality(self) -> QMediaRecorder.Quality """ pass def qualityChanged(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 receivers(self, *args, **kwargs): # real signature unknown pass def record(self): # real signature unknown; restored from __doc__ """ record(self) """ pass def recorderState(self): # real signature unknown; restored from __doc__ """ recorderState(self) -> QMediaRecorder.RecorderState """ pass def recorderStateChanged(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 sender(self, *args, **kwargs): # real signature unknown pass def senderSignalIndex(self, *args, **kwargs): # real signature unknown pass def setAudioBitRate(self, bitRate): # real signature unknown; restored from __doc__ """ setAudioBitRate(self, bitRate: int) """ pass def setAudioChannelCount(self, channels): # real signature unknown; restored from __doc__ """ setAudioChannelCount(self, channels: int) """ pass def setAudioSampleRate(self, sampleRate): # real signature unknown; restored from __doc__ """ setAudioSampleRate(self, sampleRate: int) """ pass def setEncodingMode(self, a0): # real signature unknown; restored from __doc__ """ setEncodingMode(self, a0: QMediaRecorder.EncodingMode) """ pass def setMediaFormat(self, format): # real signature unknown; restored from __doc__ """ setMediaFormat(self, format: QMediaFormat) """ pass def setMetaData(self, metaData): # real signature unknown; restored from __doc__ """ setMetaData(self, metaData: QMediaMetaData) """ pass def setOutputLocation(self, location): # real signature unknown; restored from __doc__ """ setOutputLocation(self, location: QUrl) """ pass def setQuality(self, quality): # real signature unknown; restored from __doc__ """ setQuality(self, quality: QMediaRecorder.Quality) """ pass def setVideoBitRate(self, bitRate): # real signature unknown; restored from __doc__ """ setVideoBitRate(self, bitRate: int) """ pass def setVideoFrameRate(self, frameRate): # real signature unknown; restored from __doc__ """ setVideoFrameRate(self, frameRate: float) """ pass def setVideoResolution(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads """ setVideoResolution(self, a0: QSize) setVideoResolution(self, width: int, height: int) """ pass def stop(self): # real signature unknown; restored from __doc__ """ stop(self) """ pass def timerEvent(self, *args, **kwargs): # real signature unknown pass def videoBitRate(self): # real signature unknown; restored from __doc__ """ videoBitRate(self) -> int """ return 0 def videoBitRateChanged(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 videoFrameRate(self): # real signature unknown; restored from __doc__ """ videoFrameRate(self) -> float """ return 0.0 def videoFrameRateChanged(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 videoResolution(self): # real signature unknown; restored from __doc__ """ videoResolution(self) -> QSize """ pass def videoResolutionChanged(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 __init__(self, parent, QObject=None, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ pass EncodingMode = None # (!) real value is "" Error = None # (!) real value is "" Quality = None # (!) real value is "" RecorderState = None # (!) real value is "" class QMediaTimeRange(__PyQt6_sip.simplewrapper): """ QMediaTimeRange() QMediaTimeRange(a0: QMediaTimeRange.Interval) QMediaTimeRange(start: int, end: int) QMediaTimeRange(range: QMediaTimeRange) """ def addInterval(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads """ addInterval(self, interval: QMediaTimeRange.Interval) addInterval(self, start: int, end: int) """ pass def addTimeRange(self, a0): # real signature unknown; restored from __doc__ """ addTimeRange(self, a0: QMediaTimeRange) """ pass def clear(self): # real signature unknown; restored from __doc__ """ clear(self) """ pass def contains(self, time): # real signature unknown; restored from __doc__ """ contains(self, time: int) -> bool """ return False def earliestTime(self): # real signature unknown; restored from __doc__ """ earliestTime(self) -> int """ return 0 def intervals(self): # real signature unknown; restored from __doc__ """ intervals(self) -> List[QMediaTimeRange.Interval] """ return [] def isContinuous(self): # real signature unknown; restored from __doc__ """ isContinuous(self) -> bool """ return False def isEmpty(self): # real signature unknown; restored from __doc__ """ isEmpty(self) -> bool """ return False def latestTime(self): # real signature unknown; restored from __doc__ """ latestTime(self) -> int """ return 0 def removeInterval(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads """ removeInterval(self, interval: QMediaTimeRange.Interval) removeInterval(self, start: int, end: int) """ pass def removeTimeRange(self, a0): # real signature unknown; restored from __doc__ """ removeTimeRange(self, a0: QMediaTimeRange) """ pass def __add__(self, *args, **kwargs): # real signature unknown """ Return self+value. """ pass def __eq__(self, *args, **kwargs): # real signature unknown """ Return self==value. """ pass def __ge__(self, *args, **kwargs): # real signature unknown """ Return self>=value. """ pass def __gt__(self, *args, **kwargs): # real signature unknown """ Return self>value. """ pass def __iadd__(self, *args, **kwargs): # real signature unknown """ Return self+=value. """ pass def __init__(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads pass def __isub__(self, *args, **kwargs): # real signature unknown """ Return self-=value. """ pass def __le__(self, *args, **kwargs): # real signature unknown """ Return self<=value. """ pass def __lt__(self, *args, **kwargs): # real signature unknown """ Return self" __hash__ = None class QSoundEffect(__PyQt6_QtCore.QObject): """ QSoundEffect(audioDevice: QAudioDevice, parent: typing.Optional[QObject] = None) QSoundEffect(parent: typing.Optional[QObject] = None) """ def audioDevice(self): # real signature unknown; restored from __doc__ """ audioDevice(self) -> QAudioDevice """ return QAudioDevice def audioDeviceChanged(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 childEvent(self, *args, **kwargs): # real signature unknown pass def connectNotify(self, *args, **kwargs): # real signature unknown pass def customEvent(self, *args, **kwargs): # real signature unknown pass def disconnectNotify(self, *args, **kwargs): # real signature unknown pass def isLoaded(self): # real signature unknown; restored from __doc__ """ isLoaded(self) -> bool """ return False def isMuted(self): # real signature unknown; restored from __doc__ """ isMuted(self) -> bool """ return False def isPlaying(self): # real signature unknown; restored from __doc__ """ isPlaying(self) -> bool """ return False def isSignalConnected(self, *args, **kwargs): # real signature unknown pass def loadedChanged(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 loopCount(self): # real signature unknown; restored from __doc__ """ loopCount(self) -> int """ return 0 def loopCountChanged(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 loopsRemaining(self): # real signature unknown; restored from __doc__ """ loopsRemaining(self) -> int """ return 0 def loopsRemainingChanged(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 mutedChanged(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 play(self): # real signature unknown; restored from __doc__ """ play(self) """ pass def playingChanged(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 receivers(self, *args, **kwargs): # real signature unknown pass def sender(self, *args, **kwargs): # real signature unknown pass def senderSignalIndex(self, *args, **kwargs): # real signature unknown pass def setAudioDevice(self, device): # real signature unknown; restored from __doc__ """ setAudioDevice(self, device: QAudioDevice) """ pass def setLoopCount(self, loopCount): # real signature unknown; restored from __doc__ """ setLoopCount(self, loopCount: int) """ pass def setMuted(self, muted): # real signature unknown; restored from __doc__ """ setMuted(self, muted: bool) """ pass def setSource(self, url): # real signature unknown; restored from __doc__ """ setSource(self, url: QUrl) """ pass def setVolume(self, volume): # real signature unknown; restored from __doc__ """ setVolume(self, volume: float) """ pass def source(self): # real signature unknown; restored from __doc__ """ source(self) -> QUrl """ pass def sourceChanged(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 status(self): # real signature unknown; restored from __doc__ """ status(self) -> QSoundEffect.Status """ pass def statusChanged(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 stop(self): # real signature unknown; restored from __doc__ """ stop(self) """ pass def supportedMimeTypes(self): # real signature unknown; restored from __doc__ """ supportedMimeTypes() -> List[str] """ return [] def timerEvent(self, *args, **kwargs): # real signature unknown pass def volume(self): # real signature unknown; restored from __doc__ """ volume(self) -> float """ return 0.0 def volumeChanged(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 __init__(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads pass Loop = None # (!) real value is "" Status = None # (!) real value is "" class QVideoFrame(__PyQt6_sip.simplewrapper): """ QVideoFrame() QVideoFrame(format: QVideoFrameFormat) QVideoFrame(other: QVideoFrame) """ def bits(self, plane): # real signature unknown; restored from __doc__ """ bits(self, plane: int) -> PyQt6.sip.voidptr """ pass def bytesPerLine(self, plane): # real signature unknown; restored from __doc__ """ bytesPerLine(self, plane: int) -> int """ return 0 def endTime(self): # real signature unknown; restored from __doc__ """ endTime(self) -> int """ return 0 def handleType(self): # real signature unknown; restored from __doc__ """ handleType(self) -> QVideoFrame.HandleType """ pass def height(self): # real signature unknown; restored from __doc__ """ height(self) -> int """ return 0 def isMapped(self): # real signature unknown; restored from __doc__ """ isMapped(self) -> bool """ return False def isReadable(self): # real signature unknown; restored from __doc__ """ isReadable(self) -> bool """ return False def isValid(self): # real signature unknown; restored from __doc__ """ isValid(self) -> bool """ return False def isWritable(self): # real signature unknown; restored from __doc__ """ isWritable(self) -> bool """ return False def map(self, mode): # real signature unknown; restored from __doc__ """ map(self, mode: QVideoFrame.MapMode) -> bool """ return False def mapMode(self): # real signature unknown; restored from __doc__ """ mapMode(self) -> QVideoFrame.MapMode """ pass def mappedBytes(self, plane): # real signature unknown; restored from __doc__ """ mappedBytes(self, plane: int) -> int """ return 0 def mirrored(self): # real signature unknown; restored from __doc__ """ mirrored(self) -> bool """ return False def paint(self, painter, rect, options): # real signature unknown; restored from __doc__ """ paint(self, painter: QPainter, rect: QRectF, options: QVideoFrame.PaintOptions) """ pass def pixelFormat(self): # real signature unknown; restored from __doc__ """ pixelFormat(self) -> QVideoFrameFormat.PixelFormat """ pass def planeCount(self): # real signature unknown; restored from __doc__ """ planeCount(self) -> int """ return 0 def rotationAngle(self): # real signature unknown; restored from __doc__ """ rotationAngle(self) -> QVideoFrame.RotationAngle """ pass def setEndTime(self, time): # real signature unknown; restored from __doc__ """ setEndTime(self, time: int) """ pass def setMirrored(self, a0): # real signature unknown; restored from __doc__ """ setMirrored(self, a0: bool) """ pass def setRotationAngle(self, a0): # real signature unknown; restored from __doc__ """ setRotationAngle(self, a0: QVideoFrame.RotationAngle) """ pass def setStartTime(self, time): # real signature unknown; restored from __doc__ """ setStartTime(self, time: int) """ pass def setSubtitleText(self, text): # real signature unknown; restored from __doc__ """ setSubtitleText(self, text: str) """ pass def size(self): # real signature unknown; restored from __doc__ """ size(self) -> QSize """ pass def startTime(self): # real signature unknown; restored from __doc__ """ startTime(self) -> int """ return 0 def subtitleText(self): # real signature unknown; restored from __doc__ """ subtitleText(self) -> str """ return "" def surfaceFormat(self): # real signature unknown; restored from __doc__ """ surfaceFormat(self) -> QVideoFrameFormat """ return QVideoFrameFormat def toImage(self): # real signature unknown; restored from __doc__ """ toImage(self) -> QImage """ pass def unmap(self): # real signature unknown; restored from __doc__ """ unmap(self) """ pass def width(self): # real signature unknown; restored from __doc__ """ width(self) -> int """ return 0 def __eq__(self, *args, **kwargs): # real signature unknown """ Return self==value. """ pass def __ge__(self, *args, **kwargs): # real signature unknown """ Return self>=value. """ pass def __gt__(self, *args, **kwargs): # real signature unknown """ Return self>value. """ pass def __init__(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads pass def __le__(self, *args, **kwargs): # real signature unknown """ Return self<=value. """ pass def __lt__(self, *args, **kwargs): # real signature unknown """ Return self" MapMode = None # (!) real value is "" PaintOptions = None # (!) real value is "" RotationAngle = None # (!) real value is "" __hash__ = None class QVideoFrameFormat(__PyQt6_sip.simplewrapper): """ QVideoFrameFormat() QVideoFrameFormat(size: QSize, pixelFormat: QVideoFrameFormat.PixelFormat) QVideoFrameFormat(format: QVideoFrameFormat) """ def colorRange(self): # real signature unknown; restored from __doc__ """ colorRange(self) -> QVideoFrameFormat.ColorRange """ pass def colorSpace(self): # real signature unknown; restored from __doc__ """ colorSpace(self) -> QVideoFrameFormat.ColorSpace """ pass def colorTransfer(self): # real signature unknown; restored from __doc__ """ colorTransfer(self) -> QVideoFrameFormat.ColorTransfer """ pass def frameHeight(self): # real signature unknown; restored from __doc__ """ frameHeight(self) -> int """ return 0 def frameRate(self): # real signature unknown; restored from __doc__ """ frameRate(self) -> float """ return 0.0 def frameSize(self): # real signature unknown; restored from __doc__ """ frameSize(self) -> QSize """ pass def frameWidth(self): # real signature unknown; restored from __doc__ """ frameWidth(self) -> int """ return 0 def imageFormatFromPixelFormat(self, format): # real signature unknown; restored from __doc__ """ imageFormatFromPixelFormat(format: QVideoFrameFormat.PixelFormat) -> QImage.Format """ pass def isMirrored(self): # real signature unknown; restored from __doc__ """ isMirrored(self) -> bool """ return False def isValid(self): # real signature unknown; restored from __doc__ """ isValid(self) -> bool """ return False def pixelFormat(self): # real signature unknown; restored from __doc__ """ pixelFormat(self) -> QVideoFrameFormat.PixelFormat """ pass def pixelFormatFromImageFormat(self, format): # real signature unknown; restored from __doc__ """ pixelFormatFromImageFormat(format: QImage.Format) -> QVideoFrameFormat.PixelFormat """ pass def pixelFormatToString(self, pixelFormat): # real signature unknown; restored from __doc__ """ pixelFormatToString(pixelFormat: QVideoFrameFormat.PixelFormat) -> str """ return "" def planeCount(self): # real signature unknown; restored from __doc__ """ planeCount(self) -> int """ return 0 def scanLineDirection(self): # real signature unknown; restored from __doc__ """ scanLineDirection(self) -> QVideoFrameFormat.Direction """ pass def setColorRange(self, range): # real signature unknown; restored from __doc__ """ setColorRange(self, range: QVideoFrameFormat.ColorRange) """ pass def setColorSpace(self, colorSpace): # real signature unknown; restored from __doc__ """ setColorSpace(self, colorSpace: QVideoFrameFormat.ColorSpace) """ pass def setColorTransfer(self, colorTransfer): # real signature unknown; restored from __doc__ """ setColorTransfer(self, colorTransfer: QVideoFrameFormat.ColorTransfer) """ pass def setFrameRate(self, rate): # real signature unknown; restored from __doc__ """ setFrameRate(self, rate: float) """ pass def setFrameSize(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads """ setFrameSize(self, size: QSize) setFrameSize(self, width: int, height: int) """ pass def setMirrored(self, mirrored): # real signature unknown; restored from __doc__ """ setMirrored(self, mirrored: bool) """ pass def setScanLineDirection(self, direction): # real signature unknown; restored from __doc__ """ setScanLineDirection(self, direction: QVideoFrameFormat.Direction) """ pass def setViewport(self, viewport): # real signature unknown; restored from __doc__ """ setViewport(self, viewport: QRect) """ pass def setYCbCrColorSpace(self, colorSpace): # real signature unknown; restored from __doc__ """ setYCbCrColorSpace(self, colorSpace: QVideoFrameFormat.YCbCrColorSpace) """ pass def viewport(self): # real signature unknown; restored from __doc__ """ viewport(self) -> QRect """ pass def yCbCrColorSpace(self): # real signature unknown; restored from __doc__ """ yCbCrColorSpace(self) -> QVideoFrameFormat.YCbCrColorSpace """ pass def __eq__(self, *args, **kwargs): # real signature unknown """ Return self==value. """ pass def __ge__(self, *args, **kwargs): # real signature unknown """ Return self>=value. """ pass def __gt__(self, *args, **kwargs): # real signature unknown """ Return self>value. """ pass def __init__(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads pass def __le__(self, *args, **kwargs): # real signature unknown """ Return self<=value. """ pass def __lt__(self, *args, **kwargs): # real signature unknown """ Return self" ColorSpace = None # (!) real value is "" ColorTransfer = None # (!) real value is "" Direction = None # (!) real value is "" PixelFormat = None # (!) real value is "" YCbCrColorSpace = None # (!) real value is "" __hash__ = None class QVideoSink(__PyQt6_QtCore.QObject): """ QVideoSink(parent: typing.Optional[QObject] = None) """ def childEvent(self, *args, **kwargs): # real signature unknown pass def connectNotify(self, *args, **kwargs): # real signature unknown pass def customEvent(self, *args, **kwargs): # real signature unknown pass def disconnectNotify(self, *args, **kwargs): # real signature unknown pass def isSignalConnected(self, *args, **kwargs): # real signature unknown pass def receivers(self, *args, **kwargs): # real signature unknown pass def sender(self, *args, **kwargs): # real signature unknown pass def senderSignalIndex(self, *args, **kwargs): # real signature unknown pass def setSubtitleText(self, subtitle): # real signature unknown; restored from __doc__ """ setSubtitleText(self, subtitle: str) """ pass def setVideoFrame(self, frame): # real signature unknown; restored from __doc__ """ setVideoFrame(self, frame: QVideoFrame) """ pass def subtitleText(self): # real signature unknown; restored from __doc__ """ subtitleText(self) -> str """ return "" def subtitleTextChanged(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 timerEvent(self, *args, **kwargs): # real signature unknown pass def videoFrame(self): # real signature unknown; restored from __doc__ """ videoFrame(self) -> QVideoFrame """ return QVideoFrame def videoFrameChanged(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 videoSize(self): # real signature unknown; restored from __doc__ """ videoSize(self) -> QSize """ pass def videoSizeChanged(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 __init__(self, parent, QObject=None, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ pass # variables with complex values __loader__ = None # (!) real value is '<_frozen_importlib_external.ExtensionFileLoader object at 0x000002EC8354C350>' __spec__ = None # (!) real value is "ModuleSpec(name='PyQt6.QtMultimedia', loader=<_frozen_importlib_external.ExtensionFileLoader object at 0x000002EC8354C350>, origin='C:\\\\Users\\\\xukai\\\\Downloads\\\\??2\\\\venv\\\\Lib\\\\site-packages\\\\PyQt6\\\\QtMultimedia.pyd')"