docs: def _check_for_dyn_timed_auto_backup(self):
          """ The method implements the timed storage feature.
  
           The method re-initiating a new timed thread if the state-machine not already stored to backup
           (what could be caused by the force_temp_storage_interval) or force the storing of the state-machine if there
           is no new request for a timed backup. New timed backup request are intrinsically represented by
           self._timer_request_time and initiated by the check_for_auto_backup-method.
           The feature uses only one thread for each ModificationHistoryModel and lock to be thread save.
          """
          current_time = time.time()
          self.timer_request_lock.acquire()
          # sm = self.state_machine_model.state_machine
          # TODO check for self._timer_request_time is None to avoid and reset auto-backup in case and fix it better
          if self._timer_request_time is None:
              # logger.warning("timer_request is None")
              return self.timer_request_lock.release()
          if self.timed_temp_storage_interval < current_time - self._timer_request_time:
              # logger.info("{0} Perform timed auto-backup of state-machine {1}.".format(time.time(),
              #                                                                          sm.state_machine_id))
              self.check_for_auto_backup(force=True)
          else:
              duration_to_wait = self.timed_temp_storage_interval - (current_time - self._timer_request_time)
              hard_limit_duration_to_wait = self.force_temp_storage_interval - (current_time - self.last_backup_time)
              hard_limit_active = hard_limit_duration_to_wait < duration_to_wait
              # logger.info('{2} restart_thread {0} time to go {1}, hard limit {3}'.format(sm.state_machine_id,
              #                                                                            duration_to_wait, time.time(),
              #                                                                            hard_limit_active))
              if hard_limit_active:
                  self.set_timed_thread(hard_limit_duration_to_wait, self.check_for_auto_backup, True)
              else:
                  self.set_timed_thread(duration_to_wait, self._check_for_dyn_timed_auto_backup)
          self.timer_request_lock.release()