azure-functions 1.25.0b3.dev1__tar.gz → 1.25.0b3.dev3__tar.gz

{azure_functions-1.25.0b3.dev1/azure_functions.egg-info → azure_functions-1.25.0b3.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: azure-functions
-Version: 1.25.0b3.dev1
+Version: 1.25.0b3.dev3
 Summary: Python library for Azure Functions.
 Author-email: "Azure Functions team at Microsoft Corp." <azurefunctions@microsoft.com>
 License: MIT License

{azure_functions-1.25.0b3.dev1 → azure_functions-1.25.0b3.dev3}/azure/functions/__init__.py

@@ -110,4 +110,4 @@ __all__ = (
     'McpPropertyType'
 )
 
-__version__ = '1.25.0b3dev1'
+__version__ = '1.25.0b3.dev3'

azure_functions-1.25.0b3.dev3/azure/functions/decorators/durable_functions.py

@@ -0,0 +1,45 @@
+#  Copyright (c) Microsoft Corporation. All rights reserved.
+#  Licensed under the MIT License.
+import logging
+
+_logger = logging.getLogger('azure.functions.DurableFunctions')
+
+df = None
+
+
+def get_durable_package():
+    """Determines which Durable SDK is being used.
+
+    If the `azure-functions-durable` package is installed, we
+    log a warning that this legacy package
+    is deprecated.
+
+    If both the legacy and current packages are installed,
+    we log a warning and prefer the current package.
+
+    If neither package is installed, we return None.
+    """
+    _logger.info("Attempting to import Durable Functions package.")
+    global df
+    if df:
+        _logger.info("Durable Functions package already loaded. DF: %s", df)
+        return df
+
+    # Check for azure-functions-durable package
+    try:
+        import azure.durable_functions as durable_functions # noqa
+        _logger.info("`azure.durable_functions` package found.")
+    except ImportError:
+        _logger.info("`azure.durable_functions` package not found.")
+        return None
+
+    # Check version of azure-functions-durable package
+    try:
+        if hasattr(durable_functions, 'version') and durable_functions.version.startswith("2."):
+            _logger.info("Using `azure.durable_functions` v2.x package.")
+    except Exception:
+        _logger.info("Using `azure.durable_functions` v1.x package.")
+
+    df = durable_functions
+
+    return df

{azure_functions-1.25.0b3.dev1 → azure_functions-1.25.0b3.dev3}/azure/functions/decorators/function_app.py

@@ -58,7 +58,8 @@ from .._http_wsgi import WsgiMiddleware, Context
 from azure.functions.decorators.mysql import MySqlInput, MySqlOutput, \
     MySqlTrigger
 
-_logger = logging.getLogger('azure.functions.AsgiMiddleware')
+_logger = logging.getLogger('azure.functions.DurableFunctions')
+
 
 class Function(object):
     """
@@ -357,8 +358,8 @@ class DecoratorApi(ABC):
         else:
             error_message = \
                 "Attempted to use a Durable Functions decorator, " \
-                "but the `durabletask-azurefunctions` SDK package could not be " \
-                "found. Please install `durabletask-azurefunctions` to use " \
+                "but the `azure-functions-durable` SDK package could not be " \
+                "found. Please install `azure-functions-durable` to use " \
                 "Durable Functions."
             raise Exception(error_message)
 

{azure_functions-1.25.0b3.dev1 → azure_functions-1.25.0b3.dev3}/azure/functions/durable_functions.py

@@ -9,14 +9,15 @@ from azure.functions.decorators.durable_functions import get_durable_package
 from . import meta
 
 import logging
-_logger = logging.getLogger('azure.functions.AsgiMiddleware')
+_logger = logging.getLogger('azure.functions.DurableFunctions')
+
 
 # ---------------- Legacy Durable Functions Converters ---------------- #
 # Legacy Durable Function Orchestration Trigger
 class LegacyOrchestrationTriggerConverter(meta.InConverter,
-                                    meta.OutConverter,
-                                    binding=None,
-                                    trigger=True):
+                                          meta.OutConverter,
+                                          binding=None,
+                                          trigger=True):
     @classmethod
     def check_input_type_annotation(cls, pytype):
         return issubclass(pytype, _durable_functions.OrchestrationContext)
@@ -45,9 +46,9 @@ class LegacyOrchestrationTriggerConverter(meta.InConverter,
 
 # Legacy Durable Function Entity Trigger
 class LegacyEnitityTriggerConverter(meta.InConverter,
-                              meta.OutConverter,
-                              binding=None,
-                              trigger=True):
+                                    meta.OutConverter,
+                                    binding=None,
+                                    trigger=True):
     @classmethod
     def check_input_type_annotation(cls, pytype):
         return issubclass(pytype, _durable_functions.EntityContext)
@@ -76,9 +77,9 @@ class LegacyEnitityTriggerConverter(meta.InConverter,
 
 # Legacy Durable Function Activity Trigger
 class LegacyActivityTriggerConverter(meta.InConverter,
-                               meta.OutConverter,
-                               binding=None,
-                               trigger=True):
+                                     meta.OutConverter,
+                                     binding=None,
+                                     trigger=True):
     @classmethod
     def check_input_type_annotation(cls, pytype):
         # Activity Trigger's arguments should accept any types
@@ -133,8 +134,8 @@ class LegacyActivityTriggerConverter(meta.InConverter,
 
 # Legacy Durable Functions Durable Client Bindings
 class LegacyDurableClientConverter(meta.InConverter,
-                             meta.OutConverter,
-                             binding=None):
+                                   meta.OutConverter,
+                                   binding=None):
     @classmethod
     def has_implicit_output(cls) -> bool:
         return False
@@ -331,7 +332,7 @@ class DurableClientConverter(meta.InConverter,
 
     @classmethod
     def check_input_type_annotation(cls, pytype: type) -> bool:
-        import durabletask.azurefunctions as adf
+        import azure.durable_functions as adf
         return issubclass(pytype, (str, bytes, adf.DurableFunctionsClient))
 
     @classmethod
@@ -363,11 +364,15 @@ class DurableClientConverter(meta.InConverter,
 
     @classmethod
     def decode(cls, data: meta.Datum, *, trigger_metadata) -> typing.Any:
-        from durabletask.azurefunctions.client import DurableFunctionsClient
-        return DurableFunctionsClient(data.value)
+        import azure.durable_functions as adf
+        return adf.DurableFunctionsClient(data.value)
 
 
 def register_durable_converters():
+    """
+    Registers the appropriate Durable Functions converters based on the
+    installed Durable Functions package.
+    """
     _logger.info("Registering Durable Functions converters based on ")
     pkg = get_durable_package()
     if pkg is None:
@@ -382,17 +387,18 @@ def register_durable_converters():
     meta._ConverterMeta._bindings.pop("activityTrigger", None)
     meta._ConverterMeta._bindings.pop("durableClient", None)
 
-    if pkg.__name__ == "azure.durable_functions":
+    if not hasattr(pkg, 'version'):
         _logger.info("Registering Legacy Durable Functions converters.")
         meta._ConverterMeta._bindings["orchestrationTrigger"] = LegacyOrchestrationTriggerConverter
         meta._ConverterMeta._bindings["entityTrigger"] = LegacyEnitityTriggerConverter
         meta._ConverterMeta._bindings["activityTrigger"] = LegacyActivityTriggerConverter
         meta._ConverterMeta._bindings["durableClient"] = LegacyDurableClientConverter
-    else:
+    elif hasattr(pkg, 'version') and pkg.version.startswith("2."):
         _logger.info("Registering Durable Task Durable Functions converters.")
         meta._ConverterMeta._bindings["orchestrationTrigger"] = OrchestrationTriggerConverter
         meta._ConverterMeta._bindings["entityTrigger"] = EnitityTriggerConverter
         meta._ConverterMeta._bindings["activityTrigger"] = ActivityTriggerConverter
         meta._ConverterMeta._bindings["durableClient"] = DurableClientConverter
+
     _logger.info("Durable Functions converters registered.")
     _logger.info("Current bindings after registration: %s", meta._ConverterMeta._bindings)

{azure_functions-1.25.0b3.dev1 → azure_functions-1.25.0b3.dev3/azure_functions.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: azure-functions
-Version: 1.25.0b3.dev1
+Version: 1.25.0b3.dev3
 Summary: Python library for Azure Functions.
 Author-email: "Azure Functions team at Microsoft Corp." <azurefunctions@microsoft.com>
 License: MIT License

{azure_functions-1.25.0b3.dev1 → azure_functions-1.25.0b3.dev3}/tests/test_durable_functions.py

@@ -5,10 +5,10 @@ import unittest
 import json
 
 from azure.functions.durable_functions import (
-    OrchestrationTriggerConverter,
-    EnitityTriggerConverter,
-    ActivityTriggerConverter,
-    DurableClientConverter
+    LegacyOrchestrationTriggerConverter,
+    LegacyEnitityTriggerConverter,
+    LegacyActivityTriggerConverter,
+    LegacyDurableClientConverter
 )
 from azure.functions._durable_functions import (
     OrchestrationContext,
@@ -17,7 +17,7 @@ from azure.functions._durable_functions import (
 from azure.functions.meta import Datum
 
 CONTEXT_CLASSES = [OrchestrationContext, EntityContext]
-CONVERTERS = [OrchestrationTriggerConverter, EnitityTriggerConverter]
+CONVERTERS = [LegacyOrchestrationTriggerConverter, LegacyEnitityTriggerConverter]
 
 
 class TestDurableFunctions(unittest.TestCase):
@@ -127,7 +127,7 @@ class TestDurableFunctions(unittest.TestCase):
         ]
 
         for datum in data:
-            decoded = ActivityTriggerConverter.decode(
+            decoded = LegacyActivityTriggerConverter.decode(
                 data=datum['input'],
                 trigger_metadata=None)
             self.assertEqual(decoded, datum['expected_value'])
@@ -160,7 +160,7 @@ class TestDurableFunctions(unittest.TestCase):
         ]
 
         for datum in data:
-            encoded = ActivityTriggerConverter.encode(
+            encoded = LegacyActivityTriggerConverter.encode(
                 obj=datum['output'],
                 expected_type=type(datum['output']))
             self.assertEqual(encoded, datum['expected_value'])
@@ -173,7 +173,7 @@ class TestDurableFunctions(unittest.TestCase):
         data = NonEncodable()
 
         try:
-            ActivityTriggerConverter.encode(data, expected_type=None)
+            LegacyActivityTriggerConverter.encode(data, expected_type=None)
         except ValueError as e:
             self.assertIsNotNone(e.__cause__)
             self.assertIsInstance(e.__cause__, TypeError)
@@ -217,7 +217,7 @@ class TestDurableFunctions(unittest.TestCase):
         ]
 
         for datum in data:
-            decoded = ActivityTriggerConverter.decode(
+            decoded = LegacyActivityTriggerConverter.decode(
                 data=datum['input'],
                 trigger_metadata=None)
             self.assertEqual(decoded, datum['expected_value'])
@@ -226,7 +226,7 @@ class TestDurableFunctions(unittest.TestCase):
         data = Datum('{"value": "bar"}', 'json')
 
         try:
-            ActivityTriggerConverter.decode(
+            LegacyActivityTriggerConverter.decode(
                 data=data,
                 trigger_metadata=None)
         except ValueError as e:
@@ -235,17 +235,17 @@ class TestDurableFunctions(unittest.TestCase):
 
     def test_activity_trigger_has_implicit_return(self):
         self.assertTrue(
-            ActivityTriggerConverter.has_implicit_output()
+            LegacyActivityTriggerConverter.has_implicit_output()
         )
 
     def test_durable_client_no_implicit_return(self):
         self.assertFalse(
-            DurableClientConverter.has_implicit_output()
+            LegacyDurableClientConverter.has_implicit_output()
         )
 
     def test_enitity_trigger_check_output_type_annotation(self):
         self.assertTrue(
-            EnitityTriggerConverter.check_output_type_annotation(pytype=None)
+            LegacyEnitityTriggerConverter.check_output_type_annotation(pytype=None)
         )
 
     def test_activity_trigger_converter_decode_no_implementation_exception(
@@ -254,7 +254,7 @@ class TestDurableFunctions(unittest.TestCase):
         datum = Datum(value=b"dummy", type="bytes")
         # when
         try:
-            ActivityTriggerConverter.decode(data=datum, trigger_metadata=None)
+            LegacyActivityTriggerConverter.decode(data=datum, trigger_metadata=None)
         except NotImplementedError:
             is_exception_raised = True
 
@@ -265,82 +265,82 @@ class TestDurableFunctions(unittest.TestCase):
 
         data = '{"dummy_key": "dummy_value"}'
 
-        result = EnitityTriggerConverter.encode(
+        result = LegacyEnitityTriggerConverter.encode(
             obj=data, expected_type=None)
 
         self.assertEqual(result.type, "json")
         self.assertEqual(result.python_value, {'dummy_key': 'dummy_value'})
 
     def test_durable_client_converter_has_trigger_support(self):
-        self.assertFalse(DurableClientConverter.has_trigger_support())
+        self.assertFalse(LegacyDurableClientConverter.has_trigger_support())
 
     def test_durable_client_converter_check_input_type_annotation(self):
-        self.assertTrue(DurableClientConverter.check_input_type_annotation(str))
-        self.assertTrue(DurableClientConverter.check_input_type_annotation(bytes))
-        self.assertFalse(DurableClientConverter.check_input_type_annotation(int))
+        self.assertTrue(LegacyDurableClientConverter.check_input_type_annotation(str))
+        self.assertTrue(LegacyDurableClientConverter.check_input_type_annotation(bytes))
+        self.assertFalse(LegacyDurableClientConverter.check_input_type_annotation(int))
 
     def test_durable_client_converter_check_output_type_annotation(self):
-        self.assertTrue(DurableClientConverter.check_output_type_annotation(str))
-        self.assertTrue(DurableClientConverter.check_output_type_annotation(bytes))
-        self.assertTrue(DurableClientConverter.check_output_type_annotation(bytearray))
-        self.assertFalse(DurableClientConverter.check_output_type_annotation(int))
+        self.assertTrue(LegacyDurableClientConverter.check_output_type_annotation(str))
+        self.assertTrue(LegacyDurableClientConverter.check_output_type_annotation(bytes))
+        self.assertTrue(LegacyDurableClientConverter.check_output_type_annotation(bytearray))
+        self.assertFalse(LegacyDurableClientConverter.check_output_type_annotation(int))
 
     def test_durable_client_converter_encode(self):
-        datum = DurableClientConverter.encode(obj="hello", expected_type=str)
+        datum = LegacyDurableClientConverter.encode(obj="hello", expected_type=str)
         self.assertEqual(datum.type, "string")
         self.assertEqual(datum.value, "hello")
 
-        datum = DurableClientConverter.encode(obj=b"data", expected_type=bytes)
+        datum = LegacyDurableClientConverter.encode(obj=b"data", expected_type=bytes)
         self.assertEqual(datum.type, "bytes")
         self.assertEqual(datum.value, b"data")
 
-        datum = DurableClientConverter.encode(obj=None, expected_type=None)
+        datum = LegacyDurableClientConverter.encode(obj=None, expected_type=None)
         self.assertIsNone(datum.type)
         self.assertIsNone(datum.value)
 
-        datum = DurableClientConverter.encode(obj={"a": 1}, expected_type=dict)
+        datum = LegacyDurableClientConverter.encode(obj={"a": 1}, expected_type=dict)
         self.assertEqual(datum.type, "dict")
         self.assertEqual(datum.value, {"a": 1})
 
-        datum = DurableClientConverter.encode(obj=[1, 2], expected_type=list)
+        datum = LegacyDurableClientConverter.encode(obj=[1, 2], expected_type=list)
         self.assertEqual(datum.type, "list")
         self.assertEqual(datum.value, [1, 2])
 
-        datum = DurableClientConverter.encode(obj=42, expected_type=int)
+        datum = LegacyDurableClientConverter.encode(obj=42, expected_type=int)
         self.assertEqual(datum.type, "int")
         self.assertEqual(datum.value, 42)
 
-        datum = DurableClientConverter.encode(obj=3.14, expected_type=float)
+        datum = LegacyDurableClientConverter.encode(obj=3.14, expected_type=float)
         self.assertEqual(datum.type, "double")
         self.assertEqual(datum.value, 3.14)
 
-        datum = DurableClientConverter.encode(obj=True, expected_type=bool)
+        datum = LegacyDurableClientConverter.encode(obj=True, expected_type=bool)
         self.assertEqual(datum.type, "bool")
         self.assertTrue(datum.value)
 
         with self.assertRaises(NotImplementedError):
-            DurableClientConverter.encode(obj=set([1, 2]), expected_type=set)
+            LegacyDurableClientConverter.encode(obj=set([1, 2]), expected_type=set)
 
     def test_durable_client_converter_decode(self):
         data = Datum(type="string", value="abc")
-        result = DurableClientConverter.decode(data=data, trigger_metadata=None)
+        result = LegacyDurableClientConverter.decode(data=data, trigger_metadata=None)
         self.assertEqual(result, "abc")
 
         data = Datum(type="bytes", value=b"123")
-        result = DurableClientConverter.decode(data=data, trigger_metadata=None)
+        result = LegacyDurableClientConverter.decode(data=data, trigger_metadata=None)
         self.assertEqual(result, b"123")
 
         data = Datum(type="json", value={"key": "val"})
-        result = DurableClientConverter.decode(data=data, trigger_metadata=None)
+        result = LegacyDurableClientConverter.decode(data=data, trigger_metadata=None)
         self.assertEqual(result, {"key": "val"})
 
         data = Datum(type=None, value=None)
-        result = DurableClientConverter.decode(data=data, trigger_metadata=None)
+        result = LegacyDurableClientConverter.decode(data=data, trigger_metadata=None)
         self.assertIsNone(result)
 
-        result = DurableClientConverter.decode(data=None, trigger_metadata=None)
+        result = LegacyDurableClientConverter.decode(data=None, trigger_metadata=None)
         self.assertIsNone(result)
 
         data = Datum(type="weird", value="???")
         with self.assertRaises(ValueError):
-            DurableClientConverter.decode(data=data, trigger_metadata=None)
+            LegacyDurableClientConverter.decode(data=data, trigger_metadata=None)

azure_functions-1.25.0b3.dev1/azure/functions/decorators/durable_functions.py

@@ -1,59 +0,0 @@
-#  Copyright (c) Microsoft Corporation. All rights reserved.
-#  Licensed under the MIT License.
-import logging
-
-_logger = logging.getLogger('azure.functions.AsgiMiddleware')
-
-df = None
-
-
-def get_durable_package():
-    """Determines which Durable SDK is being used.
-
-    If the `azure-functions-durable` package is installed, we
-    log a warning that this legacy package
-    is deprecated.
-
-    If both the legacy and current packages are installed,
-    we log a warning and prefer the current package.
-
-    If neither package is installed, we return None.    
-    """
-    _logger.info("Attempting to import Durable Functions package.")
-    using_legacy = False
-    using_durable_task = False
-    global df
-    if df:
-        _logger.info("Durable Functions package already loaded. DF: %s", df)
-        return df
-
-    try:
-        import azure.durable_functions as durable_functions
-        using_legacy = True
-        _logger.warning("`durabletask-azurefunctions` is available now! " \
-        "See <AKA.MS LINK HERE> for more details.")
-    except ImportError:
-        _logger.info("`azure-functions-durable` package not found.")
-        pass
-    try:
-        import durabletask.azurefunctions as durable_functions
-        using_durable_task = True
-    except ImportError:
-        _logger.info("`durabletask-azurefunctions` package not found.")
-        pass
-
-    if using_durable_task and using_legacy:
-        # Both packages are installed; prefer `durabletask-azurefunctions`.
-        _logger.warning("Both `azure-functions-durable` and " \
-        "`durabletask-azurefunctions` packages are installed. " \
-        "This may lead to unexpected behavior. Please resolve this " \
-        "conflict by removing one of these packages from the Python " \
-        "environment. Decorators from `durabletask-azurefunctions` will " \
-        "be used.")
-    
-    if not using_durable_task and not using_legacy:
-        return None
-
-    df = durable_functions
-
-    return durable_functions