class_docstr: Task Scheduling controller.
  Notice time-zone is ALWAYS UTC
class_docstr_tok: ["Task","Scheduling","controller",".","Notice","time-zone","is","ALWAYS","UTC"]
docstr: Update the configuration and execution table plots
docstr_tok: ["Update","the","configuration","and","execution","table","plots"]
code: def _update_execution_plots(self):
      # type: () -> None
      """
      Update the configuration and execution table plots
      """
      if not self._task:
          return
  
      task_link_template = (
          self._task.get_output_log_web_page()
          .replace("/{}/".format(self._task.project), "/{project}/")
          .replace("/{}/".format(self._task.id), "/{task}/")
      )
  
      # plot the schedule definition
      columns = [
          "name",
          "base_task_id",
          "base_function",
          "next_run",
          "target_project",
          "queue",
          "minute",
          "hour",
          "day",
          "month",
          "year",
          "starting_time",
          "execution_limit_hours",
          "recurring",
          "single_instance",
          "task_parameters",
          "task_overrides",
          "clone_task",
      ]
      scheduler_table = [columns]
      for j in self._schedule_jobs:
          j_dict = j.to_dict()
          j_dict["next_run"] = j.next()
          j_dict["base_function"] = (
              "{}.{}".format(
                  getattr(j.base_function, "__module__", ""),
                  getattr(j.base_function, "__name__", ""),
              )
              if j.base_function
              else ""
          )
  
          if not j_dict.get("base_task_id"):
              j_dict["clone_task"] = ""
  
          row = [
              str(j_dict.get(c)).split(".", 1)[0]
              if isinstance(j_dict.get(c), datetime)
              else str(j_dict.get(c) or "")
              for c in columns
          ]
          if row[1]:
              row[1] = '<a href="{}">{}</a>'.format(
                  task_link_template.format(project="*", task=row[1]),
                  row[1],
              )
          scheduler_table += [row]
  
      # plot the already executed Tasks
      executed_table = [["name", "task id", "started", "finished"]]
      for executed_job in sorted(
          self._executed_jobs, key=lambda x: x.started, reverse=True
      ):
          if not executed_job.finished:
              if executed_job.task_id:
                  t = Task.get_task(task_id=executed_job.task_id)
                  if t.status not in ("in_progress", "queued"):
                      executed_job.finished = (
                          t.data.completed or datetime.utcnow()
                      )
              elif executed_job.thread_id:
                  # noinspection PyBroadException
                  try:
                      a_thread = [
                          t
                          for t in enumerate_threads()
                          if t.ident == executed_job.thread_id
                      ]
                      if not a_thread or not a_thread[0].is_alive():
                          executed_job.finished = datetime.utcnow()
                  except Exception:
                      pass
  
          executed_table += [
              [
                  executed_job.name,
                  '<a href="{}">{}</a>'.format(
                      task_link_template.format(
                          project="*", task=executed_job.task_id
                      ),
                      executed_job.task_id,
                  )
                  if executed_job.task_id
                  else "function",
                  str(executed_job.started).split(".", 1)[0],
                  str(executed_job.finished).split(".", 1)[0],
              ]
          ]
  
      self._task.get_logger().report_table(
          title="Schedule Tasks",
          series=" ",
          iteration=0,
          table_plot=scheduler_table,
      )
      self._task.get_logger().report_table(
          title="Executed Tasks",
          series=" ",
          iteration=0,
          table_plot=executed_table,
      )
  
imports: import json
  import logging
  from datetime import datetime
  from threading import Thread, enumerate
  from time import sleep, time
  from typing import List, Union, Optional, Callable, Sequence, Dict
  from attr import attrs, attrib
  from dateutil.relativedelta import relativedelta
  from .job import ClearmlJob
  from .controller import PipelineController
  from ..backend_interface.util import datetime_from_isoformat, datetime_to_isoformat, mutually_exclusive
  from ..task import Task
label_desc: Use image node_id 14 for calling the TaskScheduler obj's underlying member method code with example usage: obj._update_execution_plots() without return types