Restore original tab layout while keeping cached data

README.md

@@ -11,3 +11,14 @@ license: apache-2.0
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+## Repository layout
+
+The prototype is now organized into lightweight layers to keep responsibilities clear even in a demo setting:
+
+- `application/` – orchestration services that combine prompts with infrastructure adapters.
+- `infrastructure/` – clients for external APIs and market data providers (Featherless, Coinlore, etc.).
+- `presentation/` – Gradio components, dashboards, and CSS themes displayed in the Space UI.
+- `domain/` – placeholder for future data models specific to the investment analytics domain.
+
+`app.py` wires these pieces together to expose the multi-tab Gradio experience on Hugging Face Spaces.

app.py

@@ -1,11 +1,19 @@
 import gradio as gr
-from services.llm_client import llm_service
-from core.analyzer import PortfolioAnalyzer
-from core.comparer import PortfolioComparer
-from core.chat import ChatAssistant
-from core.metrics import show_metrics_table
-from core.crypto_dashboard import build_crypto_dashboard  # Plotly dashboard + KPI-line
-from core.visual_comparison import build_price_chart, build_volatility_chart  # Interactive pair comparison
+
+from application.chat_assistant import ChatAssistant
+from application.metrics_table import show_metrics_table
+from application.portfolio_analyzer import PortfolioAnalyzer
+from application.portfolio_comparer import PortfolioComparer
+from infrastructure.llm_client import llm_service
+from presentation.components.crypto_dashboard import (
+    build_crypto_dashboard,
+)  # Plotly dashboard + KPI-line
+from presentation.components.comparison_table import show_comparison_table
+from presentation.components.visual_comparison import (
+    build_price_chart,
+    build_volatility_chart,
+    preload_pairs,
+)  # Interactive pair comparison
 
 # === CSS loader ===
 def load_css(path: str) -> str:
@@ -13,8 +21,8 @@ def load_css(path: str) -> str:
         return f.read()
 
 # === Styles ===
-base_css   = load_css("core/styles/base.css")
-crypto_css = load_css("core/styles/crypto_dashboard.css")
+base_css = load_css("presentation/styles/themes/base.css")
+crypto_css = load_css("presentation/styles/themes/crypto_dashboard.css")
 
 # === Model setup ===
 MODEL_NAME = "meta-llama/Meta-Llama-3.1-8B-Instruct"
@@ -39,18 +47,35 @@ with gr.Blocks(css=base_css) as demo:
                 value="b1ef37aa-5b9a-41b4-9394-8823f2de36bb",
             )
             analyze_btn = gr.Button("Run Analysis", variant="primary")
-            analyze_out = gr.Textbox(label="Analysis Result", lines=15, elem_id="analysis_output")
+            analyze_out = gr.Textbox(
+                label="Analysis Result",
+                lines=15,
+                elem_id="analysis_output",
+            )
             analyze_btn.click(fn=analyzer.run, inputs=portfolio_input, outputs=analyze_out)
 
         # --- Comparison Table ---
         with gr.TabItem("Comparison Table"):
-            from core.comparison_table import show_comparison_table
             pid_a = gr.Textbox(label="Portfolio A", value="3852a354-e66e-4bc5-97e9-55124e31e687")
             pid_b = gr.Textbox(label="Portfolio B", value="b1ef37aa-5b9a-41b4-8823f2de36bb")
             compare_btn = gr.Button("Load Comparison", variant="primary")
             comp_table = gr.Dataframe(label="Comparative Metrics", wrap=True)
             comp_comment = gr.Textbox(label="AI Commentary", lines=14, elem_id="llm_comment_box")
-            compare_btn.click(fn=show_comparison_table, inputs=[pid_a, pid_b], outputs=[comp_table, comp_comment])
+            compare_btn.click(
+                fn=show_comparison_table,
+                inputs=[pid_a, pid_b],
+                outputs=[comp_table, comp_comment],
+            )
+
+        # --- Metrics Table ---
+        with gr.TabItem("Metrics Table"):
+            metrics_in = gr.Textbox(
+                label="Portfolio ID",
+                value="b1ef37aa-5b9a-41b4-9394-8823f2de36bb",
+            )
+            metrics_btn = gr.Button("Load Metrics", variant="primary")
+            metrics_out = gr.Dataframe(label="Portfolio Metrics", wrap=True)
+            metrics_btn.click(fn=show_metrics_table, inputs=metrics_in, outputs=metrics_out)
 
         # --- Assistant ---
         with gr.TabItem("Assistant"):
@@ -59,13 +84,6 @@ with gr.Blocks(css=base_css) as demo:
             chat_out = gr.Textbox(label="AI Response", lines=8)
             chat_btn.click(fn=chatbot.run, inputs=chat_in, outputs=chat_out)
 
-        # --- Metrics Table ---
-        with gr.TabItem("Metrics Table"):
-            metrics_in = gr.Textbox(label="Portfolio ID", value="b1ef37aa-5b9a-41b4-9394-8823f2de36bb")
-            metrics_btn = gr.Button("Load Metrics", variant="primary")
-            metrics_out = gr.Dataframe(label="Portfolio Metrics", wrap=True)
-            metrics_btn.click(fn=show_metrics_table, inputs=metrics_in, outputs=metrics_out)
-
         # --- Visual Comparison (Interactive Plotly Edition) ---
         with gr.TabItem("Visual Comparison"):
             gr.Markdown("### 📊 Market Pair Comparison — Interactive Plotly Edition")
@@ -97,6 +115,7 @@ with gr.Blocks(css=base_css) as demo:
             pair_selector.change(fn=update_visuals, inputs=pair_selector, outputs=[price_plot, vol_plot])
 
             def init_visuals():
+                preload_pairs(available_pairs)
                 return update_visuals("Bitcoin vs Ethereum")
 
             demo.load(fn=init_visuals, inputs=None, outputs=[price_plot, vol_plot])

application/__init__.py

@@ -0,0 +1,13 @@
+"""Application layer services orchestrating domain and infrastructure."""
+
+from .chat_assistant import ChatAssistant
+from .metrics_table import show_metrics_table
+from .portfolio_analyzer import PortfolioAnalyzer
+from .portfolio_comparer import PortfolioComparer
+
+__all__ = [
+    "ChatAssistant",
+    "PortfolioAnalyzer",
+    "PortfolioComparer",
+    "show_metrics_table",
+]

core/chat.py → application/chat_assistant.py

@@ -7,7 +7,8 @@ Purpose: General chat interface for user questions about investments or portfoli
 """
 
 from typing import Generator
-from services.llm_client import llm_service
+
+from infrastructure.llm_client import llm_service
 from prompts.system_prompts import GENERAL_CONTEXT
 
 

core/metrics.py → application/metrics_table.py

@@ -6,29 +6,39 @@ Purpose: Provides async utilities to fetch and display portfolio metrics as a Da
 Назначение: предоставляет асинхронные функции для получения и отображения метрик портфеля в виде DataFrame.
 """
 
-import pandas as pd
 import asyncio
-from services.output_api import extract_portfolio_id, fetch_metrics_async
+
+import pandas as pd
+
+from infrastructure.cache import CacheUnavailableError
+from infrastructure.output_api import extract_portfolio_id, fetch_metrics_cached
 
 
 def show_metrics_table(portfolio_input: str):
     """Fetch portfolio metrics and return them as a DataFrame for Gradio."""
     pid = extract_portfolio_id(portfolio_input)
     if not pid:
-        return "❌ Invalid portfolioId format."
+        return _message_df("❌ Invalid portfolioId format.")
 
     try:
         df = asyncio.run(_get_metrics_df(pid))
         return df
+    except CacheUnavailableError as e:
+        wait = int(e.retry_in) + 1
+        return _message_df(f"⚠️ Metrics API cooling down. Retry in ~{wait} seconds.")
     except Exception as e:
-        return f"❌ Error fetching metrics: {e}"
+        return _message_df(f"❌ Error fetching metrics: {e}")
 
 
 async def _get_metrics_df(portfolio_id: str) -> pd.DataFrame:
     """Internal helper to asynchronously get metrics."""
-    metrics = await fetch_metrics_async(portfolio_id)
+    metrics = await fetch_metrics_cached(portfolio_id)
     if not metrics:
         raise ValueError("No metrics found for given portfolio.")
 
     df = pd.DataFrame(list(metrics.items()), columns=["Metric", "Value"])
     return df
+
+
+def _message_df(message: str) -> pd.DataFrame:
+    return pd.DataFrame({"Message": [message]})

core/analyzer.py → application/portfolio_analyzer.py

@@ -8,8 +8,10 @@ Purpose: Handles single-portfolio analysis using LLM. Fetches metrics, builds pr
 
 import asyncio
 from typing import Generator
-from services.output_api import extract_portfolio_id, fetch_metrics_async
-from services.llm_client import llm_service
+
+from infrastructure.cache import CacheUnavailableError
+from infrastructure.output_api import extract_portfolio_id, fetch_metrics_cached
+from infrastructure.llm_client import llm_service
 from prompts.system_prompts import ANALYSIS_SYSTEM_PROMPT
 from prompts.reference_templates import REFERENCE_PROMPT
 
@@ -30,7 +32,11 @@ class PortfolioAnalyzer:
 
         yield "⏳ Working..."
         try:
-            metrics = asyncio.run(fetch_metrics_async(portfolio_id))
+            metrics = asyncio.run(fetch_metrics_cached(portfolio_id))
+        except CacheUnavailableError as e:
+            wait = int(e.retry_in) + 1
+            yield f"⚠️ API temporarily unavailable. Please retry in ~{wait} seconds."
+            return
         except Exception as e:
             yield f"❌ Fail to collect metrics: {e}"
             return

core/comparer.py → application/portfolio_comparer.py

@@ -8,8 +8,10 @@ Purpose: Compares two portfolios using LLM. Fetches metrics for both and builds
 
 import asyncio
 from typing import Generator
-from services.output_api import extract_portfolio_id, fetch_metrics_async
-from services.llm_client import llm_service
+
+from infrastructure.cache import CacheUnavailableError
+from infrastructure.output_api import extract_portfolio_id, fetch_metrics_cached
+from infrastructure.llm_client import llm_service
 from prompts.system_prompts import COMPARISON_SYSTEM_PROMPT
 from prompts.reference_templates import REFERENCE_COMPARISON_PROMPT
 
@@ -35,8 +37,12 @@ class PortfolioComparer:
 
         yield "⏳ Working..."
         try:
-            m1 = asyncio.run(fetch_metrics_async(id1))
-            m2 = asyncio.run(fetch_metrics_async(id2))
+            m1 = asyncio.run(fetch_metrics_cached(id1))
+            m2 = asyncio.run(fetch_metrics_cached(id2))
+        except CacheUnavailableError as e:
+            wait = int(e.retry_in) + 1
+            yield f"⚠️ API temporarily unavailable. Retry in ~{wait} seconds."
+            return
         except Exception as e:
             yield f"❌ There are issue via collecting data: {e}"
             return

config.py

@@ -18,3 +18,7 @@ EXTERNAL_API_URL = os.getenv("EXTERNAL_API_URL")
 # === Request / Connection Settings ===
 REQUEST_TIMEOUT = 15
 DEBUG = os.getenv("DEBUG", "false").lower() == "true"
+
+# === Caching Settings ===
+CACHE_TTL_SECONDS = int(os.getenv("CACHE_TTL_SECONDS", "600"))  # 10 minutes
+CACHE_RETRY_SECONDS = int(os.getenv("CACHE_RETRY_SECONDS", "30"))  # cooldown after failures

core/__init__.py

@@ -1,2 +1,13 @@
-# __init__.py
-# Marks this directory as a Python package.
+"""Legacy compatibility layer bridging old imports to the new structure."""
+
+from application.chat_assistant import ChatAssistant
+from application.metrics_table import show_metrics_table
+from application.portfolio_analyzer import PortfolioAnalyzer
+from application.portfolio_comparer import PortfolioComparer
+
+__all__ = [
+    "ChatAssistant",
+    "PortfolioAnalyzer",
+    "PortfolioComparer",
+    "show_metrics_table",
+]

domain/__init__.py

@@ -0,0 +1,3 @@
+"""Domain layer placeholder for future data models in the prototype."""
+
+__all__: list[str] = []

infrastructure/__init__.py

@@ -0,0 +1,20 @@
+"""Infrastructure adapters for external services and data providers."""
+
+from . import market_data
+from .llm_client import FeatherlessLLM, llm_service
+from .output_api import (
+    extract_portfolio_id,
+    fetch_absolute_pnl_async,
+    fetch_metrics_async,
+    fetch_metrics_cached,
+)
+
+__all__ = [
+    "FeatherlessLLM",
+    "llm_service",
+    "extract_portfolio_id",
+    "fetch_absolute_pnl_async",
+    "fetch_metrics_async",
+    "fetch_metrics_cached",
+    "market_data",
+]

infrastructure/cache.py

@@ -0,0 +1,167 @@
+"""Utility caching primitives used across the demo application."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from dataclasses import dataclass
+from threading import Lock
+from typing import Awaitable, Callable, Dict, Generic, Hashable, Optional, TypeVar
+
+T = TypeVar("T")
+
+
+class CacheUnavailableError(RuntimeError):
+    """Raised when cached resource is temporarily unavailable."""
+
+    def __init__(self, message: str, retry_in: float):
+        super().__init__(message)
+        self.retry_in = max(retry_in, 0.0)
+
+
+@dataclass
+class _CacheRecord(Generic[T]):
+    value: Optional[T]
+    expires_at: float
+    error_until: float
+    error_message: Optional[str]
+
+
+class AsyncTTLCache(Generic[T]):
+    """Simple async-aware TTL cache with cooldown on failures."""
+
+    def __init__(self, ttl: float, retry_after: float):
+        self.ttl = ttl
+        self.retry_after = retry_after
+        self._store: Dict[Hashable, _CacheRecord[T]] = {}
+        self._locks: Dict[Hashable, asyncio.Lock] = {}
+        self._global_lock = asyncio.Lock()
+
+    async def get(self, key: Hashable, loader: Callable[[], Awaitable[T]]) -> T:
+        now = time.monotonic()
+        record = self._store.get(key)
+        if record:
+            if record.value is not None and now < record.expires_at:
+                return record.value
+            if record.error_message and now < record.error_until:
+                raise CacheUnavailableError(
+                    record.error_message,
+                    record.error_until - now,
+                )
+
+        lock = await self._get_lock(key)
+        async with lock:
+            now = time.monotonic()
+            record = self._store.get(key)
+            if record:
+                if record.value is not None and now < record.expires_at:
+                    return record.value
+                if record.error_message and now < record.error_until:
+                    raise CacheUnavailableError(
+                        record.error_message,
+                        record.error_until - now,
+                    )
+
+            try:
+                value = await loader()
+            except CacheUnavailableError as exc:
+                cooldown = max(exc.retry_in, self.retry_after)
+                message = str(exc) or "Resource unavailable"
+                self._store[key] = _CacheRecord(
+                    value=None,
+                    expires_at=0.0,
+                    error_until=now + cooldown,
+                    error_message=message,
+                )
+                raise CacheUnavailableError(message, cooldown) from exc
+            except Exception as exc:  # noqa: BLE001 - surface upstream
+                message = str(exc) or "Source request failed"
+                self._store[key] = _CacheRecord(
+                    value=None,
+                    expires_at=0.0,
+                    error_until=now + self.retry_after,
+                    error_message=message,
+                )
+                raise CacheUnavailableError(message, self.retry_after) from exc
+            else:
+                self._store[key] = _CacheRecord(
+                    value=value,
+                    expires_at=now + self.ttl,
+                    error_until=0.0,
+                    error_message=None,
+                )
+                return value
+
+    async def _get_lock(self, key: Hashable) -> asyncio.Lock:
+        lock = self._locks.get(key)
+        if lock is not None:
+            return lock
+        async with self._global_lock:
+            lock = self._locks.get(key)
+            if lock is None:
+                lock = asyncio.Lock()
+                self._locks[key] = lock
+            return lock
+
+
+class TTLCache(Generic[T]):
+    """Synchronous TTL cache with cooldown control."""
+
+    def __init__(self, ttl: float, retry_after: float):
+        self.ttl = ttl
+        self.retry_after = retry_after
+        self._store: Dict[Hashable, _CacheRecord[T]] = {}
+        self._lock = Lock()
+
+    def get(self, key: Hashable, loader: Callable[[], T]) -> T:
+        now = time.monotonic()
+        record = self._store.get(key)
+        if record:
+            if record.value is not None and now < record.expires_at:
+                return record.value
+            if record.error_message and now < record.error_until:
+                raise CacheUnavailableError(
+                    record.error_message,
+                    record.error_until - now,
+                )
+
+        with self._lock:
+            now = time.monotonic()
+            record = self._store.get(key)
+            if record:
+                if record.value is not None and now < record.expires_at:
+                    return record.value
+                if record.error_message and now < record.error_until:
+                    raise CacheUnavailableError(
+                        record.error_message,
+                        record.error_until - now,
+                    )
+            try:
+                value = loader()
+            except CacheUnavailableError as exc:
+                cooldown = max(exc.retry_in, self.retry_after)
+                message = str(exc) or "Resource unavailable"
+                self._store[key] = _CacheRecord(
+                    value=None,
+                    expires_at=0.0,
+                    error_until=now + cooldown,
+                    error_message=message,
+                )
+                raise CacheUnavailableError(message, cooldown) from exc
+            except Exception as exc:  # noqa: BLE001 - propagate for visibility
+                message = str(exc) or "Source request failed"
+                self._store[key] = _CacheRecord(
+                    value=None,
+                    expires_at=0.0,
+                    error_until=now + self.retry_after,
+                    error_message=message,
+                )
+                raise CacheUnavailableError(message, self.retry_after) from exc
+            else:
+                self._store[key] = _CacheRecord(
+                    value=value,
+                    expires_at=now + self.ttl,
+                    error_until=0.0,
+                    error_message=None,
+                )
+                return value

infrastructure/market_data/__init__.py

@@ -0,0 +1,5 @@
+"""Market data providers used across the prototype."""
+
+from . import binance, coinlore, yfinance
+
+__all__ = ["binance", "coinlore", "yfinance"]

{services → infrastructure}/output_api.py

@@ -11,7 +11,14 @@ Handles fetching metrics, alphaBTC data, and other portfolio information.
 import re
 import httpx
 from typing import Any, Dict, List, Optional
-from config import EXTERNAL_API_URL, REQUEST_TIMEOUT, DEBUG
+from config import (
+    CACHE_RETRY_SECONDS,
+    CACHE_TTL_SECONDS,
+    DEBUG,
+    EXTERNAL_API_URL,
+    REQUEST_TIMEOUT,
+)
+from infrastructure.cache import AsyncTTLCache, CacheUnavailableError
 
 # === UUID detection ===
 UUID_PATTERN = re.compile(
@@ -59,6 +66,24 @@ async def fetch_metrics_async(portfolio_id: str) -> Optional[Dict[str, Any]]:
         return None
 
 
+_metrics_cache = AsyncTTLCache(CACHE_TTL_SECONDS, CACHE_RETRY_SECONDS)
+
+
+async def fetch_metrics_cached(portfolio_id: str) -> Dict[str, Any]:
+    """Cached variant with cooldown on upstream failures."""
+
+    async def _loader() -> Dict[str, Any]:
+        data = await fetch_metrics_async(portfolio_id)
+        if not data:
+            raise CacheUnavailableError(
+                "Metrics temporarily unavailable from upstream API.",
+                CACHE_RETRY_SECONDS,
+            )
+        return data
+
+    return await _metrics_cache.get(portfolio_id, _loader)
+
+
 async def fetch_absolute_pnl_async(portfolio_id: str) -> Optional[List[Dict[str, Any]]]:
     """Fetch absolutePnL daily data."""
     url = f"{EXTERNAL_API_URL}/portfolio/get?portfolioId={portfolio_id}&extended=1&step=day"

presentation/__init__.py

@@ -0,0 +1,5 @@
+"""Presentation layer: UI components, charts, and styles."""
+
+from . import components, styles
+
+__all__ = ["components", "styles"]

presentation/components/__init__.py

@@ -0,0 +1,12 @@
+"""Individual UI components used by the Gradio interface."""
+
+from .comparison_table import show_comparison_table
+from .crypto_dashboard import build_crypto_dashboard
+from .visual_comparison import build_price_chart, build_volatility_chart
+
+__all__ = [
+    "show_comparison_table",
+    "build_crypto_dashboard",
+    "build_price_chart",
+    "build_volatility_chart",
+]

{core → presentation/components}/comparison_table.py

@@ -6,34 +6,90 @@ Purpose: Generates comparative DataFrame for two portfolios and an LLM commentar
 Назначение: создаёт сравнительную таблицу метрик двух портфелей и комментарий LLM.
 """
 
-import pandas as pd
 import asyncio
-from services.output_api import fetch_metrics_async, extract_portfolio_id
-from services.llm_client import llm_service
+
+import pandas as pd
+
+from infrastructure.cache import CacheUnavailableError
+from infrastructure.llm_client import llm_service
+from infrastructure.output_api import (
+    extract_portfolio_id,
+    fetch_metrics_cached,
+)
 from prompts.system_prompts import COMPARISON_SYSTEM_PROMPT
 
 
 def show_comparison_table(portfolio_a: str, portfolio_b: str):
-    """Public Gradio entry: returns both a DataFrame and LLM commentary."""
+    """Return the comparison DataFrame along with commentary."""
+
     pid_a = extract_portfolio_id(portfolio_a)
     pid_b = extract_portfolio_id(portfolio_b)
     if not pid_a or not pid_b:
-        return "❌ Invalid portfolio IDs.", "No commentary available."
+        message = "❌ Invalid portfolio IDs."
+        return _message_df(message), message
 
     try:
         df, commentary = asyncio.run(_build_comparison_with_comment(pid_a, pid_b))
         return df, commentary
+    except CacheUnavailableError as e:
+        wait = int(e.retry_in) + 1
+        message = f"⚠️ Metrics temporarily unavailable. Retry in ~{wait} seconds."
+        return _message_df(message), message
+    except Exception as e:
+        message = f"❌ Error building comparison table: {e}"
+        return _message_df(message), message
+
+
+def stream_comparison_commentary(portfolio_a: str, portfolio_b: str):
+    """Stream the AI commentary using cached metrics."""
+
+    pid_a = extract_portfolio_id(portfolio_a)
+    pid_b = extract_portfolio_id(portfolio_b)
+    if not pid_a or not pid_b:
+        yield "❌ Invalid portfolio IDs."
+        return
+
+    yield "⏳ Working..."
+    try:
+        m1, m2 = asyncio.run(_fetch_metric_pair(pid_a, pid_b))
+    except CacheUnavailableError as e:
+        wait = int(e.retry_in) + 1
+        yield f"⚠️ Metrics temporarily unavailable. Retry in ~{wait} seconds."
+        return
     except Exception as e:
-        return f"❌ Error building comparison table: {e}", "❌ LLM analysis failed."
+        yield f"❌ Error collecting metrics: {e}"
+        return
+
+    if not m1 or not m2:
+        yield "❗ Metrics unavailable for one of the portfolios."
+        return
+
+    try:
+        for partial in _commentary_stream(_rows_from_metrics(m1, m2)):
+            yield partial
+    except Exception as e:  # noqa: BLE001
+        yield f"❌ LLM analysis failed: {e}"
 
 
 async def _build_comparison_with_comment(p1: str, p2: str):
-    """Async helper: builds table and gets commentary."""
-    m1 = await fetch_metrics_async(p1)
-    m2 = await fetch_metrics_async(p2)
+    m1, m2 = await _fetch_metric_pair(p1, p2)
     if not m1 or not m2:
         raise ValueError("Metrics unavailable for one or both portfolios.")
 
+    rows = _rows_from_metrics(m1, m2)
+    df = pd.DataFrame(rows, columns=["Metric", "Portfolio A", "Portfolio B", "Δ Difference"])
+    commentary = _collect_commentary(rows)
+    return df, commentary
+
+
+async def _fetch_metric_pair(p1: str, p2: str):
+    return await asyncio.gather(
+        fetch_metrics_cached(p1),
+        fetch_metrics_cached(p2),
+    )
+
+
+def _rows_from_metrics(m1: dict, m2: dict):
     all_keys = sorted(set(m1.keys()) | set(m2.keys()))
     rows = []
     for k in all_keys:
@@ -41,15 +97,29 @@ async def _build_comparison_with_comment(p1: str, p2: str):
         v2 = m2.get(k, 0)
         diff = v1 - v2
         symbol = "▲" if diff > 0 else "▼" if diff < 0 else "—"
-        rows.append({
-            "Metric": k,
-            "Portfolio A": round(v1, 3),
-            "Portfolio B": round(v2, 3),
-            "Δ Difference": f"{symbol} {diff:+.3f}"
-        })
-    df = pd.DataFrame(rows, columns=["Metric", "Portfolio A", "Portfolio B", "Δ Difference"])
+        rows.append(
+            {
+                "Metric": k,
+                "Portfolio A": round(v1, 3),
+                "Portfolio B": round(v2, 3),
+                "Δ Difference": f"{symbol} {diff:+.3f}",
+            }
+        )
+    return rows
+
 
-    # Generate LLM commentary
+def _message_df(message: str) -> pd.DataFrame:
+    return pd.DataFrame({"Message": [message]})
+
+
+def _collect_commentary(rows: list[dict]) -> str:
+    commentary = ""
+    for partial in _commentary_stream(rows):
+        commentary = partial
+    return commentary
+
+
+def _commentary_stream(rows: list[dict]):
     summary = "\n".join(f"{r['Metric']}: {r['Δ Difference']}" for r in rows)
     prompt = (
         f"{COMPARISON_SYSTEM_PROMPT}\n"
@@ -57,7 +127,7 @@ async def _build_comparison_with_comment(p1: str, p2: str):
         f"Write your insights as a concise professional commentary."
     )
 
-    commentary = ""
+    partial = ""
     for delta in llm_service.stream_chat(
         messages=[
             {"role": "system", "content": "You are an investment portfolio analyst."},
@@ -65,6 +135,5 @@ async def _build_comparison_with_comment(p1: str, p2: str):
         ],
         model="meta-llama/Meta-Llama-3.1-8B-Instruct",
     ):
-        commentary += delta
-
-    return df, commentary
+        partial += delta
+        yield partial

{core → presentation/components}/crypto_dashboard.py

@@ -5,9 +5,11 @@ Crypto Dashboard — Plotly Edition (clean layout)
 • без глобального Markdown-заголовка
 """
 import requests
+
 import pandas as pd
 import plotly.express as px
-from services.llm_client import llm_service
+
+from infrastructure.llm_client import llm_service
 
 
 def fetch_coinlore_data(limit=100):

{core → presentation/components}/visual_comparison.py

@@ -7,26 +7,43 @@ import requests
 import pandas as pd
 import plotly.graph_objects as go
 
+from config import CACHE_RETRY_SECONDS, CACHE_TTL_SECONDS
+from infrastructure.cache import CacheUnavailableError, TTLCache
+
 COINGECKO_API = "https://api.coingecko.com/api/v3"
 
+_history_cache = TTLCache(CACHE_TTL_SECONDS, CACHE_RETRY_SECONDS)
+
 
 def get_coin_history(coin_id: str, days: int = 180):
     """Fetch historical market data for given coin from CoinGecko API."""
-    url = f"{COINGECKO_API}/coins/{coin_id}/market_chart?vs_currency=usd&days={days}"
-    r = requests.get(url)
-    r.raise_for_status()
-    data = r.json()
-    df = pd.DataFrame(data["prices"], columns=["timestamp", "price"])
-    df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")
-    return df
+    def _load():
+        url = f"{COINGECKO_API}/coins/{coin_id}/market_chart?vs_currency=usd&days={days}"
+        r = requests.get(url, timeout=20)
+        r.raise_for_status()
+        data = r.json()
+        df = pd.DataFrame(data["prices"], columns=["timestamp", "price"])
+        df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")
+        return df
+
+    return _history_cache.get((coin_id, days), _load)
 
 
 def build_price_chart(pair: tuple[str, str], days: int = 180):
     """Build comparative price chart for selected pair."""
     coin_a, coin_b = pair
 
-    df_a = get_coin_history(coin_a, days)
-    df_b = get_coin_history(coin_b, days)
+    try:
+        df_a = get_coin_history(coin_a, days)
+        df_b = get_coin_history(coin_b, days)
+    except CacheUnavailableError as e:
+        wait = int(e.retry_in) + 1
+        return _error_figure(
+            "Price Comparison",
+            f"API cooling down. Retry in ~{wait} seconds.",
+        )
+    except Exception as e:  # noqa: BLE001
+        return _error_figure("Price Comparison", f"Failed to load data: {e}")
 
     fig = go.Figure()
     fig.add_trace(go.Scatter(
@@ -59,8 +76,17 @@ def build_volatility_chart(pair: tuple[str, str], days: int = 180):
     """Build comparative volatility chart for selected pair."""
     coin_a, coin_b = pair
 
-    df_a = get_coin_history(coin_a, days)
-    df_b = get_coin_history(coin_b, days)
+    try:
+        df_a = get_coin_history(coin_a, days)
+        df_b = get_coin_history(coin_b, days)
+    except CacheUnavailableError as e:
+        wait = int(e.retry_in) + 1
+        return _error_figure(
+            "Volatility Comparison",
+            f"API cooling down. Retry in ~{wait} seconds.",
+        )
+    except Exception as e:  # noqa: BLE001
+        return _error_figure("Volatility Comparison", f"Failed to load data: {e}")
 
     df_a["returns"] = df_a["price"].pct_change() * 100
     df_b["returns"] = df_b["price"].pct_change() * 100
@@ -92,3 +118,37 @@ def build_volatility_chart(pair: tuple[str, str], days: int = 180):
     )
 
     return fig
+
+
+def preload_pairs(pairs: list[tuple[str, str]], days: int = 180) -> None:
+    """Warm up the cache for all coins involved in the provided pairs."""
+
+    coins = {coin for pair in pairs for coin in pair}
+    for coin in coins:
+        try:
+            get_coin_history(coin, days)
+        except CacheUnavailableError:
+            continue
+        except Exception:
+            continue
+
+
+def _error_figure(title: str, message: str):
+    fig = go.Figure()
+    fig.add_annotation(
+        text=message,
+        showarrow=False,
+        font=dict(color="#ff6b6b", size=16),
+        xref="paper",
+        yref="paper",
+        x=0.5,
+        y=0.5,
+    )
+    fig.update_layout(
+        template="plotly_dark",
+        title=title,
+        xaxis=dict(visible=False),
+        yaxis=dict(visible=False),
+        height=420,
+    )
+    return fig

presentation/styles/__init__.py

@@ -0,0 +1,5 @@
+"""Static style assets for the presentation layer."""
+
+__all__ = [
+    "themes",
+]

presentation/styles/themes/__init__.py

@@ -0,0 +1,3 @@
+"""Theme CSS assets for the presentation layer."""
+
+__all__: list[str] = []

services/__init__.py

@@ -1,2 +0,0 @@
-# __init__.py
-# Marks this directory as a Python package.