Support for new Python language model

package.json

@@ -2,7 +2,7 @@
     "name": "vscode-azurefunctions",
     "displayName": "Azure Functions",
     "description": "%azureFunctions.description%",
-    "version": "1.7.5-alpha.0",
+    "version": "1.8.0-alpha.0",
     "publisher": "ms-azuretools",
     "icon": "resources/azure-functions.png",
     "aiKey": "AIF-d9b70cd4-b9f9-4d70-929b-a071c400b217",
@@ -77,6 +77,7 @@
         "onCommand:azureFunctions.viewDeploymentLogs",
         "onCommand:azureFunctions.viewProperties",
         "onDebugInitialConfigurations",
+        "onFileSystem:vscode-azurefunctions-static-content",
         "onUri",
         "onView:azureWorkspace",
         "workspaceContains:**/host.json"
@@ -833,6 +834,12 @@
                             ""
                         ]
                     },
+                    "azureFunctions.projectLanguageModel": {
+                        "scope": "resource",
+                        "type": "number",
+                        "description": "%azureFunctions.projectLanguageModel%",
+                        "minimum": 1
+                    },
                     "azureFunctions.projectTemplateKey": {
                         "scope": "resource",
                         "type": "string",

package.nls.json

@@ -50,6 +50,7 @@
     "azureFunctions.problemMatchers.funcPythonWatch": "Azure Functions Python problems (watch mode)",
     "azureFunctions.problemMatchers.funcWatch": "Azure Functions problems (watch mode)",
     "azureFunctions.projectLanguage": "The default language to use when performing operations like \"Create New Function\".",
+    "azureFunctions.projectLanguageModel": "The default language model to use when performing operations like \"Create New Function\".",
     "azureFunctions.projectLanguage.preview": "(Preview)",
     "azureFunctions.projectOpenBehavior": "The behavior to use after creating a new project. The options are \"AddToWorkspace\", \"OpenInNewWindow\", or \"OpenInCurrentWindow\".",
     "azureFunctions.projectRuntime": "The default version of the Azure Functions runtime to use when performing operations like \"Create New Function\".",

src/LocalResourceProvider.ts

@@ -8,7 +8,7 @@ import * as path from 'path';
 import { Disposable, workspace, WorkspaceFolder } from "vscode";
 import { tryGetFunctionProjectRoot } from "./commands/createNewProject/verifyIsProject";
 import { getFunctionAppName, getJavaDebugSubpath } from "./commands/initProjectForVSCode/InitVSCodeStep/JavaInitVSCodeStep";
-import { funcVersionSetting, JavaBuildTool, javaBuildTool, ProjectLanguage, projectLanguageSetting } from "./constants";
+import { funcVersionSetting, JavaBuildTool, javaBuildTool, ProjectLanguage, projectLanguageModelSetting, projectLanguageSetting } from "./constants";
 import { FuncVersion, tryParseFuncVersion } from "./FuncVersion";
 import { localize } from "./localize";
 import { InitLocalProjectTreeItem } from "./tree/localProject/InitLocalProjectTreeItem";
@@ -35,6 +35,7 @@ export class FunctionsLocalResourceProvider implements WorkspaceResourceProvider
                 if (projectPath) {
                     try {
                         const language: ProjectLanguage | undefined = getWorkspaceSetting(projectLanguageSetting, projectPath);
+                        const languageModel: number | undefined = getWorkspaceSetting(projectLanguageModelSetting, projectPath);
                         const version: FuncVersion | undefined = tryParseFuncVersion(getWorkspaceSetting(funcVersionSetting, projectPath));
                         if (language === undefined || version === undefined) {
                             children.push(new InitLocalProjectTreeItem(parent, projectPath, folder));
@@ -52,7 +53,7 @@ export class FunctionsLocalResourceProvider implements WorkspaceResourceProvider
                             }
 
 
-                            const treeItem: LocalProjectTreeItem = new LocalProjectTreeItem(parent, { effectiveProjectPath, folder, language, version, preCompiledProjectPath, isIsolated });
+                            const treeItem: LocalProjectTreeItem = new LocalProjectTreeItem(parent, { effectiveProjectPath, folder, language, languageModel, version, preCompiledProjectPath, isIsolated });
                             this._projectDisposables.push(treeItem);
                             children.push(treeItem);
                         }

src/commands/addBinding/BindingListStep.ts

@@ -42,7 +42,7 @@ export class BindingListStep extends AzureWizardPromptStep<IBindingWizardContext
         const language: ProjectLanguage = nonNullProp(context, 'language');
         const version: FuncVersion = nonNullProp(context, 'version');
         const templateProvider = ext.templateProvider.get(context);
-        const templates: IBindingTemplate[] = await templateProvider.getBindingTemplates(context, context.projectPath, language, version);
+        const templates: IBindingTemplate[] = await templateProvider.getBindingTemplates(context, context.projectPath, language, undefined, version);
         return templates
             .filter(b => b.direction.toLowerCase() === direction.toLowerCase())
             .sort((a, b) => a.displayName.localeCompare(b.displayName))

src/commands/addBinding/addBinding.ts

@@ -32,7 +32,9 @@ export async function addBinding(context: IActionContext, data: Uri | LocalFunct
         workspaceFolder = nonNullValue(getContainingWorkspace(functionJsonPath), 'workspaceFolder');
         workspacePath = workspaceFolder.uri.fsPath;
         projectPath = await tryGetFunctionProjectRoot(context, workspaceFolder, 'modalPrompt') || workspacePath;
-        [language, version] = await verifyInitForVSCode(context, projectPath);
+        const verifiedInit = await verifyInitForVSCode(context, projectPath);
+        language = verifiedInit.language;
+        version = verifiedInit.version;
     } else {
         if (!data) {
             const noItemFoundErrorMessage: string = localize('noLocalProject', 'No matching functions found. C# and Java projects do not support this operation.');
@@ -48,7 +50,7 @@ export async function addBinding(context: IActionContext, data: Uri | LocalFunct
         workspaceFolder = projectTi.workspaceFolder;
         workspacePath = projectTi.workspacePath;
         projectPath = projectTi.effectiveProjectPath;
-        language = projectTi.langauge;
+        language = projectTi.language;
         version = projectTi.version;
     }
 

src/commands/createFunction/FunctionCreateStepBase.ts

@@ -74,7 +74,8 @@ function runPostFunctionCreateSteps(func: ICachedFunction): void {
     void callWithTelemetryAndErrorHandling('postFunctionCreate', async (context: IActionContext) => {
         context.telemetry.suppressIfSuccessful = true;
 
-        if (getContainingWorkspace(func.projectPath)) {
+        // If function creation created a new file, open it in an editor...
+        if (func.newFilePath && getContainingWorkspace(func.projectPath)) {
             if (await AzExtFsExtra.pathExists(func.newFilePath)) {
                 await window.showTextDocument(await workspace.openTextDocument(Uri.file(func.newFilePath)));
             }

src/commands/createFunction/FunctionListStep.ts

@@ -3,32 +3,19 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { AzureWizardExecuteStep, AzureWizardPromptStep, IActionContext, IAzureQuickPickItem, IAzureQuickPickOptions, IWizardOptions } from '@microsoft/vscode-azext-utils';
+import { AzureWizardPromptStep, IActionContext, IAzureQuickPickItem, IAzureQuickPickOptions, IWizardOptions } from '@microsoft/vscode-azext-utils';
 import * as escape from 'escape-string-regexp';
 import { JavaBuildTool, ProjectLanguage, TemplateFilter, templateFilterSetting } from '../../constants';
-import { canValidateAzureWebJobStorageOnDebug } from '../../debug/validatePreDebug';
 import { ext } from '../../extensionVariables';
-import { getAzureWebJobsStorage } from '../../funcConfig/local.settings';
 import { FuncVersion } from '../../FuncVersion';
 import { localize } from '../../localize';
 import { IFunctionTemplate } from '../../templates/IFunctionTemplate';
 import { nonNullProp } from '../../utils/nonNull';
+import { isPythonV2Plus } from '../../utils/pythonUtils';
 import { getWorkspaceSetting, updateWorkspaceSetting } from '../../vsCodeConfig/settings';
-import { addBindingSettingSteps } from '../addBinding/settingSteps/addBindingSettingSteps';
-import { AzureWebJobsStorageExecuteStep } from '../appSettings/AzureWebJobsStorageExecuteStep';
-import { AzureWebJobsStoragePromptStep } from '../appSettings/AzureWebJobsStoragePromptStep';
-import { JavaPackageNameStep } from '../createNewProject/javaSteps/JavaPackageNameStep';
-import { DotnetFunctionCreateStep } from './dotnetSteps/DotnetFunctionCreateStep';
-import { DotnetFunctionNameStep } from './dotnetSteps/DotnetFunctionNameStep';
-import { DotnetNamespaceStep } from './dotnetSteps/DotnetNamespaceStep';
+import { FunctionSubWizard } from './FunctionSubWizard';
 import { IFunctionWizardContext } from './IFunctionWizardContext';
-import { JavaFunctionCreateStep } from './javaSteps/JavaFunctionCreateStep';
-import { JavaFunctionNameStep } from './javaSteps/JavaFunctionNameStep';
-import { OpenAPICreateStep } from './openAPISteps/OpenAPICreateStep';
-import { OpenAPIGetSpecificationFileStep } from './openAPISteps/OpenAPIGetSpecificationFileStep';
-import { ScriptFunctionCreateStep } from './scriptSteps/ScriptFunctionCreateStep';
-import { ScriptFunctionNameStep } from './scriptSteps/ScriptFunctionNameStep';
-import { TypeScriptFunctionCreateStep } from './scriptSteps/TypeScriptFunctionCreateStep';
+import { PythonLocationStep } from './scriptSteps/PythonLocationStep';
 
 export class FunctionListStep extends AzureWizardPromptStep<IFunctionWizardContext> {
     public hideStepCount: boolean = true;
@@ -47,7 +34,7 @@ export class FunctionListStep extends AzureWizardPromptStep<IFunctionWizardConte
             const language: ProjectLanguage = nonNullProp(context, 'language');
             const version: FuncVersion = nonNullProp(context, 'version');
             const templateProvider = ext.templateProvider.get(context);
-            const templates: IFunctionTemplate[] = await templateProvider.getFunctionTemplates(context, context.projectPath, language, version, TemplateFilter.All, context.projectTemplateKey);
+            const templates: IFunctionTemplate[] = await templateProvider.getFunctionTemplates(context, context.projectPath, language, context.languageModel, version, TemplateFilter.All, context.projectTemplateKey);
             const foundTemplate: IFunctionTemplate | undefined = templates.find((t: IFunctionTemplate) => {
                 if (options.templateId) {
                     const actualId: string = t.id.toLowerCase();
@@ -69,75 +56,15 @@ export class FunctionListStep extends AzureWizardPromptStep<IFunctionWizardConte
     }
 
     public async getSubWizard(context: IFunctionWizardContext): Promise<IWizardOptions<IFunctionWizardContext> | undefined> {
-        const template: IFunctionTemplate | undefined = context.functionTemplate;
-        if (template) {
-            const promptSteps: AzureWizardPromptStep<IFunctionWizardContext>[] = [];
-            switch (context.language) {
-                case ProjectLanguage.Java:
-                    promptSteps.push(new JavaPackageNameStep(), new JavaFunctionNameStep());
-                    break;
-                case ProjectLanguage.CSharp:
-                case ProjectLanguage.FSharp:
-                    promptSteps.push(new DotnetFunctionNameStep(), new DotnetNamespaceStep());
-                    break;
-                default:
-                    promptSteps.push(new ScriptFunctionNameStep());
-                    break;
-            }
-
-            // Add settings to context that were programmatically passed in
-            for (const key of Object.keys(this._functionSettings)) {
-                context[key.toLowerCase()] = this._functionSettings[key];
-            }
-
-            addBindingSettingSteps(template.userPromptedSettings, promptSteps);
-
-            const executeSteps: AzureWizardExecuteStep<IFunctionWizardContext>[] = [];
-            switch (context.language) {
-                case ProjectLanguage.Java:
-                    executeSteps.push(new JavaFunctionCreateStep());
-                    break;
-                case ProjectLanguage.CSharp:
-                case ProjectLanguage.FSharp:
-                    executeSteps.push(await DotnetFunctionCreateStep.createStep(context));
-                    break;
-                case ProjectLanguage.TypeScript:
-                    executeSteps.push(new TypeScriptFunctionCreateStep());
-                    break;
-                default:
-                    executeSteps.push(new ScriptFunctionCreateStep());
-                    break;
-            }
-
-            if ((!template.isHttpTrigger && !template.isSqlBindingTemplate) && !canValidateAzureWebJobStorageOnDebug(context.language) && !await getAzureWebJobsStorage(context, context.projectPath)) {
-                promptSteps.push(new AzureWebJobsStoragePromptStep());
-                executeSteps.push(new AzureWebJobsStorageExecuteStep());
-            }
-
-            const title: string = localize('createFunction', 'Create new {0}', template.name);
-            return { promptSteps, executeSteps, title };
-        } else if (context.generateFromOpenAPI) {
-            const promptSteps: AzureWizardPromptStep<IFunctionWizardContext>[] = [];
-            const executeSteps: AzureWizardExecuteStep<IFunctionWizardContext>[] = [];
-
-            switch (context.language) {
-                case ProjectLanguage.Java:
-                    promptSteps.push(new JavaPackageNameStep());
-                    break;
-                case ProjectLanguage.CSharp:
-                    promptSteps.push(new DotnetNamespaceStep());
-                    break;
-                default:
-                    break;
-            }
-
-            promptSteps.push(new OpenAPIGetSpecificationFileStep());
-            executeSteps.push(await OpenAPICreateStep.createStep(context));
+        const isV2PythonModel = isPythonV2Plus(context.language, context.languageModel);
 
-            const title: string = localize('createFunction', 'Create new {0}', 'HTTP Triggers from OpenAPI (v2/v3) Specification File');
-            return { promptSteps, executeSteps, title };
+        if (isV2PythonModel) {
+            return {
+                // TODO: Title?
+                promptSteps: [ new PythonLocationStep(this._functionSettings) ]
+            };
         } else {
-            return undefined;
+            return await FunctionSubWizard.createSubWizard(context, this._functionSettings);
         }
     }
 
@@ -169,7 +96,7 @@ export class FunctionListStep extends AzureWizardPromptStep<IFunctionWizardConte
                 context.generateFromOpenAPI = true;
                 break;
             } else if (result === 'reloadTemplates') {
-                await templateProvider.clearTemplateCache(context, context.projectPath, nonNullProp(context, 'language'), nonNullProp(context, 'version'));
+                await templateProvider.clearTemplateCache(context, context.projectPath, nonNullProp(context, 'language'), context.languageModel, nonNullProp(context, 'version'));
                 context.telemetry.properties.reloaded = 'true';
             } else {
                 context.functionTemplate = result;
@@ -185,9 +112,10 @@ export class FunctionListStep extends AzureWizardPromptStep<IFunctionWizardConte
 
     private async getPicks(context: IFunctionWizardContext, templateFilter: TemplateFilter): Promise<IAzureQuickPickItem<IFunctionTemplate | TemplatePromptResult>[]> {
         const language: ProjectLanguage = nonNullProp(context, 'language');
+        const languageModel = context.languageModel;
         const version: FuncVersion = nonNullProp(context, 'version');
         const templateProvider = ext.templateProvider.get(context);
-        const templates: IFunctionTemplate[] = await templateProvider.getFunctionTemplates(context, context.projectPath, language, version, templateFilter, context.projectTemplateKey);
+        const templates: IFunctionTemplate[] = await templateProvider.getFunctionTemplates(context, context.projectPath, language, context.languageModel, version, templateFilter, context.projectTemplateKey);
         context.telemetry.measurements.templateCount = templates.length;
         const picks: IAzureQuickPickItem<IFunctionTemplate | TemplatePromptResult>[] = templates
             .sort((a, b) => sortTemplates(a, b, templateFilter))
@@ -208,7 +136,7 @@ export class FunctionListStep extends AzureWizardPromptStep<IFunctionWizardConte
                 data: <IFunctionTemplate | TemplatePromptResult><unknown>undefined,
                 onPicked: () => { /* do nothing */ }
             })
-        } else if (language === ProjectLanguage.CSharp || language === ProjectLanguage.Java || language === ProjectLanguage.Python || language === ProjectLanguage.TypeScript) {
+        } else if (language === ProjectLanguage.CSharp || language === ProjectLanguage.Java || (language === ProjectLanguage.Python && !isPythonV2Plus(language, languageModel)) || language === ProjectLanguage.TypeScript) {
             // NOTE: Only show this if we actually found other templates
             picks.push({
                 label: localize('openAPI', 'HTTP trigger(s) from OpenAPI V2/V3 Specification (Preview)'),