Linter fixes

Author: andystaples

azure/durable_functions/models/DurableOrchestrationContext.py

@@ -26,7 +26,7 @@
 from uuid import UUID, uuid5, NAMESPACE_URL, NAMESPACE_OID
 from datetime import timezone
 
-from azure.durable_functions.models.utils.json_utils import parse_datetime_attrib_timespan
+from azure.durable_functions.models.utils.json_utils import parse_timespan_attrib
 
 from .RetryOptions import RetryOptions
 from .FunctionContext import FunctionContext
@@ -51,18 +51,20 @@ class DurableOrchestrationContext:
     def __init__(self,
                  history: List[Dict[Any, Any]], instanceId: str, isReplaying: bool,
                  parentInstanceId: str, input: Any = None, upperSchemaVersion: int = 0,
-                 maximumShortTimerDuration=None, longRunningTimerIntervalDuration=None,
-                 upperSchemaVersionNew = None, **kwargs):
+                 maximumShortTimerDuration:str = None, longRunningTimerIntervalDuration:str = None,
+                 upperSchemaVersionNew:int = None, **kwargs):
         self._histories: List[HistoryEvent] = [HistoryEvent(**he) for he in history]
         self._instance_id: str = instanceId
         self._is_replaying: bool = isReplaying
         self._parent_instance_id: str = parentInstanceId
         self._maximum_short_timer_duration: datetime.timedelta
         if maximumShortTimerDuration is not None:
-            self._maximum_short_timer_duration = parse_datetime_attrib_timespan(maximumShortTimerDuration)
-        self._long_running_timer_interval_duration: datetime.timedelta
+            max_short_duration = parse_timespan_attrib(maximumShortTimerDuration)
+            self._maximum_short_timer_duration = max_short_duration
+        self._long_timer_interval_duration: datetime.timedelta
         if longRunningTimerIntervalDuration is not None:
-            self._long_running_timer_interval_duration = parse_datetime_attrib_timespan(longRunningTimerIntervalDuration)
+            long_interval_duration = parse_timespan_attrib(longRunningTimerIntervalDuration)
+            self._long_timer_interval_duration = long_interval_duration
         self._custom_status: Any = None
         self._new_uuid_counter: int = 0
         self._sub_orchestrator_counter: int = 0
@@ -485,7 +487,7 @@ def parent_instance_id(self) -> str:
 
     @property
     def maximum_short_timer_duration(self) -> datetime.timedelta:
-        """Get the maximum duration for a short timer
+        """Get the maximum duration for a short timer.
 
         The maximum length of a "short timer" is defined by the storage backend.
         Some storage backends have a maximum future date for scheduled tasks, and
@@ -500,7 +502,7 @@ def maximum_short_timer_duration(self) -> datetime.timedelta:
         return self._maximum_short_timer_duration
 
     @property
-    def long_running_timer_interval_duration(self) -> datetime.timedelta:
+    def long_timer_interval_duration(self) -> datetime.timedelta:
         """Get the interval for long timers.
 
         When a timer is scheduled for a duration longer than the maximum short timer
@@ -512,7 +514,7 @@ def long_running_timer_interval_duration(self) -> datetime.timedelta:
         str
             Duration for intervals of a long-running timer
         """
-        return self._long_running_timer_interval_duration
+        return self._long_timer_interval_duration
 
     @property
     def current_utc_datetime(self) -> datetime.datetime:
@@ -624,18 +626,21 @@ def create_timer(self, fire_at: datetime.datetime) -> TaskBase:
             A Durable Timer Task that schedules the timer to wake up the activity
         """
         if self._replay_schema.value >= ReplaySchema.V3.value:
-            if not self.maximum_short_timer_duration or not self.long_running_timer_interval_duration:
+            if not self.maximum_short_timer_duration or not self.long_timer_interval_duration:
                 raise Exception(
-                    "A framework-internal error was detected: replay schema version >= V3 is being used, " +
-                        "but one or more of the properties `maximumShortTimerDuration` and `longRunningTimerIntervalDuration` are not defined. " +
+                    "A framework-internal error was detected: " +
+                        "replay schema version >= V3 is being used, " +
+                        "but one or more of the properties `maximumShortTimerDuration`" +
+                        "and `longRunningTimerIntervalDuration` are not defined. " +
                         "This is likely an issue with the Durable Functions Extension. " +
-                        "Please report this bug here: https://github.com/Azure/azure-functions-durable-js/issues\n" +
+                        "Please report this bug here: " + 
+                        "https://github.com/Azure/azure-functions-durable-python/issues\n" +
                         f"maximumShortTimerDuration: {self.maximum_short_timer_duration}\n" +
-                        f"longRunningTimerIntervalDuration: {self.long_running_timer_interval_duration}"
+                        f"longRunningTimerIntervalDuration: {self.long_timer_interval_duration}"
                 )
             if fire_at > self.current_utc_datetime + self.maximum_short_timer_duration:
                 action = CreateTimerAction(fire_at)
-                return LongTimerTask(None, action, self, None, self.maximum_short_timer_duration, self.long_running_timer_interval_duration)
+                return LongTimerTask(None, action, self)
 
         action = CreateTimerAction(fire_at)
         task = self._generate_task(action, task_constructor=TimerTask)
@@ -713,7 +718,8 @@ def _add_to_actions(self, action_repr: Union[List[Action], Action]):
 
         if self._replay_schema is ReplaySchema.V1 and isinstance(action_repr, list):
             self._action_payload_v1.append(action_repr)
-        elif self._replay_schema.value >= ReplaySchema.V2.value and isinstance(action_repr, Action):
+        elif (self._replay_schema.value >= ReplaySchema.V2.value 
+              and isinstance(action_repr, Action)):
             self._action_payload_v2.append(action_repr)
         else:
             raise Exception(f"DF-internal exception: ActionRepr of signature {type(action_repr)}"

azure/durable_functions/models/Task.py

@@ -319,13 +319,26 @@ def try_set_value(self, child: TaskBase):
 
 
 class LongTimerTask(WhenAllTask):
-    def __init__(self, id, action: CreateTimerAction, orchestration_context, executor, maximum_timer_length, long_running_timer_duration):
+    """A Timer Task for intervals longer than supported by the storage backend."""
+
+    def __init__(self, id, action: CreateTimerAction, orchestration_context):
+        """Initialize a LongTimerTask.
+
+        Parameters
+        ----------
+        id_ : int
+            An ID for the task
+        action : CreateTimerAction
+            The action this task represents
+        orchestration_context: DurableOrchestrationContext
+            The orchestration context this task was created in
+        """
         current_time = orchestration_context.current_utc_datetime
         final_fire_time = action.fire_at
         duration_until_fire = final_fire_time - current_time
 
-        if duration_until_fire > maximum_timer_length:
-            next_fire_time = current_time + long_running_timer_duration
+        if duration_until_fire > self.orchestration_context.maximum_timer_length:
+            next_fire_time = current_time + self.orchestration_context.long_running_timer_duration
         else:
             next_fire_time = final_fire_time
 
@@ -336,35 +349,79 @@ def __init__(self, id, action: CreateTimerAction, orchestration_context, executo
         self.id = id
         self.action = action
         self.orchestration_context = orchestration_context
-        self.executor = executor
-        self.maximum_timer_length = maximum_timer_length
-        self.long_running_timer_duration = long_running_timer_duration
+        self.maximum_timer_length = self.orchestration_context.maximum_timer_length
+        self.long_running_timer_duration = self.orchestration_context.long_running_timer_duration
 
     def is_canceled(self) -> bool:
+        """Check if the LongTimer is cancelled.
+
+        Returns
+        -------
+        bool
+            Returns whether the timer has been cancelled or not
+        """
         return self.action.is_cancelled
-    
+
     def cancel(self):
+        """Cancel a timer.
+
+        Raises
+        ------
+        ValueError
+            Raises an error if the task is already completed and an attempt is made to cancel it
+        """
         if (self.result):
             raise Exception("Cannot cancel a completed task.")
         self.action.is_cancelled = True
 
     def try_set_value(self, child: TimerTask):
+        """Transition this LongTimer Task to a terminal state and set its value.
+
+        If the LongTimer has not yet reached the designated completion time, starts a new 
+        TimerTask for the next interval and does not close. 
+
+        Parameters
+        ----------
+        child : TimerTask
+            A timer sub-task that just completed
+        """
         current_time = self.orchestration_context.current_utc_datetime
         final_fire_time = self.action.fire_at
         if final_fire_time > current_time:
             next_timer = self.get_next_timer_task(final_fire_time, current_time)
             self.add_new_child(next_timer)
         return super().try_set_value(child)
-    
-    def get_next_timer_task(self, final_fire_time:datetime, current_time:datetime):
+
+    def get_next_timer_task(self, final_fire_time: datetime, current_time: datetime) -> TimerTask: 
+        """Creates a TimerTask that represents the next interval of the LongTimer
+
+        Parameters
+        ----------
+        final_fire_time : datetime.datetime
+            The final firing time of the LongTimer
+        current_time : datetime.datetime
+            The current time
+
+        Returns
+        -------
+        TimerTask
+            A TimerTask representing the next interval of the LongTimer
+        """
         duration_until_fire = final_fire_time - current_time
         if duration_until_fire > self.maximum_timer_length:
             next_fire_time = current_time + self.long_running_timer_duration
         else:
             next_fire_time = final_fire_time
         return TimerTask(None, CreateTimerAction(next_fire_time))
-    
+
     def add_new_child(self, child_timer: TimerTask):
+        """Adds the TimerTask to this Task's children and schedules it in the orchestrationcontext
+
+        Parameters
+        ----------
+        child_timer : TimerTask
+            The newly created TimerTask to add
+        """
         child_timer.parent = self
         self.pending_tasks.add(child_timer)
         self.orchestration_context._add_to_open_tasks(child_timer)

azure/durable_functions/models/utils/json_utils.py

@@ -38,12 +38,13 @@ def add_datetime_attrib(json_dict: Dict[str, Any], object_,
         json_dict[alt_name or attribute_name] = \
             getattr(object_, attribute_name).strftime(DATETIME_STRING_FORMAT)
 
-# When we recieve properties from WebJobs extension originally parsed as TimeSpan objects through Newtonsoft, 
-#   the format complies with the constant format specifier for TimeSpan in .NET. 
-#   See https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-timespan-format-strings#the-constant-c-format-specifier
-#   Python offers no convenient way to parse these back into timedeltas, so we use this regex method instead
-def parse_datetime_attrib_timespan(from_str: str) -> datetime.timedelta:
-    """Converts a string originally produced by TimeSpan.ToString("c") in .NET into python's timespan.timedelta
+# When we recieve properties from WebJobs extension originally parsed as 
+#   TimeSpan objects through Newtonsoft, the format complies with the constant 
+#   format specifier for TimeSpan in .NET.
+#   Python offers no convenient way to parse these back into timedeltas, 
+#   so we use this regex method instead
+def parse_timespan_attrib(from_str: str) -> datetime.timedelta:
+    """Converts a string representing TimeSpan.ToString("c") in .NET to python timespan.timedelta
 
     Parameters
     ----------
@@ -55,9 +56,16 @@ def parse_datetime_attrib_timespan(from_str: str) -> datetime.timedelta:
         The TimeSpan expressed as a Python datetime.timedelta
 
     """
-    match = re.match(r"^(-)?(?:([0-9]*)\.)?([0-9]{2}):([0-9]{2}):([0-9]{2})(?:\.([0-9]{7}))?$", from_str)
+    expr = r"^(-)?(?:([0-9]*)\.)?([0-9]{2}):([0-9]{2}):([0-9]{2})(?:\.([0-9]{7}))?$"
+    match = re.match(expr, from_str)
     if match:
-        span = datetime.timedelta(days=int(match.group(2) or "0"), hours=int(match.group(3)), minutes=int(match.group(4)), seconds=int(match.group(5)), microseconds=int(match.group(6) or "0") // 10)
+        span = datetime.timedelta(
+            days=int(match.group(2) or "0"), 
+            hours=int(match.group(3)), 
+            minutes=int(match.group(4)), 
+            seconds=int(match.group(5)), 
+            microseconds=int(match.group(6) or "0") // 10)
+        
         if match.group(1):
             span = -span
         return span