Add note, update imports and refactor code

Author: maximrytych-ms

articles/communication-services/tutorials/hmac-header-tutorial.md

@@ -18,6 +18,9 @@ zone_pivot_groups: acs-programming-languages-csharp-python
 
 In this tutorial, you'll learn how to sign an HTTP request with an HMAC signature.
 
+>[!NOTE]
+>We strongly encourage to use [Azure SDKs](https://github.com/Azure/azure-sdk). Approach described here is a fallback option for cases when Azure SDKs can't be used for any reason.
+
 ::: zone pivot="programming-language-csharp"
 [!INCLUDE [Sign an HTTP request with C#](./includes/hmac-header-csharp.md)]
 ::: zone-end

articles/communication-services/tutorials/includes/hmac-header-python.md

@@ -16,8 +16,8 @@ Before you get started, make sure to:
 
 - Create an Azure account with an active subscription. For details, see [Create an account for free](https://azure.microsoft.com/free/?WT.mc_id=A261C142F).
 - Download and install [Python](https://www.python.org/).
-- Download and install [Visual Studio Code](https://code.visualstudio.com/).
-- Create an Azure Communication Services resource. For details, see [Create an Azure Communication Services resource](../../quickstarts/create-communication-resource.md). You'll need to record your **resourceEndpoint** and **resourceAccessKey** for this tutorial.
+- Download and install [Visual Studio Code](https://code.visualstudio.com/) or other IDE that supports Python.
+- Create an Azure Communication Services resource. For details, see [Create an Azure Communication Services resource](../../quickstarts/create-communication-resource.md). You'll need your **resource_endpoint_name** and **resource_endpoint_secret** for this tutorial.
 
 ## Sign an HTTP request with Python
 
@@ -48,52 +48,50 @@ Open Visual Studio Code and create a new file named `SignHmacTutorial.py`. Save
 Update the `SignHmacTutorial.py` script with the following code to begin.
 
 ```python
-import json
-import requests
-import hashlib
-import base64
-import datetime
-import hmac
-from wsgiref.handlers import format_date_time
-from datetime import datetime
-from time import mktime
+from base64 import b64decode, b64encode
+from datetime import datetime, timezone
+from hashlib import sha256
+from hmac import digest
+from json import dumps
+from locale import LC_TIME, setlocale
+from requests import post
 ```
 
 ## Prepare data for the request
 
-For this example, we'll sign a request to create a new identity by using the Communication Services Authentication API (version `2021-03-07`).
+For this example, we'll sign a request to create a new identity by using the Communication Services Authentication API [(version `2021-03-07`)](https://github.com/Azure/azure-rest-api-specs/tree/main/specification/communication/data-plane/Identity/stable/2021-03-07).
 
 Add the following code to the `SignHmacTutorial.py` script.
 
+Replace `resource_endpoint_name` with your real resource endpoint name value. This value can be found in Overview section of your Azure Communication Services resource. It's the value of "Endpoint" after "https://". 
+Replace `resource_endpoint_secret` with your real resource endpoint secret value. This value can be found in Keys section of your Azure Communication Services resource. It's the value of "Key" - either primary or secondary.
+
 ```python
-host = "resourceEndpointName"
+host = "resource_endpoint_name"
 resource_endpoint = f"https://{host}"
 path_and_query = "/identities?api-version=2021-03-07"
-secret = "resourceEndpointSecret"
+secret = "resource_endpoint_secret"
 
 # Create a uri you are going to call.
 request_uri = f"{resource_endpoint}{path_and_query}"
 
 # Endpoint identities?api-version=2021-03-07 accepts list of scopes as a body.
 scopes = ["chat"]
 
-serialized_body = json.dumps(scopes)
+serialized_body = dumps(scopes)
 content = serialized_body.encode("utf-8")
 ```
 
-Replace `resourceEndpointName` with your real resource endpoint name value.
-Replace `resourceEndpointSecret` with your real resource endpoit secret value.
-
 ## Create a content hash
 
 The content hash is a part of your HMAC signature. Use the following code to compute the content hash. You can add this method to `SignHmacTutorial.py` script.
 
 ```python
 def compute_content_hash(content):
-    sha_256 = hashlib.sha256()
+    sha_256 = sha256()
     sha_256.update(content)
     hashed_bytes = sha_256.digest()
-    base64_encoded_bytes = base64.b64encode(hashed_bytes)
+    base64_encoded_bytes = b64encode(hashed_bytes)
     content_hash = base64_encoded_bytes.decode('utf-8')
     return content_hash
 ```
@@ -104,10 +102,10 @@ Use the following code to create a method for computing your HMAC signature.
 
 ```python
 def compute_signature(string_to_sign, secret):
-    decoded_secret = base64.b64decode(secret)
+    decoded_secret = b64decode(secret)
     encoded_string_to_sign = string_to_sign.encode('ascii')
-    hashed_bytes = hmac.digest(decoded_secret, encoded_string_to_sign, digest=hashlib.sha256)
-    encoded_signature = base64.b64encode(hashed_bytes)
+    hashed_bytes = digest(decoded_secret, encoded_string_to_sign, digest=sha256)
+    encoded_signature = b64encode(hashed_bytes)
     signature = encoded_signature.decode('utf-8')
     return signature
 ```
@@ -128,9 +126,9 @@ Add the following code to the `SignHmacTutorial.py` script.
 
 ```python
 # Specify the 'x-ms-date' header as the current UTC timestamp according to the RFC1123 standard
-now = datetime.now()
-stamp = mktime(now.timetuple())
-date = format_date_time(stamp)
+utc_now = datetime.now(timezone.utc)
+setlocale(LC_TIME, 'en_US')
+date = utc_now.strftime('%a, %d %b %Y %H:%M:%S GMT')
 # Compute a content hash for the 'x-ms-content-sha256' header.
 content_hash = compute_content_hash(content)
 
@@ -164,10 +162,10 @@ request_headers["Authorization"] = authorization_header
 
 ## Test the client
 
-Call the endpoint by using `Requests`, and check the response.
+Call the endpoint and check the response.
 
 ```python
-response = requests.post(request_uri, data=content, headers=request_headers)
+response = post(request_uri, data=content, headers=request_headers)
 response_string = response.content.decode("utf-8")
 print(response_string)
 ```