Naming consistency

Author: andystaples

azure/durable_functions/models/DurableOrchestrationContext.py

@@ -492,7 +492,7 @@ def parent_instance_id(self) -> str:
         return self._parent_instance_id
 
     @property
-    def maximum_short_timer_duration(self) -> datetime.timedelta:
+    def _maximum_short_timer_duration(self) -> datetime.timedelta:
         """Get the maximum duration for a short timer.
 
         The maximum length of a "short timer" is defined by the storage backend.
@@ -508,7 +508,7 @@ def maximum_short_timer_duration(self) -> datetime.timedelta:
         return self._maximum_short_timer_duration
 
     @property
-    def long_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
@@ -632,7 +632,7 @@ 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_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, "
@@ -641,10 +641,10 @@ def create_timer(self, fire_at: datetime.datetime) -> TaskBase:
                     "This is likely an issue with the Durable Functions Extension. "
                     "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_timer_interval_duration}"
+                    f"maximumShortTimerDuration: {self._maximum_short_timer_duration}\n"
+                    f"longRunningTimerIntervalDuration: {self._long_timer_interval_duration}"
                 )
-            if fire_at > self.current_utc_datetime + self.maximum_short_timer_duration:
+            if fire_at > self.current_utc_datetime + self._maximum_short_timer_duration:
                 action = CreateTimerAction(fire_at)
                 return LongTimerTask(None, action, self)
 

azure/durable_functions/models/Task.py

@@ -321,7 +321,7 @@ def try_set_value(self, child: TaskBase):
 class LongTimerTask(WhenAllTask):
     """A Timer Task for intervals longer than supported by the storage backend."""
 
-    def __init__(self, id, action: CreateTimerAction, orchestration_context):
+    def __init__(self, id_, action: CreateTimerAction, orchestration_context):
         """Initialize a LongTimerTask.
 
         Parameters
@@ -337,20 +337,20 @@ def __init__(self, id, action: CreateTimerAction, orchestration_context):
         final_fire_time = action.fire_at
         duration_until_fire = final_fire_time - current_time
 
-        if duration_until_fire > orchestration_context.maximum_short_timer_duration:
-            next_fire_time = current_time + orchestration_context.long_timer_interval_duration
+        if duration_until_fire > orchestration_context._maximum_short_timer_duration:
+            next_fire_time = current_time + orchestration_context._long_timer_interval_duration
         else:
             next_fire_time = final_fire_time
 
         next_timer_action = CreateTimerAction(next_fire_time)
         next_timer_task = TimerTask(None, next_timer_action)
         super().__init__([next_timer_task], orchestration_context._replay_schema)
 
-        self.id = id
+        self.id = id_
         self.action = action
-        self.orchestration_context = orchestration_context
-        self.maximum_short_timer_duration = self.orchestration_context.maximum_short_timer_duration
-        self.long_timer_interval_duration = self.orchestration_context.long_timer_interval_duration
+        self._orchestration_context = orchestration_context
+        self._max_short_timer_duration = self._orchestration_context._maximum_short_timer_duration
+        self._long_timer_interval = self._orchestration_context._long_timer_interval_duration
 
     def is_canceled(self) -> bool:
         """Check if the LongTimer is cancelled.
@@ -385,7 +385,7 @@ def try_set_value(self, child: TimerTask):
         child : TimerTask
             A timer sub-task that just completed
         """
-        current_time = self.orchestration_context.current_utc_datetime
+        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)
@@ -408,8 +408,8 @@ def get_next_timer_task(self, final_fire_time: datetime, current_time: datetime)
             A TimerTask representing the next interval of the LongTimer
         """
         duration_until_fire = final_fire_time - current_time
-        if duration_until_fire > self.maximum_short_timer_duration:
-            next_fire_time = current_time + self.long_timer_interval_duration
+        if duration_until_fire > self._max_short_timer_duration:
+            next_fire_time = current_time + self._long_timer_interval
         else:
             next_fire_time = final_fire_time
         return TimerTask(None, CreateTimerAction(next_fire_time))
@@ -426,8 +426,8 @@ def add_new_child(self, child_timer: TimerTask):
         """
         child_timer.parent = self
         self.pending_tasks.add(child_timer)
-        self.orchestration_context._add_to_open_tasks(child_timer)
-        self.orchestration_context._add_to_actions(child_timer.action_repr)
+        self._orchestration_context._add_to_open_tasks(child_timer)
+        self._orchestration_context._add_to_actions(child_timer.action_repr)
         child_timer._set_is_scheduled(True)
 
 

tests/tasks/test_long_timers.py

@@ -43,28 +43,28 @@ def test_long_timer_fires_appropriately(starting_context_v3):
     starting_time = starting_context_v3.current_utc_datetime
     final_fire_time = starting_time + datetime.timedelta(hours=20)
     long_timer_action = CreateTimerAction(final_fire_time)
-    long_timer_task = LongTimerTask(None, long_timer_action, starting_context_v3)
-    assert long_timer_task.action.fire_at == final_fire_time
-    assert long_timer_task.action == long_timer_action
+    long_timer = LongTimerTask(None, long_timer_action, starting_context_v3)
+    assert long_timer.action.fire_at == final_fire_time
+    assert long_timer.action == long_timer_action
 
     # Check the first "inner" timer and simulate firing it
-    short_timer_task = long_timer_task.pending_tasks.pop()
-    assert short_timer_task.action_repr.fire_at == starting_time + datetime.timedelta(hours=8)
+    short_timer = long_timer.pending_tasks.pop()
+    assert short_timer.action_repr.fire_at == starting_time + datetime.timedelta(hours=8)
     # This happens when the task is reconstructed during replay, doing it manually for the test
-    long_timer_task.orchestration_context.current_utc_datetime = short_timer_task.action_repr.fire_at
-    short_timer_task.state = TaskState.SUCCEEDED 
-    long_timer_task.try_set_value(short_timer_task)
+    long_timer._orchestration_context.current_utc_datetime = short_timer.action_repr.fire_at
+    short_timer.state = TaskState.SUCCEEDED 
+    long_timer.try_set_value(short_timer)
 
-    assert long_timer_task.state == TaskState.RUNNING
+    assert long_timer.state == TaskState.RUNNING
 
     # Check the scond "inner" timer and simulate firing it. This one should be set to the final
     # fire time, the remaining time (12 hours) is less than the max long timer duration (16 hours)
-    short_timer_task = long_timer_task.pending_tasks.pop()
-    assert short_timer_task.action_repr.fire_at == final_fire_time
-    long_timer_task.orchestration_context.current_utc_datetime = short_timer_task.action_repr.fire_at
-    short_timer_task.state = TaskState.SUCCEEDED 
-    long_timer_task.try_set_value(short_timer_task)
+    short_timer = long_timer.pending_tasks.pop()
+    assert short_timer.action_repr.fire_at == final_fire_time
+    long_timer._orchestration_context.current_utc_datetime = short_timer.action_repr.fire_at
+    short_timer.state = TaskState.SUCCEEDED 
+    long_timer.try_set_value(short_timer)
 
     # Ensure the LongTimerTask finished
-    assert len(long_timer_task.pending_tasks) == 0
-    assert long_timer_task.state == TaskState.SUCCEEDED
+    assert len(long_timer.pending_tasks) == 0
+    assert long_timer.state == TaskState.SUCCEEDED