Feat/revamp dashboard

.streamlit/config.toml

@@ -1,5 +1,5 @@
 [theme]
-base="light"
+base="dark"
 font="monospace"
 [server]
 port=8501

CONFIG.py

@@ -1,3 +1,10 @@
+import os
+
+from dotenv import load_dotenv
+
+
+load_dotenv()
+
 MINER_COINS = ["Algorand", "Avalanche", "DAO Maker", "Faith Tribe", "Fear", "Frontier",
                    "Harmony", "Hot Cross", "HUMAN Protocol", "Oddz", "Shera", "Firo",
                    "Vesper Finance", "Youclout", "Nimiq"]
@@ -12,3 +19,6 @@
 CERTIFIED_STRATEGIES = ["xemm", "cross exchange market making", "pmm", "pure market making"]
 
 AUTH_SYSTEM_ENABLED = False
+
+BACKEND_API_HOST = os.getenv("BACKEND_API_HOST", "127.0.0.1")
+BACKEND_API_PORT = os.getenv("BACKEND_API_PORT", 8000)

Dockerfile

@@ -39,18 +39,11 @@ ENV COMMIT_SHA=${COMMIT}
 ENV COMMIT_BRANCH=${BRANCH}
 ENV BUILD_DATE=${DATE}
 
-ENV INSTALLATION_TYPE=docker
-
 # Install system dependencies
 RUN apt-get update && \
     apt-get install -y curl && \
     rm -rf /var/lib/apt/lists/*
 
-# Install Docker CLI
-RUN curl -fsSL https://get.docker.com -o get-docker.sh && \
-    sh get-docker.sh && \
-    rm get-docker.sh
-
 # Create mount points
 RUN mkdir -p /home/dashboard/data
 

Makefile

@@ -1,19 +1,19 @@
 .ONESHELL:
 .PHONY: run
-.PHONY: conda_remove
-.PHONY: conda_create
+.PHONY: uninstall
+.PHONY: install
 
 run:
 	streamlit run main.py
 
-env_remove:
+uninstall:
 	conda env remove -n dashboard
 
-env_create:
+install:
 	conda env create -f environment_conda.yml
 
 docker_build:
-	docker build -t dashboard:latest .
+	docker build -t hummingbot/dashboard:latest .
 
 docker_run:
 	docker run -p 8501:8501 dashboard:latest

backend/services/backend_api_client.py

@@ -0,0 +1,281 @@
+import pandas as pd
+import requests
+from hummingbot.strategy_v2.models.executors_info import ExecutorInfo
+
+
+class BackendAPIClient:
+    """
+    This class is a client to interact with the backend API. The Backend API is a REST API that provides endpoints to
+    create new Hummingbot instances, start and stop them, add new script and controller config files, and get the status
+    of the active bots.
+    """
+    _shared_instance = None
+
+    @classmethod
+    def get_instance(cls, *args, **kwargs) -> "MarketsRecorder":
+        if cls._shared_instance is None:
+            cls._shared_instance = BackendAPIClient(*args, **kwargs)
+        return cls._shared_instance
+
+    def __init__(self, host: str = "localhost", port: int = 8000):
+        self.host = host
+        self.port = port
+        self.base_url = f"http://{self.host}:{self.port}"
+
+    def is_docker_running(self):
+        """Check if Docker is running."""
+        url = f"{self.base_url}/is-docker-running"
+        response = requests.get(url)
+        return response.json()
+
+    def pull_image(self, image_name: str):
+        """Pull a Docker image."""
+        url = f"{self.base_url}/pull-image/"
+        payload = {"image_name": image_name}
+        response = requests.post(url, json=payload)
+        return response.json()
+
+    def list_available_images(self, image_name: str):
+        """List available images by name."""
+        url = f"{self.base_url}/available-images/{image_name}"
+        response = requests.get(url)
+        return response.json()
+
+    def list_active_containers(self):
+        """List all active containers."""
+        url = f"{self.base_url}/active-containers"
+        response = requests.get(url)
+        return response.json()
+
+    def list_exited_containers(self):
+        """List all exited containers."""
+        url = f"{self.base_url}/exited-containers"
+        response = requests.get(url)
+        return response.json()
+
+    def clean_exited_containers(self):
+        """Clean up exited containers."""
+        url = f"{self.base_url}/clean-exited-containers"
+        response = requests.post(url)
+        return response.json()
+
+    def remove_container(self, container_name: str, archive_locally: bool = True, s3_bucket: str = None):
+        """Remove a specific container."""
+        url = f"{self.base_url}/remove-container/{container_name}"
+        params = {"archive_locally": archive_locally}
+        if s3_bucket:
+            params["s3_bucket"] = s3_bucket
+        response = requests.post(url, params=params)
+        return response.json()
+
+    def stop_container(self, container_name: str):
+        """Stop a specific container."""
+        url = f"{self.base_url}/stop-container/{container_name}"
+        response = requests.post(url)
+        return response.json()
+
+    def start_container(self, container_name: str):
+        """Start a specific container."""
+        url = f"{self.base_url}/start-container/{container_name}"
+        response = requests.post(url)
+        return response.json()
+
+    def create_hummingbot_instance(self, instance_config: dict):
+        """Create a new Hummingbot instance."""
+        url = f"{self.base_url}/create-hummingbot-instance"
+        response = requests.post(url, json=instance_config)
+        return response.json()
+
+    def start_bot(self, start_bot_config: dict):
+        """Start a Hummingbot bot."""
+        url = f"{self.base_url}/start-bot"
+        response = requests.post(url, json=start_bot_config)
+        return response.json()
+
+    def stop_bot(self, bot_name: str, skip_order_cancellation: bool = False, async_backend: bool = True):
+        """Stop a Hummingbot bot."""
+        url = f"{self.base_url}/stop-bot"
+        response = requests.post(url, json={"bot_name": bot_name, "skip_order_cancellation": skip_order_cancellation, "async_backend": async_backend})
+        return response.json()
+
+    def import_strategy(self, strategy_config: dict):
+        """Import a trading strategy to a bot."""
+        url = f"{self.base_url}/import-strategy"
+        response = requests.post(url, json=strategy_config)
+        return response.json()
+
+    def get_bot_status(self, bot_name: str):
+        """Get the status of a bot."""
+        url = f"{self.base_url}/get-bot-status/{bot_name}"
+        response = requests.get(url)
+        if response.status_code == 200:
+            return response.json()
+        else:
+            return {"status": "error", "data": "Bot not found"}
+
+    def get_bot_history(self, bot_name: str):
+        """Get the historical data of a bot."""
+        url = f"{self.base_url}/get-bot-history/{bot_name}"
+        response = requests.get(url)
+        return response.json()
+
+    def get_active_bots_status(self):
+        """
+        Retrieve the cached status of all active bots.
+        Returns a JSON response with the status and data of active bots.
+        """
+        url = f"{self.base_url}/get-active-bots-status"
+        response = requests.get(url)
+        if response.status_code == 200:
+            return response.json()  # Successful request
+        else:
+            return {"status": "error", "data": "No active bots found"}
+
+    def get_all_controllers_config(self):
+        """Get all controller configurations."""
+        url = f"{self.base_url}/all-controller-configs"
+        response = requests.get(url)
+        return response.json()
+
+    def get_available_images(self, image_name: str = "hummingbot"):
+        """Get available images."""
+        url = f"{self.base_url}/available-images/{image_name}"
+        response = requests.get(url)
+        return response.json()["available_images"]
+
+    def add_script_config(self, script_config: dict):
+        """Add a new script configuration."""
+        url = f"{self.base_url}/add-script-config"
+        response = requests.post(url, json=script_config)
+        return response.json()
+
+    def add_controller_config(self, controller_config: dict):
+        """Add a new controller configuration."""
+        url = f"{self.base_url}/add-controller-config"
+        config = {
+            "name": controller_config["id"],
+            "content": controller_config
+        }
+        response = requests.post(url, json=config)
+        return response.json()
+
+    def get_real_time_candles(self, connector: str, trading_pair: str, interval: str, max_records: int):
+        """Get candles data."""
+        url = f"{self.base_url}/real-time-candles"
+        payload = {
+            "connector": connector,
+            "trading_pair": trading_pair,
+            "interval": interval,
+            "max_records": max_records
+        }
+        response = requests.post(url, json=payload)
+        return response.json()
+
+    def get_historical_candles(self, connector: str, trading_pair: str, interval: str, start_time: int, end_time: int):
+        """Get historical candles data."""
+        url = f"{self.base_url}/historical-candles"
+        payload = {
+            "connector": connector,
+            "trading_pair": trading_pair,
+            "interval": interval,
+            "start_time": start_time,
+            "end_time": end_time
+        }
+        response = requests.post(url, json=payload)
+        return response.json()
+
+    def run_backtesting(self, start_time: int, end_time: int, backtesting_resolution: str, trade_cost: float, config: dict):
+        """Run backtesting."""
+        url = f"{self.base_url}/run-backtesting"
+        payload = {
+            "start_time": start_time,
+            "end_time": end_time,
+            "backtesting_resolution": backtesting_resolution,
+            "trade_cost": trade_cost,
+            "config": config
+        }
+        response = requests.post(url, json=payload)
+        backtesting_results = response.json()
+        if "processed_data" not in backtesting_results:
+            data = None
+        else:
+            data = pd.DataFrame(backtesting_results["processed_data"])
+        return {
+            "processed_data": data,
+            "executors": [ExecutorInfo(**executor) for executor in backtesting_results["executors"]],
+            "results": backtesting_results["results"]
+        }
+
+    def get_all_configs_from_bot(self, bot_name: str):
+        """Get all configurations from a bot."""
+        url = f"{self.base_url}/all-controller-configs/bot/{bot_name}"
+        response = requests.get(url)
+        return response.json()
+
+    def stop_controller_from_bot(self, bot_name: str, controller_id: str):
+        """Stop a controller from a bot."""
+        config = {"manual_kill_switch": True}
+        url = f"{self.base_url}/update-controller-config/bot/{bot_name}/{controller_id}"
+        response = requests.post(url, json=config)
+        return response.json()
+
+    def start_controller_from_bot(self, bot_name: str, controller_id: str):
+        """Start a controller from a bot."""
+        config = {"manual_kill_switch": False}
+        url = f"{self.base_url}/update-controller-config/bot/{bot_name}/{controller_id}"
+        response = requests.post(url, json=config)
+        return response.json()
+
+    def get_connector_config_map(self, connector_name: str):
+        """Get connector configuration map."""
+        url = f"{self.base_url}/connector-config-map/{connector_name}"
+        response = requests.get(url)
+        return response.json()
+
+    def get_all_connectors_config_map(self):
+        """Get all connector configuration maps."""
+        url = f"{self.base_url}/all-connectors-config-map"
+        response = requests.get(url)
+        return response.json()
+
+    def add_account(self, account_name: str):
+        """Add a new account."""
+        url = f"{self.base_url}/add-account"
+        response = requests.post(url, params={"account_name": account_name})
+        return response.json()
+
+    def delete_account(self, account_name: str):
+        """Delete an account."""
+        url = f"{self.base_url}/delete-account/"
+        response = requests.post(url, params={"account_name": account_name})
+        return response.json()
+
+    def delete_credential(self, account_name: str, connector_name: str):
+        """Delete credentials."""
+        url = f"{self.base_url}/delete-credential/{account_name}/{connector_name}"
+        response = requests.post(url)
+        return response.json()
+
+    def add_connector_keys(self, account_name: str, connector_name: str, connector_config: dict):
+        """Add connector keys."""
+        url = f"{self.base_url}/add-connector-keys/{account_name}/{connector_name}"
+        response = requests.post(url, json=connector_config)
+        return response.json()
+
+    def get_accounts(self):
+        """Get available credentials."""
+        url = f"{self.base_url}/list-accounts"
+        response = requests.get(url)
+        return response.json()
+
+    def get_credentials(self, account_name: str):
+        """Get available credentials."""
+        url = f"{self.base_url}/list-credentials/{account_name}"
+        response = requests.get(url)
+        return response.json()
+
+    def get_all_balances(self):
+        """Get all balances."""
+        url = f"{self.base_url}/get-all-balances"
+        response = requests.get(url)
+        return response.json()

utils/coingecko_utils.py → backend/services/coingecko_client.py

@@ -5,7 +5,7 @@
 import re
 
 
-class CoinGeckoUtils:
+class CoinGeckoClient:
     def __init__(self):
         self.connector = CoinGeckoAPI()
 

utils/miner_utils.py → backend/services/miner_client.py

@@ -3,7 +3,7 @@
 from glom import *
 
 
-class MinerUtils:
+class MinerClient:
     MARKETS_ENDPOINT = "https://api.hummingbot.io/bounty/markets"
 
     @staticmethod

utils/file_templates.py → backend/utils/file_templates.py

@@ -10,9 +10,9 @@ def directional_trading_controller_template(strategy_cls_name: str) -> str:
 import pandas as pd
 from pydantic import Field
 
-from hummingbot.smart_components.executors.position_executor.position_executor import PositionExecutor
-from hummingbot.smart_components.strategy_frameworks.data_types import OrderLevel
-from hummingbot.smart_components.strategy_frameworks.directional_trading.directional_trading_controller_base import (
+from hummingbot.strategy_v2.executors.position_executor.position_executor import PositionExecutor
+from hummingbot.strategy_v2.strategy_frameworks.data_types import OrderLevel
+from hummingbot.strategy_v2.strategy_frameworks.directional_trading.directional_trading_controller_base import (
     DirectionalTradingControllerBase,
     DirectionalTradingControllerConfigBase,
 )
@@ -100,9 +100,9 @@ def strategy_optimization_template(strategy_info: dict):
 
 from hummingbot.core.data_type.common import PositionMode, TradeType, OrderType
 from hummingbot.data_feed.candles_feed.candles_factory import CandlesConfig
-from hummingbot.smart_components.strategy_frameworks.data_types import TripleBarrierConf, OrderLevel
-from hummingbot.smart_components.strategy_frameworks.directional_trading import DirectionalTradingBacktestingEngine
-from hummingbot.smart_components.utils.config_encoder_decoder import ConfigEncoderDecoder
+from hummingbot.strategy_v2.strategy_frameworks.data_types import TripleBarrierConf, OrderLevel
+from hummingbot.strategy_v2.strategy_frameworks.directional_trading import DirectionalTradingBacktestingEngine
+from hummingbot.strategy_v2.utils.config_encoder_decoder import ConfigEncoderDecoder
 from optuna import TrialPruned   
 
 from quants_lab.controllers.{strategy_module} import {strategy_cls.__name__}, {strategy_config.__name__}