12 fix docs (#13)

* fix dependencies uv.lock

* refactor test markers for clarity

* refactor: clean up imports and remove unused files

* refactor: remove unused agent files and clean up market API instructions

* refactor: enhance wrapper initialization with keyword arguments and clean up tests

* refactor: remove PublicBinanceAgent

* refactor: aggregator
- simplified MarketDataAggregator and related models to functions

* refactor: update README and .env.example to reflect the latest changes to the project

* refactor: simplify product info and price creation in YFinanceWrapper

* refactor: remove get_all_products method from market API wrappers and update documentation

* fix: environment variable assertions

* refactor: remove status attribute from ProductInfo and update related methods to use timestamp_ms

* feat: implement aggregate_history_prices function to calculate hourly price averages

* refactor: update docker-compose and app.py for improved environment variable handling and compatibility

* feat: add detailed market instructions and improve error handling in price aggregation methods

* feat: add aggregated news retrieval methods for top headlines and latest news

* refactor: improve error messages in WrapperHandler for better clarity

* fix: correct quote currency extraction in create_product_info and remove debug prints from tests

src/app/utils/market_aggregation.py

@@ -0,0 +1,91 @@
+import statistics
+from app.markets.base import ProductInfo, Price
+
+
+def aggregate_history_prices(prices: dict[str, list[Price]]) -> list[Price]:
+    """
+    Aggrega i prezzi storici per symbol calcolando la media oraria.
+    Args:
+        prices (dict[str, list[Price]]): Mappa provider -> lista di Price
+    Returns:
+        list[Price]: Lista di Price aggregati per ora
+    """
+
+    # Costruiamo una mappa timestamp_h -> lista di Price
+    timestamped_prices: dict[int, list[Price]] = {}
+    for _, price_list in prices.items():
+        for price in price_list:
+            time = price.timestamp_ms - (price.timestamp_ms % 3600000)  # arrotonda all'ora (non dovrebbe essere necessario)
+            timestamped_prices.setdefault(time, []).append(price)
+
+    # Ora aggregiamo i prezzi per ogni ora
+    aggregated_prices = []
+    for time, price_list in timestamped_prices.items():
+        price = Price()
+        price.timestamp_ms = time
+        price.high = statistics.mean([p.high for p in price_list])
+        price.low = statistics.mean([p.low for p in price_list])
+        price.open = statistics.mean([p.open for p in price_list])
+        price.close = statistics.mean([p.close for p in price_list])
+        price.volume = statistics.mean([p.volume for p in price_list])
+        aggregated_prices.append(price)
+    return aggregated_prices
+
+def aggregate_product_info(products: dict[str, list[ProductInfo]]) -> list[ProductInfo]:
+    """
+    Aggrega una lista di ProductInfo per symbol.
+    Args:
+        products (dict[str, list[ProductInfo]]): Mappa provider -> lista di ProductInfo
+    Returns:
+        list[ProductInfo]: Lista di ProductInfo aggregati per symbol
+    """
+
+    # Costruzione mappa symbol -> lista di ProductInfo
+    symbols_infos: dict[str, list[ProductInfo]] = {}
+    for _, product_list in products.items():
+        for product in product_list:
+            symbols_infos.setdefault(product.symbol, []).append(product)
+
+    # Aggregazione per ogni symbol
+    sources = list(products.keys())
+    aggregated_products = []
+    for symbol, product_list in symbols_infos.items():
+        product = ProductInfo()
+
+        product.id = f"{symbol}_AGGREGATED"
+        product.symbol = symbol
+        product.quote_currency = next(p.quote_currency for p in product_list if p.quote_currency)
+
+        volume_sum = sum(p.volume_24h for p in product_list)
+        product.volume_24h = volume_sum / len(product_list) if product_list else 0.0
+
+        prices = sum(p.price * p.volume_24h for p in product_list)
+        product.price = (prices / volume_sum) if volume_sum > 0 else 0.0
+
+        aggregated_products.append(product)
+    return aggregated_products
+
+def _calculate_confidence(products: list[ProductInfo], sources: list[str]) -> float:
+    """Calcola un punteggio di confidenza 0-1"""
+    if not products:
+        return 0.0
+
+    score = 1.0
+
+    # Riduci score se pochi dati
+    if len(products) < 2:
+        score *= 0.7
+
+    # Riduci score se prezzi troppo diversi
+    prices = [p.price for p in products if p.price > 0]
+    if len(prices) > 1:
+        price_std = (max(prices) - min(prices)) / statistics.mean(prices)
+        if price_std > 0.05:  # >5% variazione
+            score *= 0.8
+
+    # Riduci score se fonti sconosciute
+    unknown_sources = sum(1 for s in sources if s == "unknown")
+    if unknown_sources > 0:
+        score *= (1 - unknown_sources / len(sources))
+
+    return max(0.0, min(1.0, score))