Minor fixes/Fixed flake8

Author: gavin-aguiar

azure_functions_worker/dispatcher.py

@@ -14,12 +14,12 @@
 import sys
 import threading
 import uuid
-import grpc
-
 from asyncio import BaseEventLoop
 from logging import LogRecord
 from typing import List, Optional
 
+import grpc
+
 from . import bindings, constants, functions, loader, protos
 from .bindings.shared_memory_data_transfer import SharedMemoryManager
 from .constants import (PYTHON_THREADPOOL_THREAD_COUNT,
@@ -38,7 +38,6 @@
 from .utils.wrappers import disable_feature_by
 from .version import VERSION
 
-
 _TRUE = "true"
 
 """In Python 3.6, the current_task method was in the Task class, but got moved
@@ -313,9 +312,7 @@ async def _handle__functions_metadata_request(self, request):
                 function=indexed_function)
 
             binding_protos = {}
-            
             for binding in indexed_function.get_bindings():
-                
                 binding_protos[binding.name] = protos.BindingInfo(
                     type=binding.type,
                     data_type=binding.data_type,
@@ -795,12 +792,7 @@ def get_current_invocation_id() -> Optional[str]:
             if task_invocation_id is not None:
                 return task_invocation_id
 
-    #return getattr(_invocation_id_local, 'v', None)
-    
-    invocation_local_id = getattr(logging.getLogger(), 'invocation_local_id', None)
-    return getattr(invocation_local_id, 'v', None)
-
-
+    return getattr(_invocation_id_local, 'v', None)
 
 
 _invocation_id_local = threading.local()

azure_functions_worker/functions.py

@@ -50,7 +50,6 @@ def get_function(self, function_id: str) -> FunctionInfo:
 
         return None
 
-
     @staticmethod
     def validate_binding_direction(binding_name: str,
                                    binding_direction: str,
@@ -113,18 +112,18 @@ def validate_function_params(params, bound_params, annotations, func_name):
                     param_anno_origin = typing_inspect.get_origin(param_anno)
                     if param_anno_origin is not None:
                         is_param_out = (
-                                isinstance(param_anno_origin, type)
-                                and param_anno_origin.__name__ == 'Out'
+                            isinstance(param_anno_origin, type)
+                            and param_anno_origin.__name__ == 'Out'
                         )
                     else:
                         is_param_out = (
-                                isinstance(param_anno, type)
-                                and param_anno.__name__ == 'Out'
+                            isinstance(param_anno, type)
+                            and param_anno.__name__ == 'Out'
                         )
                 else:
                     is_param_out = (
-                            isinstance(param_anno, type)
-                            and param_anno.__name__ == 'Out'
+                        isinstance(param_anno, type)
+                        and param_anno.__name__ == 'Out'
                     )
             else:
                 is_param_out = False
@@ -191,9 +190,9 @@ def validate_function_params(params, bound_params, annotations, func_name):
                         raise FunctionLoadError(
                             func_name,
                             f'{param.name!r} binding type "{binding.type}" '
-                            f'and dataType "{binding.data_type}" in function.json'
-                            f' do not match the corresponding function '
-                            f'parameter\'s Python type '
+                            f'and dataType "{binding.data_type}" in '
+                            f'function.json do not match the corresponding '
+                            f'function parameter\'s Python type '
                             f'annotation "{param_py_type.__name__}"')
                     else:
                         raise FunctionLoadError(
@@ -364,7 +363,8 @@ def add_indexed_function(self, function_id: str,
             directory=func_dir,
             requires_context=requires_context,
             is_async=inspect.iscoroutinefunction(func),
-            has_return=has_explicit_return, # has_explicit_return or has_implicit_return,
+            has_return=has_explicit_return,
+            # has_explicit_return or has_implicit_return,
             input_types=input_types,
             output_types=output_types,
             return_type=return_type)

azure_functions_worker/loader.py

@@ -1,7 +1,6 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License.
 """Python functions loader."""
-import glob
 import importlib
 import importlib.machinery
 import importlib.util
@@ -48,8 +47,8 @@ def uninstall() -> None:
 
 
 @attach_message_to_exception(
-        expt_type=ImportError,
-        message=f'Troubleshooting Guide: {MODULE_NOT_FOUND_TS_URL}'
+    expt_type=ImportError,
+    message=f'Troubleshooting Guide: {MODULE_NOT_FOUND_TS_URL}'
 )
 def load_function(name: str, directory: str, script_file: str,
                   entry_point: typing.Optional[str]):
@@ -65,16 +64,16 @@ def load_function(name: str, directory: str, script_file: str,
         rel_script_path = script_path.relative_to(dir_path.parent)
     except ValueError:
         raise RuntimeError(
-                f'script path {script_file} is not relative to the specified '
-                f'directory {directory}'
+            f'script path {script_file} is not relative to the specified '
+            f'directory {directory}'
         )
 
     last_part = rel_script_path.parts[-1]
     modname, ext = os.path.splitext(last_part)
     if ext != '.py':
         raise RuntimeError(
-                f'cannot load function {name}: '
-                f'invalid Python filename {script_file}')
+            f'cannot load function {name}: '
+            f'invalid Python filename {script_file}')
 
     modname_parts = [_AZURE_NAMESPACE]
     modname_parts.extend(rel_script_path.parts[:-1])
@@ -90,15 +89,15 @@ def load_function(name: str, directory: str, script_file: str,
     func = getattr(mod, entry_point, None)
     if func is None or not callable(func):
         raise RuntimeError(
-                f'cannot load function {name}: function {entry_point}() is not '
-                f'present in {rel_script_path}')
+            f'cannot load function {name}: function {entry_point}() is not '
+            f'present in {rel_script_path}')
 
     return func
 
 
 @attach_message_to_exception(
-        expt_type=ImportError,
-        message=f'Troubleshooting Guide: {MODULE_NOT_FOUND_TS_URL}'
+    expt_type=ImportError,
+    message=f'Troubleshooting Guide: {MODULE_NOT_FOUND_TS_URL}'
 )
 def index_function_app(directory: str) -> typing.List[Function]:
     function_path = os.path.join(directory, SCRIPT_FILE_NAME)

azure_functions_worker/logging.py

@@ -16,11 +16,6 @@
 error_logger: logging.Logger = (
     logging.getLogger('azure_functions_worker_errors'))
 
-local_handler = logging.FileHandler('D://mylog.txt')
-logging.getLogger().addHandler(local_handler)
-
-
-
 handler: Optional[logging.Handler] = None
 error_handler: Optional[logging.Handler] = None
 

azure_functions_worker/testutils.py

@@ -915,7 +915,6 @@ def start_webhost(*, script_dir=None, stdout=None):
     health_check_endpoint = f'{addr}/api/ping'
     host_out = stdout.readlines(100)
     for _ in range(5):
-        break
         try:
             r = requests.get(health_check_endpoint,
                              params={'code': 'testFunctionKey'})

tests/endtoend/test_http_functions.py

@@ -105,42 +105,3 @@ def test_worker_status_endpoint_should_return_ok_when_disabled(self):
                           params={'checkHealth': '1'},
                           timeout=REQUEST_TIMEOUT_SEC)
         self.assertTrue(r.ok)
-
-
-class TestHttpFunctionsNewProgrammingModel(testutils.WebHostTestCase):
-    """Test the native Http Trigger in the local webhost.
-
-        This test class will spawn a webhost from your <project_root>/build/webhost
-        folder and replace the built-in Python with azure_functions_worker from
-        your code base. Since the Http Trigger is a native suport from host, we
-        don't need to setup any external resources.
-
-        Compared to the unittests/test_http_functions.py, this file is more focus
-        on testing the E2E flow scenarios.
-        """
-
-    @classmethod
-    def setUpClass(cls):
-        os_environ = os.environ.copy()
-        # Turn on feature flag
-        os_environ['AzureWebJobsFeatureFlags'] = 'EnableWorkerIndexing'
-        cls._patch_environ = patch.dict('os.environ', os_environ)
-        cls._patch_environ.start()
-        super().setUpClass()
-
-    @classmethod
-    def tearDownClass(self):
-        super().tearDownClass()
-        self._patch_environ.stop()
-
-    @classmethod
-    def get_script_dir(cls):
-        return testutils.E2E_TESTS_FOLDER / 'http_functions'
-
-    # @testutils.retryable_test(3, 5)
-    def test_default_http_template_should_return_ok(self):
-        """Test if the default template of Http trigger in Python Function app
-        will return OK
-        """
-        r = self.webhost.request('GET', 'default_template')
-        self.assertEqual(r.status_code, 200)

tests/stein_tests/constants.py

@@ -17,4 +17,4 @@
 TIMER_FUNCS_PATH = UNIT_TESTS_ROOT / 'timer_functions'
 DISPATCHER_FUNCTIONS_DIR = UNIT_TESTS_ROOT / 'dispatcher_functions'
 E2E_TESTS_FOLDER = pathlib.Path('endtoendtests')
-E2E_TESTS_ROOT = STEIN_TESTS_ROOT / E2E_TESTS_FOLDER
+E2E_TESTS_ROOT = STEIN_TESTS_ROOT / E2E_TESTS_FOLDER

tests/stein_tests/endtoendtests/http_functions/function_app.py

@@ -20,9 +20,12 @@ def main(req: func.HttpRequest) -> func.HttpResponse:
 
     if name:
         return func.HttpResponse(
-            f"Hello, {name}. This HTTP triggered function executed successfully.")
+            f"Hello, {name}. This HTTP triggered function executed "
+            f"successfully.")
     else:
         return func.HttpResponse(
-            "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.",
+            "This HTTP triggered function executed successfully. Pass a name"
+            " in the query string or in the request body for a personalized "
+            "response.",
             status_code=200
         )

tests/stein_tests/testutils.py

@@ -1,6 +1,7 @@
 import argparse
 import configparser
 import functools
+import logging
 import os
 import pathlib
 import platform
@@ -9,13 +10,11 @@
 import socket
 import subprocess
 import sys
+import tempfile
 import time
 import unittest
-import tempfile
 
 import requests
-
-import logging
 from tests.stein_tests.constants import PYAZURE_WEBHOST_DEBUG, \
     PYAZURE_WORKER_DIR, \
     PYAZURE_INTEGRATION_TEST, PROJECT_ROOT, STEIN_TESTS_ROOT, WORKER_CONFIG, \
@@ -288,9 +287,9 @@ def popen_webhost(*, stdout, stderr, script_root=HTTP_FUNCS_PATH, port=None):
         stderr=stderr)
 
 
-
 def start_webhost(*, script_dir=None, stdout=None):
-    script_root = STEIN_TESTS_ROOT / script_dir if script_dir else HTTP_FUNCS_PATH
+    script_root = STEIN_TESTS_ROOT / script_dir if script_dir else \
+        HTTP_FUNCS_PATH
     if stdout is None:
         if is_env_var_true(PYAZURE_WEBHOST_DEBUG):
             stdout = sys.stdout
@@ -464,6 +463,6 @@ def _main():
         host.terminate()
         _teardown_func_app()
 
+
 if __name__ == '__main__':
     _main()
-

tests/stein_tests/unittests/http_functions/function_app.py

@@ -221,7 +221,7 @@ def return_context(req: func.HttpRequest, context: func.Context):
 @app.route(route="return_http")
 def return_http(req: func.HttpRequest):
     return func.HttpResponse('<h1>Hello World™</h1>',
-                            mimetype='text/html')
+                             mimetype='text/html')
 
 
 @app.route(route="return_http_404")
@@ -232,7 +232,7 @@ def return_http_404(req: func.HttpRequest):
 @app.route(route="return_http_auth_admin", auth_level=func.AuthLevel.ADMIN)
 def return_http_auth_admin(req: func.HttpRequest):
     return func.HttpResponse('<h1>Hello World™</h1>',
-                            mimetype='text/html')
+                             mimetype='text/html')
 
 
 @app.route(route="return_http_no_body")
@@ -294,10 +294,12 @@ def unhandled_urllib_error(req: func.HttpRequest) -> str:
     image_url = req.params.get('img')
     urlopen(image_url).read()
 
+
 class UnserializableException(Exception):
     def __str__(self):
         raise RuntimeError('cannot serialize me')
 
+
 @app.route(route="unhandled_unserializable_error")
 def unhandled_unserializable_error(req: func.HttpRequest) -> str:
     raise UnserializableException('foo')
@@ -306,6 +308,7 @@ def unhandled_unserializable_error(req: func.HttpRequest) -> str:
 async def try_log():
     logger.info("try_log")
 
+
 @app.route(route="user_event_loop")
 def user_event_loop(req: func.HttpRequest) -> func.HttpResponse:
     loop = asyncio.SelectorEventLoop()
@@ -315,4 +318,3 @@ def user_event_loop(req: func.HttpRequest) -> func.HttpResponse:
     loop.run_until_complete(try_log())
     loop.close()
     return 'OK-user-event-loop'
-