Refactor and update structure (#20)

* Aggiorna gli agenti e il modello del team per utilizzare OLLAMA_QWEN_1B

* Riorganizza e rinomina funzioni di estrazione in moduli di mercato e notizie; migliora la gestione delle importazioni

* Spostato main nel corretto file __main__ e aggiornato il README.md

* Aggiunta cartella per i modelli, agenti e team

* Aggiornata la posizione delle istruzioni

* Rimossi TODO e Aggiunto documentazione per metodi aggregated

* Aggiornate le istruzioni del coordinatore del team

* utils type checks

* Rinominato BaseWrapper in MarketWrapper e fix type check markets

* fix type checks di notizie e social.

* Aggiunti type hints finali

* Riorganizzati gli import

* Refactoring architetturale e spostamento classi base

- Eliminazione del file __init__.py obsoleto che importava ChatManager e Pipeline
- Spostamento della classe Pipeline in agents/pipeline.py
- Spostamento della classe ChatManager in utils/chat_manager.py
- Aggiornamento di __main__.py per importare da app.utils e app.agents, e modifica della logica per utilizzare Pipeline invece di chat per la selezione di provider e stile
- Creazione della cartella base con classi base comuni: markets.py (ProductInfo, Price, MarketWrapper), news.py (Article, NewsWrapper), social.py (SocialPost, SocialComment, SocialWrapper)
- Aggiornamento di tutti gli import nel progetto (markets/, news/, social/, utils/, tests/) per utilizzare la nuova struttura base/

* Aggiornato Readme

* Corretto il valore predefinito della valuta in BinanceWrapper da "USDT" a "USD"

* fix type in tests

* fix type per models

* Rinominato 'quote_currency' in 'currency' e aggiornato il trattamento del timestamp in Price

* fix errors found by Copilot

* WrapperHandler: semplificata la logica di chiamata delle funzioni sui wrapper

* fix docs

* fix demos, semplificata logica lista ollama

src/app/agents/__init__.py

@@ -0,0 +1,6 @@
+from app.agents.models import AppModels
+from app.agents.predictor import PredictorInput, PredictorOutput, PredictorStyle, PREDICTOR_INSTRUCTIONS
+from app.agents.team import create_team_with
+from app.agents.pipeline import Pipeline
+
+__all__ = ["AppModels", "PredictorInput", "PredictorOutput", "PredictorStyle", "PREDICTOR_INSTRUCTIONS", "create_team_with", "Pipeline"]

src/app/agents/models.py

@@ -0,0 +1,107 @@
+import os
+import ollama
+from enum import Enum
+from agno.agent import Agent
+from agno.models.base import Model
+from agno.models.google import Gemini
+from agno.models.ollama import Ollama
+from agno.tools import Toolkit
+from agno.utils.log import log_warning #type: ignore
+from pydantic import BaseModel
+
+
+class AppModels(Enum):
+    """
+    Enum per i modelli supportati.
+    Aggiungere nuovi modelli qui se necessario.
+    Per quanto riguarda Ollama, i modelli dovranno essere scaricati e installati
+    localmente seguendo le istruzioni di https://ollama.com/docs/guide/install-models
+    """
+    GEMINI = "gemini-2.0-flash" # API online
+    GEMINI_PRO = "gemini-2.0-pro" # API online, più costoso ma migliore
+    OLLAMA_GPT = "gpt-oss:latest" # + good - slow (13b)
+    OLLAMA_QWEN = "qwen3:latest" # + good + fast (8b)
+    OLLAMA_QWEN_4B = "qwen3:4b" # + fast + decent (4b)
+    OLLAMA_QWEN_1B = "qwen3:1.7b" # + very fast + decent (1.7b)
+
+    @staticmethod
+    def availables_local() -> list['AppModels']:
+        """
+        Controlla quali provider di modelli LLM locali sono disponibili.
+        Ritorna una lista di provider disponibili.
+        """
+        try:
+            models_list = ollama.list()
+            availables = [model['model'] for model in models_list['models']]
+            app_models = [model for model in AppModels if model.name.startswith("OLLAMA")]
+            return [model for model in app_models if model.value in availables]
+        except Exception as e:
+            log_warning(f"Ollama is not running or not reachable: {e}")
+            return []
+
+    @staticmethod
+    def availables_online() -> list['AppModels']:
+        """
+        Controlla quali provider di modelli LLM online hanno le loro API keys disponibili
+        come variabili d'ambiente e ritorna una lista di provider disponibili.
+        """
+        if not os.getenv("GOOGLE_API_KEY"):
+            log_warning("No GOOGLE_API_KEY set in environment variables.")
+            return []
+        availables = [AppModels.GEMINI, AppModels.GEMINI_PRO]
+        return availables
+
+    @staticmethod
+    def availables() -> list['AppModels']:
+        """
+        Controlla quali provider di modelli LLM locali sono disponibili e quali
+        provider di modelli LLM online hanno le loro API keys disponibili come variabili
+        d'ambiente e ritorna una lista di provider disponibili.
+        L'ordine di preferenza è:
+        1. Gemini (Google)
+        2. Ollama (locale)
+        """
+        availables = [
+            *AppModels.availables_online(),
+            *AppModels.availables_local()
+        ]
+        assert availables, "No valid model API keys set in environment variables."
+        return availables
+
+    def get_model(self, instructions:str) -> Model:
+        """
+        Restituisce un'istanza del modello specificato.
+        Args:
+            instructions: istruzioni da passare al modello (system prompt).
+        Returns:
+             Un'istanza di BaseModel o una sua sottoclasse.
+        Raise:
+            ValueError se il modello non è supportato.
+        """
+        name = self.value
+        if self in {model for model in AppModels if model.name.startswith("GEMINI")}:
+            return Gemini(name, instructions=[instructions])
+        elif self in {model for model in AppModels if model.name.startswith("OLLAMA")}:
+            return Ollama(name, instructions=[instructions])
+
+        raise ValueError(f"Modello non supportato: {self}")
+
+    def get_agent(self, instructions: str, name: str = "", output_schema: type[BaseModel] | None = None, tools: list[Toolkit] | None = None) -> Agent:
+        """
+        Costruisce un agente con il modello e le istruzioni specificate.
+        Args:
+            instructions: istruzioni da passare al modello (system prompt)
+            name: nome dell'agente (opzionale)
+            output: schema di output opzionale (Pydantic BaseModel)
+            tools: lista opzionale di strumenti (tools) da fornire all'agente
+        Returns:
+             Un'istanza di Agent.
+        """
+        return Agent(
+            model=self.get_model(instructions),
+            name=name,
+            retries=2,
+            tools=tools,
+            delay_between_retries=5, # seconds
+            output_schema=output_schema
+        )

src/app/agents/pipeline.py

@@ -0,0 +1,105 @@
+from agno.run.agent import RunOutput
+from app.agents.models import AppModels
+from app.agents.team import create_team_with
+from app.agents.predictor import PREDICTOR_INSTRUCTIONS, PredictorInput, PredictorOutput, PredictorStyle
+from app.base.markets import ProductInfo
+
+
+class Pipeline:
+    """
+    Coordina gli agenti di servizio (Market, News, Social) e il Predictor finale.
+    Il Team è orchestrato da qwen3:latest (Ollama), mentre il Predictor è dinamico
+    e scelto dall'utente tramite i dropdown dell'interfaccia grafica.
+    """
+
+    def __init__(self):
+        self.available_models = AppModels.availables()
+        self.all_styles = list(PredictorStyle)
+
+        self.style = self.all_styles[0]
+        self.team = create_team_with(AppModels.OLLAMA_QWEN_1B)
+        self.choose_predictor(0)  # Modello di default
+
+    # ======================
+    # Dropdown handlers
+    # ======================
+    def choose_predictor(self, index: int):
+        """
+        Sceglie il modello LLM da usare per il Predictor.
+        """
+        model = self.available_models[index]
+        self.predictor = model.get_agent(
+            PREDICTOR_INSTRUCTIONS,
+            output_schema=PredictorOutput,
+        )
+
+    def choose_style(self, index: int):
+        """
+        Sceglie lo stile (conservativo/aggressivo) da usare per il Predictor.
+        """
+        self.style = self.all_styles[index]
+
+    # ======================
+    # Helpers
+    # ======================
+    def list_providers(self) -> list[str]:
+        """
+        Restituisce la lista dei nomi dei modelli disponibili.
+        """
+        return [model.name for model in self.available_models]
+
+    def list_styles(self) -> list[str]:
+        """
+        Restituisce la lista degli stili di previsione disponibili.
+        """
+        return [style.value for style in self.all_styles]
+
+    # ======================
+    # Core interaction
+    # ======================
+    def interact(self, query: str) -> str:
+        """
+        1. Raccoglie output dai membri del Team
+        2. Aggrega output strutturati
+        3. Invoca Predictor
+        4. Restituisce la strategia finale
+        """
+        # Step 1: raccolta output dai membri del Team
+        team_outputs = self.team.run(query) # type: ignore
+
+        # Step 2: aggregazione output strutturati
+        all_products: list[ProductInfo] = []
+        sentiments: list[str] = []
+
+        for agent_output in team_outputs.member_responses:
+            if isinstance(agent_output, RunOutput) and agent_output.metadata is not None:
+                keys = agent_output.metadata.keys()
+                if "products" in keys:
+                    all_products.extend(agent_output.metadata["products"])
+                if "sentiment_news" in keys:
+                    sentiments.append(agent_output.metadata["sentiment_news"])
+                if "sentiment_social" in keys:
+                    sentiments.append(agent_output.metadata["sentiment_social"])
+
+        aggregated_sentiment = "\n".join(sentiments)
+
+        # Step 3: invocazione Predictor
+        predictor_input = PredictorInput(
+            data=all_products,
+            style=self.style,
+            sentiment=aggregated_sentiment
+        )
+
+        result = self.predictor.run(predictor_input) # type: ignore
+        if not isinstance(result.content, PredictorOutput):
+            return "❌ Errore: il modello non ha restituito un output valido."
+        prediction: PredictorOutput = result.content
+
+        # Step 4: restituzione strategia finale
+        portfolio_lines = "\n".join(
+            [f"{item.asset} ({item.percentage}%): {item.motivation}" for item in prediction.portfolio]
+        )
+        return (
+            f"📊 Strategia ({self.style.value}): {prediction.strategy}\n\n"
+            f"💼 Portafoglio consigliato:\n{portfolio_lines}"
+        )

src/app/agents/predictor.py

@@ -0,0 +1,53 @@
+from enum import Enum
+from pydantic import BaseModel, Field
+from app.base.markets import ProductInfo
+
+
+class PredictorStyle(Enum):
+    CONSERVATIVE = "Conservativo"
+    AGGRESSIVE = "Aggressivo"
+
+class PredictorInput(BaseModel):
+    data: list[ProductInfo] = Field(..., description="Market data as a list of ProductInfo")
+    style: PredictorStyle = Field(..., description="Prediction style")
+    sentiment: str = Field(..., description="Aggregated sentiment from news and social analysis")
+
+class ItemPortfolio(BaseModel):
+    asset: str = Field(..., description="Name of the asset")
+    percentage: float = Field(..., description="Percentage allocation to the asset")
+    motivation: str = Field(..., description="Motivation for the allocation")
+
+class PredictorOutput(BaseModel):
+    strategy: str = Field(..., description="Concise operational strategy in Italian")
+    portfolio: list[ItemPortfolio] = Field(..., description="List of portfolio items with allocations")
+
+
+PREDICTOR_INSTRUCTIONS = """
+You are an **Allocation Algorithm (Crypto-Algo)** specialized in analyzing market data and sentiment to generate an investment strategy and a target portfolio.
+
+Your sole objective is to process the user_input data and generate the strictly structured output as required by the response format. **You MUST NOT provide introductions, preambles, explanations, conclusions, or any additional comments that are not strictly required.**
+
+## Processing Instructions (Absolute Rule)
+
+The allocation strategy must be **derived exclusively from the "Allocation Logic" corresponding to the requested *style*** and the provided market/sentiment data. **DO NOT** use external or historical knowledge.
+
+## Allocation Logic
+
+### "Aggressivo" Style (Aggressive)
+* **Priority:** Maximizing return (high volatility accepted).
+* **Focus:** Higher allocation to **non-BTC/ETH assets** with high momentum potential (Altcoins, mid/low-cap assets).
+* **BTC/ETH:** Must serve as a base (anchor), but their allocation **must not exceed 50%** of the total portfolio.
+* **Sentiment:** Use positive sentiment to increase exposure to high-risk assets.
+
+### "Conservativo" Style (Conservative)
+* **Priority:** Capital preservation (volatility minimized).
+* **Focus:** Major allocation to **BTC and/or ETH (Large-Cap Assets)**.
+* **BTC/ETH:** Their allocation **must be at least 70%** of the total portfolio.
+* **Altcoins:** Any allocations to non-BTC/ETH assets must be minimal (max 30% combined) and for assets that minimize speculative risk.
+* **Sentiment:** Use positive sentiment only as confirmation for exposure, avoiding reactions to excessive "FOMO" signals.
+
+## Output Requirements (Content MUST be in Italian)
+
+1.  **Strategy (strategy):** Must be a concise operational description **in Italian ("in Italiano")**, with a maximum of 5 sentences.
+2.  **Portfolio (portfolio):** The sum of all percentages must be **exactly 100%**. The justification (motivation) for each asset must be a single clear sentence **in Italian ("in Italiano")**.
+"""

src/app/agents/team.py

@@ -0,0 +1,109 @@
+from agno.team import Team
+from app.agents import AppModels
+from app.markets import MarketAPIsTool
+from app.news import NewsAPIsTool
+from app.social import SocialAPIsTool
+
+
+def create_team_with(models: AppModels, coordinator: AppModels | None = None) -> Team:
+    market_agent = models.get_agent(
+        instructions=MARKET_INSTRUCTIONS,
+        name="MarketAgent",
+        tools=[MarketAPIsTool()]
+    )
+    news_agent = models.get_agent(
+        instructions=NEWS_INSTRUCTIONS,
+        name="NewsAgent",
+        tools=[NewsAPIsTool()]
+    )
+    social_agent = models.get_agent(
+        instructions=SOCIAL_INSTRUCTIONS,
+        name="SocialAgent",
+        tools=[SocialAPIsTool()]
+    )
+
+    coordinator = coordinator or models
+    return Team(
+        model=coordinator.get_model(COORDINATOR_INSTRUCTIONS),
+        name="CryptoAnalysisTeam",
+        members=[market_agent, news_agent, social_agent],
+    )
+
+COORDINATOR_INSTRUCTIONS = """
+You are the expert coordinator of a financial analysis team specializing in cryptocurrencies.
+
+Your team consists of three agents:
+- **MarketAgent**: Provides quantitative market data, price analysis, and technical indicators.
+- **NewsAgent**: Scans and analyzes the latest news, articles, and official announcements.
+- **SocialAgent**: Gauges public sentiment, trends, and discussions on social media.
+
+Your primary objective is to answer the user's query by orchestrating the work of your team members.
+
+Your workflow is as follows:
+1.  **Deconstruct the user's query** to identify the required information.
+2.  **Delegate specific tasks** to the most appropriate agent(s) to gather the necessary data and initial analysis.
+3.  **Analyze the information** returned by the agents.
+4.  If the initial data is insufficient or the query is complex, **iteratively re-engage the agents** with follow-up questions to build a comprehensive picture.
+5.  **Synthesize all the gathered information** into a final, coherent, and complete analysis that fills all the required output fields.
+"""
+
+MARKET_INSTRUCTIONS = """
+**TASK:** You are a specialized **Crypto Price Data Retrieval Agent**. Your primary goal is to fetch the most recent and/or historical price data for requested cryptocurrency assets (e.g., 'BTC', 'ETH', 'SOL'). You must provide the data in a clear and structured format.
+
+**AVAILABLE TOOLS:**
+1.  `get_products(asset_ids: list[str])`: Get **current** product/price info for a list of assets. **(PREFERITA: usa questa per i prezzi live)**
+2.  `get_historical_prices(asset_id: str, limit: int)`: Get historical price data for one asset. Default limit is 100. **(PREFERITA: usa questa per i dati storici)**
+3.  `get_products_aggregated(asset_ids: list[str])`: Get **aggregated current** product/price info for a list of assets. **(USA SOLO SE richiesto 'aggregato' o se `get_products` fallisce)**
+4.  `get_historical_prices_aggregated(asset_id: str, limit: int)`: Get **aggregated historical** price data for one asset. **(USA SOLO SE richiesto 'aggregato' o se `get_historical_prices` fallisce)**
+
+**USAGE GUIDELINE:**
+* **Asset ID:** Always convert common names (e.g., 'Bitcoin', 'Ethereum') into their official ticker/ID (e.g., 'BTC', 'ETH').
+* **Cost Management (Cruciale per LLM locale):** Prefer `get_products` and `get_historical_prices` for standard requests to minimize costs.
+* **Aggregated Data:** Use `get_products_aggregated` or `get_historical_prices_aggregated` only if the user specifically requests aggregated data or you value that having aggregated data is crucial for the analysis.
+* **Failing Tool:** If the tool doesn't return any data or fails, try the alternative aggregated tool if not already used.
+
+**REPORTING REQUIREMENT:**
+1.  **Format:** Output the results in a clear, easy-to-read list or table.
+2.  **Live Price Request:** If an asset's *current price* is requested, report the **Asset ID**, **Latest Price**, and **Time/Date of the price**.
+3.  **Historical Price Request:** If *historical data* is requested, report the **Asset ID**, the **Limit** of points returned, and the **First** and **Last** entries from the list of historical prices (Date, Price).
+4.  **Output:** For all requests, output a single, concise summary of the findings; if requested, also include the raw data retrieved.
+"""
+
+NEWS_INSTRUCTIONS = """
+**TASK:** You are a specialized **Crypto News Analyst**. Your goal is to fetch the latest news or top headlines related to cryptocurrencies, and then **analyze the sentiment** of the content to provide a concise report to the team leader. Prioritize 'crypto' or specific cryptocurrency names (e.g., 'Bitcoin', 'Ethereum') in your searches.
+
+**AVAILABLE TOOLS:**
+1.  `get_latest_news(query: str, limit: int)`: Get the 'limit' most recent news articles for a specific 'query'.
+2.  `get_top_headlines(limit: int)`: Get the 'limit' top global news headlines.
+3.  `get_latest_news_aggregated(query: str, limit: int)`: Get aggregated latest news articles for a specific 'query'.
+4.  `get_top_headlines_aggregated(limit: int)`: Get aggregated top global news headlines.
+
+**USAGE GUIDELINE:**
+* Always use `get_latest_news` with a relevant crypto-related query first.
+* The default limit for news items should be 5 unless specified otherwise.
+* If the tool doesn't return any articles, respond with "No relevant news articles found."
+
+**REPORTING REQUIREMENT:**
+1.  **Analyze** the tone and key themes of the retrieved articles.
+2.  **Summarize** the overall **market sentiment** (e.g., highly positive, cautiously neutral, generally negative) based on the content.
+3.  **Identify** the top 2-3 **main topics** discussed (e.g., new regulation, price surge, institutional adoption).
+4.  **Output** a single, brief report summarizing these findings. Do not output the raw articles.
+"""
+
+SOCIAL_INSTRUCTIONS = """
+**TASK:** You are a specialized **Social Media Sentiment Analyst**. Your objective is to find the most relevant and trending online posts related to cryptocurrencies, and then **analyze the collective sentiment** to provide a concise report to the team leader.
+
+**AVAILABLE TOOLS:**
+1.  `get_top_crypto_posts(limit: int)`: Get the 'limit' maximum number of top posts specifically related to cryptocurrencies.
+
+**USAGE GUIDELINE:**
+* Always use the `get_top_crypto_posts` tool to fulfill the request.
+* The default limit for posts should be 5 unless specified otherwise.
+* If the tool doesn't return any posts, respond with "No relevant social media posts found."
+
+**REPORTING REQUIREMENT:**
+1.  **Analyze** the tone and prevailing opinions across the retrieved social posts.
+2.  **Summarize** the overall **community sentiment** (e.g., high enthusiasm/FOMO, uncertainty, FUD/fear) based on the content.
+3.  **Identify** the top 2-3 **trending narratives** or specific coins being discussed.
+4.  **Output** a single, brief report summarizing these findings. Do not output the raw posts.
+"""