olas-operate-middleware 0.13.0__tar.gz → 0.13.2__tar.gz

{olas_operate_middleware-0.13.0 → olas_operate_middleware-0.13.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: olas-operate-middleware
-Version: 0.13.0
+Version: 0.13.2
 Summary: 
 License-File: LICENSE
 Author: David Vilela

{olas_operate_middleware-0.13.0 → olas_operate_middleware-0.13.2}/operate/cli.py

@@ -223,7 +223,7 @@ class OperateApp:  # pylint: disable=too-many-instance-attributes
             )
 
         logger.info(f"Backing up existing {OPERATE} directory to {backup_path}")
-        shutil.copytree(self._path, backup_path)
+        shutil.copytree(self._path, backup_path, ignore_dangling_symlinks=True)
         version_file.write_text(str(current_version))
 
         # remove recoverable files from the backup to save space

{olas_operate_middleware-0.13.0 → olas_operate_middleware-0.13.2}/operate/services/deployment_runner.py

@@ -112,14 +112,30 @@ class BaseDeploymentRunner(AbstractDeploymentRunner, metaclass=ABCMeta):
 
     def _open_agent_runner_log_file(self) -> TextIOWrapper:
         """Open agent_runner.log file."""
-        return (
-            Path(self._work_directory).parent.parent.parent / "agent_runner.log"
-        ).open("w+")
+        return (self._get_operate_dir() / "agent_runner.log").open("w+")
+
+    def _open_tendermint_log_file(self) -> TextIOWrapper:
+        """Open tm.log file."""
+        return (self._get_operate_dir() / "tm.log").open("w+")
+
+    def _get_operate_dir(self) -> Path:
+        """Get .operate dir."""
+        return Path(self._work_directory).parent.parent.parent
 
     def _run_aea_command(self, *args: str, cwd: Path) -> Any:
         """Run aea command."""
-        cmd = " ".join(args)
-        self.logger.info(f"Running aea command: {cmd} at {str(cwd)}")
+        no_password_args = []
+        for i, arg in enumerate(args):
+            if i > 0 and args[i - 1] == "--password":
+                no_password_args.append("******")
+            elif arg.startswith("--password="):
+                no_password_args.append("--password=******")
+            else:
+                no_password_args.append(arg)
+
+        self.logger.info(
+            f"Running aea command: {' '.join(no_password_args)} at {str(cwd)}"
+        )
         p = multiprocessing.Process(
             target=self.__class__._call_aea_command,  # pylint: disable=protected-access
             args=(cwd, args),
@@ -128,7 +144,7 @@ class BaseDeploymentRunner(AbstractDeploymentRunner, metaclass=ABCMeta):
         p.join()
         if p.exitcode != 0:
             raise RuntimeError(
-                f"aea command `{cmd}`execution failed with exit code: {p.exitcode}"
+                f"aea command `{' '.join(no_password_args)}` execution failed with exit code: {p.exitcode}"
             )
 
     @staticmethod
@@ -188,82 +204,90 @@ class BaseDeploymentRunner(AbstractDeploymentRunner, metaclass=ABCMeta):
         return env
 
     def _setup_agent(self, password: str) -> None:
-        """Setup agent."""
-        working_dir = self._work_directory
-        env = self._prepare_agent_env()
-        agent_alias_name = "agent"
-        agent_dir_full_path = Path(working_dir) / agent_alias_name
-        if not self._is_aea:
-            if agent_dir_full_path.exists():
-                # remove if exists before fetching! can have issues with retry mechanism of multiple start attempts
-                with suppress(Exception):
-                    shutil.rmtree(agent_dir_full_path, ignore_errors=True)
-
-            # Add keys
-            agent_dir_full_path.mkdir(exist_ok=True, parents=True)
-            shutil.copy(
-                working_dir / "ethereum_private_key.txt",
-                working_dir / "agent" / "ethereum_private_key.txt",
-            )
-            return
+        """Setup agent with retries for network operations."""
+        max_attempts = 10
+        for attempt in range(1, max_attempts + 1):
+            try:
+                working_dir = self._work_directory
+                env = self._prepare_agent_env()
+
+                # Clear agent directory before each attempt to avoid partial state
+                agent_alias_name = "agent"
+                agent_dir_full_path = Path(working_dir) / agent_alias_name
+                if agent_dir_full_path.exists():
+                    with suppress(Exception):
+                        shutil.rmtree(agent_dir_full_path, ignore_errors=True)
+
+                self._run_aea_command(
+                    "init",
+                    "--reset",
+                    "--author",
+                    "valory",
+                    "--remote",
+                    "--ipfs",
+                    "--ipfs-node",
+                    "/dns/registry.autonolas.tech/tcp/443/https",
+                    cwd=working_dir,
+                )
 
-        self._run_aea_command(
-            "init",
-            "--reset",
-            "--author",
-            "valory",
-            "--remote",
-            "--ipfs",
-            "--ipfs-node",
-            "/dns/registry.autonolas.tech/tcp/443/https",
-            cwd=working_dir,
-        )
+                self._run_aea_command(
+                    "-s",
+                    "fetch",
+                    env["AEA_AGENT"],
+                    "--alias",
+                    agent_alias_name,
+                    cwd=working_dir,
+                )
 
-        if agent_dir_full_path.exists():
-            # remove if exists before fetching! can have issues with retry mechanism of multiple start attempts
-            with suppress(Exception):
-                shutil.rmtree(agent_dir_full_path, ignore_errors=True)
-
-        self._run_aea_command(
-            "-s",
-            "fetch",
-            env["AEA_AGENT"],
-            "--alias",
-            agent_alias_name,
-            cwd=working_dir,
-        )
+                # Add keys
+                shutil.copy(
+                    working_dir / "ethereum_private_key.txt",
+                    working_dir / "agent" / "ethereum_private_key.txt",
+                )
 
-        # Add keys
-        shutil.copy(
-            working_dir / "ethereum_private_key.txt",
-            working_dir / "agent" / "ethereum_private_key.txt",
-        )
+                self._run_aea_command(
+                    "-s",
+                    "add-key",
+                    "--password",
+                    password,
+                    "ethereum",
+                    cwd=working_dir / "agent",
+                )
+                self._run_aea_command(
+                    "-s",
+                    "add-key",
+                    "--password",
+                    password,
+                    "ethereum",
+                    "--connection",
+                    cwd=working_dir / "agent",
+                )
 
-        self._run_aea_command(
-            "-s",
-            "add-key",
-            "--password",
-            password,
-            "ethereum",
-            cwd=working_dir / "agent",
-        )
-        self._run_aea_command(
-            "-s",
-            "add-key",
-            "--password",
-            password,
-            "ethereum",
-            "--connection",
-            cwd=working_dir / "agent",
-        )
+                self._run_aea_command(
+                    "-s",
+                    "issue-certificates",
+                    "--password",
+                    password,
+                    cwd=working_dir / "agent",
+                )
 
-        self._run_aea_command(
-            "-s",
-            "issue-certificates",
-            "--password",
-            password,
-            cwd=working_dir / "agent",
-        )
+                # Success - break out of retry loop
+                self.logger.info(
+                    f"Agent setup completed successfully on attempt {attempt}"
+                )
+                break
+
+            except Exception as e:  # pylint: disable=broad-except
+                self.logger.warning(
+                    f"Agent setup attempt {attempt}/{max_attempts} failed: {e}"
+                )
+                if attempt < max_attempts:
+                    sleep_time = attempt * 5
+                    self.logger.info(f"Retrying agent setup in {sleep_time} seconds...")
+                    time.sleep(sleep_time)
+                else:
+                    self.logger.error(f"All {max_attempts} agent setup attempts failed")
+                    raise
 
     def start(self, password: str) -> None:
         """Start the deployment with retries."""
@@ -439,12 +463,12 @@ class PyInstallerHostDeploymentRunnerMac(PyInstallerHostDeploymentRunner):
             **env,
         }
         env["PATH"] = os.path.dirname(sys.executable) + ":" + os.environ["PATH"]
-
+        tm_log_file = self._open_tendermint_log_file()
         process = subprocess.Popen(  # pylint: disable=consider-using-with,subprocess-popen-preexec-fn # nosec
             args=[self._tendermint_bin],
             cwd=working_dir,
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
+            stdout=tm_log_file,
+            stderr=tm_log_file,
             env=env,
             preexec_fn=os.setpgrp,  # pylint: disable=subprocess-popen-preexec-fn # nosec
         )
@@ -559,13 +583,14 @@ class PyInstallerHostDeploymentRunnerWindows(PyInstallerHostDeploymentRunner):
         env = {
             **env,
         }
+        tm_log_file = self._open_tendermint_log_file()
         env["PATH"] = os.path.dirname(sys.executable) + ";" + os.environ["PATH"]
 
         process = subprocess.Popen(  # pylint: disable=consider-using-with # nosec
             args=[self._tendermint_bin],
             cwd=working_dir,
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
+            stdout=tm_log_file,
+            stderr=tm_log_file,
             env=env,
             creationflags=0x00000200,  # Detach process from the main process
         )

{olas_operate_middleware-0.13.0 → olas_operate_middleware-0.13.2}/operate/services/health_checker.py

@@ -21,6 +21,7 @@
 import asyncio
 import json
 import logging
+import time
 import typing as t
 from concurrent.futures import ThreadPoolExecutor
 from http import HTTPStatus
@@ -40,6 +41,8 @@ class HealthChecker:
     PORT_UP_TIMEOUT_DEFAULT = 300  # seconds
     REQUEST_TIMEOUT_DEFAULT = 90  # seconds
     NUMBER_OF_FAILS_DEFAULT = 60
+    FAILFAST_NUM = 15
+    FAILFAST_TIMEOUT = 15 * 60  # 15 minutes
 
     def __init__(
         self,
@@ -121,7 +124,7 @@ class HealthChecker:
                     )
                     return False
 
-    async def healthcheck_job(
+    async def healthcheck_job(  # pylint: disable=too-many-statements
         self,
         service_config_id: str,
     ) -> None:
@@ -214,7 +217,24 @@ class HealthChecker:
                     if exception is not None:
                         raise exception
 
+            async def _stop(
+                service_manager: ServiceManager, service_config_id: str
+            ) -> None:
+                def _do_stop() -> None:
+                    service_manager.stop_service_locally(
+                        service_config_id=service_config_id
+                    )
+
+                loop = asyncio.get_event_loop()
+                with ThreadPoolExecutor() as executor:
+                    future = loop.run_in_executor(executor, _do_stop)
+                    await future
+                    exception = future.exception()
+                    if exception is not None:
+                        raise exception
+
             # upper cycle
+            failfast_records: t.List[float] = []
             while True:
                 self.logger.info(
                     f"[HEALTH_CHECKER] {service_config_id} wait for port ready"
@@ -224,6 +244,7 @@ class HealthChecker:
                     self.logger.info(
                         f"[HEALTH_CHECKER]  {service_config_id} port is ready, checking health every {self.sleep_period}"
                     )
+                    failfast_records = []
                     await _check_health(
                         number_of_fails=self.number_of_fails,
                         sleep_period=self.sleep_period,
@@ -236,7 +257,22 @@ class HealthChecker:
 
                 # perform restart
                 # TODO: blocking!!!!!!!
-                await _restart(self._service_manager, service_config_id)
+                while True:
+                    # we count every restart till success (port is up and healtcheck started)
+                    failfast_records.append(time.time())
+                    try:
+                        await _restart(self._service_manager, service_config_id)
+                        break
+                    except Exception:  # pylint: disable=broad-except
+                        if (len(failfast_records) >= self.FAILFAST_NUM) or (
+                            time.time() - failfast_records[0]
+                        ) > self.FAILFAST_TIMEOUT:
+                            await _stop(self._service_manager, service_config_id)
+                            raise
+
+                        self.logger.exception(f"Restart problem: {service_config_id}")
+                        await asyncio.sleep(30)
+
         except Exception:
             self.logger.exception(
                 f"Problems running healthcheck job for {service_config_id}"

{olas_operate_middleware-0.13.0 → olas_operate_middleware-0.13.2}/operate/services/manage.py

@@ -22,6 +22,7 @@
 import json
 import logging
 import os
+import time
 import traceback
 import typing as t
 from collections import Counter, defaultdict
@@ -105,6 +106,8 @@ from operate.wallet.master import InsufficientFundsException, MasterWalletManage
 # If multiple agents are provided in the service.yaml file, only the 0th index config will be used.
 NUM_LOCAL_AGENT_INSTANCES = 1
 
+RPC_SYNC_TIMEOUT = 15
+
 
 class ServiceManager:
     """Service manager."""
@@ -964,6 +967,10 @@ class ServiceManager:
             chain_data.token = event_data["args"]["serviceId"]
             service.store()
 
+        if is_first_mint:  # Hotfix to prevent RPC out-of-sync issues
+            time.sleep(RPC_SYNC_TIMEOUT)
+
+        # Activate service
         if (
             self._get_on_chain_state(service=service, chain=chain)
             == OnChainState.PRE_REGISTRATION
@@ -1028,6 +1035,10 @@ class ServiceManager:
                 )
             ).settle()
 
+        if is_first_mint:  # Hotfix to prevent RPC out-of-sync issues
+            time.sleep(RPC_SYNC_TIMEOUT)
+
+        # Register agent instances
         if (
             self._get_on_chain_state(service=service, chain=chain)
             == OnChainState.ACTIVE_REGISTRATION
@@ -1094,6 +1105,9 @@ class ServiceManager:
                 )
             ).settle()
 
+        if is_first_mint:  # Hotfix to prevent RPC out-of-sync issues
+            time.sleep(RPC_SYNC_TIMEOUT)
+
         # Deploy service
         is_initial_funding = False
         if (

{olas_operate_middleware-0.13.0 → olas_operate_middleware-0.13.2}/operate/wallet/master.py

@@ -722,6 +722,9 @@ class EthereumMasterWallet(MasterWallet):
                 "The master wallet cannot be set as the Safe backup owner."
             )
 
+        if self.address not in owners:
+            return False
+
         owners.remove(self.address)
         old_backup_owner = owners[0] if owners else None
 
@@ -769,7 +772,9 @@ class EthereumMasterWallet(MasterWallet):
             chain_str = chain.value
             ledger_api = self.ledger_api(chain=chain, rpc=rpc)
             owners = get_owners(ledger_api=ledger_api, safe=safe)
-            owners.remove(self.address)
+
+            if self.address in owners:
+                owners.remove(self.address)
 
             balances[chain_str] = {self.address: {}, safe: {}}
 
@@ -781,8 +786,8 @@ class EthereumMasterWallet(MasterWallet):
                 balances[chain_str][safe][asset] = self.get_balance(
                     chain=chain, asset=asset, from_safe=True
                 )
-            wallet_json["safes"][chain.value] = {
-                wallet_json["safes"][chain.value]: {
+            wallet_json["safes"][chain_str] = {
+                safe: {
                     "backup_owners": owners,
                     "balances": balances[chain_str][safe],
                 }
@@ -791,6 +796,9 @@ class EthereumMasterWallet(MasterWallet):
 
         wallet_json["balances"] = balances
         wallet_json["extended_json"] = True
+        wallet_json["all_safes_have_backup_owner"] = all(
+            len(owners) > 0 for owners in owner_sets
+        )
         wallet_json["consistent_safe_address"] = len(set(self.safes.values())) == 1
         wallet_json["consistent_backup_owner"] = len(owner_sets) == 1
         wallet_json["consistent_backup_owner_count"] = all(

{olas_operate_middleware-0.13.0 → olas_operate_middleware-0.13.2}/operate/wallet/wallet_recovery_manager.py

@@ -19,6 +19,7 @@
 
 """Wallet recovery manager"""
 
+import enum
 import shutil
 import typing as t
 import uuid
@@ -49,6 +50,19 @@ RECOVERY_NEW_OBJECTS_DIR = "new"
 RECOVERY_OLD_OBJECTS_DIR = "old"
 
 
+class WalletRecoveryStatus(str, enum.Enum):
+    """ProviderRequestStatus"""
+
+    NOT_PREPARED = "NOT_PREPARED"
+    PREPARED = "PREPARED"
+    IN_PROGRESS = "IN_PROGRESS"
+    COMPLETED = "COMPLETED"
+
+    def __str__(self) -> str:
+        """__str__"""
+        return self.value
+
+
 class WalletRecoveryError(Exception):
     """WalletRecoveryError"""
 
@@ -125,20 +139,16 @@ class WalletRecoveryManager:
                     )
 
         last_prepared_bundle_id = self.data.last_prepared_bundle_id
-        if last_prepared_bundle_id is not None:
-            (
-                _,
-                num_safes_with_new_wallet,
-                _,
-                _,
-            ) = self._get_swap_status(last_prepared_bundle_id)
-            if num_safes_with_new_wallet > 0:
-                self.logger.info(
-                    f"[WALLET RECOVERY MANAGER] Uncompleted bundle {last_prepared_bundle_id} has Safes with new wallet."
-                )
-                return self._load_bundle(
-                    bundle_id=last_prepared_bundle_id, new_password=new_password
-                )
+        if (
+            last_prepared_bundle_id is not None
+            and self.status()["num_safes_with_new_wallet"] > 0
+        ):
+            self.logger.info(
+                f"[WALLET RECOVERY MANAGER] Uncompleted bundle {last_prepared_bundle_id} has Safes with new wallet."
+            )
+            return self._load_bundle(
+                bundle_id=last_prepared_bundle_id, new_password=new_password
+            )
 
         # Create new recovery bundle
         bundle_id = f"{RECOVERY_BUNDLE_PREFIX}{str(uuid.uuid4())}"
@@ -178,23 +188,45 @@ class WalletRecoveryManager:
         )
         return self._load_bundle(bundle_id=bundle_id, new_password=new_password)
 
-    def _get_swap_status(self, bundle_id: str) -> t.Tuple[int, int, int, int]:
+    def _load_bundle(  # pylint: disable=too-many-locals
+        self, bundle_id: str, new_password: t.Optional[str] = None
+    ) -> t.Dict:
         new_root = self.path / bundle_id / RECOVERY_NEW_OBJECTS_DIR
+
+        new_user_account = UserAccount.load(new_root / USER_JSON)
+        if new_password is not None and not new_user_account.is_valid(
+            password=new_password
+        ):
+            raise ValueError(MSG_INVALID_PASSWORD)
+
         new_wallets_path = new_root / WALLETS_DIR
-        new_wallet_manager = MasterWalletManager(path=new_wallets_path, password=None)
+        new_wallet_manager = MasterWalletManager(
+            path=new_wallets_path, password=new_password
+        )
 
         num_safes = 0
         num_safes_with_new_wallet = 0
         num_safes_with_old_wallet = 0
         num_safes_with_both_wallets = 0
+        backup_owner_sets = set()
 
+        wallets = []
         for wallet in self.wallet_manager:
             new_wallet = next(
                 (w for w in new_wallet_manager if w.ledger_type == wallet.ledger_type)
             )
+            new_mnemonic = None
+            if new_password:
+                new_mnemonic = new_wallet.decrypt_mnemonic(password=new_password)
+
+            wallet_json = wallet.json
+
             for chain, safe in wallet.safes.items():
+                chain_str = chain.value
                 ledger_api = get_default_ledger_api(chain)
                 owners = get_owners(ledger_api=ledger_api, safe=safe)
+                backup_owners = list(set(owners) - {wallet.address, new_wallet.address})
+                backup_owner_sets.add(frozenset(backup_owners))
 
                 num_safes += 1
                 if new_wallet.address in owners and wallet.address in owners:
@@ -204,42 +236,52 @@ class WalletRecoveryManager:
                 if wallet.address in owners:
                     num_safes_with_old_wallet += 1
 
-        return (
-            num_safes,
-            num_safes_with_new_wallet,
-            num_safes_with_old_wallet,
-            num_safes_with_both_wallets,
-        )
-
-    def _load_bundle(self, bundle_id: str, new_password: str) -> t.Dict:
-        new_root = self.path / bundle_id / RECOVERY_NEW_OBJECTS_DIR
-
-        new_user_account = UserAccount.load(new_root / USER_JSON)
-        if not new_user_account.is_valid(password=new_password):
-            raise ValueError(MSG_INVALID_PASSWORD)
-
-        new_wallets_path = new_root / WALLETS_DIR
-        new_wallet_manager = MasterWalletManager(
-            path=new_wallets_path, password=new_password
-        )
+                wallet_json["safes"][chain_str] = {
+                    safe: {
+                        "owners": owners,
+                        "backup_owners": backup_owners,
+                        "owner_to_remove": wallet.address
+                        if wallet.address in owners
+                        else None,
+                        "owner_to_add": new_wallet.address
+                        if new_wallet.address not in owners
+                        else None,
+                    }
+                }
 
-        wallets = []
-        for wallet in self.wallet_manager:
-            ledger_type = wallet.ledger_type
-            new_wallet = new_wallet_manager.load(ledger_type=ledger_type)
-            new_mnemonic = None
-            if new_password:
-                new_mnemonic = new_wallet.decrypt_mnemonic(password=new_password)
             wallets.append(
                 {
-                    "current_wallet": wallet.json,
+                    "current_wallet": wallet_json,
                     "new_wallet": new_wallet.json,
                     "new_mnemonic": new_mnemonic,
                 }
             )
+
+        if num_safes_with_new_wallet == 0:
+            status = WalletRecoveryStatus.PREPARED
+        elif num_safes_with_new_wallet < num_safes:
+            status = WalletRecoveryStatus.IN_PROGRESS
+        else:
+            status = WalletRecoveryStatus.COMPLETED
+
         return {
             "id": bundle_id,
             "wallets": wallets,
+            "status": status,
+            "all_safes_have_backup_owner": all(
+                len(owners) >= 1 for owners in backup_owner_sets
+            ),
+            "consistent_backup_owner": len(backup_owner_sets) == 1,
+            "consistent_backup_owner_count": all(
+                len(owners) == 1 for owners in backup_owner_sets
+            ),
+            "prepared": bundle_id is not None,
+            "has_swaps": num_safes_with_new_wallet > 0,
+            "has_pending_swaps": num_safes_with_new_wallet < num_safes,
+            "num_safes": num_safes,
+            "num_safes_with_new_wallet": num_safes_with_new_wallet,
+            "num_safes_with_old_wallet": num_safes_with_old_wallet,
+            "num_safes_with_both_wallets": num_safes_with_both_wallets,
         }
 
     def recovery_requirements(  # pylint: disable=too-many-locals
@@ -317,27 +359,37 @@ class WalletRecoveryManager:
     def status(self) -> t.Dict[str, t.Any]:
         """Get recovery status."""
         bundle_id = self.data.last_prepared_bundle_id
-        if not bundle_id:
+        if bundle_id is None:
+            backup_owner_sets = set()
+            for wallet in self.wallet_manager:
+                for chain, safe in wallet.safes.items():
+                    ledger_api = get_default_ledger_api(chain)
+                    owners = get_owners(ledger_api=ledger_api, safe=safe)
+                    backup_owners = list(set(owners) - {wallet.address})
+                    backup_owner_sets.add(frozenset(backup_owners))
+
             return {
+                "id": None,
+                "wallets": [],
+                "status": WalletRecoveryStatus.NOT_PREPARED,
+                "all_safes_have_backup_owner": all(
+                    len(owners) >= 1 for owners in backup_owner_sets
+                ),
+                "consistent_backup_owner": len(backup_owner_sets) == 1,
+                "consistent_backup_owner_count": all(
+                    len(owners) == 1 for owners in backup_owner_sets
+                ),
                 "prepared": False,
                 "bundle_id": bundle_id,
                 "has_swaps": False,
                 "has_pending_swaps": False,
+                "num_safes": 0,
+                "num_safes_with_new_wallet": 0,
+                "num_safes_with_old_wallet": 0,
+                "num_safes_with_both_wallets": 0,
             }
 
-        (
-            num_safes,
-            num_safes_with_new_wallet,
-            _,
-            _,
-        ) = self._get_swap_status(bundle_id)
-
-        return {
-            "prepared": bundle_id is not None,
-            "bundle_id": bundle_id,
-            "has_swaps": num_safes_with_new_wallet > 0,
-            "has_pending_swaps": num_safes_with_new_wallet < num_safes,
-        }
+        return self._load_bundle(bundle_id=bundle_id)
 
     def complete_recovery(  # pylint: disable=too-many-locals,too-many-statements
         self, raise_if_inconsistent_owners: bool = True

{olas_operate_middleware-0.13.0 → olas_operate_middleware-0.13.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "olas-operate-middleware"
-version = "0.13.0"
+version = "0.13.2"
 description = ""
 authors = ["David Vilela <dvilelaf@gmail.com>", "Viraj Patel <vptl185@gmail.com>"]
 readme = "README.md"