* View signature and similar by hovering over a function or method

* Debugging with support for local variables, arguments, expressions, watch window, stack information, break points

* Debugging Multiple threads (Web Applications - Flask, etc) and expanding values (on Windows and Mac)

* Debugging with custom environment variables

* Unit testing (unittests and nosetests, with config files)

* Sorting imports

##[Wiki](https://github.com/DonJayamanne/pythonVSCode/wiki)

##[Issues and Feature Requests](https://github.com/DonJayamanne/pythonVSCode/issues)

* Support for Virtual Environments (in development)

* More features on the way

* Debugging with support for shebang

* Support for passing environment variables to debug program

* Improved error handling in the extension

"name": "python",

"displayName": "Python",

"description": "Linting, Debugging (multi-threaded, remote), Intellisense, auto-completion, code formatting, snippets, and more.",

"publisher": "donjayamanne",

"license": "SEE LICENSE IN LICENSE or README.MD",

"homepage": "https://github.com/DonJayamanne/pythonVSCode/blob/master/README.md",

private InitializeEventHandlers() {

this.pythonProcess.on("last", arg => this.onDetachDebugger());

this.pythonProcess.on("threadExited", arg => this.onPythonThreadExited(arg));

this.pythonProcess.on("output", (pyThread, output) => this.onDebuggerOutput(pyThread, output));

this.pythonProcess.on("exceptionRaised", (pyThread, ex) => this.onPythonException(pyThread, ex));

this.pythonProcess.on("breakpointHit", (pyThread, breakpointId) => this.onBreakpointHit(pyThread, breakpointId));

this.pythonProcess.on("stepCompleted", (pyThread) => this.onStepCompleted(pyThread));

this.pythonProcess.on("detach", () => this.onDetachDebugger());

this.pythonProcess.on("error", ex => this.sendEvent(new OutputEvent(ex, "stderr")));

this.debugServer.on("detach", () => this.onDetachDebugger());

}

this.launchArgs = args;

this.debugClient = CreateLaunchDebugClient(args, this);

this.debuggerLoadedPromiseResolve = resolve;

});

this.startDebugServer().then(dbgServer => {

that.debugClient.LaunchApplicationToDebug(dbgServer).then(() => {

this.sendEvent(new OutputEvent(error + "\n", "stderr"));

this.sendErrorResponse(that.entryResponse, 2000, error);

});

});

this.sendEvent(new OutputEvent(error + "\n", "stderr"));

this.sendErrorResponse(that.entryResponse, 2000, error);

});

this.attachArgs = args;

this.debugClient = CreateAttachDebugClient(args, this);

this.debuggerLoadedPromiseResolve = resolve;

});

this.startDebugServer().then(dbgServer => {

that.debugClient.LaunchApplicationToDebug(dbgServer);

});

this.sendEvent(new OutputEvent(error + "\n", "stderr"));

this.sendErrorResponse(that.entryResponse, 2000, error);

});

Enabled: true

};

}

protected setBreakPointsRequest(response: DebugProtocol.SetBreakpointsResponse, args: DebugProtocol.SetBreakpointsArguments): void {

this.debuggerLoaded.then(() => {

if (!this.registeredBreakpointsByFileName.has(args.source.path)) {

var breakpoints: { verified: boolean, line: number }[] = [];

var breakpointsToRemove = [];

var registeredBks = this.registeredBreakpointsByFileName.get(args.source.path);

//Always add new breakpoints, don't re-enable previous breakpoints

//Cuz sometimes some breakpoints get added too early (e.g. in django) and don't get registeredBks

//and the response comes back indicating it wasn't set properly

//However, at a later point in time, the program breaks at that point!!!

var breakpoint: IPythonBreakpoint;

if (existingBreakpointsForThisLine.length > 0) {

//We have an existing breakpoint for this line

//just enable that

breakpoint = existingBreakpointsForThisLine[0]

breakpoint.Enabled = true;

}

else {

}

this.pythonProcess.BindBreakpoint(breakpoint).then(() => {

this.registeredBreakpoints.set(breakpoint.Id, breakpoint);

breakpoints.push({ verified: true, line: bk.line });

registeredBks.push(breakpoint);

resolve();

this.registeredBreakpoints.set(breakpoint.Id, breakpoint);

breakpoints.push({ verified: false, line: bk.line });

registeredBks.push(breakpoint);

});

});

var registeredBks = this.registeredBreakpointsByFileName.get(args.source.path);

//Ok, we won't get a response back, so update the breakpoints list indicating this has been disabled

bk.Enabled = false;

this.pythonProcess.DisableBreakPoint(bk);

protected threadsRequest(response: DebugProtocol.ThreadsResponse): void {

var threads = [];

threads.push(new Thread(t.Id, t.Name));

});

return this.sendResponse(response);

}

//If this value can be expanded, then create a vars ref for user to expand it

if (result.IsExpandable) {

const parentVariable: IDebugVariable = {

if (varRef.evaluateChildren !== true) {

let variables = [];

let variablesReference = 0;

//If this value can be expanded, then create a vars ref for user to expand it

if (variable.IsExpandable) {

return this.sendResponse(response);

}

//Ok, we need to evaluate the children of the current variable

var variables = [];

let variablesReference = 0;

//If this value can be expanded, then create a vars ref for user to expand it

if (child.IsExpandable) {

variablesReference: variablesReference

});

});

this.sendErrorResponse(response, 2001, error);

});

});

this.callbackHandler = new PythonProcessCallbackHandler(this, this.stream, this._idDispenser);

this.callbackHandler.on("detach", () => this.emit("detach"));

this.callbackHandler.on("last", () => this.emit("last"));

this.callbackHandler.on("output", (pyThread, output) => this.emit("output", pyThread, output));

this.callbackHandler.on("exceptionRaised", (pyThread, ex, brkType) => {

this._lastExecutedThread = pyThread;

this.emit("exceptionRaised", pyThread, ex, brkType);

});

this.callbackHandler.on("breakpointHit", (pyThread, breakpointId) => this.onBreakpointHit(pyThread, breakpointId));

this._mainThread = <IPythonThread>arg;

this._lastExecutedThread = this._mainThread;

this.emit("processLoaded", arg);

this.callbackHandler.HandleIncomingData();

}

//#region Step Commands

private onPythonStepCompleted(pyThread: IPythonThread) {

this._lastExecutedThread = pyThread;

}

private onBreakpointSet(breakpointId: number, success: boolean) {

//Find the last breakpoint command associated with this breakpoint

if (index === -1) {

//Hmm this is not possible, log this exception and carry on

this.emit("error", "command.breakpoint.hit", `Uknown Breakpoit Id ${breakpointId}`);