Refactor for dev and cli detection

savannahostrowski · savannahostrowski · commit 06fc5bb33d38 · 2026-05-27T11:21:42.000-07:00
diff --git a/src/extension/common/utils/localize.ts b/src/extension/common/utils/localize.ts
@@ -111,6 +111,13 @@ export namespace DebugConfigStrings {
             label: l10n.t('FastAPI'),
             description: l10n.t('Launch and debug a FastAPI web application'),
         };
+        export const snippetFile = {
+            name: l10n.t('Python Debugger: FastAPI File'),
+        };
+        export const selectConfigurationWithFile = {
+            label: l10n.t('FastAPI File'),
+            description: l10n.t('Launch and debug a FastAPI web application using the current file'),
+        };
     }
     export namespace flask {
         export const snippet = {
diff --git a/src/extension/debugger/configuration/debugConfigurationService.ts b/src/extension/debugger/configuration/debugConfigurationService.ts
@@ -8,7 +8,7 @@ import { IMultiStepInputFactory, InputStep, IQuickPickParameters, MultiStepInput
 import { AttachRequestArguments, DebugConfigurationArguments, LaunchRequestArguments } from '../../types';
 import { DebugConfigurationState, DebugConfigurationType, IDebugConfigurationService } from '../types';
 import { buildDjangoLaunchDebugConfiguration } from './providers/djangoLaunch';
-import { buildFastAPILaunchDebugConfiguration } from './providers/fastapiLaunch';
+import { buildFastAPILaunchDebugConfiguration, buildFastAPIWithFileLaunchDebugConfiguration } from './providers/fastapiLaunch';
 import { buildFileLaunchDebugConfiguration } from './providers/fileLaunch';
 import { buildFlaskLaunchDebugConfiguration } from './providers/flaskLaunch';
 import { buildModuleLaunchConfiguration } from './providers/moduleLaunch';
@@ -158,6 +158,11 @@ export class PythonDebugConfigurationService implements IDebugConfigurationServi
                 type: DebugConfigurationType.launchFastAPI,
                 description: DebugConfigStrings.fastapi.selectConfiguration.description,
             },
+            {
+                label: DebugConfigStrings.fastapi.selectConfigurationWithFile.label,
+                type: DebugConfigurationType.launchFastAPIWithFile,
+                description: DebugConfigStrings.fastapi.selectConfigurationWithFile.description,
+            },
             {
                 label: DebugConfigStrings.flask.selectConfiguration.label,
                 type: DebugConfigurationType.launchFlask,
@@ -178,6 +183,7 @@ export class PythonDebugConfigurationService implements IDebugConfigurationServi
         >();
         debugConfigurations.set(DebugConfigurationType.launchDjango, buildDjangoLaunchDebugConfiguration);
         debugConfigurations.set(DebugConfigurationType.launchFastAPI, buildFastAPILaunchDebugConfiguration);
+        debugConfigurations.set(DebugConfigurationType.launchFastAPIWithFile, buildFastAPIWithFileLaunchDebugConfiguration);
         debugConfigurations.set(DebugConfigurationType.launchFile, buildFileLaunchDebugConfiguration);
         debugConfigurations.set(DebugConfigurationType.launchFileWithArgs, buildFileWithArgsLaunchDebugConfiguration);
         debugConfigurations.set(DebugConfigurationType.launchFlask, buildFlaskLaunchDebugConfiguration);
diff --git a/src/extension/debugger/configuration/dynamicdebugConfigurationService.ts b/src/extension/debugger/configuration/dynamicdebugConfigurationService.ts
@@ -8,9 +8,10 @@ import * as path from 'path';
 import { CancellationToken, DebugConfiguration, WorkspaceFolder } from 'vscode';
 import { IDynamicDebugConfigurationService } from '../types';
 import { DebuggerTypeName } from '../../constants';
-import { getDjangoPaths, getFastApiPaths, getFlaskPaths } from './utils/configuration';
+import { getDjangoPaths, getFastApiPaths, getFlaskPaths, isFastApiCliAvailable } from './utils/configuration';
 import { sendTelemetryEvent } from '../../telemetry';
 import { EventName } from '../../telemetry/constants';
+import { replaceAll } from '../../common/stringUtils';
 
 const workspaceFolderToken = '${workspaceFolder}';
 
@@ -63,13 +64,38 @@ export class DynamicPythonDebugConfigurationService implements IDynamicDebugConf
 
         const fastApiPaths = await getFastApiPaths(folder);
         if (fastApiPaths?.length) {
-            providers.push({
-                name: 'Python Debugger: FastAPI',
-                type: DebuggerTypeName,
-                request: 'launch',
-                module: 'fastapi',
-                args: ['run'],
-            });
+            const hasFastApiCli = await isFastApiCliAvailable(folder.uri);
+            if (hasFastApiCli) {
+                providers.push({
+                    name: 'Python Debugger: FastAPI',
+                    type: DebuggerTypeName,
+                    request: 'launch',
+                    module: 'fastapi',
+                    args: ['dev'],
+                    jinja: true,
+                    subProcess: true,
+                });
+                providers.push({
+                    name: 'Python Debugger: FastAPI File',
+                    type: DebuggerTypeName,
+                    request: 'launch',
+                    module: 'fastapi',
+                    args: ['dev', '${file}'],
+                    jinja: true,
+                    subProcess: true,
+                });
+            } else {
+                // Legacy fallback when fastapi-cli is not available.
+                const fastApiPath = replaceAll(path.relative(folder.uri.fsPath, fastApiPaths[0].fsPath), path.sep, '.').replace('.py', '');
+                providers.push({
+                    name: 'Python Debugger: FastAPI',
+                    type: DebuggerTypeName,
+                    request: 'launch',
+                    module: 'uvicorn',
+                    args: [`${fastApiPath}:app`, '--reload'],
+                    jinja: true,
+                });
+            }
         }
 
         sendTelemetryEvent(EventName.DEBUGGER_DYNAMIC_CONFIGURATION, undefined, { providers: providers });
diff --git a/src/extension/debugger/configuration/providers/fastapiLaunch.ts b/src/extension/debugger/configuration/providers/fastapiLaunch.ts
@@ -20,10 +20,31 @@ export async function buildFastAPILaunchDebugConfiguration(
         type: DebuggerTypeName,
         request: 'launch',
         module: 'fastapi',
-        args: ['run'],
+        args: ['dev'],
+        jinja: true,
+        subProcess: true,
     };
     sendTelemetryEvent(EventName.DEBUGGER_CONFIGURATION_PROMPTS, undefined, {
         configurationType: DebugConfigurationType.launchFastAPI,
     });
     Object.assign(state.config, config);
 }
+
+export async function buildFastAPIWithFileLaunchDebugConfiguration(
+    _input: MultiStepInput<DebugConfigurationState>,
+    state: DebugConfigurationState,
+): Promise<void> {
+    const config: Partial<LaunchRequestArguments> = {
+        name: DebugConfigStrings.fastapi.snippetFile.name,
+        type: DebuggerTypeName,
+        request: 'launch',
+        module: 'fastapi',
+        args: ['dev', '${file}'],
+        jinja: true,
+        subProcess: true,
+    };
+    sendTelemetryEvent(EventName.DEBUGGER_CONFIGURATION_PROMPTS, undefined, {
+        configurationType: DebugConfigurationType.launchFastAPIWithFile,
+    });
+    Object.assign(state.config, config);
+}
diff --git a/src/extension/debugger/configuration/utils/configuration.ts b/src/extension/debugger/configuration/utils/configuration.ts
@@ -15,8 +15,11 @@ import { AttachRequestArguments } from '../../../types';
 import { DebugConfigurationState, DebugConfigurationType } from '../../types';
 import { Uri, WorkspaceFolder, workspace } from 'vscode';
 import { asyncFilter } from '../../../common/utilities';
+import { getInterpreterDetails } from '../../../common/python';
+import { plainExec } from '../../../common/process/rawProcessApis';
 
 const defaultPort = 5678;
+const fastApiCliCache = new Map<string, Promise<boolean>>();
 
 export async function configurePort(
     input: MultiStepInput<DebugConfigurationState>,
@@ -81,6 +84,22 @@ export async function getFastApiPaths(folder: WorkspaceFolder | undefined) {
     return fastApiPaths;
 }
 
+export async function isFastApiCliAvailable(resource?: Uri): Promise<boolean> {
+    const interpreterDetails = await getInterpreterDetails(resource);
+    const pythonPath = interpreterDetails?.path?.[0];
+    if (!pythonPath) {
+        return false;
+    }
+    if (fastApiCliCache.has(pythonPath)) {
+        return fastApiCliCache.get(pythonPath)!;
+    }
+    const promise = plainExec(pythonPath, ['-c', 'import fastapi_cli'], { throwOnStdErr: false })
+        .then(() => true)
+        .catch(() => false);
+    fastApiCliCache.set(pythonPath, promise);
+    return promise;
+}
+
 export async function getFlaskPaths(folder: WorkspaceFolder | undefined) {
     if (!folder) {
         return [];
diff --git a/src/extension/debugger/types.ts b/src/extension/debugger/types.ts
@@ -34,6 +34,7 @@ export enum DebugConfigurationType {
     remoteAttach = 'remoteAttach',
     launchDjango = 'launchDjango',
     launchFastAPI = 'launchFastAPI',
+    launchFastAPIWithFile = 'launchFastAPIWithFile',
     launchFlask = 'launchFlask',
     launchModule = 'launchModule',
     launchPyramid = 'launchPyramid',
diff --git a/src/test/unittest/configuration/providers/fastapiLaunch.unit.test.ts b/src/test/unittest/configuration/providers/fastapiLaunch.unit.test.ts
@@ -31,7 +31,28 @@ suite('Debugging - Configuration Provider FastAPI', () => {
             type: DebuggerTypeName,
             request: 'launch',
             module: 'fastapi',
-            args: ['run'],
+            args: ['dev'],
+            jinja: true,
+            subProcess: true,
+        };
+
+        expect(state.config).to.be.deep.equal(config);
+    });
+
+    test('Launch JSON with file configuration', async () => {
+        const folder = { uri: Uri.parse(path.join('one', 'two')), name: '1', index: 0 };
+        const state = { config: {}, folder };
+
+        await fastApiLaunch.buildFastAPIWithFileLaunchDebugConfiguration(instance(input), state);
+
+        const config = {
+            name: DebugConfigStrings.fastapi.snippetFile.name,
+            type: DebuggerTypeName,
+            request: 'launch',
+            module: 'fastapi',
+            args: ['dev', '${file}'],
+            jinja: true,
+            subProcess: true,
         };
 
         expect(state.config).to.be.deep.equal(config);
