azure-functions-runtime 1.0.0__py3-none-any.whl

azure_functions_runtime/__init__.py

@@ -0,0 +1,21 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+from .handle_event import (worker_init_request,
+                           functions_metadata_request,
+                           function_environment_reload_request,
+                           invocation_request,
+                           function_load_request)
+from .utils.threadpool import (
+    start_threadpool_executor,
+    stop_threadpool_executor,
+    get_threadpool_executor,
+)
+
+__all__ = ('worker_init_request',
+           'functions_metadata_request',
+           'function_environment_reload_request',
+           'invocation_request',
+           'function_load_request',
+           'start_threadpool_executor',
+           'stop_threadpool_executor',
+           'get_threadpool_executor')

azure_functions_runtime/bindings/context.py

@@ -0,0 +1,66 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+import threading
+
+from .retrycontext import RetryContext
+from .tracecontext import TraceContext
+
+
+class Context:
+    def __init__(self,
+                 func_name: str,
+                 func_dir: str,
+                 invocation_id: str,
+                 thread_local_storage: threading.local,
+                 trace_context: TraceContext,
+                 retry_context: RetryContext) -> None:
+        self.__func_name = func_name
+        self.__func_dir = func_dir
+        self.__invocation_id = invocation_id
+        self.__thread_local_storage = thread_local_storage
+        self.__trace_context = trace_context
+        self.__retry_context = retry_context
+
+    @property
+    def invocation_id(self) -> str:
+        return self.__invocation_id
+
+    @property
+    def thread_local_storage(self) -> threading.local:
+        return self.__thread_local_storage
+
+    @property
+    def function_name(self) -> str:
+        return self.__func_name
+
+    @property
+    def function_directory(self) -> str:
+        return self.__func_dir
+
+    @property
+    def trace_context(self) -> TraceContext:
+        return self.__trace_context
+
+    @property
+    def retry_context(self) -> RetryContext:
+        return self.__retry_context
+
+
+def get_context(invoc_request, name: str,
+                directory: str) -> Context:
+    """ For more information refer:
+    https://aka.ms/azfunc-invocation-context
+    """
+    trace_context = TraceContext(
+        invoc_request.trace_context.trace_parent,
+        invoc_request.trace_context.trace_state,
+        invoc_request.trace_context.attributes)
+
+    retry_context = RetryContext(
+        invoc_request.retry_context.retry_count,
+        invoc_request.retry_context.max_retry_count,
+        invoc_request.retry_context.exception)
+
+    return Context(
+        name, directory, invoc_request.invocation_id,
+        threading.local(), trace_context, retry_context)

azure_functions_runtime/bindings/datumdef.py

@@ -0,0 +1,232 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+import json
+import logging
+
+from datetime import datetime
+from typing import Any, List, Optional
+
+from .nullable_converters import (
+    to_nullable_bool,
+    to_nullable_double,
+    to_nullable_string,
+    to_nullable_timestamp,
+)
+
+try:
+    from http.cookies import SimpleCookie
+except ImportError:
+    from Cookie import SimpleCookie  # type: ignore
+
+
+class Datum:
+    def __init__(self, value, type):
+        self.value = value
+        self.type = type
+
+    @property
+    def python_value(self) -> Any:
+        if self.value is None or self.type is None:
+            return None
+        elif self.type in ('bytes', 'string', 'int', 'double'):
+            return self.value
+        elif self.type == 'json':
+            return json.loads(self.value)
+        elif self.type == 'collection_string':
+            return [v for v in self.value.string]
+        elif self.type == 'collection_bytes':
+            return [v for v in self.value.bytes]
+        elif self.type == 'collection_double':
+            return [v for v in self.value.double]
+        elif self.type == 'collection_sint64':
+            return [v for v in self.value.sint64]
+        else:
+            return self.value
+
+    @property
+    def python_type(self) -> type:
+        return type(self.python_value)
+
+    def __eq__(self, other):
+        if not isinstance(other, type(self)):
+            return False
+
+        return self.value == other.value and self.type == other.type
+
+    def __hash__(self):
+        return hash((type(self), (self.value, self.type)))
+
+    def __repr__(self):
+        val_repr = repr(self.value)
+        if len(val_repr) > 10:
+            val_repr = val_repr[:10] + '...'
+        return '<Datum ' + str(self.type) + val_repr + '>'
+
+    @classmethod
+    def from_typed_data(cls, protos):
+        try:
+            td = protos.TypedData
+        except Exception:
+            td = protos
+        tt = td.WhichOneof('data')
+        if tt == 'http':
+            http = td.http
+            val = dict(
+                method=Datum(http.method, 'string'),
+                url=Datum(http.url, 'string'),
+                headers={
+                    k: Datum(v, 'string') for k, v in http.headers.items()
+                },
+                body=(
+                    Datum.from_typed_data(http.body)
+                    or Datum(type='bytes', value=b'')
+                ),
+                params={
+                    k: Datum(v, 'string') for k, v in http.params.items()
+                },
+                query={
+                    k: Datum(v, 'string') for k, v in http.query.items()
+                },
+            )
+        elif tt == 'string':
+            val = td.string
+        elif tt == 'bytes':
+            val = td.bytes
+        elif tt == 'json':
+            val = td.json
+        elif tt == 'collection_bytes':
+            val = td.collection_bytes
+        elif tt == 'collection_string':
+            val = td.collection_string
+        elif tt == 'collection_sint64':
+            val = td.collection_sint64
+        elif tt == 'model_binding_data':
+            val = td.model_binding_data
+        elif tt == 'collection_model_binding_data':
+            val = td.collection_model_binding_data
+        elif tt is None:
+            return None
+        else:
+            raise NotImplementedError(
+                'unsupported TypeData kind: %s' % tt
+            )
+
+        return cls(val, tt)
+
+
+def datum_as_proto(datum: Datum, protos):
+    if datum.type == 'string':
+        return protos.TypedData(string=datum.value)
+    elif datum.type == 'bytes':
+        return protos.TypedData(bytes=datum.value)
+    elif datum.type == 'json':
+        return protos.TypedData(json=datum.value)
+    elif datum.type == 'http':
+        return protos.TypedData(http=protos.RpcHttp(
+            status_code=datum.value['status_code'].value,
+            headers={
+                k: v.value
+                for k, v in datum.value['headers'].items()
+            },
+            cookies=parse_to_rpc_http_cookie_list(datum.value.get('cookies'), protos),
+            enable_content_negotiation=False,
+            body=datum_as_proto(datum.value['body'], protos),
+        ))
+    elif datum.type is None:
+        return None
+    elif datum.type == 'dict':
+        # TypedData doesn't support dict, so we return it as json
+        return protos.TypedData(json=json.dumps(datum.value))
+    elif datum.type == 'list':
+        # TypedData doesn't support list, so we return it as json
+        return protos.TypedData(json=json.dumps(datum.value))
+    elif datum.type == 'int':
+        return protos.TypedData(int=datum.value)
+    elif datum.type == 'double':
+        return protos.TypedData(double=datum.value)
+    elif datum.type == 'bool':
+        # TypedData doesn't support bool, so we return it as an int
+        return protos.TypedData(int=int(datum.value))
+    else:
+        raise NotImplementedError(
+            'unexpected Datum type: %s' % datum.type
+        )
+
+
+def parse_to_rpc_http_cookie_list(cookies: Optional[List[SimpleCookie]], protos):
+    if cookies is None:
+        return cookies
+
+    rpc_http_cookies = []
+
+    for cookie in cookies:
+        for name, cookie_entity in cookie.items():
+            rpc_http_cookies.append(
+                protos.RpcHttpCookie(name=name,
+                                     value=cookie_entity.value,
+                                     domain=to_nullable_string(
+                                         cookie_entity['domain'],
+                                         'cookie.domain',
+                                         protos),
+                                     path=to_nullable_string(
+                                         cookie_entity['path'],
+                                         'cookie.path',
+                                         protos),
+                                     expires=to_nullable_timestamp(
+                                         parse_cookie_attr_expires(
+                                             cookie_entity), 'cookie.expires',
+                                         protos),
+                                     secure=to_nullable_bool(
+                                         bool(cookie_entity['secure']),
+                                         'cookie.secure',
+                                         protos),
+                                     http_only=to_nullable_bool(
+                                         bool(cookie_entity['httponly']),
+                                         'cookie.httpOnly',
+                                         protos),
+                                     same_site=parse_cookie_attr_same_site(
+                                         cookie_entity, protos),
+                                     max_age=to_nullable_double(
+                                         cookie_entity['max-age'],
+                                         'cookie.maxAge',
+                                         protos)))
+
+    return rpc_http_cookies
+
+
+def parse_cookie_attr_expires(cookie_entity):
+    expires = cookie_entity['expires']
+
+    if expires is not None and len(expires) != 0:
+        try:
+            return datetime.strptime(expires, "%a, %d %b %Y %H:%M:%S GMT")
+        except ValueError:
+            logging.error(
+                "Can not parse value %s of expires in the cookie "
+                "due to invalid format.", expires)
+            raise
+        except OverflowError:
+            logging.error(
+                "Can not parse value %s of expires in the cookie "
+                "because the parsed date exceeds the largest valid C "
+                "integer on your system.", expires)
+            raise
+
+    return None
+
+
+def parse_cookie_attr_same_site(cookie_entity, protos):
+    same_site = getattr(protos.RpcHttpCookie.SameSite, "None")
+    try:
+        raw_same_site_str = cookie_entity['samesite'].lower()
+
+        if raw_same_site_str == 'lax':
+            same_site = protos.RpcHttpCookie.SameSite.Lax
+        elif raw_same_site_str == 'strict':
+            same_site = protos.RpcHttpCookie.SameSite.Strict
+        elif raw_same_site_str == 'none':
+            same_site = protos.RpcHttpCookie.SameSite.ExplicitNone
+    except Exception:
+        return same_site
+
+    return same_site

azure_functions_runtime/bindings/generic.py

@@ -0,0 +1,75 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+import typing
+
+from typing import Any, Optional
+
+from .datumdef import Datum
+
+
+class GenericBinding:
+
+    @classmethod
+    def has_trigger_support(cls) -> bool:
+        return False
+
+    @classmethod
+    def check_input_type_annotation(cls, pytype: type) -> bool:
+        return issubclass(pytype, (str, bytes))
+
+    @classmethod
+    def check_output_type_annotation(cls, pytype: type) -> bool:
+        return issubclass(pytype, (str, bytes, bytearray))
+
+    @classmethod
+    def encode(cls, obj: Any, *,
+               expected_type: Optional[type]) -> Datum:
+        if isinstance(obj, str):
+            return Datum(type='string', value=obj)
+
+        elif isinstance(obj, (bytes, bytearray)):
+            return Datum(type='bytes', value=bytes(obj))
+        elif obj is None:
+            return Datum(type=None, value=obj)
+        elif isinstance(obj, dict):
+            return Datum(type='dict', value=obj)
+        elif isinstance(obj, list):
+            return Datum(type='list', value=obj)
+        elif isinstance(obj, int):
+            return Datum(type='int', value=obj)
+        elif isinstance(obj, float):
+            return Datum(type='double', value=obj)
+        elif isinstance(obj, bool):
+            return Datum(type='bool', value=obj)
+        else:
+            raise NotImplementedError
+
+    @classmethod
+    def decode(cls, data: Datum, *, trigger_metadata) -> typing.Any:
+        # Enabling support for Dapr bindings
+        # https://github.com/Azure/azure-functions-python-worker/issues/1316
+        if data is None:
+            return None
+        data_type = data.type
+
+        if data_type == 'string':
+            result = data.value
+        elif data_type == 'bytes':
+            result = data.value
+        elif data_type == 'json':
+            result = data.value
+        elif data_type is None:
+            result = None
+        else:
+            raise ValueError(
+                'unexpected type of data received for the "generic" binding ',
+                repr(data_type)
+            )
+
+        return result
+
+    @classmethod
+    def has_implicit_output(cls, bind_name: Optional[str]) -> bool:
+        if bind_name == 'durableClient':
+            return False
+        return True

azure_functions_runtime/bindings/meta.py

@@ -0,0 +1,288 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+# mypy: disable-error-code="attr-defined"
+import os
+import sys
+
+from typing import Any, Dict, Optional, Union
+
+from .datumdef import Datum, datum_as_proto
+from .generic import GenericBinding
+
+from ..http_v2 import HttpV2Registry
+from ..logging import logger
+from ..utils.constants import (
+    CUSTOMER_PACKAGES_PATH,
+    HTTP,
+    HTTP_TRIGGER,
+)
+from ..utils.helpers import set_sdk_version
+
+
+PB_TYPE = 'rpc_data'
+PB_TYPE_DATA = 'data'
+PB_TYPE_RPC_SHARED_MEMORY = 'rpc_shared_memory'
+
+BINDING_REGISTRY = None
+DEFERRED_BINDING_REGISTRY = None
+
+
+def _check_http_input_type_annotation(bind_name: str, pytype: type,
+                                      is_deferred_binding: bool) -> bool:
+    if HttpV2Registry.http_v2_enabled():
+        return HttpV2Registry.ext_base().RequestTrackerMeta \
+            .check_type(pytype)
+
+    binding = get_binding(bind_name, is_deferred_binding)
+    return binding.check_input_type_annotation(pytype)
+
+
+def _check_http_output_type_annotation(bind_name: str, pytype: type) -> bool:
+    if HttpV2Registry.http_v2_enabled():
+        return HttpV2Registry.ext_base().ResponseTrackerMeta.check_type(pytype)
+
+    binding = get_binding(bind_name)
+    return binding.check_output_type_annotation(pytype)
+
+
+INPUT_TYPE_CHECK_OVERRIDE_MAP = {
+    HTTP_TRIGGER: _check_http_input_type_annotation
+}
+
+OUTPUT_TYPE_CHECK_OVERRIDE_MAP = {
+    HTTP: _check_http_output_type_annotation
+}
+
+
+def load_binding_registry() -> None:
+    """
+    Tries to load azure-functions from the customer's BYO. If it's
+    not found, it loads the builtin. If the BINDING_REGISTRY is None,
+    azure-functions hasn't been loaded in properly.
+
+    Tries to load the base extension.
+    """
+
+    func = sys.modules.get('azure.functions')
+
+    if func is None:
+        import azure.functions as func
+
+    set_sdk_version(func.__version__)  # type: ignore
+
+    global BINDING_REGISTRY
+    BINDING_REGISTRY = func.get_binding_registry()  # type: ignore
+
+    if BINDING_REGISTRY is None:
+        raise AttributeError('BINDING_REGISTRY is None. azure-functions '
+                             'library not found. Sys Path: %s. '
+                             'Sys Modules: %s. '
+                             'python-packages Path exists: %s.',
+                             sys.path, sys.modules,
+                             os.path.exists(CUSTOMER_PACKAGES_PATH))
+
+    try:
+        import azurefunctions.extensions.base as clients
+        global DEFERRED_BINDING_REGISTRY
+        DEFERRED_BINDING_REGISTRY = clients.get_binding_registry()
+    except ImportError:
+        logger.debug('Base extension not found. '
+                     'Python version: 3.%s, Sys path: %s, '
+                     'Sys Module: %s, python-packages Path exists: %s.',
+                     sys.version_info.minor, sys.path,
+                     sys.modules, os.path.exists(CUSTOMER_PACKAGES_PATH))
+
+
+def get_binding(bind_name: str,
+                is_deferred_binding: Optional[bool] = False)\
+        -> object:
+    """
+    First checks if the binding is a non-deferred binding. This is
+    the most common case.
+    Second checks if the binding is a deferred binding.
+    If the binding is neither, it's a generic type.
+    """
+    binding = None
+    if binding is None and not is_deferred_binding:
+        binding = BINDING_REGISTRY.get(bind_name)  # type: ignore
+    if binding is None and is_deferred_binding:
+        binding = DEFERRED_BINDING_REGISTRY.get(bind_name)  # type: ignore
+    if binding is None:
+        binding = GenericBinding
+    return binding
+
+
+def is_trigger_binding(bind_name: str) -> bool:
+    binding = get_binding(bind_name)
+    return binding.has_trigger_support()
+
+
+def check_input_type_annotation(bind_name: str,
+                                pytype: type,
+                                is_deferred_binding: bool) -> bool:
+    global INPUT_TYPE_CHECK_OVERRIDE_MAP
+    if bind_name in INPUT_TYPE_CHECK_OVERRIDE_MAP:
+        return INPUT_TYPE_CHECK_OVERRIDE_MAP[bind_name](bind_name, pytype,
+                                                        is_deferred_binding)
+
+    binding = get_binding(bind_name, is_deferred_binding)
+
+    return binding.check_input_type_annotation(pytype)
+
+
+def check_output_type_annotation(bind_name: str, pytype: type) -> bool:
+    global OUTPUT_TYPE_CHECK_OVERRIDE_MAP
+    if bind_name in OUTPUT_TYPE_CHECK_OVERRIDE_MAP:
+        return OUTPUT_TYPE_CHECK_OVERRIDE_MAP[bind_name](bind_name, pytype)
+
+    binding = get_binding(bind_name)
+    return binding.check_output_type_annotation(pytype)
+
+
+def has_implicit_output(bind_name: str) -> bool:
+    binding = get_binding(bind_name)
+
+    # Need to pass in bind_name to exempt Durable Functions
+    if binding is GenericBinding:
+        return (getattr(binding, 'has_implicit_output', lambda: False)
+                (bind_name))  # type: ignore
+
+    else:
+        # If the binding does not have metaclass of meta.InConverter
+        # The implicit_output does not exist
+        return getattr(binding, 'has_implicit_output', lambda: False)()
+
+
+def from_incoming_proto(
+        binding: str,
+        pb, *,
+        pytype: Optional[type],
+        trigger_metadata: Optional[Dict[str, Any]],
+        function_name: str,
+        is_deferred_binding: Optional[bool] = False) -> Any:
+    binding_obj = get_binding(binding, is_deferred_binding)
+    if trigger_metadata:
+        metadata = {
+            k: Datum.from_typed_data(v)
+            for k, v in trigger_metadata.items()
+        }
+    else:
+        metadata = {}
+
+    pb_type = pb.WhichOneof(PB_TYPE)
+    if pb_type == PB_TYPE_DATA:
+        val = pb.data
+        datum = Datum.from_typed_data(val)
+    else:
+        raise TypeError('Unknown ParameterBindingType: %s' % pb_type)
+
+    try:
+        # if the binding is an sdk type binding
+        if is_deferred_binding:
+            return deferred_bindings_decode(binding=binding_obj,
+                                            pb=pb,
+                                            pytype=pytype,
+                                            datum=datum,
+                                            metadata=metadata,
+                                            function_name=function_name)
+        return binding_obj.decode(datum, trigger_metadata=metadata)
+    except NotImplementedError:
+        # Binding does not support the data.
+        dt = val.WhichOneof('data')
+        raise TypeError(
+            'unable to decode incoming TypedData: '
+            'unsupported combination of TypedData field %s '
+            'and expected binding type %s' % (repr(dt), binding_obj))
+
+
+def get_datum(binding: str, obj: Any,
+              pytype: Optional[type]) -> Union[Datum, None]:
+    """
+    Convert an object to a datum with the specified type.
+    """
+    binding_obj = get_binding(binding)
+    try:
+        datum = binding_obj.encode(obj, expected_type=pytype)
+    except NotImplementedError:
+        # Binding does not support the data.
+        raise TypeError(
+            'unable to encode outgoing TypedData: '
+            'unsupported type "%s" for '
+            'Python type "%s"' % (binding, type(obj).__name__))
+    return datum
+
+
+def _does_datatype_support_caching(datum: Datum):
+    supported_datatypes = ('bytes', 'string')
+    return datum.type in supported_datatypes
+
+
+def to_outgoing_proto(binding: str, obj: Any, *,
+                      pytype: Optional[type],
+                      protos):
+    datum = get_datum(binding, obj, pytype)
+    return datum_as_proto(datum, protos)  # type: ignore
+
+
+def to_outgoing_param_binding(binding: str, obj: Any, *,
+                              pytype: Optional[type],
+                              out_name: str,
+                              protos):
+    datum = get_datum(binding, obj, pytype)
+    # If not, send it as part of the response message over RPC
+    # rpc_val can be None here as we now support a None return type
+    rpc_val = datum_as_proto(datum, protos)  # type: ignore
+    return protos.ParameterBinding(
+        name=out_name,
+        data=rpc_val)
+
+
+def deferred_bindings_decode(binding: Any,
+                             pb: Any, *,
+                             pytype: Optional[type],
+                             datum: Any,
+                             metadata: Any,
+                             function_name: str):
+    """
+    The extension manages a cache for clients (ie. BlobClient, ContainerClient)
+    That have already been created, so that the worker can reuse the
+    previously created type without creating a new one.
+
+    For async types, the function_name is needed as a key to differentiate.
+    This prevents a known SDK issue where reusing a client across functions
+    can lose the session context and cause an error.
+
+    """
+
+    deferred_binding_type = binding.decode(datum,
+                                           trigger_metadata=metadata,
+                                           pytype=pytype)
+
+    return deferred_binding_type
+
+
+def check_deferred_bindings_enabled(param_anno: Union[type, None],
+                                    deferred_bindings_enabled: bool) -> Any:
+    """
+    Checks if deferred bindings is enabled at fx and single binding level
+
+    The first bool represents if deferred bindings is enabled at a fx level
+    The second represents if the current binding is deferred binding
+    """
+    if (DEFERRED_BINDING_REGISTRY is not None
+            and DEFERRED_BINDING_REGISTRY.check_supported_type(param_anno)):
+        return True, True
+    else:
+        return deferred_bindings_enabled, False
+
+
+def get_deferred_raw_bindings(indexed_function, input_types):
+    """
+    Calls a method from the base extension that generates the raw bindings
+    for a given function. It also returns logs for that function including
+    the defined binding type and if deferred bindings is enabled for that
+    binding.
+    """
+    raw_bindings, bindings_logs = DEFERRED_BINDING_REGISTRY.get_raw_bindings(
+        indexed_function, input_types)
+    return raw_bindings, bindings_logs