zrb 0.28.1__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

zrb/task/http_check.py

@@ -0,0 +1,73 @@
+import asyncio
+from collections.abc import Callable
+
+import requests
+
+from ..attr.type import StrAttr
+from ..context.any_context import AnyContext
+from ..context.context import Context
+from ..env.any_env import AnyEnv
+from ..input.any_input import AnyInput
+from ..util.attr import get_str_attr
+from .any_task import AnyTask
+from .base_task import BaseTask
+
+
+class HttpCheck(BaseTask):
+    def __init__(
+        self,
+        name: str,
+        color: int | None = None,
+        icon: str | None = None,
+        description: str | None = None,
+        cli_only: bool = False,
+        input: list[AnyInput] | AnyInput | None = None,
+        env: list[AnyEnv] | AnyEnv | None = None,
+        url: StrAttr = "http://localhost",
+        auto_render_url: bool = True,
+        http_method: StrAttr = "GET",
+        interval: int = 5,
+        execute_condition: bool | str | Callable[[Context], bool] = True,
+        upstream: list[AnyTask] | AnyTask | None = None,
+        fallback: list[AnyTask] | AnyTask | None = None,
+    ):
+        super().__init__(
+            name=name,
+            color=color,
+            icon=icon,
+            description=description,
+            cli_only=cli_only,
+            input=input,
+            env=env,
+            execute_condition=execute_condition,
+            retries=0,
+            upstream=upstream,
+            fallback=fallback,
+        )
+        self._url = url
+        self._auto_render_url = auto_render_url
+        self._http_method = http_method
+        self._interval = interval
+
+    def _get_url(self, ctx: AnyContext) -> str:
+        return get_str_attr(
+            ctx, self._url, "http://localhost", auto_render=self._auto_render_url
+        )
+
+    def _get_http_method(self, ctx: AnyContext) -> str:
+        return get_str_attr(ctx, self._http_method, "GET", auto_render=True).upper()
+
+    async def _exec_action(self, ctx: AnyContext) -> bool:
+        url = self._get_url(ctx)
+        http_method = self._get_http_method(ctx)
+        while True:
+            try:
+                response = requests.request(http_method, url)
+                if response.status_code == 200:
+                    return response
+                ctx.log_info(f"HTTP Status code: {response.status_code}")
+            except asyncio.TimeoutError as e:
+                ctx.log_info(f"Timeout error {e}")
+            except Exception as e:
+                ctx.log_info(f"Error: {e}")
+            await asyncio.sleep(self._interval)

zrb/task/make_task.py

@@ -0,0 +1,62 @@
+from collections.abc import Callable
+from typing import Any
+
+from ..context.any_context import AnyContext
+from ..context.any_shared_context import AnySharedContext
+from ..env.any_env import AnyEnv
+from ..group.any_group import AnyGroup
+from ..input.any_input import AnyInput
+from .any_task import AnyTask
+from .base_task import BaseTask
+
+
+def make_task(
+    name: str,
+    color: int | None = None,
+    icon: str | None = None,
+    description: str | None = None,
+    cli_only: bool = False,
+    input: list[AnyInput] | AnyInput | None = None,
+    env: list[AnyEnv] | AnyEnv | None = None,
+    execute_condition: bool | str | Callable[[AnySharedContext], bool] = True,
+    retries: int = 2,
+    retry_period: float = 0,
+    readiness_check: list[AnyTask] | AnyTask | None = None,
+    readiness_check_delay: float = 0.5,
+    readiness_check_period: float = 5,
+    readiness_failure_threshold: int = 1,
+    readiness_timeout: int = 60,
+    monitor_readiness: bool = False,
+    upstream: list[AnyTask] | AnyTask | None = None,
+    fallback: list[AnyTask] | AnyTask | None = None,
+    group: AnyGroup | None = None,
+    alias: str | None = None,
+) -> Callable[[Callable[[AnyContext], Any]], AnyTask]:
+
+    def _make_task(fn: Callable[[AnyContext], Any]) -> BaseTask:
+        task = BaseTask(
+            name=name,
+            color=color,
+            icon=icon,
+            description=description,
+            cli_only=cli_only,
+            input=input,
+            env=env,
+            action=fn,
+            execute_condition=execute_condition,
+            retries=retries,
+            retry_period=retry_period,
+            readiness_check=readiness_check,
+            readiness_check_delay=readiness_check_delay,
+            readiness_check_period=readiness_check_period,
+            readiness_failure_threshold=readiness_failure_threshold,
+            readiness_timeout=readiness_timeout,
+            monitor_readiness=monitor_readiness,
+            upstream=upstream,
+            fallback=fallback,
+        )
+        if group is not None:
+            return group.add_task(task, alias=alias)
+        return task
+
+    return _make_task

zrb/task/rsync_task.py

@@ -1,144 +1,151 @@
-import os
-import pathlib
-from collections.abc import Callable, Iterable
-from typing import Any, Optional, Union
+from collections.abc import Callable
 
-from zrb.helper.accessories.color import colored
-from zrb.helper.log import logger
-from zrb.helper.typecheck import typechecked
-from zrb.helper.typing import JinjaTemplate
-from zrb.task.any_task import AnyTask
-from zrb.task.any_task_event_handler import (
-    OnFailed,
-    OnReady,
-    OnRetry,
-    OnSkipped,
-    OnStarted,
-    OnTriggered,
-    OnWaiting,
-)
-from zrb.task.cmd_task import CmdTask
-from zrb.task_env.env import Env, PrivateEnv
-from zrb.task_env.env_file import EnvFile
-from zrb.task_group.group import Group
-from zrb.task_input.any_input import AnyInput
+from ..attr.type import IntAttr, StrAttr
+from ..context.any_context import AnyContext
+from ..env.any_env import AnyEnv
+from ..input.any_input import AnyInput
+from ..util.attr import get_str_attr
+from .any_task import AnyTask
+from .cmd_task import CmdTask
 
-logger.debug(colored("Loading zrb.task.rsync_task", attrs=["dark"]))
 
-_CURRENT_DIR = os.path.dirname(__file__)
-_SHELL_SCRIPT_DIR = os.path.join(_CURRENT_DIR, "..", "shell-scripts")
-
-ensure_rsync_is_installed = CmdTask(
-    name="ensure-ssh-is-installed",
-    cmd_path=[
-        os.path.join(_SHELL_SCRIPT_DIR, "_common-util.sh"),
-        os.path.join(_SHELL_SCRIPT_DIR, "ensure-ssh-is-installed.sh"),
-        os.path.join(_SHELL_SCRIPT_DIR, "ensure-rsync-is-installed.sh"),
-    ],
-    preexec_fn=None,
-    should_print_cmd_result=False,
-    should_show_cmd=False,
-    should_show_working_directory=False,
-)
-
-
-@typechecked
 class RsyncTask(CmdTask):
     def __init__(
         self,
         name: str,
-        group: Optional[Group] = None,
-        inputs: Iterable[AnyInput] = [],
-        envs: Iterable[Env] = [],
-        env_files: Iterable[EnvFile] = [],
-        icon: Optional[str] = None,
-        color: Optional[str] = None,
-        description: str = "",
-        executable: Optional[str] = None,
-        remote_host: JinjaTemplate = "localhost",
-        remote_port: Union[JinjaTemplate, int] = 22,
-        remote_user: JinjaTemplate = "root",
-        remote_password: JinjaTemplate = "",
-        remote_ssh_key: JinjaTemplate = "",
-        src_path: JinjaTemplate = ".",
-        src_is_remote: bool = False,
-        dst_path: JinjaTemplate = ".",
-        dst_is_remote: bool = True,
-        cwd: Optional[Union[JinjaTemplate, pathlib.Path]] = None,
-        should_render_cwd: bool = True,
-        upstreams: Iterable[AnyTask] = [],
-        fallbacks: Iterable[AnyTask] = [],
-        on_triggered: Optional[OnTriggered] = None,
-        on_waiting: Optional[OnWaiting] = None,
-        on_skipped: Optional[OnSkipped] = None,
-        on_started: Optional[OnStarted] = None,
-        on_ready: Optional[OnReady] = None,
-        on_retry: Optional[OnRetry] = None,
-        on_failed: Optional[OnFailed] = None,
-        checkers: Iterable[AnyTask] = [],
-        checking_interval: Union[float, int] = 0.05,
-        retry: int = 2,
-        retry_interval: Union[float, int] = 1,
+        color: int | None = None,
+        icon: str | None = None,
+        description: str | None = None,
+        cli_only: bool = False,
+        input: list[AnyInput] | AnyInput | None = None,
+        env: list[AnyEnv] | AnyEnv | None = None,
+        shell: StrAttr | None = None,
+        auto_render_shell: bool = True,
+        remote_host: StrAttr | None = None,
+        auto_render_remote_host: bool = True,
+        remote_port: IntAttr | None = None,
+        auto_render_remote_port: bool = True,
+        remote_user: StrAttr | None = None,
+        auto_render_remote_user: bool = True,
+        remote_password: StrAttr | None = None,
+        auto_render_remote_password: bool = True,
+        remote_ssh_key: StrAttr | None = None,
+        auto_render_remote_ssh_key: bool = True,
+        remote_source_path: StrAttr | None = None,
+        auto_render_remote_source_path: bool = True,
+        remote_destination_path: StrAttr | None = None,
+        auto_render_remote_destination_path: bool = True,
+        local_source_path: StrAttr | None = None,
+        auto_render_local_source_path: bool = True,
+        local_destination_path: StrAttr | None = None,
+        auto_render_local_destination_path: bool = True,
+        cwd: str | None = None,
+        auto_render_cwd: bool = True,
         max_output_line: int = 1000,
         max_error_line: int = 1000,
-        preexec_fn: Optional[Callable[[], Any]] = os.setsid,
-        should_execute: Union[bool, str, Callable[..., bool]] = True,
-        return_upstream_result: bool = False,
-        should_print_cmd_result: bool = True,
-        should_show_cmd: bool = True,
-        should_show_working_directory: bool = True,
+        execute_condition: bool | str | Callable[[AnyContext], bool] = True,
+        retries: int = 2,
+        retry_period: float = 0,
+        readiness_check: list[AnyTask] | AnyTask | None = None,
+        upstream: list[AnyTask] | AnyTask | None = None,
+        fallback: list[AnyTask] | AnyTask | None = None,
     ):
-        CmdTask.__init__(
-            self,
+        super().__init__(
             name=name,
-            group=group,
-            inputs=inputs,
-            envs=envs + [PrivateEnv(name="_ZRB_SSH_PASSWORD", default=remote_password)],
-            env_files=env_files,
-            icon=icon,
             color=color,
+            icon=icon,
             description=description,
-            executable=executable,
+            cli_only=cli_only,
+            input=input,
+            env=env,
+            shell=shell,
+            auto_render_shell=auto_render_shell,
+            remote_host=remote_host,
+            auto_render_remote_host=auto_render_remote_host,
+            remote_port=remote_port,
+            auto_render_remote_port=auto_render_remote_port,
+            remote_user=remote_user,
+            auto_render_remote_user=auto_render_remote_user,
+            remote_password=remote_password,
+            auto_render_remote_password=auto_render_remote_password,
+            remote_ssh_key=remote_ssh_key,
+            auto_render_remote_ssh_key=auto_render_remote_ssh_key,
             cwd=cwd,
-            should_render_cwd=should_render_cwd,
-            upstreams=[ensure_rsync_is_installed] + upstreams,
-            fallbacks=fallbacks,
-            on_triggered=on_triggered,
-            on_waiting=on_waiting,
-            on_skipped=on_skipped,
-            on_started=on_started,
-            on_ready=on_ready,
-            on_retry=on_retry,
-            on_failed=on_failed,
-            checkers=checkers,
-            checking_interval=checking_interval,
-            retry=retry,
-            retry_interval=retry_interval,
+            auto_render_cwd=auto_render_cwd,
             max_output_line=max_output_line,
             max_error_line=max_error_line,
-            preexec_fn=preexec_fn,
-            should_execute=should_execute,
-            return_upstream_result=return_upstream_result,
-            should_print_cmd_result=should_print_cmd_result,
-            should_show_cmd=should_show_cmd,
-            should_show_working_directory=should_show_working_directory,
+            execute_condition=execute_condition,
+            retries=retries,
+            retry_period=retry_period,
+            readiness_check=readiness_check,
+            upstream=upstream,
+            fallback=fallback,
+        )
+        self._remote_source_path = remote_source_path
+        self._auto_render_remote_source_path = auto_render_remote_source_path
+        self._remote_destination_path = remote_destination_path
+        self._auto_render_remote_destination_path = auto_render_remote_destination_path
+        self._local_source_path = local_source_path
+        self._auto_render_local_source_path = auto_render_local_source_path
+        self._local_destination_path = local_destination_path
+        self._auto_render_local_destination_path = auto_render_local_destination_path
+
+    def _get_source_path(self, ctx: AnyContext) -> str:
+        local_source_path = self._get_local_source_path(ctx)
+        if local_source_path != "":
+            return local_source_path
+        remote_source_path = self._get_remote_source_path(ctx)
+        host = self._get_remote_host(ctx)
+        user = self._get_remote_user(ctx)
+        return f"{user}@{host}:{remote_source_path}"
+
+    def _get_destination_path(self, ctx: AnyContext) -> str:
+        local_destination_path = self._get_local_destination_path(ctx)
+        if local_destination_path != "":
+            return local_destination_path
+        remote_destination_path = self._get_remote_destination_path(ctx)
+        host = self._get_remote_host(ctx)
+        user = self._get_remote_user(ctx)
+        return f"{user}@{host}:{remote_destination_path}"
+
+    def _get_remote_source_path(self, ctx: AnyContext) -> str:
+        return get_str_attr(
+            ctx,
+            self._remote_source_path,
+            "",
+            auto_render=self._auto_render_remote_source_path,
+        )
+
+    def _get_remote_destination_path(self, ctx: AnyContext) -> str:
+        return get_str_attr(
+            ctx,
+            self._remote_destination_path,
+            "",
+            auto_render=self._auto_render_remote_destination_path,
+        )
+
+    def _get_local_source_path(self, ctx: AnyContext) -> str:
+        return get_str_attr(
+            ctx,
+            self._local_source_path,
+            "",
+            auto_render=self._auto_render_local_source_path,
+        )
+
+    def _get_local_destination_path(self, ctx: AnyContext) -> str:
+        return get_str_attr(
+            ctx,
+            self._local_destination_path,
+            "",
+            auto_render=self._auto_render_local_destination_path,
         )
-        self._remote_host = remote_host
-        self._remote_port = remote_port
-        self._remote_user = remote_user
-        self._remote_password = remote_password
-        self._remote_ssh_key = remote_ssh_key
-        self._src_path = src_path
-        self._src_is_remote = src_is_remote
-        self._dst_path = dst_path
-        self._dst_is_remote = dst_is_remote
 
-    def get_cmd_script(self, *args: Any, **kwargs: Any) -> str:
-        port = self.render_str(self._remote_port)
-        password = self.render_str(self._remote_password)
-        key = self.render_str(self._remote_ssh_key)
-        src = self._get_path(self._src_path, self._src_is_remote)
-        dst = self._get_path(self._dst_path, self._dst_is_remote)
+    def _get_cmd_script(self, ctx: AnyContext) -> str:
+        port = self._get_remote_port(ctx)
+        password = self._get_remote_password(ctx)
+        key = self._get_remote_ssh_key(ctx)
+        src = self._get_source_path(ctx)
+        dst = self._get_destination_path(ctx)
         if key != "" and password != "":
             return f'sshpass -p "$_ZRB_SSH_PASSWORD" rsync --mkpath -avz -e "ssh -i {key} -p {port}" {src} {dst}'  # noqa
         if key != "":
@@ -146,11 +153,3 @@ class RsyncTask(CmdTask):
         if password != "":
             return f'sshpass -p "$_ZRB_SSH_PASSWORD" rsync --mkpath -avz -e "ssh -p {port}" {src} {dst}'  # noqa
         return f'rsync --mkpath -avz -e "ssh -p {port}" {src} {dst}'
-
-    def _get_path(self, resource_path: str, is_remote: bool) -> str:
-        rendered_path = self.render_str(resource_path)
-        if is_remote:
-            host = self.render_str(self._remote_host)
-            user = self.render_str(self._remote_user)
-            return f"{user}@{host}:{rendered_path}"
-        return rendered_path

zrb/task/scaffolder.py

@@ -0,0 +1,144 @@
+import os
+import shutil
+from collections.abc import Callable
+
+from ..attr.type import BoolAttr, StrAttr
+from ..content_transformer.any_content_transformer import AnyContentTransformer
+from ..content_transformer.content_transformer import ContentTransformer
+from ..context.any_context import AnyContext
+from ..env.any_env import AnyEnv
+from ..input.any_input import AnyInput
+from ..util.attr import get_str_attr
+from .any_task import AnyTask
+from .base_task import BaseTask
+
+TransformConfig = dict[str, str] | Callable[[AnyContext, str], str]
+
+
+class Scaffolder(BaseTask):
+    def __init__(
+        self,
+        name: str,
+        color: int | None = None,
+        icon: str | None = None,
+        description: str | None = None,
+        cli_only: bool = False,
+        input: list[AnyInput] | AnyInput | None = None,
+        env: list[AnyEnv] | AnyEnv | None = None,
+        source_path: StrAttr | None = None,
+        auto_render_source_path: bool = True,
+        destination_path: StrAttr | None = None,
+        auto_render_destination_path: bool = True,
+        transform_path: TransformConfig = {},
+        transform_content: (
+            list[AnyContentTransformer] | AnyContentTransformer | TransformConfig
+        ) = [],
+        execute_condition: BoolAttr = True,
+        retries: int = 2,
+        retry_period: float = 0,
+        readiness_check: list[AnyTask] | AnyTask | None = None,
+        readiness_check_delay: float = 0.5,
+        readiness_check_period: float = 5,
+        readiness_failure_threshold: int = 1,
+        readiness_timeout: int = 60,
+        monitor_readiness: bool = False,
+        upstream: list[AnyTask] | AnyTask | None = None,
+        fallback: list[AnyTask] | AnyTask | None = None,
+    ):
+        super().__init__(
+            name=name,
+            color=color,
+            icon=icon,
+            description=description,
+            cli_only=cli_only,
+            input=input,
+            env=env,
+            execute_condition=execute_condition,
+            retries=retries,
+            retry_period=retry_period,
+            readiness_check=readiness_check,
+            readiness_check_delay=readiness_check_delay,
+            readiness_check_period=readiness_check_period,
+            readiness_failure_threshold=readiness_failure_threshold,
+            readiness_timeout=readiness_timeout,
+            monitor_readiness=monitor_readiness,
+            upstream=upstream,
+            fallback=fallback,
+        )
+        self._source_path = source_path
+        self._auto_render_source_path = auto_render_source_path
+        self._destination_path = destination_path
+        self._auto_render_destination_path = auto_render_destination_path
+        self._content_transformers = transform_content
+        self._path_transformer = transform_path
+
+    def _get_source_path(self, ctx: AnyContext) -> str:
+        return get_str_attr(ctx, self._source_path, "", auto_render=True)
+
+    def _get_destination_path(self, ctx: AnyContext) -> str:
+        return get_str_attr(ctx, self._destination_path, "", auto_render=True)
+
+    def _get_content_transformers(self) -> list[AnyContentTransformer]:
+        if callable(self._content_transformers):
+            return [ContentTransformer(match="*", transform=self._content_transformers)]
+        if isinstance(self._content_transformers, dict):
+            return [ContentTransformer(match="*", transform=self._content_transformers)]
+        if isinstance(self._content_transformers, AnyContentTransformer):
+            return [self._content_transformers]
+        return self._content_transformers
+
+    async def _exec_action(self, ctx: AnyContext):
+        source_path = self._get_source_path(ctx)
+        destination_path = self._get_destination_path(ctx)
+        self._copy_path(ctx, source_path, destination_path)
+        transformers = self._get_content_transformers()
+        file_paths = self._get_all_file_paths(destination_path)
+        for file_path in file_paths:
+            for transformer in transformers:
+                if transformer.match(ctx, file_path):
+                    transformer.transform_file(ctx, file_path)
+
+    def _copy_path(self, ctx: AnyContext, source_path: str, destination_path: str):
+        """
+        Copies a directory or file from source_path to destination_path recursively.
+        """
+        if os.path.isdir(source_path):
+            for root, dirs, files in os.walk(source_path):
+                rel_root = os.path.relpath(root, source_path)
+                dest_dir = os.path.join(
+                    destination_path, self._transform_path(ctx, rel_root)
+                )
+                os.makedirs(dest_dir, exist_ok=True)
+                for file_name in files:
+                    src_file = os.path.join(root, file_name)
+                    dest_file = os.path.join(
+                        dest_dir, self._transform_path(ctx, file_name)
+                    )
+                    shutil.copy2(src_file, dest_file)
+                    ctx.log_info(f"Copied and renamed {src_file} to {dest_file}")
+        else:
+            dest_file = os.path.join(
+                destination_path,
+                self._transform_path(os.path.basename(ctx, source_path)),
+            )
+            shutil.copy2(source_path, dest_file)
+            ctx.log_info(f"Copied and renamed {source_path} to {dest_file}")
+
+    def _transform_path(self, ctx: AnyContext, file_path: str):
+        if callable(self._path_transformer):
+            return self._path_transformer(ctx, file_path)
+        new_file_path = file_path
+        for keyword, replacement in self._path_transformer.items():
+            new_file_path = new_file_path.replace(keyword, replacement)
+        return new_file_path
+
+    def _get_all_file_paths(self, path):
+        """
+        Returns a list of absolute file paths for all files in the given path, recursively.
+        """
+        file_paths = []
+        for root, _, files in os.walk(path):
+            for file in files:
+                absolute_path = os.path.abspath(os.path.join(root, file))
+                file_paths.append(absolute_path)
+        return file_paths

zrb/task/scheduler.py

@@ -0,0 +1,82 @@
+import asyncio
+import datetime
+from collections.abc import Callable
+
+from zrb.attr.type import StrAttr, fstring
+from zrb.callback.any_callback import AnyCallback
+from zrb.context.any_context import AnyContext
+from zrb.context.any_shared_context import AnySharedContext
+from zrb.env.any_env import AnyEnv
+from zrb.input.any_input import AnyInput
+from zrb.task.any_task import AnyTask
+
+from ..util.attr import get_str_attr
+from ..util.cron import match_cron
+from ..xcom.xcom import Xcom
+from .base_trigger import BaseTrigger
+
+
+class Scheduler(BaseTrigger):
+
+    def __init__(
+        self,
+        name: str,
+        color: int | None = None,
+        icon: str | None = None,
+        description: str | None = None,
+        cli_only: bool = False,
+        input: list[AnyInput] | AnyInput | None = None,
+        env: list[AnyEnv] | AnyEnv | None = None,
+        schedule: StrAttr = None,
+        execute_condition: bool | str | Callable[[AnySharedContext], bool] = True,
+        queue_name: fstring | None = None,
+        callback: list[AnyCallback] | AnyCallback = [],
+        retries: int = 2,
+        retry_period: float = 0,
+        readiness_check: list[AnyTask] | AnyTask | None = None,
+        readiness_check_delay: float = 0.5,
+        readiness_check_period: float = 5,
+        readiness_failure_threshold: int = 1,
+        readiness_timeout: int = 60,
+        monitor_readiness: bool = False,
+        upstream: list[AnyTask] | AnyTask | None = None,
+        fallback: list[AnyTask] | AnyTask | None = None,
+    ):
+        super().__init__(
+            name=name,
+            color=color,
+            icon=icon,
+            description=description,
+            cli_only=cli_only,
+            input=input,
+            env=env,
+            execute_condition=execute_condition,
+            queue_name=queue_name,
+            callback=callback,
+            retries=retries,
+            retry_period=retry_period,
+            readiness_check=readiness_check,
+            readiness_check_delay=readiness_check_delay,
+            readiness_check_period=readiness_check_period,
+            readiness_failure_threshold=readiness_failure_threshold,
+            readiness_timeout=readiness_timeout,
+            monitor_readiness=monitor_readiness,
+            upstream=upstream,
+            fallback=fallback,
+        )
+        self._cron_pattern = schedule
+
+    def _get_cron_pattern(self, shared_ctx: AnySharedContext) -> str:
+        return get_str_attr(shared_ctx, self._cron_pattern, "@minutely", True)
+
+    async def _exec_action(self, ctx: AnyContext):
+        cron_pattern = self._get_cron_pattern(ctx)
+        ctx.print(f"Monitoring cron pattern: {cron_pattern}")
+        while True:
+            now = datetime.datetime.now()
+            ctx.print(f"Current time: {now}")
+            if match_cron(cron_pattern, now):
+                ctx.print(f"Matching {now} with pattern: {cron_pattern}")
+                xcom: Xcom = ctx.xcom[self.queue_name]
+                xcom.push(now)
+            await asyncio.sleep(60)