ddeutil-workflow 0.0.9__py3-none-any.whl → 0.0.10__py3-none-any.whl

ddeutil/workflow/scheduler.py

@@ -5,6 +5,8 @@
 # ------------------------------------------------------------------------------
 from __future__ import annotations
 
+import copy
+import json
 import logging
 import os
 import time
@@ -15,49 +17,189 @@ from datetime import datetime, timedelta
 from functools import wraps
 from heapq import heappush
 from threading import Thread
+from typing import Optional
 from zoneinfo import ZoneInfo
 
-from ddeutil.workflow.__types import DictData
-from ddeutil.workflow.cron import CronRunner
-from ddeutil.workflow.exceptions import WorkflowException
-from ddeutil.workflow.log import FileLog, Log
-from ddeutil.workflow.on import On
-from ddeutil.workflow.pipeline import Pipeline
-from ddeutil.workflow.utils import (
+from dotenv import load_dotenv
+from pydantic import BaseModel, Field
+from pydantic.functional_validators import model_validator
+from typing_extensions import Self
+
+try:
+    from schedule import CancelJob, Scheduler
+except ImportError:
+    raise ImportError(
+        "Should install schedule package before use this module."
+    ) from None
+
+from .__types import DictData
+from .cron import CronRunner
+from .exceptions import WorkflowException
+from .log import FileLog, Log, get_logger
+from .on import On
+from .pipeline import Pipeline
+from .utils import (
+    Loader,
     Result,
     batch,
     delay,
     get_diff_sec,
     param2template,
 )
-from dotenv import load_dotenv
-from schedule import CancelJob, Scheduler
-
-load_dotenv("../../../.env")
-logging.basicConfig(
-    level=logging.DEBUG,
-    format=(
-        "%(asctime)s.%(msecs)03d (%(name)-10s, %(process)-5d, %(thread)-5d) "
-        "[%(levelname)-7s] %(message)-120s (%(filename)s:%(lineno)s)"
-    ),
-    handlers=[logging.StreamHandler()],
-    datefmt="%Y-%m-%d %H:%M:%S",
-)
+
+load_dotenv()
+logger = get_logger("ddeutil.workflow")
 logging.getLogger("schedule").setLevel(logging.INFO)
 
-tz: ZoneInfo = ZoneInfo(os.getenv("WORKFLOW_CORE_TIMEZONE", "UTC"))
+
+__all__ = (
+    "PipelineSchedule",
+    "Schedule",
+    "workflow",
+)
+
+
+class PipelineSchedule(BaseModel):
+    """Pipeline schedule Pydantic Model."""
+
+    name: str = Field(description="A pipeline name.")
+    on: list[On] = Field(
+        default_factory=list,
+        description="An override On instance value.",
+    )
+    params: DictData = Field(
+        default_factory=dict,
+        description="A parameters that want to use to pipeline execution.",
+    )
+
+    @model_validator(mode="before")
+    def __prepare__values(cls, values: DictData) -> DictData:
+        """Prepare incoming values before validating with model fields."""
+
+        values["name"] = values["name"].replace(" ", "_")
+
+        cls.__bypass_on(values)
+        return values
+
+    @classmethod
+    def __bypass_on(cls, data: DictData, externals: DictData | None = None):
+        """Bypass the on data to loaded config data."""
+        if on := data.pop("on", []):
+
+            if isinstance(on, str):
+                on = [on]
+
+            if any(not isinstance(n, (dict, str)) for n in on):
+                raise TypeError("The ``on`` key should be list of str or dict")
+
+            # NOTE: Pass on value to Loader and keep on model object to on field
+            data["on"] = [
+                (
+                    Loader(n, externals=(externals or {})).data
+                    if isinstance(n, str)
+                    else n
+                )
+                for n in on
+            ]
+        return data
+
+
+class Schedule(BaseModel):
+    """Schedule Pydantic Model that use to run with scheduler package. It does
+    not equal the on value in Pipeline model but it use same logic to running
+    release date with crontab interval.
+    """
+
+    desc: Optional[str] = Field(
+        default=None,
+        description=(
+            "A schedule description that can be string of markdown content."
+        ),
+    )
+    pipelines: list[PipelineSchedule] = Field(
+        default_factory=list,
+        description="A list of PipelineSchedule models.",
+    )
+
+    @classmethod
+    def from_loader(
+        cls,
+        name: str,
+        externals: DictData | None = None,
+    ) -> Self:
+        loader: Loader = Loader(name, externals=(externals or {}))
+
+        # NOTE: Validate the config type match with current connection model
+        if loader.type != cls:
+            raise ValueError(f"Type {loader.type} does not match with {cls}")
+
+        loader_data: DictData = copy.deepcopy(loader.data)
+
+        # NOTE: Add name to loader data
+        loader_data["name"] = name.replace(" ", "_")
+
+        return cls.model_validate(obj=loader_data)
+
+    def tasks(
+        self,
+        start_date: datetime,
+        queue: dict[str, list[datetime]],
+        running: dict[str, list[datetime]],
+        externals: DictData | None = None,
+    ) -> list[PipelineTask]:
+        """Generate Task from the current datetime.
+
+        :param start_date: A start date that get from the workflow schedule.
+        :param queue:
+        :param running:
+        :param externals: An external parameters that pass to the Loader object.
+        :rtype: list[PipelineTask]
+        """
+
+        # NOTE: Create pair of pipeline and on.
+        pipeline_tasks: list[PipelineTask] = []
+        externals: DictData = externals or {}
+
+        for pipe in self.pipelines:
+            pipeline: Pipeline = Pipeline.from_loader(
+                pipe.name, externals=externals
+            )
+
+            # NOTE: Create default list of release datetime.
+            queue[pipe.name]: list[datetime] = []
+            running[pipe.name]: list[datetime] = []
+
+            for on in pipeline.on:
+                on_gen = on.generate(start_date)
+                next_running_date = on_gen.next
+                while next_running_date in queue[pipe.name]:
+                    next_running_date = on_gen.next
+
+                heappush(queue[pipe.name], next_running_date)
+
+                pipeline_tasks.append(
+                    PipelineTask(
+                        pipeline=pipeline,
+                        on=on,
+                        params=pipe.params,
+                        queue=queue,
+                        running=running,
+                    ),
+                )
+
+        return pipeline_tasks
 
 
 def catch_exceptions(cancel_on_failure=False):
     """Catch exception error from scheduler job."""
 
-    def catch_exceptions_decorator(job_func):
-        @wraps(job_func)
+    def catch_exceptions_decorator(func):
+        @wraps(func)
         def wrapper(*args, **kwargs):
             try:
-                return job_func(*args, **kwargs)
+                return func(*args, **kwargs)
             except Exception as err:
-                logging.exception(err)
+                logger.exception(err)
                 if cancel_on_failure:
                     return CancelJob
 
@@ -66,136 +208,156 @@ def catch_exceptions(cancel_on_failure=False):
     return catch_exceptions_decorator
 
 
-@dataclass
+def catch_exceptions_method(cancel_on_failure=False):
+    """Catch exception error from scheduler job."""
+
+    def catch_exceptions_decorator(func):
+        @wraps(func)
+        def wrapper(self, *args, **kwargs):
+            try:
+                return func(self, *args, **kwargs)
+            except Exception as err:
+                logger.exception(err)
+                if cancel_on_failure:
+                    return CancelJob
+
+        return wrapper
+
+    return catch_exceptions_decorator
+
+
+@dataclass(frozen=True)
 class PipelineTask:
+    """Pipeline task dataclass that use to keep mapping data and objects for
+    passing in multithreading task.
+    """
+
     pipeline: Pipeline
     on: On
+    params: DictData
     queue: list[datetime]
     running: list[datetime]
 
+    @catch_exceptions_method(cancel_on_failure=True)
+    def release(self, log: Log | None = None) -> None:
+        """Pipeline release, it will use with the same logic of
+        `pipeline.release` method.
 
-def queue2str(queue: list[datetime]) -> Iterator[str]:
-    return (f"{q:%Y-%m-%d %H:%M:%S}" for q in queue)
+        :param log: A log object.
+        """
+        tz: ZoneInfo = ZoneInfo(os.getenv("WORKFLOW_CORE_TIMEZONE", "UTC"))
+        log: Log = log or FileLog
+        pipeline: Pipeline = self.pipeline
+        on: On = self.on
 
+        gen: CronRunner = on.generate(
+            datetime.now(tz=tz).replace(second=0, microsecond=0)
+        )
+        cron_tz: ZoneInfo = gen.tz
 
-def pipeline_release(
-    task: PipelineTask,
-    *,
-    log: Log | None = None,
-) -> None:
-    """Pipeline release, it will use with the same logic of `pipeline.release`
-    method.
+        # NOTE: get next schedule time that generate from now.
+        next_time: datetime = gen.next
 
-    :param task: A PipelineTask dataclass.
-    :param log: A log object.
-    """
-    log: Log = log or FileLog
-    pipeline: Pipeline = task.pipeline
-    on: On = task.on
+        # NOTE: get next utils it does not running.
+        while log.is_pointed(
+            pipeline.name, next_time, queue=self.running[pipeline.name]
+        ):
+            next_time: datetime = gen.next
 
-    gen: CronRunner = on.generate(
-        datetime.now(tz=tz).replace(second=0, microsecond=0)
-    )
-    cron_tz: ZoneInfo = gen.tz
+        logger.debug(
+            f"({pipeline.run_id}) [CORE]: {pipeline.name!r} : {on.cronjob} : "
+            f"{next_time:%Y-%m-%d %H:%M:%S}"
+        )
+        heappush(self.running[pipeline.name], next_time)
 
-    next_running_time: datetime = gen.next
-    while next_running_time in task.running[pipeline.name]:
-        next_running_time: datetime = gen.next
+        if get_diff_sec(next_time, tz=cron_tz) > 55:
+            logger.debug(
+                f"({pipeline.run_id}) [CORE]: {pipeline.name!r} : {on.cronjob} "
+                f": Does not closely >> {next_time:%Y-%m-%d %H:%M:%S}"
+            )
 
-    logging.debug(
-        f"[CORE]: {pipeline.name!r} : {on.cronjob} : "
-        f"{next_running_time:%Y-%m-%d %H:%M:%S}"
-    )
-    heappush(task.running[pipeline.name], next_running_time)
+            # NOTE: Add this next running datetime that not in period to queue
+            #   and remove it to running.
+            self.running[pipeline.name].remove(next_time)
+            heappush(self.queue[pipeline.name], next_time)
 
-    # TODO: event should set on this step for release next pipeline task?
+            time.sleep(0.2)
+            return
 
-    if get_diff_sec(next_running_time, tz=cron_tz) > 55:
-        logging.debug(
+        logger.debug(
             f"({pipeline.run_id}) [CORE]: {pipeline.name!r} : {on.cronjob} : "
-            f"Does not closely >> {next_running_time:%Y-%m-%d %H:%M:%S}"
+            f"Closely to run >> {next_time:%Y-%m-%d %H:%M:%S}"
         )
 
-        # NOTE: Add this next running datetime to queue
-        heappush(task.queue[pipeline.name], next_running_time)
-        task.running[pipeline.name].remove(next_running_time)
+        # NOTE: Release when the time is nearly to schedule time.
+        while (duration := get_diff_sec(next_time, tz=tz)) > (15 + 5):
+            logger.debug(
+                f"({pipeline.run_id}) [CORE]: {pipeline.name!r} : {on.cronjob} "
+                f": Sleep until: {duration}"
+            )
+            time.sleep(15)
+
         time.sleep(0.5)
-        return
 
-    logging.debug(
-        f"({pipeline.run_id}) [CORE]: {pipeline.name!r} : {on.cronjob} : "
-        f"Closely to run >> {next_running_time:%Y-%m-%d %H:%M:%S}"
-    )
+        # NOTE: Release parameter that use to change if params has
+        #   templating.
+        release_params: DictData = {
+            "release": {
+                "logical_date": next_time,
+            },
+        }
 
-    # NOTE: Release when the time is nearly to schedule time.
-    while (duration := get_diff_sec(next_running_time, tz=tz)) > (15 + 5):
-        logging.debug(
-            f"({pipeline.run_id}) [CORE]: {pipeline.name!r} : {on.cronjob} : "
-            f"Sleep until: {duration}"
+        # WARNING: Re-create pipeline object that use new running pipeline
+        #   ID.
+        runner: Pipeline = pipeline.get_running_id(run_id=pipeline.new_run_id)
+        rs: Result = runner.execute(
+            params=param2template(self.params, release_params),
+        )
+        logger.debug(
+            f"({runner.run_id}) [CORE]: {pipeline.name!r} : {on.cronjob} : "
+            f"End release - {next_time:%Y-%m-%d %H:%M:%S}"
         )
-        time.sleep(15)
-
-    time.sleep(0.5)
-
-    # NOTE: Release parameter that use to change if params has
-    #   templating.
-    release_params: DictData = {
-        "release": {
-            "logical_date": next_running_time,
-        },
-    }
-
-    # WARNING: Re-create pipeline object that use new running pipeline
-    #   ID.
-    runner: Pipeline = pipeline.get_running_id(run_id=pipeline.new_run_id)
-    rs: Result = runner.execute(
-        # FIXME: replace fix parameters on this execution process.
-        params=param2template(
-            {"asat-dt": "${{ release.logical_date }}"}, release_params
-        ),
-    )
-    logging.debug(
-        f"({runner.run_id}) [CORE]: {pipeline.name!r} : {on.cronjob} : "
-        f"End release"
-    )
 
-    del runner
+        del runner
+
+        # NOTE: Set parent ID on this result.
+        rs.set_parent_run_id(pipeline.run_id)
+
+        # NOTE: Save result to log object saving.
+        rs_log: Log = log.model_validate(
+            {
+                "name": pipeline.name,
+                "on": str(on.cronjob),
+                "release": next_time,
+                "context": rs.context,
+                "parent_run_id": rs.run_id,
+                "run_id": rs.run_id,
+            }
+        )
+        rs_log.save(excluded=None)
 
-    # NOTE: remove this release date from running
-    task.running[pipeline.name].remove(next_running_time)
+        # NOTE: remove this release date from running
+        self.running[pipeline.name].remove(next_time)
 
-    # IMPORTANT:
-    #   Add the next running datetime to pipeline queue
-    finish_time: datetime = datetime.now(tz=cron_tz).replace(
-        second=0, microsecond=0
-    )
-    future_running_time: datetime = gen.next
-    while (
-        future_running_time in task.running[pipeline.name]
-        or future_running_time in task.queue[pipeline.name]
-        or future_running_time < finish_time
-    ):
+        # IMPORTANT:
+        #   Add the next running datetime to pipeline queue
+        finish_time: datetime = datetime.now(tz=cron_tz).replace(
+            second=0, microsecond=0
+        )
         future_running_time: datetime = gen.next
+        while (
+            future_running_time in self.running[pipeline.name]
+            or future_running_time in self.queue[pipeline.name]
+            or future_running_time < finish_time
+        ):
+            future_running_time: datetime = gen.next
 
-    heappush(task.queue[pipeline.name], future_running_time)
-
-    # NOTE: Set parent ID on this result.
-    rs.set_parent_run_id(pipeline.run_id)
+        heappush(self.queue[pipeline.name], future_running_time)
+        logger.debug(f"[CORE]: {'-' * 100}")
 
-    # NOTE: Save result to log object saving.
-    rs_log: Log = log.model_validate(
-        {
-            "name": pipeline.name,
-            "on": str(on.cronjob),
-            "release": next_running_time,
-            "context": rs.context,
-            "parent_run_id": rs.run_id,
-            "run_id": rs.run_id,
-        }
-    )
-    rs_log.save()
 
-    logging.debug(f"[CORE]: {rs}")
+def queue2str(queue: list[datetime]) -> Iterator[str]:
+    return (f"{q:%Y-%m-%d %H:%M:%S}" for q in queue)
 
 
 @catch_exceptions(cancel_on_failure=True)
@@ -208,14 +370,20 @@ def workflow_task(
     the threading in background.
 
         This workflow task will start every minute at :02 second.
+
+    :param pipeline_tasks:
+    :param stop:
+    :param threads:
+    :rtype: CancelJob | None
     """
+    tz: ZoneInfo = ZoneInfo(os.getenv("WORKFLOW_CORE_TIMEZONE", "UTC"))
     start_date: datetime = datetime.now(tz=tz)
-    start_date_minute = start_date.replace(second=0, microsecond=0)
+    start_date_minute: datetime = start_date.replace(second=0, microsecond=0)
 
     if start_date > stop:
-        logging.info("[WORKFLOW]: Stop this schedule with datetime stopper.")
+        logger.info("[WORKFLOW]: Stop this schedule with datetime stopper.")
         while len(threads) > 0:
-            logging.warning(
+            logger.warning(
                 "[WORKFLOW]: Waiting pipeline release thread that still "
                 "running in background."
             )
@@ -238,7 +406,7 @@ def workflow_task(
     for task in pipeline_tasks:
 
         # NOTE: Get incoming datetime queue.
-        logging.debug(
+        logger.debug(
             f"[WORKFLOW]: Current queue: {task.pipeline.name!r} : "
             f"{list(queue2str(task.queue[task.pipeline.name]))}"
         )
@@ -255,15 +423,14 @@ def workflow_task(
             task.on.next(current_running_time)
             != task.queue[task.pipeline.name][0]
         ):
-            logging.debug(
+            logger.debug(
                 f"[WORKFLOW]: Skip schedule "
                 f"{current_running_time:%Y-%m-%d %H:%M:%S} "
                 f"for : {task.pipeline.name!r} : {task.on.cronjob}"
             )
             continue
         elif len(task.queue[task.pipeline.name]) == 0:
-            # TODO: Should auto add new queue?
-            logging.warning(
+            logger.warning(
                 f"[WORKFLOW]: Queue is empty for : {task.pipeline.name!r} : "
                 f"{task.on.cronjob}"
             )
@@ -272,13 +439,14 @@ def workflow_task(
         # NOTE: Remove this datetime from queue.
         task.queue[task.pipeline.name].pop(0)
 
+        # NOTE: Create thread name that able to tracking with observe schedule
+        #   job.
         thread_name: str = (
             f"{task.pipeline.name}|{str(task.on.cronjob)}|"
             f"{current_running_time:%Y%m%d%H%M}"
         )
         pipe_thread: Thread = Thread(
-            target=pipeline_release,
-            args=(task,),
+            target=task.release,
             name=thread_name,
             daemon=True,
         )
@@ -289,7 +457,7 @@ def workflow_task(
 
         delay()
 
-    logging.debug(f"[WORKFLOW]: {'=' * 100}")
+    logger.debug(f"[WORKFLOW]: {'=' * 100}")
 
 
 def workflow_long_running_task(threads: dict[str, Thread]) -> None:
@@ -297,8 +465,11 @@ def workflow_long_running_task(threads: dict[str, Thread]) -> None:
     control.
 
     :param threads: A mapping of Thread object and its name.
+    :rtype: None
     """
-    logging.debug("[MONITOR]: Start checking long running pipeline release.")
+    logger.debug(
+        "[MONITOR]: Start checking long running pipeline release task."
+    )
     snapshot_threads = list(threads.keys())
     for t_name in snapshot_threads:
 
@@ -308,16 +479,18 @@ def workflow_long_running_task(threads: dict[str, Thread]) -> None:
 
 
 def workflow_control(
-    pipelines: list[str],
-    until: datetime | None = None,
+    schedules: list[str],
+    stop: datetime | None = None,
     externals: DictData | None = None,
 ) -> list[str]:
     """Workflow scheduler control.
 
-    :param pipelines: A list of pipeline names that want to schedule running.
-    :param until:
+    :param schedules: A list of pipeline names that want to schedule running.
+    :param stop: An datetime value that use to stop running schedule.
     :param externals: An external parameters that pass to Loader.
+    :rtype: list[str]
     """
+    tz: ZoneInfo = ZoneInfo(os.getenv("WORKFLOW_CORE_TIMEZONE", "UTC"))
     schedule: Scheduler = Scheduler()
     start_date: datetime = datetime.now(tz=tz)
 
@@ -333,35 +506,28 @@ def workflow_control(
         second=0, microsecond=0
     )
 
-    # NOTE: Create pair of pipeline and on.
+    # NOTE: Create pair of pipeline and on from schedule model.
     pipeline_tasks: list[PipelineTask] = []
-
-    for name in pipelines:
-        pipeline: Pipeline = Pipeline.from_loader(name, externals=externals)
-
-        # NOTE: Create default list of release datetime.
-        wf_queue[name]: list[datetime] = []
-        wf_running[name]: list[datetime] = []
-
-        for on in pipeline.on:
-
-            on_gen = on.generate(start_date_waiting)
-            next_running_date = on_gen.next
-            while next_running_date in wf_queue[name]:
-                next_running_date = on_gen.next
-
-            heappush(wf_queue[name], next_running_date)
-            pipeline_tasks.append(
-                PipelineTask(
-                    pipeline=pipeline, on=on, queue=wf_queue, running=wf_running
-                ),
-            )
+    for name in schedules:
+        sch: Schedule = Schedule.from_loader(name, externals=externals)
+        pipeline_tasks.extend(
+            sch.tasks(start_date_waiting, wf_queue, wf_running, externals)
+        )
 
     # NOTE: This schedule job will start every minute at :02 seconds.
     schedule.every(1).minutes.at(":02").do(
         workflow_task,
         pipeline_tasks=pipeline_tasks,
-        stop=until or (start_date + timedelta(minutes=5, seconds=20)),
+        stop=stop
+        or (
+            start_date
+            + timedelta(
+                **json.loads(
+                    os.getenv("WORKFLOW_APP_STOP_BOUNDARY_DELTA")
+                    or '{"minutes": 5, "seconds": 20}'
+                )
+            )
+        ),
         threads=thread_releases,
     ).tag("control")
 
@@ -372,37 +538,42 @@ def workflow_control(
     ).tag("monitor")
 
     # NOTE: Start running schedule
-    logging.info(f"[WORKFLOW]: Start schedule: {pipelines}")
+    logger.info(f"[WORKFLOW]: Start schedule: {schedules}")
     while True:
         schedule.run_pending()
         time.sleep(1)
         if not schedule.get_jobs("control"):
             schedule.clear("monitor")
-            logging.warning(
+            logger.warning(
                 f"[WORKFLOW]: Pipeline release thread: {thread_releases}"
             )
-            logging.warning("[WORKFLOW]: Does not have any schedule jobs !!!")
+            logger.warning("[WORKFLOW]: Does not have any schedule jobs !!!")
             break
 
-    logging.warning(f"Queue: {[wf_queue[wf] for wf in wf_queue]}")
-    logging.warning(f"Running: {[wf_running[wf] for wf in wf_running]}")
-    return pipelines
+    logger.warning(
+        f"Queue: {[list(queue2str(wf_queue[wf])) for wf in wf_queue]}"
+    )
+    logger.warning(
+        f"Running: {[list(queue2str(wf_running[wf])) for wf in wf_running]}"
+    )
+    return schedules
 
 
 def workflow(
-    until: datetime | None = None,
+    stop: datetime | None = None,
     externals: DictData | None = None,
     excluded: list[str] | None = None,
-):
+) -> list[str]:
     """Workflow application that running multiprocessing schedule with chunk of
     pipelines that exists in config path.
 
-    :param until:
+    :param stop:
     :param excluded:
     :param externals:
+    :rtype: list[str]
 
         This function will get all pipelines that include on value that was
-    created in config path and chuck it with WORKFLOW_APP_PIPELINE_PER_PROCESS
+    created in config path and chuck it with WORKFLOW_APP_SCHEDULE_PER_PROCESS
     value to multiprocess executor pool.
 
     The current workflow logic:
@@ -417,36 +588,33 @@ def workflow(
                                                            pipeline task 02 02
                   ==> ...
     """
-    excluded: list = excluded or []
+    excluded: list[str] = excluded or []
 
-    with ProcessPoolExecutor(max_workers=2) as executor:
+    with ProcessPoolExecutor(
+        max_workers=int(os.getenv("WORKFLOW_APP_PROCESS_WORKER") or "2"),
+    ) as executor:
         futures: list[Future] = [
             executor.submit(
                 workflow_control,
-                pipelines=[load[0] for load in loader],
-                until=until,
+                schedules=[load[0] for load in loader],
+                stop=stop,
                 externals=(externals or {}),
             )
             for loader in batch(
-                # Loader.find(Pipeline, include=["on"], excluded=excluded),
-                [
-                    ("pipe-scheduling", None),
-                    # ("pipe-scheduling-minute", None),
-                ],
-                n=1,
+                Loader.finds(Schedule, excluded=excluded),
+                n=int(os.getenv("WORKFLOW_APP_SCHEDULE_PER_PROCESS") or "100"),
             )
         ]
 
         results: list[str] = []
         for future in as_completed(futures):
             if err := future.exception():
-                logging.error(str(err))
+                logger.error(str(err))
                 raise WorkflowException(str(err)) from err
             results.extend(future.result(timeout=1))
         return results
 
 
 if __name__ == "__main__":
-    # TODO: Define input arguments that want to manage this application.
     workflow_rs: list[str] = workflow()
-    logging.info(f"Application run success: {workflow_rs}")
+    logger.info(f"Application run success: {workflow_rs}")