Add basic PyStein support V4

src/Azure.Functions.Cli/Actions/LocalActions/CreateFunctionAction.cs

@@ -147,6 +147,17 @@ public async override Task RunAsync()
                 workerRuntime = WorkerRuntimeLanguageHelper.SetWorkerRuntime(_secretsManager, Language);
             }
 
+            // Check if the programming model is PyStein
+            if (isNewPythonProgrammingModel())
+            {
+                // TODO: Remove these messages once creating new functions in the new programming model is supported
+                ColoredConsole.WriteLine(WarningColor("When using the new Python programming model, triggers and bindings are created as decorators within the Python file itself."));
+                ColoredConsole.Write(AdditionalInfoColor("For information on how to create a new function with the new programming model, see "));
+                PythonHelpers.PrintPySteinWikiLink();
+                throw new CliException(
+                    "Function not created!");
+            }
+
             if (WorkerRuntimeLanguageHelper.IsDotnet(workerRuntime) && !Csx)
             {
                 SelectionMenuHelper.DisplaySelectionWizardPrompt("template");
@@ -205,6 +216,10 @@ public async override Task RunAsync()
                 }
             }
             ColoredConsole.WriteLine($"The function \"{FunctionName}\" was created successfully from the \"{TemplateName}\" template.");
+            if (!isNewPythonProgrammingModel())
+            {
+                PythonHelpers.PrintPySteinAwarenessMessage();
+            }
         }
 
         private void ConfigureAuthorizationLevel(Template template)
@@ -261,5 +276,11 @@ private void PerformPostDeployTasks(string functionName, string language)
                 FileSystemHelpers.WriteAllTextToFile(funcJsonFile, JsonConvert.SerializeObject(funcObj, Formatting.Indented));
             }
         }
+
+        private bool isNewPythonProgrammingModel()
+        {
+            return string.Equals(Language, Languages.Python, StringComparison.InvariantCultureIgnoreCase)
+                && FileSystemHelpers.FileExists(Path.Combine(Environment.CurrentDirectory, Constants.PySteinFunctionAppPy));
+        }
     }
 }

src/Azure.Functions.Cli/Actions/LocalActions/InitAction.cs

@@ -46,10 +46,14 @@ internal class InitAction : BaseAction
 
         public bool? ManagedDependencies { get; set; }
 
+        public string ProgrammingModel { get; set; }
+
         public WorkerRuntime ResolvedWorkerRuntime { get; set; }
 
         public string ResolvedLanguage { get; set; }
 
+        public ProgrammingModel ResolvedProgrammingModel { get; set; }
+
         internal static readonly Dictionary<Lazy<string>, Task<string>> fileToContentMap = new Dictionary<Lazy<string>, Task<string>>
         {
             { new Lazy<string>(() => ".gitignore"), StaticResources.GitIgnore }
@@ -118,6 +122,11 @@ public override ICommandLineParserResult ParseArgs(string[] args)
                 .Setup<bool>("managed-dependencies")
                 .WithDescription("Installs managed dependencies. Currently, only the PowerShell worker runtime supports this functionality.")
                 .Callback(f => ManagedDependencies = f);
+
+            Parser
+                .Setup<string>('m', "model")
+                .WithDescription($"Selects the programming model for the function app. Options are {EnumerationHelper.Join(", ", ProgrammingModelHelper.GetProgrammingModels())}. Currently, only the Python worker runtime supports the preview programming model")
+                .Callback(m => ProgrammingModel = m);
 
             Parser
                 .Setup<bool>("no-bundle")
@@ -174,6 +183,16 @@ private async Task InitFunctionAppProject()
             else
             {
                 (ResolvedWorkerRuntime, ResolvedLanguage) = ResolveWorkerRuntimeAndLanguage(WorkerRuntime, Language);
+                // Order here is important: each language may have multiple runtimes, and each unique (language, worker-runtime) pair
+                // may have its own programming model. Thus, we assume that ResolvedLanguage and ResolvedWorkerRuntime are properly set
+                // before attempting to resolve the programming model.
+                var supportedProgrammingModels = ProgrammingModelHelper.GetSupportedProgrammingModels(ResolvedWorkerRuntime);
+                ResolvedProgrammingModel = ProgrammingModelHelper.ResolveProgrammingModel(ProgrammingModel, ResolvedWorkerRuntime, ResolvedLanguage);
+                if (!supportedProgrammingModels.Contains(ResolvedProgrammingModel))
+                {
+                    throw new CliArgumentsException(
+                        $"The {ResolvedProgrammingModel.ToString()} programming model is not supported for worker runtime {ResolvedWorkerRuntime.ToString()}. Supported programming models for worker runtime {ResolvedWorkerRuntime.ToString()} are:\n{EnumerationHelper.Join<ProgrammingModel>("\n", supportedProgrammingModels)}");
+                }
             }
 
             TelemetryHelpers.AddCommandEventToDictionary(TelemetryCommandEvents, "WorkerRuntime", ResolvedWorkerRuntime.ToString());
@@ -186,10 +205,10 @@ private async Task InitFunctionAppProject()
             else
             {
                 bool managedDependenciesOption = ResolveManagedDependencies(ResolvedWorkerRuntime, ManagedDependencies);
-                await InitLanguageSpecificArtifacts(ResolvedWorkerRuntime, ResolvedLanguage, managedDependenciesOption, GeneratePythonDocumentation);
+                await InitLanguageSpecificArtifacts(ResolvedWorkerRuntime, ResolvedLanguage, ResolvedProgrammingModel, managedDependenciesOption, GeneratePythonDocumentation);
                 await WriteFiles();
                 await WriteHostJson(ResolvedWorkerRuntime, managedDependenciesOption, ExtensionBundle);
-                await WriteLocalSettingsJson(ResolvedWorkerRuntime);
+                await WriteLocalSettingsJson(ResolvedWorkerRuntime, ResolvedProgrammingModel);
             }
 
             await WriteExtensionsJson();
@@ -251,11 +270,16 @@ private static string LanguageSelectionIfRelevant(WorkerRuntime workerRuntime)
             return string.Empty;
         }
 
-        private static async Task InitLanguageSpecificArtifacts(WorkerRuntime workerRuntime, string language, bool managedDependenciesOption, bool generatePythonDocumentation=true)
+        private static async Task InitLanguageSpecificArtifacts(
+            WorkerRuntime workerRuntime,
+            string language,
+            ProgrammingModel programmingModel,
+            bool managedDependenciesOption,
+            bool generatePythonDocumentation=true)
         {
             switch (workerRuntime) {
                 case Helpers.WorkerRuntime.python:
-                    await PythonHelpers.SetupPythonProject(generatePythonDocumentation);
+                    await PythonHelpers.SetupPythonProject(programmingModel, generatePythonDocumentation);
                     break;
                 case Helpers.WorkerRuntime.powershell:
                     await WriteFiles("profile.ps1", await StaticResources.PowerShellProfilePs1);
@@ -327,7 +351,7 @@ private void ValidateTargetFramework()
             }
         }
 
-        private static async Task WriteLocalSettingsJson(WorkerRuntime workerRuntime)
+        private static async Task WriteLocalSettingsJson(WorkerRuntime workerRuntime, ProgrammingModel programmingModel)
         {
             var localSettingsJsonContent = await StaticResources.LocalSettingsJson;
             localSettingsJsonContent = localSettingsJsonContent.Replace($"{{{Constants.FunctionsWorkerRuntime}}}", WorkerRuntimeLanguageHelper.GetRuntimeMoniker(workerRuntime));
@@ -340,7 +364,12 @@ private static async Task WriteLocalSettingsJson(WorkerRuntime workerRuntime)
 
             if (workerRuntime == Helpers.WorkerRuntime.powershell)
             {
-                localSettingsJsonContent = AddWorkerVersion(localSettingsJsonContent, Constants.PowerShellWorkerDefaultVersion);
+                localSettingsJsonContent = AddLocalSetting(localSettingsJsonContent, Constants.FunctionsWorkerRuntimeVersion, Constants.PowerShellWorkerDefaultVersion);
+            }
+
+            if (programmingModel == Common.ProgrammingModel.V2)
+            {
+                localSettingsJsonContent = AddLocalSetting(localSettingsJsonContent, Constants.AzureWebJobsFeatureFlags, Constants.EnableWorkerIndexing);
             }
 
             await WriteFiles("local.settings.json", localSettingsJsonContent);
@@ -473,7 +502,7 @@ private static bool ResolveManagedDependencies(WorkerRuntime workerRuntime, bool
             return true;
         }
 
-        private static async Task WriteHostJson(WorkerRuntime workerRuntime, bool managedDependenciesOption, bool extensionBundle = true)
+        private async Task WriteHostJson(WorkerRuntime workerRuntime, bool managedDependenciesOption, bool extensionBundle = true)
         {
             var hostJsonContent = await StaticResources.HostJson;
 
@@ -484,7 +513,14 @@ private static async Task WriteHostJson(WorkerRuntime workerRuntime, bool manage
 
             if (extensionBundle)
             {
-                hostJsonContent = await hostJsonContent.AppendContent(Constants.ExtensionBundleConfigPropertyName, StaticResources.BundleConfig);
+                if (ResolvedProgrammingModel == Common.ProgrammingModel.V2 && ResolvedWorkerRuntime == Helpers.WorkerRuntime.python)
+                {
+                    hostJsonContent = await hostJsonContent.AppendContent(Constants.ExtensionBundleConfigPropertyName, StaticResources.BundleConfigPyStein);
+                }
+                else
+                {
+                    hostJsonContent = await hostJsonContent.AppendContent(Constants.ExtensionBundleConfigPropertyName, StaticResources.BundleConfig);
+                }
             }
 
             if(workerRuntime == Helpers.WorkerRuntime.custom)
@@ -495,15 +531,15 @@ private static async Task WriteHostJson(WorkerRuntime workerRuntime, bool manage
             await WriteFiles(Constants.HostJsonFileName, hostJsonContent);
         }
 
-        private static string AddWorkerVersion(string localSettingsContent, string workerVersion)
+        private static string AddLocalSetting(string localSettingsContent, string key, string value)
         {
             var localSettingsObj = JsonConvert.DeserializeObject<JObject>(localSettingsContent);
 
             if (localSettingsObj.TryGetValue("Values", StringComparison.OrdinalIgnoreCase, out var valuesContent))
             {
                 var values = valuesContent as JObject;
                 values.Property(Constants.FunctionsWorkerRuntime).AddAfterSelf(
-                        new JProperty(Constants.FunctionsWorkerRuntimeVersion, workerVersion));
+                        new JProperty(key, value));
             }
 
             return JsonConvert.SerializeObject(localSettingsObj, Formatting.Indented);

src/Azure.Functions.Cli/Azure.Functions.Cli.csproj

@@ -37,6 +37,9 @@
     <EmbeddedResource Include="StaticResources\bundleConfig.json">
       <LogicalName>$(AssemblyName).bundleConfig.json</LogicalName>
     </EmbeddedResource>
+    <EmbeddedResource Include="StaticResources\bundleConfigPyStein.json">
+      <LogicalName>$(AssemblyName).bundleConfigPyStein.json</LogicalName>
+    </EmbeddedResource>
     <EmbeddedResource Include="StaticResources\customHandlerConfig.json">
       <LogicalName>$(AssemblyName).customHandlerConfig.json</LogicalName>
     </EmbeddedResource>
@@ -118,6 +121,9 @@
     <EmbeddedResource Include="StaticResources\funcignore">
       <LogicalName>$(AssemblyName).funcignore</LogicalName>
     </EmbeddedResource>
+    <EmbeddedResource Include="StaticResources\function_app.py.template">
+      <LogicalName>$(AssemblyName).function_app.py</LogicalName>
+    </EmbeddedResource>
     <EmbeddedResource Include="StaticResources\requirements.psd1">
       <LogicalName>$(AssemblyName).requirements.psd1</LogicalName>
     </EmbeddedResource>
@@ -159,7 +165,7 @@
     <PackageReference Include="Microsoft.ApplicationInsights" Version="2.20.0" />
     <PackageReference Include="Microsoft.AspNetCore.DataProtection" Version="2.2.0" />
     <PackageReference Include="Microsoft.Azure.DurableTask.AzureStorage.Internal" Version="1.4.0" />
-    <PackageReference Include="Microsoft.Azure.WebJobs.Script.WebHost" Version="4.8.1" />
+    <PackageReference Include="Microsoft.Azure.WebJobs.Script.WebHost" Version="4.9.1" />
     <PackageReference Include="Microsoft.Build" Version="17.0.0" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
     <PackageReference Include="WindowsAzure.Storage" Version="9.3.1" />
@@ -170,7 +176,7 @@
     <PackageReference Include="Microsoft.Azure.Functions.NodeJsWorker" Version="3.4.0" />
     <PackageReference Include="Microsoft.Azure.Functions.PowerShellWorker.PS7.0" Version="4.0.2045" />
     <PackageReference Include="Microsoft.Azure.Functions.PowerShellWorker.PS7.2" Version="4.0.2040" />
-    <PackageReference Include="Microsoft.Azure.Functions.PythonWorker" Version="4.2.0-hotfix" />
+    <PackageReference Include="Microsoft.Azure.Functions.PythonWorker" Version="4.4.0" />
   </ItemGroup>
   <Target Name="ExcludeWorkersFromReadyToRun">
     <CreateItem Include="%(None.Filename)%(None.Extension)" Condition="$([System.String]::new('%(None.TargetPath)').StartsWith('workers'))" PreserveExistingMetadata="false">

src/Azure.Functions.Cli/Common/Constants.cs

@@ -21,6 +21,7 @@ internal static class Constants
         public const string FunctionsWorkerRuntimeVersion = "FUNCTIONS_WORKER_RUNTIME_VERSION";
         public const string RequirementsTxt = "requirements.txt";
         public const string PythonGettingStarted = "getting_started.md";
+        public const string PySteinFunctionAppPy = "function_app.py";
         public const string FunctionJsonFileName = "function.json";
         public const string HostJsonFileName = "host.json";
         public const string ProxiesJsonFileName = "proxies.json";
@@ -30,6 +31,7 @@ internal static class Constants
         public const string FunctionsExtensionVersion = "FUNCTIONS_EXTENSION_VERSION";
         public const string StorageEmulatorConnectionString = "UseDevelopmentStorage=true";
         public const string AzureWebJobsStorage = "AzureWebJobsStorage";
+        public const string AzureWebJobsFeatureFlags = "AzureWebJobsFeatureFlags";
         public const string PackageReferenceElementName = "PackageReference";
         public const string LinuxFxVersion = "linuxFxVersion";
         public const string DotnetFrameworkVersion = "netFrameworkVersion";
@@ -54,6 +56,7 @@ internal static class Constants
         public const string AuthLevelErrorMessage = "Unable to configure Authorization level. The selected template does not use Http Trigger";
         public const string HttpTriggerTemplateName = "HttpTrigger";
         public const string PowerShellWorkerDefaultVersion = "7.2";
+        public const string EnableWorkerIndexing = "EnableWorkerIndexing";
         public const string UserSecretsIdElementName = "UserSecretsId";
         public const string TargetFrameworkElementName = "TargetFramework";
         public const string DisplayLogo = "FUNCTIONS_CORE_TOOLS_DISPLAY_LOGO";

src/Azure.Functions.Cli/Common/ProgrammingModel.cs

@@ -0,0 +1,8 @@
+namespace Azure.Functions.Cli.Common
+{
+    public enum ProgrammingModel
+    {
+        V1,
+        V2
+    }
+}

src/Azure.Functions.Cli/Helpers/EnumerationHelper.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Azure.Functions.Cli.Helpers
+{
+    public static class EnumerationHelper
+    {
+        public static string Join<T>(string separator, IEnumerable<T> enumerable)
+        {
+             return enumerable.Select(t => t.ToString())
+                        .Aggregate((total, next) => total + separator + next);
+        }
+    }
+}

src/Azure.Functions.Cli/Helpers/GlobalCoreToolsSettings.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Linq;
+using Azure.Functions.Cli.Common;
 using Azure.Functions.Cli.Interfaces;
 using Colors.Net;
 using static Azure.Functions.Cli.Common.OutputTheme;
@@ -9,6 +10,7 @@ namespace Azure.Functions.Cli.Helpers
     public static class GlobalCoreToolsSettings
     {
         private static WorkerRuntime _currentWorkerRuntime;
+        public static ProgrammingModel? CurrentProgrammingModel { get; set; }
         public static WorkerRuntime CurrentWorkerRuntime
         {
             get

src/Azure.Functions.Cli/Helpers/ProgrammingModelHelper.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Azure.Functions.Cli.Common;
+
+namespace Azure.Functions.Cli.Helpers
+{
+    public static class ProgrammingModelHelper
+    {
+        public static IEnumerable<ProgrammingModel> GetProgrammingModels()
+        {
+            return Enum.GetValues<ProgrammingModel>();
+        }
+
+        // Given a worker runtime, this function returns a collection of the programming models that are supported.
+        public static IEnumerable<ProgrammingModel> GetSupportedProgrammingModels(WorkerRuntime workerRuntime)
+        {
+            var allProgrammingModels = GetProgrammingModels();
+            if (workerRuntime != WorkerRuntime.python)
+            {
+                return allProgrammingModels.Where(pm => pm != ProgrammingModel.V2);
+            }
+            return allProgrammingModels;
+        }
+
+        public static ProgrammingModel ResolveProgrammingModel(string programmingModel, WorkerRuntime workerRuntime, string language)
+        {
+            if (GlobalCoreToolsSettings.CurrentProgrammingModel != null)
+            {
+                return GlobalCoreToolsSettings.CurrentProgrammingModel.Value;
+            }
+            // We default to the "Default" programming model if the model parameter is not specified
+            if (string.IsNullOrEmpty(programmingModel))
+            {
+                GlobalCoreToolsSettings.CurrentProgrammingModel = ProgrammingModel.V1;
+            }
+            else if (GetProgrammingModels().Any(pm => string.Equals(programmingModel, pm.ToString(), StringComparison.InvariantCultureIgnoreCase)))
+            {
+                GlobalCoreToolsSettings.CurrentProgrammingModel = GetProgrammingModels().First(pm => string.Equals(programmingModel, pm.ToString(), StringComparison.InvariantCultureIgnoreCase));
+            }
+            // If programmingModel is non-empty and does not match any progrmming model, then we raise an exception
+            else
+            {
+                // TODO: Explicitly define the association between language, worker-runtime, and programming model
+                throw new CliArgumentsException($"The programming model {programmingModel} is not supported. Valid options for language {language} and worker-runtime {workerRuntime.ToString()} are:\n{EnumerationHelper.Join("\n", GetSupportedProgrammingModels(workerRuntime))}");
+            }
+            return GlobalCoreToolsSettings.CurrentProgrammingModel.Value;
+        }
+    }
+}