Promote to master

.flake8

@@ -0,0 +1,9 @@
+[flake8]
+# delete D100 for docstring checks, promotes redundant documentation of what's in class docstring
+# W503 contradicts with pep8 and will soon be fixed by flake8
+ignore = W503, D100
+max-line-length = 99
+docstring-convention = numpy
+exclude =
+    __pycache__,
+    azure/durable_functions/grpc/protobuf/

CHANGELOG.md

@@ -0,0 +1,52 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## 1.0.0b3-b4
+- Release to test CD pipeline with push to PyPI
+
+## 1.0.0b2
+
+### Fixed
+- [Remove staticmethod definitions](https://github.com/Azure/azure-functions-durable-python/issues/65)
+
+## 1.0.0b1
+
+### Added
+
+The following orchestration patterns are added:
+
+- Function Chaining
+- Fan In Fan Out
+- Async HTTP APIs
+- Human Interaction
+
+#### API Parity
+- CallActivity
+- CallActivityWithRetry
+- Task.all 
+- Task.any 
+- waitForExternalEvent
+- continueAsNew
+- callHttp
+- currentUtcDateTime
+- newUuid
+- createCheckStatusResponse 
+- getStatus
+- getStatusAll
+- getStatusBy
+- purgeInstanceHistory
+- purgeInstanceHistoryBy
+- raiseEvent
+- startNew
+- terminate
+- waitForCompletionOrCreateCheckStatusResponse
+
+### Changed
+N/A
+
+### Fixed
+N/A
+
+### Removed
+N/A

CONTRIBUTING.md

@@ -0,0 +1,173 @@
+# Contributor Onboarding
+Thank you for taking the time to contribute to Durable Functions in [Python](https://www.python.org/)
+
+## Table of Contents
+
+- [What should I know before I get started?](#what-should-i-know-before-i-get-started)
+- [Pre-requisites](#pre-requisites)
+- [Pull Request Change Flow](#pull-request-change-flow)
+- [Development Setup](#development-setup)
+- [Pre Commit Tasks](#pre-commit-tasks)
+- [Continuous Integration Guidelines & Conventions](#continuous-integration-guidelines-&-conventions)
+- [Getting Help](#getting-help)
+
+## What should I know before I get started
+- [Durable Functions Overview](https://docs.microsoft.com/en-us/azure/azure-functions/durable/durable-functions-overview)
+- [Durable Functions Application Patterns](https://docs.microsoft.com/en-us/azure/azure-functions/durable/durable-functions-overview?tabs=csharp#application-patterns)
+- [Azure Functions Python Overview](https://docs.microsoft.com/en-us/azure/azure-functions/functions-create-first-azure-function-azure-cli?tabs=bash%2Cbrowser&pivots=programming-language-python)
+
+## Pre-requisites
+
+- OS
+    - MacOS (or) Windows10 Ubuntu WSL
+- Language Runtimes
+    - .NET Core 2.0
+    - \>= Python 3.6.x 
+
+Note: Some ML libraries may not be compatible with newer Python versions. Make sure the library is compatible with the Python version.
+
+- Editor
+    - Visual Studio Code
+- Python 3 Tools (pip install)
+    - [pytest](https://docs.pytest.org/en/latest/)
+    - [nox](https://nox.thea.codes/en/stable/)
+- Azure Tools
+    - [Azure Storage Emulator](https://docs.microsoft.com/en-us/azure/storage/common/storage-use-emulator) (or) [Create a storage account in Azure](https://docs.microsoft.com/en-us/azure/storage/common/storage-account-create?tabs=azure-portal)
+    - [Azure Functions Core Tools](https://github.com/Azure/azure-functions-core-tools) v2.7.x and above.
+    - [Azure Storage Explorer](https://azure.microsoft.com/en-us/features/storage-explorer/)
+
+
+## Pull Request Change flow
+
+The general flow for making a change to the library is:
+
+1. 🍴 Fork the repo (add the fork via `git remote add me <clone url here>`
+2. 🌳 Create a branch for your change (generally branch from dev) (`git checkout -b my-change`)
+3. 🛠 Make your change
+4. ✔️ Test your change
+5. ⬆️ Push your changes to your fork (`git push me my-change`)
+6. 💌 Open a PR to the dev branch
+7. 📢 Address feedback and make sure tests pass (yes even if it's an "unrelated" test failure)
+8. 📦 [Rebase](https://git-scm.com/docs/git-rebase) your changes into  meaningful commits (`git rebase -i HEAD~N` where `N` is commits you want to squash)
+9. :shipit: Rebase and merge (This will be done for you if you don't have contributor access)
+10. ✂️ Delete your branch (optional)
+
+## Development Setup
+
+### Visual Studio Code Extensions
+
+The following extensions should be installed if using Visual Studio Code for debugging:
+
+- Python support for Visual Studio Code (Python for VSCode extension)
+- Azure Functions Extensions for Visual Studio Code v0.19.1 and above.
+- autoDocString to generate documentation strings for Python API definitions.
+
+### Python Virtual Environment
+
+- Make sure a Python virtual environment is setup. If you are using VS Code, the Azure Functions Extension project will set one up for you. Alternately, you can set it up through command line as well.
+Note: Conda based environments are not yet supported in Azure Functions.
+
+### Setting up durable-py debugging
+
+
+1.  Git clone your fork and use any starter sample from this [folder] in your fork (https://github.com/Azure/azure-functions-durable-python/tree/dev/samples/) and open this folder in your VS Code editor.
+
+2. Initialize this folder as an Azure Functions project using the VS Code Extension using these [instructions](https://docs.microsoft.com/en-us/azure/azure-functions/functions-create-first-function-vs-code?pivots=programming-language-python). This step will create a Python virtual environment if one doesn't exist already.
+
+3. Add a local.settings.json file
+
+```
+{
+  "IsEncrypted": false,
+  "Values": {
+    "AzureWebJobsStorage": "<your connection string>",
+    "FUNCTIONS_WORKER_RUNTIME": "python"
+  }
+}
+```
+
+4. Add a host.json file that looks like this
+
+```
+{
+  "version": "2.0",
+  "extensionBundle": {
+    "id": "Microsoft.Azure.Functions.ExtensionBundle",
+    "version": "[1.*, 2.0.0)"
+  }
+}
+```
+
+5. Optionally, if you want to specify a custom task hub name, say MyTaskHub, you can add that in the host.json file like this:
+
+```
+{
+  "version": "2.0",
+  "extensions": {
+    "durableTask": {
+      "hubName": "MyTaskHub"
+    }
+  },
+  "extensionBundle": {
+    ...
+  }
+}
+```
+
+6. For debugging, install the code using an editable pip install like this, in the VS Code Terminal:
+
+```
+pip install -e $REPOSITORY_ROOT/
+```
+where REPOSITORY_ROOT is the root folder of the azure-functions-durable-python repository 
+
+7. Set breakpoints and click Run -> Start Debugging in VS Code. This should internally start the Azure Function using `func host start` command.
+
+### Debugging end-to-end
+
+If you want to debug into the Durable Task or any of the .NET bits, follow instructions below:
+
+1. Open the Azure Storage Explorer and connect to the local storage emulator or the storage account you are using.
+2. Make sure the Durable Python debugging is setup already and the debugger has started the `func` process.
+3. In the VSCode editor for DurableTask, click Debug -> .NET Core Attach Process and search for `func host start` process and attach to it.
+4. Add a breakpoint in both editors and continue debugging.
+
+## Testing changes locally (Windows)
+
+Follow all the steps above, use the Azure Storage Emulator for windows to simulate the storage account, and use Visual Studio to debug the .NET Durable Extension.
+
+## Pre Commit Tasks
+
+This library uses nox tooling for running unit tests and linting.
+
+Make sure nox is pre-installed:
+`pip install nox`
+
+### Running unit tests
+
+1. Add your unit tests under ./tests folder
+2. Run: `nox --sessions tests`
+
+### Running flake8 and flake8-docstring
+
+Run:  `nox --sessions lint`
+
+This library uses [numpy docstring convention](https://numpydoc.readthedocs.io/en/latest/format.html) for code documentation.
+
+
+## Continuous Integration Guidelines & Conventions
+
+This project uses a combination of Azure DevOps and GitHub Actions for CI/CD.
+
+- For each PR request/merge, a continuous integration pipeline will run internally that performs linting and running unit tests on your PR/merge.
+- A GitHub Action will also perform CI tasks against your PR/merge. This is designed to provide more control to the contributor.
+- Releases into PyPI will be curated and performed by a CD pipeline internally. See the Getting Help Section to request a release.
+
+## Getting help
+
+ - Leave comments on your PR and @username for attention
+
+### Requesting a release
+- If you need a release into PyPI, request it by raising an issue and tagging @anthonychu or @davidmrdavid
+
+

README.md

@@ -1,10 +1,11 @@
 |Branch|Status|
 |---|---|
-|master|[![Build Status](https://csefy19.visualstudio.com/Durable%20Functions%20Python%20OSS/_apis/build/status/Azure.azure-functions-durable-python?branchName=master)](https://csefy19.visualstudio.com/Durable%20Functions%20Python%20OSS/_build/latest?definitionId=39&branchName=master)|
+|master|[![Build Status](https://azfunc.visualstudio.com/Azure%20Functions%20Python/_apis/build/status/Azure%20Functions%20Durable%20Python?branchName=master)](https://azfunc.visualstudio.com/Azure%20Functions%20Python/_build/latest?definitionId=44&branchName=master)|
+|dev|[![Build Status](https://azfunc.visualstudio.com/Azure%20Functions%20Python/_apis/build/status/Azure%20Functions%20Durable%20Python?branchName=dev)](https://azfunc.visualstudio.com/Azure%20Functions%20Python/_build/latest?definitionId=44&branchName=dev)|
 
 # Durable Functions for Python
 
-The `azure-functions-durable` [pip](https://pypi.org/project/azure-functions-durable/) package allows you to write [Durable Functions](https://docs.microsoft.com/en-us/azure/azure-functions/durable/durable-functions-overview) for Python(https://docs.microsoft.com/en-us/azure/azure-functions/functions-reference-python). Durable Functions is an extension of [Azure Functions](https://docs.microsoft.com/en-us/azure/azure-functions/functions-overview) that lets you write stateful functions and workflows in a serverless environment. The extension manages state, checkpoints, and restarts for you. Durable Functions' advantages include:
+The `azure-functions-durable` [pip](https://pypi.org/project/azure-functions-durable/) package allows you to write [Durable Functions](https://docs.microsoft.com/en-us/azure/azure-functions/durable/durable-functions-overview) for [Python](https://docs.microsoft.com/en-us/azure/azure-functions/functions-reference-python). Durable Functions is an extension of [Azure Functions](https://docs.microsoft.com/en-us/azure/azure-functions/functions-overview) that lets you write stateful functions and workflows in a serverless environment. The extension manages state, checkpoints, and restarts for you. Durable Functions' advantages include:
 
 * Define workflows in code. No JSON schemas or designers are needed.
 * Call other functions synchronously and asynchronously. Output from called functions can be saved to local variables.
@@ -24,81 +25,53 @@ A durable function, or _orchestration_, is a solution made up of different types
 
 Durable Functions' function types and features are documented in-depth [here.](https://docs.microsoft.com/en-us/azure/azure-functions/durable/durable-functions-types-features-overview)
 
-## Getting Started
-
-You can follow the instructions below to get started with a function chaining example, or follow the general checklist below:
+## Current limitations
 
-1. Install prerequisites:
-    - [Azure Functions Core Tools version 2.x](https://docs.microsoft.com/en-us/azure/azure-functions/functions-run-local#install-the-azure-functions-core-tools)
-    - [Azure Storage Emulator](https://docs.microsoft.com/en-us/azure/storage/common/storage-use-emulator) (Windows) or an actual Azure storage account (Mac or Linux)
-    - Python 3.6 or later
+We're actively working on Python support for Durable Functions and we expect a Public Preview announcement in Q2 CY2020. The following are the current known limitations.
 
-2. [Create an Azure Functions app.](https://docs.microsoft.com/en-us/azure/azure-functions/functions-create-first-function-python) 
+### Functionality
 
-3. Install the Durable Functions extension
+* `DurableOrchestrationContext.create_timer()` is not yet supported (coming soon [#35](https://github.com/Azure/azure-functions-durable-python/issues/35))
+* Sub-orchestrations are not yet supported (planned [#62](https://github.com/Azure/azure-functions-durable-python/issues/62))
+* Durable Entities are not yet supported (not yet planned [#96](https://github.com/Azure/azure-functions-durable-python/issues/96))
 
-Run this command from the root folder of your Azure Functions app:
-```bash
-func extensions install -p Microsoft.Azure.WebJobs.Extensions.DurableTask -v 1.8.3
-```
+### Tooling
 
-**durable-functions requires Microsoft.Azure.WebJobs.Extensions.DurableTask 1.7.0 or greater.**
+* Python Durable Functions requires updated versions of Azure Functions Core Tools that includes Python worker [1.1.0](https://github.com/Azure/azure-functions-python-worker/releases/tag/1.1.0), templates ([bundle-1.2.0](https://github.com/Azure/azure-functions-templates/releases/tag/bundle-1.2.0)), and extension bundles ([1.2.0](https://github.com/Azure/azure-functions-extension-bundles/releases/tag/1.2.0)) that are not yet released (ETA May 2020). Use the VS Code dev container in the [Getting Started](#getting-started) section to access a development environment with the required versions of the tools installed.
 
-4. Install the `azure-durable-functions` pip package at the root of your function app:
+### Deployment
 
-Create and activate virtual environment
-```
-python3 -m venv env
-source env/bin/activate
-```
+* Python Durable Functions requires an updated version of the Azure Functions Python language worker ([1.1.0](https://github.com/Azure/azure-functions-python-worker/releases/tag/1.1.0)) that is not yet available in Azure. Deploy your Python Durable Functions apps in containers (requires Premium or App Service plans). (Linux consumption plan support ETA May 2020)
 
-```bash
-pip install azure-durable-functions
-```
-
-5. Write an activity function ([see sample](./samples/python_durable_bindings/DurableActivity)):
-```python
-def main(name: str) -> str:
-    logging.info(f"Activity Triggered: {name}")
-    # your code here
-```
+## Getting Started
 
-6. Write an orchestrator function ([see sample](./samples/python_durable_bindings/DurableOrchestrationTrigger)):
+Follow these instructions to get started with Durable Functions in Python:
 
-```python
-def main(context: str):
-    orchestrate = df.Orchestrator.create(generator_function)
-    result = orchestrate(context)
-    return result
-```
+**🚀 [Python Durable Functions quickstart](https://aka.ms/pythondurable)**
 
-**Note:** Orchestrator functions must follow certain [code constraints.](https://docs.microsoft.com/en-us/azure/azure-functions/durable-functions-checkpointing-and-replay#orchestrator-code-constraints)
+## Samples
 
-7. Write your client function ([see sample](./samples/DurableOrchestrationClient/)):
+Take a look at this project's [samples directory](./samples/):
 
-TBD
+* [Function Chaining](./samples/function_chaining)
+* [Fan-out/Fan-in - Simple](./samples/fan_out_fan_in)
+* [Fan-out/Fan-in - TensorFlow](./samples/fan_out_fan_in_tensorflow)
+* [External Events - Human Interaction & Timeouts](./samples/external_events)
 
-**Note:** Client functions are started by a trigger binding available in the Azure Functions 2.x major version. [Read more about trigger bindings and 2.x-supported bindings.](https://docs.microsoft.com/en-us/azure/azure-functions/functions-triggers-bindings#overview)
+### Orchestrator example
 
-## Samples
+```python
+import azure.durable_functions as df
 
-The [Durable Functions samples](https://docs.microsoft.com/en-us/azure/azure-functions/durable-functions-install) demonstrate several common use cases. They are located in the [samples directory.](./samples/) Descriptive documentation is also available:
 
-* [Function Chaining - Hello Sequence](https://docs.microsoft.com/en-us/azure/azure-functions/durable-functions-sequence)
-* [Fan-out/Fan-in - Cloud Backup](https://docs.microsoft.com/en-us/azure/azure-functions/durable-functions-cloud-backup)
-* [Monitors - Weather Watcher](https://docs.microsoft.com/en-us/azure/azure-functions/durable-functions-monitor)
-* [Human Interaction & Timeouts - Phone Verification](https://docs.microsoft.com/en-us/azure/azure-functions/durable-functions-phone-verification)
+def orchestrator_function(context: df.DurableOrchestrationContext):
+    task1 = yield context.call_activity("DurableActivity", "One")
+    task2 = yield context.call_activity("DurableActivity", "Two")
+    task3 = yield context.call_activity("DurableActivity", "Three")
 
-```python
-def generator_function(context):
-    outputs = []
-    task1 = yield context.df.callActivity("DurableActivity", "One")
-    task2 = yield context.df.callActivity("DurableActivity", "Two")
-    task3 = yield context.df.callActivity("DurableActivity", "Three")
+    outputs = [task1, task2, task3]
+    return outputs
 
-    outputs.append(task1)
-    outputs.append(task2)
-    outputs.append(task3)
 
-    return outputs
+main = df.Orchestrator.create(orchestrator_function)
 ```