Add conda run without output

news/1 Enhancements/7696.md

@@ -0,0 +1 @@
+Add suport for conda run withput output, using --no-capture-output.

src/client/common/process/pythonEnvironment.ts

@@ -145,15 +145,11 @@ export function createCondaEnv(
     } else {
         runArgs.push('-n', condaInfo.name);
     }
-    const pythonArgv = [condaFile, ...runArgs, 'python'];
+    const pythonArgv = [condaFile, ...runArgs, '--no-capture-output', 'python'];
     const deps = createDeps(
         async (filename) => fs.pathExists(filename),
         pythonArgv,
-
-        // TODO: Use pythonArgv here once 'conda run' can be
-        // run without buffering output.
-        // See https://github.com/microsoft/vscode-python/issues/8473.
-        undefined,
+        pythonArgv,
         (file, args, opts) => procs.exec(file, args, opts),
         (command, opts) => procs.shellExec(command, opts),
     );

src/client/common/process/pythonExecutionFactory.ts

@@ -5,7 +5,7 @@ import { gte } from 'semver';
 
 import { Uri } from 'vscode';
 import { IEnvironmentActivationService } from '../../interpreter/activation/types';
-import { IComponentAdapter, ICondaService } from '../../interpreter/contracts';
+import { IComponentAdapter, ICondaService, IInterpreterService } from '../../interpreter/contracts';
 import { IServiceContainer } from '../../ioc/types';
 import { CondaEnvironmentInfo } from '../../pythonEnvironments/common/environmentManagers/conda';
 import { sendTelemetryEvent } from '../../telemetry';
@@ -83,6 +83,15 @@ export class PythonExecutionFactory implements IPythonExecutionFactory {
         }
         const processService: IProcessService = await this.processServiceFactory.create(options.resource);
 
+        const interpreterService = this.serviceContainer.get<IInterpreterService>(IInterpreterService);
+        const hasInterpreters = await interpreterService.hasInterpreters();
+        if (hasInterpreters) {
+            const condaExecutionService = await this.createCondaExecutionService(pythonPath, processService);
+            if (condaExecutionService) {
+                return condaExecutionService;
+            }
+        }
+
         const windowsStoreInterpreterCheck = this.pyenvs.isWindowsStoreInterpreter.bind(this.pyenvs);
 
         return createPythonService(
@@ -117,6 +126,14 @@ export class PythonExecutionFactory implements IPythonExecutionFactory {
         processService.on('exec', this.logger.logProcess.bind(this.logger));
         this.disposables.push(processService);
 
+        // Allow parts of the code to ignore conda run.
+        if (!options.bypassCondaExecution) {
+            const condaExecutionService = await this.createCondaExecutionService(pythonPath, processService);
+            if (condaExecutionService) {
+                return condaExecutionService;
+            }
+        }
+
         return createPythonService(pythonPath, processService, this.fileSystem);
     }
 
@@ -144,6 +161,7 @@ export class PythonExecutionFactory implements IPythonExecutionFactory {
                 procService.on('exec', this.logger.logProcess.bind(this.logger));
                 this.disposables.push(procService);
             }
+
             return createPythonService(
                 pythonPath,
                 procService,

src/client/linters/flake8.ts

@@ -14,7 +14,7 @@ export class Flake8 extends BaseLinter {
 
     protected async runLinter(document: TextDocument, cancellation: CancellationToken): Promise<ILintMessage[]> {
         const messages = await this.run(
-            ['--format=%(row)d,%(col)d,%(code).1s,%(code)s:%(text)s', document.uri.fsPath],
+            ['--format= %(row)d,%(col)d,%(code).1s,%(code)s:%(text)s', document.uri.fsPath],
             document,
             cancellation,
         );

src/client/linters/pycodestyle.ts

@@ -14,7 +14,7 @@ export class Pycodestyle extends BaseLinter {
 
     protected async runLinter(document: TextDocument, cancellation: CancellationToken): Promise<ILintMessage[]> {
         const messages = await this.run(
-            ['--format=%(row)d,%(col)d,%(code).1s,%(code)s:%(text)s', document.uri.fsPath],
+            ['--format= %(row)d,%(col)d,%(code).1s,%(code)s:%(text)s', document.uri.fsPath],
             document,
             cancellation,
         );

src/client/linters/pylint.ts

@@ -19,7 +19,7 @@ export class Pylint extends BaseLinter {
         const uri = document.uri;
         const settings = this.configService.getSettings(uri);
         const args = [
-            "--msg-template='{line},{column},{category},{symbol}:{msg}'",
+            '--msg-template={line},{column},{category},{symbol}:{msg}',
             '--reports=n',
             '--output-format=text',
             uri.fsPath,

src/client/pythonEnvironments/legacyIOC.ts

@@ -227,14 +227,14 @@ class ComponentAdapter implements IComponentAdapter {
                 }
             }
         });
-        const initialEnvs = this.api.getEnvs();
+        const initialEnvs = this.api.getEnvs() || [];
         if (initialEnvs.length > 0) {
             return true;
         }
         // We should already have initiated discovery. Wait for an env to be added
         // to the collection until the refresh has finished.
         await Promise.race([onAddedToCollection.promise, this.api.refreshPromise]);
-        const envs = await asyncFilter(this.api.getEnvs(), (e) => filter(convertEnvInfo(e)));
+        const envs = await asyncFilter(this.api.getEnvs() || [], (e) => filter(convertEnvInfo(e)));
         return envs.length > 0;
     }
 

src/test/common/process/pythonEnvironment.unit.test.ts

@@ -271,8 +271,8 @@ suite('CondaEnvironment', () => {
 
         expect(result).to.deep.equal({
             command: condaFile,
-            args: ['run', '-n', condaInfo.name, 'python', ...args],
-            python: [condaFile, 'run', '-n', condaInfo.name, 'python'],
+            args: ['run', '-n', condaInfo.name, '--no-capture-output', 'python', ...args],
+            python: [condaFile, 'run', '-n', condaInfo.name, '--no-capture-output', 'python'],
             pythonExecutable: 'python',
         });
     });
@@ -285,25 +285,35 @@ suite('CondaEnvironment', () => {
 
         expect(result).to.deep.equal({
             command: condaFile,
-            args: ['run', '-p', condaInfo.path, 'python', ...args],
-            python: [condaFile, 'run', '-p', condaInfo.path, 'python'],
+            args: ['run', '-p', condaInfo.path, '--no-capture-output', 'python', ...args],
+            python: [condaFile, 'run', '-p', condaInfo.path, '--no-capture-output', 'python'],
             pythonExecutable: 'python',
         });
     });
 
-    test('getExecutionObservableInfo with a named environment should return execution info using pythonPath only', () => {
-        const expected = { command: pythonPath, args, python: [pythonPath], pythonExecutable: pythonPath };
+    test('getExecutionObservableInfo with a named environment should return execution info using conda full path with the name', () => {
         const condaInfo = { name: 'foo', path: 'bar' };
+        const expected = {
+            command: condaFile,
+            args: ['run', '-n', condaInfo.name, '--no-capture-output', 'python', ...args],
+            python: [condaFile, 'run', '-n', condaInfo.name, '--no-capture-output', 'python'],
+            pythonExecutable: 'python',
+        };
         const env = createCondaEnv(condaFile, condaInfo, pythonPath, processService.object, fileSystem.object);
 
         const result = env.getExecutionObservableInfo(args);
 
         expect(result).to.deep.equal(expected);
     });
 
-    test('getExecutionObservableInfo with a non-named environment should return execution info using pythonPath only', () => {
-        const expected = { command: pythonPath, args, python: [pythonPath], pythonExecutable: pythonPath };
+    test('getExecutionObservableInfo with a non-named environment should return execution info using conda full path', () => {
         const condaInfo = { name: '', path: 'bar' };
+        const expected = {
+            command: condaFile,
+            args: ['run', '-p', condaInfo.path, '--no-capture-output', 'python', ...args],
+            python: [condaFile, 'run', '-p', condaInfo.path, '--no-capture-output', 'python'],
+            pythonExecutable: 'python',
+        };
         const env = createCondaEnv(condaFile, condaInfo, pythonPath, processService.object, fileSystem.object);
 
         const result = env.getExecutionObservableInfo(args);

src/test/common/process/pythonExecutionFactory.unit.test.ts

@@ -257,9 +257,7 @@ suite('Process - PythonExecutionFactory', () => {
                 assert.equal(createInvoked, false);
             });
 
-            test('Ensure `create` returns a CondaExecutionService instance if createCondaExecutionService() returns a valid object', async function () {
-                return this.skip();
-
+            test('Ensure `create` returns a CondaExecutionService instance if createCondaExecutionService() returns a valid object', async () => {
                 const pythonPath = 'path/to/python';
                 const pythonSettings = mock(PythonSettings);
 
@@ -284,9 +282,7 @@ suite('Process - PythonExecutionFactory', () => {
                 verify(condaService.getCondaFile()).once();
             });
 
-            test('Ensure `create` returns a PythonExecutionService instance if createCondaExecutionService() returns undefined', async function () {
-                return this.skip();
-
+            test('Ensure `create` returns a PythonExecutionService instance if createCondaExecutionService() returns undefined', async () => {
                 const pythonPath = 'path/to/python';
                 const pythonSettings = mock(PythonSettings);
                 when(processFactory.create(resource)).thenResolve(processService.object);
@@ -305,9 +301,7 @@ suite('Process - PythonExecutionFactory', () => {
                 verify(condaService.getCondaFile()).once();
             });
 
-            test('Ensure `createActivatedEnvironment` returns a CondaExecutionService instance if createCondaExecutionService() returns a valid object', async function () {
-                return this.skip();
-
+            test('Ensure `createActivatedEnvironment` returns a CondaExecutionService instance if createCondaExecutionService() returns a valid object', async () => {
                 const pythonPath = 'path/to/python';
                 const pythonSettings = mock(PythonSettings);
 
@@ -336,9 +330,7 @@ suite('Process - PythonExecutionFactory', () => {
                 }
             });
 
-            test('Ensure `createActivatedEnvironment` returns a PythonExecutionService instance if createCondaExecutionService() returns undefined', async function () {
-                return this.skip();
-
+            test('Ensure `createActivatedEnvironment` returns a PythonExecutionService instance if createCondaExecutionService() returns undefined', async () => {
                 let createInvoked = false;
                 const pythonPath = 'path/to/python';
                 const mockExecService = 'mockService';

src/test/linters/lint.args.test.ts

@@ -152,12 +152,12 @@ suite('Linting - Arguments', () => {
                     }
                     test('Flake8', async () => {
                         const linter = new Flake8(outputChannel.object, serviceContainer);
-                        const expectedArgs = ['--format=%(row)d,%(col)d,%(code).1s,%(code)s:%(text)s', fileUri.fsPath];
+                        const expectedArgs = ['--format= %(row)d,%(col)d,%(code).1s,%(code)s:%(text)s', fileUri.fsPath];
                         await testLinter(linter, expectedArgs);
                     });
                     test('Pycodestyle', async () => {
                         const linter = new Pycodestyle(outputChannel.object, serviceContainer);
-                        const expectedArgs = ['--format=%(row)d,%(col)d,%(code).1s,%(code)s:%(text)s', fileUri.fsPath];
+                        const expectedArgs = ['--format= %(row)d,%(col)d,%(code).1s,%(code)s:%(text)s', fileUri.fsPath];
                         await testLinter(linter, expectedArgs);
                     });
                     test('Prospector', async () => {

src/test/linters/lint.functional.test.ts

@@ -625,6 +625,11 @@ class TestFixture extends BaseTestFixture {
         const serviceContainer = TypeMoq.Mock.ofType<IServiceContainer>(undefined, TypeMoq.MockBehavior.Strict);
         const configService = TypeMoq.Mock.ofType<IConfigurationService>(undefined, TypeMoq.MockBehavior.Strict);
         const processLogger = TypeMoq.Mock.ofType<IProcessLogger>(undefined, TypeMoq.MockBehavior.Strict);
+        const componentAdapter = TypeMoq.Mock.ofType<IComponentAdapter>(undefined, TypeMoq.MockBehavior.Strict);
+        componentAdapter
+            .setup((c) => c.getCondaEnvironment(TypeMoq.It.isAny()))
+            .returns(() => Promise.resolve(undefined));
+
         const filesystem = new FileSystem();
         processLogger
             .setup((p) => p.logProcess(TypeMoq.It.isAnyString(), TypeMoq.It.isAny(), TypeMoq.It.isAny()))
@@ -637,6 +642,9 @@ class TestFixture extends BaseTestFixture {
         serviceContainer
             .setup((s) => s.get(TypeMoq.It.isValue(IFileSystem), TypeMoq.It.isAny()))
             .returns(() => filesystem);
+        serviceContainer
+            .setup((s) => s.get(TypeMoq.It.isValue(IComponentAdapter), TypeMoq.It.isAny()))
+            .returns(() => componentAdapter.object);
 
         const platformService = new PlatformService();
 

src/test/linters/pylint.unit.test.ts

@@ -28,7 +28,7 @@ suite('Pylint - Function runLinter()', () => {
         uri: vscode.Uri.file('path/to/doc'),
     };
     const args = [
-        "--msg-template='{line},{column},{category},{symbol}:{msg}'",
+        '--msg-template={line},{column},{category},{symbol}:{msg}',
         '--reports=n',
         '--output-format=text',
         doc.uri.fsPath,