eric6.Debugger.DebugServer

Module implementing the debug server.

Global Attributes

DebuggerInterfaces

Classes

DebugServer

Class implementing the debug server embedded within the IDE.

Functions

None

DebugServer

Class implementing the debug server embedded within the IDE.

Signals

appendStdout(msg): emitted when a passive debug connection is established or lost
callTraceInfo: emitted after the client reported the call trace data (isCall, fromFile, fromLine, fromFunction, toFile, toLine, toFunction)
clientBanner(version, platform, dbgclient, venvname): emitted after the client banner data was received
clientBreakConditionError(fn, lineno): emitted after the client has signaled a syntax error in a breakpoint condition
clientCapabilities(capabilities, cltype, venvname): emitted after the clients capabilities were received
clientClearBreak(filename, lineno): emitted after the debug client has decided to clear a temporary breakpoint
clientClearWatch(condition): emitted after the debug client has decided to clear a temporary watch expression
clientCompletionList(completionList, text): emitted after the client the commandline completion list and the reworked searchstring was received from the client
clientException(exception): emitted after an exception occured on the client side
clientExit(int, str, bool): emitted after the client has exited giving the exit status, an exit message and an indication to be quiet
clientGone(bool): emitted if the client went away (planned or unplanned)
clientInterpreterChanged(str): emitted to signal a change of the client interpreter
clientLine(filename, lineno, forStack): emitted after the debug client has executed a line of code
clientOutput(str): emitted after the client has sent some output
clientProcessStderr(str): emitted after the client has sent some output via stderr
clientProcessStdout(str): emitted after the client has sent some output via stdout
clientRawInput(prompt, echo): emitted after a raw input request was received
clientRawInputSent(): emitted after the data was sent to the debug client
clientSignal(signal): emitted after a signal has been generated on the client side
clientStack(stack): emitted after the debug client has executed a line of code
clientStatement(bool): emitted after an interactive command has been executed. The parameter is 0 to indicate that the command is complete and 1 if it needs more input.
clientSyntaxError(exception): emitted after a syntax error has been detected on the client side
clientThreadList(currentId, threadList): emitted after a thread list has been received
clientThreadSet(): emitted after the client has acknowledged the change of the current thread
clientVariable(scope, variables): emitted after a dump for one class variable has been received
clientVariables(scope, variables): emitted after a variables dump has been received
clientWatchConditionError(condition): emitted after the client has signaled a syntax error in a watch expression
passiveDebugStarted(str, bool): emitted after the debug client has connected in passive debug mode
utDiscovered(testCases, exc_type, exc_value): emitted after the client has performed a test case discovery action
utFinished(): emitted after the client signalled the end of the unittest
utPrepared(nrTests, exc_type, exc_value): emitted after the client has loaded a unittest suite
utStartTest(testname, testdocu): emitted after the client has started a test
utStopTest(): emitted after the client has finished a test
utTestErrored(testname, exc_info, id): emitted after the client reported an errored test
utTestFailed(testname, exc_info, id): emitted after the client reported a failed test
utTestFailedExpected(testname, exc_info, id): emitted after the client reported an expected test failure
utTestSkipped(testname, reason, id): emitted after the client reported a skipped test
utTestSucceededUnexpected(testname, id): emitted after the client reported an unexpected test success

Derived from

QTcpServer

Class Attributes

None

Class Methods

None

Methods

DebugServer	Constructor
__addBreakPoints	Private slot to add breakpoints.
__addWatchPoints	Private slot to set a watch expression.
__breakPointDataAboutToBeChanged	Private slot to handle the dataAboutToBeChanged signal of the breakpoint model.
__changeBreakPoints	Private slot to set changed breakpoints.
__changeWatchPoints	Private slot to set changed watch expressions.
__clientClearBreakPoint	Private slot to handle the clientClearBreak signal.
__clientClearWatchPoint	Private slot to handle the clientClearWatch signal.
__clientProcessError	Private slot to process client output received via stderr.
__clientProcessOutput	Private slot to process client output received via stdout.
__createDebuggerInterface	Private slot to create the debugger interface object.
__deleteBreakPoints	Private slot to delete breakpoints.
__deleteWatchPoints	Private slot to delete watch expressions.
__findLanguageForExtension	Private method to get the language associated with a file extension.
__getNetworkInterfaceAndIndex	Private method to determine the network interface and the interface index.
__makeWatchCondition	Private method to construct the condition string.
__newConnection	Private slot to handle a new connection.
__passiveShutDown	Private method to shut down a passive debug connection.
__registerDebuggerInterfaces	Private method to register the available internal debugger interfaces.
__remoteBreakpointEnable	Private method to enable or disable a breakpoint.
__remoteBreakpointIgnore	Private method to ignore a breakpoint the next couple of occurrences.
__remoteWatchpoint	Private method to set or clear a watch expression.
__remoteWatchpointEnable	Private method to enable or disable a watch expression.
__remoteWatchpointIgnore	Private method to ignore a watch expression the next couple of occurrences.
__restoreBreakpoints	Private method to restore the breakpoints after a restart.
__restoreWatchpoints	Private method to restore the watch expressions after a restart.
__setClientType	Private method to set the client type.
__splitWatchCondition	Private method to split a remote watch expression.
__watchPointDataAboutToBeChanged	Private slot to handle the dataAboutToBeChanged signal of the watch expression model.
clientUtDiscovered	Public method to process the client unittest discover info.
clientUtFinished	Public method to process the client unit test finished info.
clientUtPrepared	Public method to process the client unittest prepared info.
clientUtStartTest	Public method to process the client start test info.
clientUtStopTest	Public method to process the client stop test info.
clientUtTestErrored	Public method to process the client test errored info.
clientUtTestFailed	Public method to process the client test failed info.
clientUtTestFailedExpected	Public method to process the client test failed expected info.
clientUtTestSkipped	Public method to process the client test skipped info.
clientUtTestSucceededUnexpected	Public method to process the client test succeeded unexpected info.
getBreakPointModel	Public slot to get a reference to the breakpoint model object.
getClientCapabilities	Public method to retrieve the debug clients capabilities.
getClientInterpreter	Public method to get the interpreter of the debug client.
getClientType	Public method to get the currently running debug client type.
getExtensions	Public slot to get the extensions associated with the given language.
getHostAddress	Public method to get the IP address or hostname the debug server is listening.
getSupportedLanguages	Public slot to return the supported programming languages.
getWatchPointModel	Public slot to get a reference to the watch expression model object.
isClientProcessUp	Public method to check, if the debug client process is up.
isConnected	Public method to test, if the debug server is connected to a backend.
isDebugging	Public method to test, if the debug server is debugging.
passiveStartUp	Public method to handle a passive debug connection.
preferencesChanged	Public slot to handle the preferencesChanged signal.
registerDebuggerInterface	Public method to register a debugger interface.
remoteBanner	Public slot to get the banner info of the remote client.
remoteBreakpoint	Public method to set or clear a breakpoint.
remoteCapabilities	Public slot to get the debug clients capabilities.
remoteClientSetFilter	Public method to set a variables filter list.
remoteClientVariable	Public method to request the variables of the debugged program.
remoteClientVariables	Public method to request the variables of the debugged program.
remoteCompletion	Public slot to get the a list of possible commandline completions from the remote client.
remoteContinue	Public method to continue the debugged program.
remoteCoverage	Public method to load a new program to collect coverage data.
remoteEnvironment	Public method to set the environment for a program to debug, run, ...
remoteLoad	Public method to load a new program to debug.
remoteMoveIP	Public method to move the instruction pointer to a different line.
remoteProfile	Public method to load a new program to collect profiling data.
remoteRawInput	Public method to send the raw input to the debugged program.
remoteRun	Public method to load a new program to run.
remoteSetThread	Public method to request to set the given thread as current thread.
remoteStatement	Public method to execute a Python statement.
remoteStep	Public method to single step the debugged program.
remoteStepOut	Public method to step out the debugged program.
remoteStepOver	Public method to step over the debugged program.
remoteStepQuit	Public method to stop the debugged program.
remoteThreadList	Public method to request the list of threads from the client.
remoteUTDiscover	Public method to perform a test case discovery.
remoteUTPrepare	Public method to prepare a new unittest run.
remoteUTRun	Public method to start a unittest run.
remoteUTStop	public method to stop a unittest run.
setCallTraceEnabled	Public method to set the call trace state.
setDebugging	Public method to set the debugging state.
shutdownServer	Public method to cleanly shut down.
signalClientBanner	Public method to process the client banner info.
signalClientBreakConditionError	Public method to process the client breakpoint condition error info.
signalClientCallTrace	Public method to process the client call trace data.
signalClientCapabilities	Public method to process the client capabilities info.
signalClientClearBreak	Public method to process the client clear breakpoint command.
signalClientClearWatch	Public slot to handle the clientClearWatch signal.
signalClientCompletionList	Public method to process the client auto completion info.
signalClientException	Public method to process the exception info from the client.
signalClientExit	Public method to process the client exit status.
signalClientLine	Public method to process client position feedback.
signalClientOutput	Public method to process a line of client output.
signalClientRawInput	Public method to process the client raw input command.
signalClientSignal	Public method to process a signal generated on the client side.
signalClientStack	Public method to process a client's stack information.
signalClientStatement	Public method to process the input response from the client.
signalClientSyntaxError	Public method to process the syntax error info from the client.
signalClientThreadList	Public method to process the client thread list info.
signalClientThreadSet	Public method to handle the change of the client thread.
signalClientVariable	Public method to process the client variable info.
signalClientVariables	Public method to process the client variables info.
signalClientWatchConditionError	Public method to process the client watch expression error info.
startClient	Public method to start a debug client.
unregisterDebuggerInterface	Public method to unregister a debugger interface.

Static Methods

None

DebugServer (Constructor)

DebugServer(originalPathString, preventPassiveDebugging=False)

Constructor

originalPathString (str): original PATH environment variable
preventPassiveDebugging (bool): flag overriding the PassiveDbgEnabled setting

DebugServer.__addBreakPoints

__addBreakPoints(parentIndex, start, end)

Private slot to add breakpoints.

parentIndex: index of parent item (QModelIndex)
start: start row (integer)
end: end row (integer)

DebugServer.__addWatchPoints

__addWatchPoints(parentIndex, start, end)

Private slot to set a watch expression.

parentIndex: index of parent item (QModelIndex)
start: start row (integer)
end: end row (integer)

DebugServer.__breakPointDataAboutToBeChanged

__breakPointDataAboutToBeChanged(startIndex, endIndex)

Private slot to handle the dataAboutToBeChanged signal of the breakpoint model.

startIndex: start index of the rows to be changed (QModelIndex)
endIndex: end index of the rows to be changed (QModelIndex)

DebugServer.__changeBreakPoints

__changeBreakPoints(startIndex, endIndex)

Private slot to set changed breakpoints.

startIndex: starting index of the change breakpoins (QModelIndex)
endIndex: ending index of the change breakpoins (QModelIndex)

DebugServer.__changeWatchPoints

__changeWatchPoints(startIndex, endIndex)

Private slot to set changed watch expressions.

startIndex: start index of the rows to be changed (QModelIndex)
endIndex: end index of the rows to be changed (QModelIndex)

DebugServer.__clientClearBreakPoint

__clientClearBreakPoint(fn, lineno)

Private slot to handle the clientClearBreak signal.

fn: filename of breakpoint to clear (string)
lineno: line number of breakpoint to clear (integer)

DebugServer.__clientClearWatchPoint

__clientClearWatchPoint(condition)

Private slot to handle the clientClearWatch signal.

condition: expression of watch expression to clear (string)

DebugServer.__clientProcessError

__clientProcessError()

Private slot to process client output received via stderr.

DebugServer.__clientProcessOutput

__clientProcessOutput()

Private slot to process client output received via stdout.

DebugServer.__createDebuggerInterface

__createDebuggerInterface(clientType=None)

Private slot to create the debugger interface object.

clientType: type of the client interface to be created (string)

DebugServer.__deleteBreakPoints

__deleteBreakPoints(parentIndex, start, end)

Private slot to delete breakpoints.

parentIndex: index of parent item (QModelIndex)
start: start row (integer)
end: end row (integer)

DebugServer.__deleteWatchPoints

__deleteWatchPoints(parentIndex, start, end)

Private slot to delete watch expressions.

parentIndex: index of parent item (QModelIndex)
start: start row (integer)
end: end row (integer)

DebugServer.__findLanguageForExtension

__findLanguageForExtension(ext)

Private method to get the language associated with a file extension.

ext (str): file extension

Returns:: associated language

Return Type:: str

DebugServer.__getNetworkInterfaceAndIndex

__getNetworkInterfaceAndIndex(address)

Private method to determine the network interface and the interface index.

address: address to determine the info for (string)

Returns:: tuple of network interface name (string) and index (integer)

DebugServer.__makeWatchCondition

__makeWatchCondition(cond, special)

Private method to construct the condition string.

cond: condition (string)
special: special condition (string)

Returns:: condition string (string)

DebugServer.__newConnection

__newConnection()

Private slot to handle a new connection.

DebugServer.__passiveShutDown

__passiveShutDown()

Private method to shut down a passive debug connection.

DebugServer.__registerDebuggerInterfaces

__registerDebuggerInterfaces()

Private method to register the available internal debugger interfaces.

DebugServer.__remoteBreakpointEnable

__remoteBreakpointEnable(fn, line, enable)

Private method to enable or disable a breakpoint.

fn: filename the breakpoint belongs to (string)
line: linenumber of the breakpoint (int)
enable: flag indicating enabling or disabling a breakpoint (boolean)

DebugServer.__remoteBreakpointIgnore

__remoteBreakpointIgnore(fn, line, count)

Private method to ignore a breakpoint the next couple of occurrences.

fn: filename the breakpoint belongs to (string)
line: linenumber of the breakpoint (int)
count: number of occurrences to ignore (int)

DebugServer.__remoteWatchpoint

__remoteWatchpoint(cond, setWatch, temp=False)

Private method to set or clear a watch expression.

cond: expression of the watch expression (string)
setWatch: flag indicating setting or resetting a watch expression (boolean)
temp: flag indicating a temporary watch expression (boolean)

DebugServer.__remoteWatchpointEnable

__remoteWatchpointEnable(cond, enable)

Private method to enable or disable a watch expression.

cond: expression of the watch expression (string)
enable: flag indicating enabling or disabling a watch expression (boolean)

DebugServer.__remoteWatchpointIgnore

__remoteWatchpointIgnore(cond, count)

Private method to ignore a watch expression the next couple of occurrences.

cond: expression of the watch expression (string)
count: number of occurrences to ignore (int)

DebugServer.__restoreBreakpoints

__restoreBreakpoints()

Private method to restore the breakpoints after a restart.

DebugServer.__restoreWatchpoints

__restoreWatchpoints()

Private method to restore the watch expressions after a restart.

DebugServer.__setClientType

__setClientType(clType)

Private method to set the client type.

clType: type of client to be started (string)

DebugServer.__splitWatchCondition

__splitWatchCondition(cond)

Private method to split a remote watch expression.

cond: remote expression (string)

Returns:: tuple of local expression (string) and special condition (string)

DebugServer.__watchPointDataAboutToBeChanged

__watchPointDataAboutToBeChanged(startIndex, endIndex)

Private slot to handle the dataAboutToBeChanged signal of the watch expression model.

startIndex: start index of the rows to be changed (QModelIndex)
endIndex: end index of the rows to be changed (QModelIndex)

DebugServer.clientUtDiscovered

clientUtDiscovered(testCases, exceptionType, exceptionValue)

Public method to process the client unittest discover info.

testCases (str): list of detected test cases
exceptionType (str): exception type
exceptionValue (str): exception message

DebugServer.clientUtFinished

clientUtFinished(status)

Public method to process the client unit test finished info.

status (int): exit status of the unit test

DebugServer.clientUtPrepared

clientUtPrepared(result, exceptionType, exceptionValue)

Public method to process the client unittest prepared info.

result: number of test cases (0 = error) (integer)
exceptionType: exception type (string)
exceptionValue: exception message (string)

DebugServer.clientUtStartTest

clientUtStartTest(testname, doc)

Public method to process the client start test info.

testname: name of the test (string)
doc: short description of the test (string)

DebugServer.clientUtStopTest

clientUtStopTest()

Public method to process the client stop test info.

DebugServer.clientUtTestErrored

clientUtTestErrored(testname, traceback, testId)

Public method to process the client test errored info.

testname: name of the test (string)
traceback: lines of traceback info (list of strings)
testId: id of the test (string)

DebugServer.clientUtTestFailed

clientUtTestFailed(testname, traceback, testId)

Public method to process the client test failed info.

testname: name of the test (string)
traceback: lines of traceback info (list of strings)
testId: id of the test (string)

DebugServer.clientUtTestFailedExpected

clientUtTestFailedExpected(testname, traceback, testId)

Public method to process the client test failed expected info.

testname: name of the test (string)
traceback: lines of traceback info (list of strings)
testId: id of the test (string)

DebugServer.clientUtTestSkipped

clientUtTestSkipped(testname, reason, testId)

Public method to process the client test skipped info.

testname: name of the test (string)
reason: reason for skipping the test (string)
testId: id of the test (string)

DebugServer.clientUtTestSucceededUnexpected

clientUtTestSucceededUnexpected(testname, testId)

Public method to process the client test succeeded unexpected info.

testname: name of the test (string)
testId: id of the test (string)

DebugServer.getBreakPointModel

getBreakPointModel()

Public slot to get a reference to the breakpoint model object.

Returns:: reference to the breakpoint model object (BreakPointModel)

DebugServer.getClientCapabilities

getClientCapabilities(clientType)

Public method to retrieve the debug clients capabilities.

clientType: debug client type (string)

Returns:: debug client capabilities (integer)

DebugServer.getClientInterpreter

getClientInterpreter()

Public method to get the interpreter of the debug client.

Returns:: interpreter of the debug client (string)

DebugServer.getClientType

getClientType()

Public method to get the currently running debug client type.

Returns:: debug client type

Return Type:: str

DebugServer.getExtensions

getExtensions(language)

Public slot to get the extensions associated with the given language.

language: language to get extensions for (string)

Returns:: tuple of extensions associated with the language (tuple of strings)

DebugServer.getHostAddress

getHostAddress(localhost)

Public method to get the IP address or hostname the debug server is listening.

localhost: flag indicating to return the address for localhost (boolean)

Returns:: IP address or hostname (string)

DebugServer.getSupportedLanguages

getSupportedLanguages(shellOnly=False)

Public slot to return the supported programming languages.

shellOnly: flag indicating only languages supporting an interactive shell should be returned

Returns:: list of supported languages (list of strings)

DebugServer.getWatchPointModel

getWatchPointModel()

Public slot to get a reference to the watch expression model object.

Returns:: reference to the watch expression model object (WatchPointModel)

DebugServer.isClientProcessUp

isClientProcessUp()

Public method to check, if the debug client process is up.

Returns:: flag indicating a running debug client process

Return Type:: bool

DebugServer.isConnected

isConnected()

Public method to test, if the debug server is connected to a backend.

Returns:: flag indicating a connection (boolean)

DebugServer.isDebugging

isDebugging()

Public method to test, if the debug server is debugging.

Returns:: flag indicating the debugging state

Return Type:: bool

DebugServer.passiveStartUp

passiveStartUp(fn, exc)

Public method to handle a passive debug connection.

fn: filename of the debugged script (string)
exc: flag to enable exception reporting of the IDE (boolean)

DebugServer.preferencesChanged

preferencesChanged()

Public slot to handle the preferencesChanged signal.

DebugServer.registerDebuggerInterface

registerDebuggerInterface(interfaceName, getRegistryData, reregister=False)

Public method to register a debugger interface.

interfaceName (str): name of the debugger interface
getRegistryData (function): reference to a function to be called to get the debugger interface details. This method shall return the client language, the client capabilities, the list of associated file extensions and a function reference to create the debugger interface (see __createDebuggerInterface())
reregister (bool): flag indicating to re-register the interface

DebugServer.remoteBanner

remoteBanner()

Public slot to get the banner info of the remote client.

DebugServer.remoteBreakpoint

remoteBreakpoint(fn, line, setBreakpoint, cond=None, temp=False)

Public method to set or clear a breakpoint.

fn: filename the breakpoint belongs to (string)
line: linenumber of the breakpoint (int)
setBreakpoint: flag indicating setting or resetting a breakpoint (boolean)
cond: condition of the breakpoint (string)
temp: flag indicating a temporary breakpoint (boolean)

DebugServer.remoteCapabilities

remoteCapabilities()

Public slot to get the debug clients capabilities.

DebugServer.remoteClientSetFilter

remoteClientSetFilter(scope, filterStr)

Public method to set a variables filter list.

scope: the scope of the variables (0 = local, 1 = global)
filterStr: regexp string for variable names to filter out (string)

DebugServer.remoteClientVariable

remoteClientVariable(scope, filterList, var, framenr=0)

Public method to request the variables of the debugged program.

scope: the scope of the variables (0 = local, 1 = global)
filterList: list of variable types to filter out (list of int)
var: list encoded name of variable to retrieve (string)
framenr: framenumber of the variables to retrieve (int)

DebugServer.remoteClientVariables

remoteClientVariables(scope, filterList, framenr=0)

Public method to request the variables of the debugged program.

scope: the scope of the variables (0 = local, 1 = global)
filterList: list of variable types to filter out (list of int)
framenr: framenumber of the variables to retrieve (int)

DebugServer.remoteCompletion

remoteCompletion(text)

Public slot to get the a list of possible commandline completions from the remote client.

text: the text to be completed (string)

DebugServer.remoteContinue

remoteContinue(special=False)

Public method to continue the debugged program.

special: flag indicating a special continue operation

DebugServer.remoteCoverage

remoteCoverage(venvName, fn, argv, wd, env, autoClearShell=True, erase=False, forProject=False, runInConsole=False, clientType="")

Public method to load a new program to collect coverage data.

venvName (str): name of the virtual environment to be used
fn (str): the filename to debug
argv (str): the command line arguments to pass to the program
wd (str): the working directory for the program
env (str): environment parameter settings
autoClearShell= (bool): flag indicating, that the interpreter window should be cleared
erase= (bool): flag indicating that coverage info should be cleared first
forProject= (bool): flag indicating a project related action
runInConsole= (bool): flag indicating to start the debugger in a console window
clientType= (str): client type to be used

DebugServer.remoteEnvironment

remoteEnvironment(env)

Public method to set the environment for a program to debug, run, ...

env: environment settings (string)

DebugServer.remoteLoad

remoteLoad(venvName, fn, argv, wd, env, autoClearShell=True, tracePython=False, autoContinue=True, forProject=False, runInConsole=False, autoFork=False, forkChild=False, clientType="", enableCallTrace=False)

Public method to load a new program to debug.

venvName (str): name of the virtual environment to be used
fn (str): the filename to debug
argv (str): the command line arguments to pass to the program
wd (str): the working directory for the program
env (str): environment parameter settings
autoClearShell= (bool): flag indicating, that the interpreter window should be cleared
tracePython= (bool): flag indicating if the Python library should be traced as well
autoContinue= (bool): flag indicating, that the debugger should not stop at the first executable line
forProject= (bool): flag indicating a project related action
runInConsole= (bool): flag indicating to start the debugger in a console window
autoFork= (bool): flag indicating the automatic fork mode
forkChild= (bool): flag indicating to debug the child after forking
clientType= (str): client type to be used
enableCallTrace= (bool): flag indicating to enable the call trace function

DebugServer.remoteMoveIP

remoteMoveIP(line)

Public method to move the instruction pointer to a different line.

line: the new line, where execution should be continued

DebugServer.remoteProfile

remoteProfile(venvName, fn, argv, wd, env, autoClearShell=True, erase=False, forProject=False, runInConsole=False, clientType="")

Public method to load a new program to collect profiling data.

venvName (str): name of the virtual environment to be used
fn (str): the filename to debug
argv (str): the command line arguments to pass to the program
wd (str): the working directory for the program
env (str): environment parameter settings
autoClearShell= (bool): flag indicating, that the interpreter window should be cleared
erase= (bool): flag indicating that coverage info should be cleared first
forProject= (bool): flag indicating a project related action
runInConsole= (bool): flag indicating to start the debugger in a console window
clientType= (str): client type to be used

DebugServer.remoteRawInput

remoteRawInput(s)

Public method to send the raw input to the debugged program.

s: the raw input (string)

DebugServer.remoteRun

remoteRun(venvName, fn, argv, wd, env, autoClearShell=True, forProject=False, runInConsole=False, autoFork=False, forkChild=False, clientType="")

Public method to load a new program to run.

venvName (str): name of the virtual environment to be used
fn (str): the filename to debug
argv (str): the command line arguments to pass to the program
wd (str): the working directory for the program
env (str): environment parameter settings
autoClearShell= (bool): flag indicating, that the interpreter window should be cleared
forProject= (bool): flag indicating a project related action
runInConsole= (bool): flag indicating to start the debugger in a console window
autoFork= (bool): flag indicating the automatic fork mode
forkChild= (bool): flag indicating to debug the child after forking
clientType= (str): client type to be used

DebugServer.remoteSetThread

remoteSetThread(tid)

Public method to request to set the given thread as current thread.

tid: id of the thread (integer)

DebugServer.remoteStatement

remoteStatement(stmt)

Public method to execute a Python statement.

stmt: the Python statement to execute (string). It should not have a trailing newline.

DebugServer.remoteStep

remoteStep()

Public method to single step the debugged program.

DebugServer.remoteStepOut

remoteStepOut()

Public method to step out the debugged program.

DebugServer.remoteStepOver

remoteStepOver()

Public method to step over the debugged program.

DebugServer.remoteStepQuit

remoteStepQuit()

Public method to stop the debugged program.

DebugServer.remoteThreadList

remoteThreadList()

Public method to request the list of threads from the client.

DebugServer.remoteUTDiscover

remoteUTDiscover(clientType, forProject, venvName, syspath, workdir, discoveryStart)

Public method to perform a test case discovery.

clientType (str): client type to be used
forProject (bool): flag indicating a project related action
venvName (str): name of a virtual environment
syspath (list of str): list of directories to be added to sys.path on the remote side
workdir (str): path name of the working directory
discoveryStart (str): directory to start auto-discovery at

DebugServer.remoteUTPrepare

remoteUTPrepare(fn, tn, tfn, failed, cov, covname, coverase, clientType="", forProject=False, venvName="", syspath=None, workdir="", discover=False, discoveryStart="", testCases=None, debug=False)

Public method to prepare a new unittest run.

fn (str): the filename to load
tn (str): the testname to load
tfn (str): the test function name to load tests from
failed (list of str): list of failed test, if only failed test should be run
cov (bool): flag indicating collection of coverage data is requested
covname (str): filename to be used to assemble the coverage caches filename
coverase (bool): flag indicating erasure of coverage data is requested
clientType (str): client type to be used
forProject (bool): flag indicating a project related action
venvName (str): name of a virtual environment
syspath (list of str): list of directories to be added to sys.path on the remote side
workdir (str): path name of the working directory
discover (bool): flag indicating to discover the tests automatically
discoveryStart (str): directory to start auto-discovery at
testCases (list of str): list of test cases to be loaded
debug (bool): flag indicating to run unittest with debugging

DebugServer.remoteUTRun

remoteUTRun(debug=False, failfast=False)

Public method to start a unittest run.

debug (bool): flag indicating to run unittest with debugging
failfast (bool): flag indicating to stop at the first error

DebugServer.remoteUTStop

remoteUTStop()

public method to stop a unittest run.

DebugServer.setCallTraceEnabled

setCallTraceEnabled(on)

Public method to set the call trace state.

on: flag indicating to enable the call trace function (boolean)

DebugServer.setDebugging

setDebugging(on)

Public method to set the debugging state.

on (bool): flag indicating the new debugging state

DebugServer.shutdownServer

shutdownServer()

Public method to cleanly shut down.

It closes our socket and shuts down the debug client. (Needed on Win OS)

DebugServer.signalClientBanner

signalClientBanner(version, platform, debugClient, venvName)

Public method to process the client banner info.

version (str): interpreter version info
platform (str): hostname of the client
debugClient (str): additional debugger type info
venvName (str): name of the virtual environment

DebugServer.signalClientBreakConditionError

signalClientBreakConditionError(filename, lineno)

Public method to process the client breakpoint condition error info.

filename: filename of the breakpoint (string)
lineno: line umber of the breakpoint (integer)

DebugServer.signalClientCallTrace

signalClientCallTrace(isCall, fromFile, fromLine, fromFunction, toFile, toLine, toFunction)

Public method to process the client call trace data.

isCall: flag indicating a 'call' (boolean)
fromFile: name of the originating file (string)
fromLine: line number in the originating file (string)
fromFunction: name of the originating function (string)
toFile: name of the target file (string)
toLine: line number in the target file (string)
toFunction: name of the target function (string)

DebugServer.signalClientCapabilities

signalClientCapabilities(capabilities, clientType, venvName)

Public method to process the client capabilities info.

capabilities (int): bitmaks with the client capabilities
clientType (str): type of the debug client
venvName (str): name of the virtual environment

DebugServer.signalClientClearBreak

signalClientClearBreak(filename, lineno)

Public method to process the client clear breakpoint command.

filename: filename of the breakpoint (string)
lineno: line umber of the breakpoint (integer)

DebugServer.signalClientClearWatch

signalClientClearWatch(condition)

Public slot to handle the clientClearWatch signal.

condition: expression of watch expression to clear (string)

DebugServer.signalClientCompletionList

signalClientCompletionList(completionList, text)

Public method to process the client auto completion info.

completionList: list of possible completions (list of strings)
text: the text to be completed (string)

DebugServer.signalClientException

signalClientException(exceptionType, exceptionMessage, stackTrace)

Public method to process the exception info from the client.

exceptionType: type of exception raised (string)
exceptionMessage: message given by the exception (string)
stackTrace: list of stack entries with the exception position first. Each stack entry is a list giving the filename and the linenumber.

DebugServer.signalClientExit

signalClientExit(status, message="")

Public method to process the client exit status.

status (int): exit code
message (str): message sent with the exit

DebugServer.signalClientLine

signalClientLine(filename, lineno, forStack=False)

Public method to process client position feedback.

filename: name of the file currently being executed (string)
lineno: line of code currently being executed (integer)
forStack: flag indicating this is for a stack dump (boolean)

DebugServer.signalClientOutput

signalClientOutput(line)

Public method to process a line of client output.

line: client output (string)

DebugServer.signalClientRawInput

signalClientRawInput(prompt, echo)

Public method to process the client raw input command.

prompt: the input prompt (string)
echo: flag indicating an echoing of the input (boolean)

DebugServer.signalClientSignal

signalClientSignal(message, filename, lineNo, funcName, funcArgs)

Public method to process a signal generated on the client side.

message (str): message of the syntax error
filename (str): translated filename of the syntax error position
lineNo (int): line number of the syntax error position
funcName (str): name of the function causing the signal
funcArgs (str): function arguments

DebugServer.signalClientStack

signalClientStack(stack)

Public method to process a client's stack information.

stack: list of stack entries. Each entry is a tuple of three values giving the filename, linenumber and method (list of lists of (string, integer, string))

DebugServer.signalClientStatement

signalClientStatement(more)

Public method to process the input response from the client.

more: flag indicating that more user input is required

DebugServer.signalClientSyntaxError

signalClientSyntaxError(message, filename, lineNo, characterNo)

Public method to process the syntax error info from the client.

message: message of the syntax error (string)
filename: translated filename of the syntax error position (string)
lineNo: line number of the syntax error position (integer)
characterNo: character number of the syntax error position (integer)

DebugServer.signalClientThreadList

signalClientThreadList(currentId, threadList)

Public method to process the client thread list info.

currentId: id of the current thread (integer)
threadList: list of dictionaries containing the thread data

DebugServer.signalClientThreadSet

signalClientThreadSet()

Public method to handle the change of the client thread.

DebugServer.signalClientVariable

signalClientVariable(scope, variables)

Public method to process the client variable info.

scope: scope of the variables (-1 = empty global, 1 = global, 0 = local)
variables: the list of members of a classvariable from the client

DebugServer.signalClientVariables

signalClientVariables(scope, variables)

Public method to process the client variables info.

scope: scope of the variables (-1 = empty global, 1 = global, 0 = local)
variables: the list of variables from the client

DebugServer.signalClientWatchConditionError

signalClientWatchConditionError(condition)

Public method to process the client watch expression error info.

condition: expression of watch expression to clear (string)

DebugServer.startClient

startClient(unplanned=True, clType=None, forProject=False, runInConsole=False, venvName="", workingDir=None)

Public method to start a debug client.

unplanned= (bool): flag indicating that the client has died
clType= (str): type of client to be started
forProject= (bool): flag indicating a project related action
runInConsole= (bool): flag indicating to start the debugger in a console window
venvName= (str): name of the virtual environment to be used
workingDir= (str): directory to start the debugger client in

DebugServer.unregisterDebuggerInterface

unregisterDebuggerInterface(interfaceName)

Public method to unregister a debugger interface.

interfaceName (str): interfaceName of the debugger interface

Home ⌂Doc Index ◂Up ▴