The user is asking me to create a cryptocurrency market analysis application. They're speaking in Serbian/Bosnian/Croatian language. Let me create a comprehensive crypto market analysis application. I'll create a Python application that: 1. Fetches real-time cryptocurrency data from public APIs (like CoinGecko) 2. Analyzes the data (price changes, market cap, volume) 3. Provides technical analysis indicators (RSI, Moving Averages, etc.) 4. Visualizes the data with charts 5. Provides alerts and insights Let me build a complete, well-structured application with multiple files/sections in a single response. I'll make it modular with: - API integration module - Data analysis module - Technical indicators module - Visualization module - Main application with CLI interface Let me write this in a professional way with good documentation, error handling, and modern Python practices. I'll use: - requests for API calls - pandas for data manipulation - numpy for calculations - matplotlib/plotly for visualization - ta library or manual implementation for technical indicators Let me write a comprehensive but clean application. # 📊 Crypto Market Analyzer - Kompletna Aplikacija Napraviću ti profesionalnu aplikaciju za analizu kripto tržišta sa realnim podacima, tehničkom analizom i vizualizacijom. ## 📁 Struktura Projekta ``` crypto_analyzer/ ├── main.py ├── modules/ │ ├── __init__.py │ ├── api_client.py │ ├── analyzer.py │ ├── indicators.py │ └── visualizer.py ├── config.py └── requirements.txt ``` --- ## 1. `requirements.txt` ```txt requests==2.31.0 pandas==2.1.4 numpy==1.26.2 matplotlib==3.8.2 plotly==5.18.0 ta==0.11.0 colorama==0.4.6 tabulate==0.9.0 ``` --- ## 2. `config.py` ```python """ Konfiguracija aplikacije za analizu kripto tržišta. """ # API endpointi (CoinGecko - besplatan, bez API ključa) COINGECKO_BASE_URL = "https://api.coingecko.com/api/v3" # Podržane valute za prikaz cena SUPPORTED_CURRENCIES = { "usd": "US Dollar ($)", "eur": "Euro (€)", "gbp": "British Pound (£)", "jpy": "Japanese Yen (¥)", "btc": "Bitcoin (₿)", "eth": "Ethereum (Ξ)" } # Default valuta DEFAULT_CURRENCY = "usd" # Tehnički indikatori - default parametri INDICATOR_PARAMS = { "rsi_period": 14, "macd_fast": 12, "macd_slow": 26, "macd_signal": 9, "sma_short": 20, "sma_long": 50, "ema_short": 12, "ema_long": 26, "bb_period": 20, "bb_std": 2 } # Pragovi za signale SIGNAL_THRESHOLDS = { "rsi_oversold": 30, "rsi_overbought": 70, "volume_spike_multiplier": 2.0, "price_change_alert": 5.0 # procenat } # Limit za API pozive API_RATE_LIMIT_DELAY = 1.5 # sekunde ``` --- ## 3. `modules/__init__.py` ```python """Crypto Analyzer moduli.""" ``` --- ## 4. `modules/api_client.py` ```python """ API klijent za komunikaciju sa CoinGecko servisom. """ import time import requests from typing import Optional, Dict, List from datetime import datetime import config class CoinGeckoClient: """Klijent za CoinGecko API.""" def __init__(self, base_url: str = None): self.base_url = base_url or config.COINGECKO_BASE_URL self.session = requests.Session() self.session.headers.update({ "Accept": "application/json", "User-Agent": "CryptoAnalyzer/1.0" }) self.last_request_time = 0 def _rate_limit(self): """Poštuje rate limit API-ja.""" elapsed = time.time() - self.last_request_time if elapsed < config.API_RATE_LIMIT_DELAY: time.sleep(config.API_RATE_LIMIT_DELAY - elapsed) self.last_request_time = time.time() def _make_request(self, endpoint: str, params: Optional[Dict] = None) -> Dict: """Generiše API zahtev sa error handlingom.""" self._rate_limit() url = f"{self.base_url}{endpoint}" try: response = self.session.get(url, params=params, timeout=15) response.raise_for_status() return response.json() except requests.exceptions.HTTPError as e: if response.status_code == 429: print("⚠️ Rate limit dostignut, čekam 60s...") time.sleep(60) return self._make_request(endpoint, params) raise Exception(f"HTTP greška: {e}") except requests.exceptions.RequestException as e: raise Exception(f"API greška: {e}") def get_top_coins(self, limit: int = 50, currency: str = "usd") -> List[Dict]: """Vraća top N kriptovaluta po tržišnoj kapitalizaciji.""" params = { "vs_currency": currency, "order": "market_cap_desc", "per_page": limit, "page": 1, "sparkline": True, "price_change_percentage": "1h,24h,7d,30d" } data = self._make_request("/coins/markets", params) return data def get_coin_history(self, coin_id: str, days: int = 30, currency: str = "usd") -> Dict: """Vraća istorijske podatke za određeni coin.""" params = { "vs_currency": currency, "days": days, "interval": "daily" if days > 30 else "hourly" } return self._make_request(f"/coins/{coin_id}/market_chart", params) def get_global_data(self) -> Dict: """Vraća globalne podatke tržišta.""" return self._make_request("/global") def get_coin_info(self, coin_id: str) -> Dict: """Vraća detaljne informacije o coin-u.""" params = { "localization": "false", "tickers": "false", "community_data": "true", "developer_data": "true" } return self._make_request(f"/coins/{coin_id}", params) def search_coins(self, query: str) -> List[Dict]: """Pretražuje coine po imenu/simbolu.""" params = {"query": query} data = self._make_request("/search", params) return data.get("coins", []) def get_trending_coins(self) -> List[Dict]: """Vraća trending coine.""" data = self._make_request("/search/trending") return [item["item"] for item in data.get("coins", [])] ``` --- ## 5. `modules/indicators.py` ```python """ Tehnički indikatori za analizu kripto tržišta. """ import numpy as np import pandas as pd from typing import Tuple, Dict def calculate_sma(prices: pd.Series, period: int) -> pd.Series: """Simple Moving Average.""" return prices.rolling(window=period, min_periods=period).mean() def calculate_ema(prices: pd.Series, period: int) -> pd.Series: """Exponential Moving Average.""" return prices.ewm(span=period, adjust=False).mean() def calculate_rsi(prices: pd.Series, period: int = 14) -> pd.Series: """ Relative Strength Index (RSI). Vrednosti: 0-100 - <30: Oversold (preprodato) - >70: Overbought (prekupljeno) """ delta = prices.diff() gain = (delta.where(delta > 0, 0)).rolling(window=period).mean() loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean() rs = gain / loss.replace(0, np.inf) rsi = 100 - (100 / (1 + rs)) return rsi def calculate_macd(prices: pd.Series, fast: int = 12, slow: int = 26, signal: int = 9) -> Dict: """ Moving Average Convergence Divergence (MACD). Vraća MACD liniju, signalnu liniju i histogram. """ ema_fast = calculate_ema(prices, fast) ema_slow = calculate_ema(prices, slow) macd_line = ema_fast - ema_slow signal_line = macd_line.ewm(span=signal, adjust=False).mean() histogram = macd_line - signal_line return { "macd": macd_line, "signal": signal_line, "histogram": histogram } def calculate_bollinger_bands(prices: pd.Series, period: int = 20, std_dev: int = 2) -> Dict: """ Bollinger Bands - mere volatilnost. Vraća gornju, srednju i donju traku. """ sma = calculate_sma(prices, period) std = prices.rolling(window=period).std() upper_band = sma + (std_dev * std) lower_band = sma - (std_dev * std) return { "upper": upper_band, "middle": sma, "lower": lower_band } def calculate_volatility(prices: pd.Series, period: int = 20) -> pd.Series: """Standardna devijacija cena - mera volatilnosti.""" returns = prices.pct_change() return returns.rolling(window=period).std() * np.sqrt(252) # godišnja def calculate_volume_profile(volume: pd.Series, period: int = 20) -> pd.Series: """Srednja zapremina trgovine.""" return volume.rolling(window=period).mean() def get_rsi_signal(rsi_value: float) -> str: """Interpretacija RSI vrednosti.""" import config if pd.isna(rsi_value): return "N/A" if rsi_value < config.SIGNAL_THRESHOLDS["rsi_oversold"]: return "🟢 OVERSOLD - Potencijalna kupovina" elif rsi_value > config.SIGNAL_THRESHOLDS["rsi_overbought"]: return "🔴 OVERBOUGHT - Potencijalna prodaja" elif 45 <= rsi_value <= 55: return "⚪ NEUTRALNO" elif rsi_value < 45: return "🟡 SLAB MOMENTUM" else: return "🟡 JAK MOMENTUM" def get_macd_signal(macd_data: Dict) -> str: """Interpretacija MACD signala.""" hist = macd_data["histogram"].iloc[-1] if pd.isna(hist): return "N/A" if hist > 0: return "🟢 BULLISH (rastući trend)" elif hist < 0: return "🔴 BEARISH (padajući trend)" return "⚪ NEUTRALNO" def get_trend_signal(prices: pd.Series, short_period: int = 20, long_period: int = 50) -> str: """Detektuje trend na osnovu MA crossover-a.""" sma_short = calculate_sma(prices, short_period).iloc[-1] sma_long = calculate_sma(prices, long_period).iloc[-1] if pd.isna(sma_short) or pd.isna(sma_long): return "N/A - Nedovoljno podataka" if sma_short > sma_long: return "🟢 UPTREND (rastući)" elif sma_short < sma_long: return "🔴 DOWNTREND (padajući)" return "⚪ SIDEWAYS" ``` --- ## 6. `modules/analyzer.py` ```python """ Glavni modul za analizu kripto tržišta. """ import numpy as np import pandas as pd from typing import Dict, List, Optional from datetime import datetime import config from .indicators import ( calculate_sma, calculate_ema, calculate_rsi, calculate_macd, calculate_bollinger_bands, calculate_volatility, get_rsi_signal, get_macd_signal, get_trend_signal ) class MarketAnalyzer: """Glavna klasa za analizu tržišta.""" def __init__(self, api_client): self.api = api_client self.cache = {} def analyze_coin(self, coin_data: Dict, detailed: bool = True) -> Dict: """ Kompletna analiza jednog coina. Vraća rečnik sa svim analizama i signalima. """ coin_id = coin_data.get("id") or coin_data.get("coin_id") analysis = { "basic_info": self._extract_basic_info(coin_data), "price_changes": self._analyze_price_changes(coin_data), "market_metrics": self._calculate_market_metrics(coin_data), "signals": {}, "score": None, "recommendation": None, "timestamp": datetime.now().isoformat() } if detailed: try: history = self.api.get_coin_history(coin_id, days=90) tech_analysis = self._technical_analysis(history) analysis["technical"] = tech_analysis analysis["signals"] = self._generate_signals( coin_data, tech_analysis ) except Exception as e: analysis["technical_error"] = str(e) analysis["score"], analysis["recommendation"] = self._calculate_score( coin_data, analysis ) return analysis def _extract_basic_info(self, data: Dict) -> Dict: """Izvlači osnovne informacije.""" return { "id": data.get("id"), "name": data.get("name"), "symbol": data.get("symbol", "").upper(), "rank": data.get("market_cap_rank"), "image": data.get("image") } def _analyze_price_changes(self, data: Dict) -> Dict: """Analiza promene cena.""" return { "current_price": data.get("current_price"), "change_1h": data.get("price_change_percentage_1h_in_currency"), "change_24h": data.get("price_change_percentage_24h_in_currency"), "change_7d": data.get("price_change_percentage_7d_in_currency"), "change_30d": data.get("price_change_percentage_30d_in_currency"), "ath": data.get("ath"), "ath_change_pct": data.get("ath_change_percentage"), "atl": data.get("atl"), "atl_change_pct": data.get("atl_change_percentage") } def _calculate_market_metrics(self, data: Dict) -> Dict: """Izračunava metriku tržišta.""" market_cap = data.get("market_cap", 0) or 0 volume = data.get("total_volume", 0) or 0 circulating = data.get("circulating_supply", 0) or 0 total_supply = data.get("total_supply", 0) or 0 volume_to_mcap = (volume / market_cap * 100) if market_cap > 0 else 0 supply_ratio = (circulating / total_supply * 100) if total_supply > 0 else None return { "market_cap": market_cap, "total_volume": volume, "volume_to_mcap_ratio": volume_to_mcap, "circulating_supply": circulating, "total_supply": total_supply, "max_supply": data.get("max_supply"), "supply_ratio": supply_ratio, "market_cap_dominance_pct": None # izračunava se globalno } def _technical_analysis(self, history: Dict) -> Dict: """Tehnička analiza na osnovu istorijskih podataka.""" prices = pd.Series(history["prices"], index=pd.to_datetime( [p[0] for p in history["prices"]], unit="ms" )).apply(lambda x: x[1] if isinstance(x, list) else x) # Parsiraj ako je [[timestamp, price], ...] price_values = [p[1] for p in history["prices"]] prices = pd.Series( price_values, index=pd.to_datetime([p[0] for p in history["prices"]], unit="ms") ) volume_values = [v[1] for v in history["total_volumes"]] volume = pd.Series( volume_values, index=pd.to_datetime([v[0] for v in history["total_volumes"]], unit="ms") ) params = config.INDICATOR_PARAMS analysis = { "sma_20": calculate_sma(prices, params["sma_short"]).iloc[-1], "sma_50": calculate_sma(prices, params["sma_long"]).iloc[-1], "ema_12": calculate_ema(prices, params["ema_short"]).iloc[-1], "ema_26": calculate_ema(prices, params["ema_long"]).iloc[-1], "rsi": calculate_rsi(prices, params["rsi_period"]).iloc[-1], "volatility": calculate_volatility(prices).iloc[-1], "avg_volume": volume.tail(params["bb_period"]).mean(), "data_points": len(prices), "period_high": prices.max(), "period_low": prices.min(), "period_return_pct": ((prices.iloc[-1] / prices.iloc[0]) - 1) * 100 } # MACD macd_data = calculate_macd(prices, params["macd_fast"], params["macd_slow"], params["macd_signal"]) analysis["macd"] = { "value": macd_data["macd"].iloc[-1], "signal": macd_data["signal"].iloc[-1], "histogram": macd_data["histogram"].iloc[-1], "interpretation": get_macd_signal(macd_data) } # Bollinger Bands bb = calculate_bollinger_bands(prices, params["bb_period"], params["bb_std"]) current_price = prices.iloc[-1] bb_upper = bb["upper"].iloc[-1] bb_lower = bb["lower"].iloc[-1] bb_middle = bb["middle"].iloc[-1] analysis["bollinger_bands"] = { "upper": bb_upper, "middle": bb_middle, "lower": bb_lower, "position": "gornja" if current_price > bb_upper else "donja" if current_price < bb_lower else "srednja" } analysis["trend"] = get_trend_signal(prices) return analysis def _generate_signals(self, coin_data: Dict, tech: Dict) -> Dict: """Generiše trading signale.""" signals = { "buy_signals": [], "sell_signals": [], "neutral_signals": [] } # RSI signali rsi = tech.get("rsi") if rsi and not pd.isna(rsi): if rsi < config.SIGNAL_THRESHOLDS["rsi_oversold"]: signals["buy_signals"].append( f"RSI = {rsi:.1f} (Oversold zona)" ) elif rsi > config.SIGNAL_THRESHOLDS["rsi_overbought"]: signals["sell_signals"].append( f"RSI = {rsi:.1f} (Overbought zona)" ) # MACD signali macd_hist = tech.get("macd", {}).get("histogram") if macd_hist and not pd.isna(macd_hist): if macd_hist > 0: signals["buy_signals"].append( f"MACD histogram pozitivan ({macd_hist:.4f})" ) else: signals["sell_signals"].append( f"MACD histogram negativan ({macd_hist:.4f})" ) # Trend signali trend = tech.get("trend", "") if "UPTREND" in trend: signals["buy_signals"].append("SMA crossover bullish") elif "DOWNTREND" in trend: signals["sell_signals"].append("SMA crossover bearish") # Bollinger Bands signali bb_pos = tech.get("bollinger_bands", {}).get("position", "") if bb_pos == "donja": signals["buy_signals"].append("Cena na donjoj BB traci") elif bb_pos == "gornja": signals["sell_signals"].append("Cena na gornjoj BB traci") # Volume spike volume = coin_data.get("total_volume", 0) # Avg volume approximation if "avg_volume" in tech: if volume > tech["avg_volume"] * config.SIGNAL_THRESHOLDS["volume_spike_multiplier"]: signals["neutral_signals"].append("⚡ Volume spike detektovan") return signals def _calculate_score(self, coin_data: Dict, analysis: Dict) -> tuple: """ Kalkulacija ukupnog score-a (0-100) i preporuke. Score > 75: STRONG BUY Score > 60: BUY Score > 40: HOLD Score > 25: SELL Score < 25: STRONG SELL """ score = 50 # neutralan baseline signali = analysis.get("signals", {}) score += len(signali.get("buy_signals", [])) * 8 score -= len(signali.get("sell_signals", [])) * 8 # Trend bonus trend = analysis.get("technical", {}).get("trend", "") if "UPTREND" in trend: score += 5 elif "DOWNTREND" in trend: score -= 5 # Price changes price_changes = analysis.get("price_changes", {}) change_24h = price_changes.get("change_24h") change_7d = price_changes.get("change_7d") if change_24h is not None: score += min(max(change_24h, -10), 10) * 0.5 if change_7d is not None: score += min(max(change_7d, -15), 15) * 0.3 # Ograniči score na 0-100 score = max(0, min(100, score)) # Preporuka if score >= 75: recommendation = "🚀 STRONG BUY" elif score >= 60: recommendation = "🟢 BUY" elif score >= 40: recommendation = "⚪ HOLD" elif score >= 25: recommendation = "🔴 SELL" else: recommendation = "💥 STRONG SELL" return round(score, 1), recommendation def analyze_market_overview(self) -> Dict: """Analiza celokupnog tržišta.""" global_data = self.api.get_global_data()["data"] top_coins = self.api.get_top_coins(limit=100) # Agregacija podataka total_market_cap = global_data["total_market_cap"]["usd"] total_volume = global_data["total_volume"]["usd"] market_cap_change = global_data["market_cap_change_percentage_24h_usd"] # Statistika top 100 gainers = [c for c in top_coins if c.get("price_change_percentage_24h", 0) > 0] losers = [c for c in top_coins if c.get("price_change_percentage_24h", 0) < 0] avg_change_24h = np.mean([ c.get("price_change_percentage_24h", 0) for c in top_coins if c.get("price_change_percentage_24h") is not None ]) return { "total_market_cap": total_market_cap, "total_volume_24h": total_volume, "market_cap_change_24h_pct": market_cap_change, "active_cryptocurrencies": global_data.get("active_cryptocurrencies"), "markets": global_data.get("markets"), "btc_dominance": global_data["market_cap_percentage"]["btc"], "eth_dominance": global_data["market_cap_percentage"]["eth"], "market_sentiment": self._market_sentiment( market_cap_change, len(gainers), len(losers) ), "top_gainer": top_coins[0] if top_coins else None, "gainers_count": len(gainers), "losers_count": len(losers), "avg_change_24h": avg_change_24h, "timestamp": datetime.now().isoformat() } def _market_sentiment(self, cap_change: float, gainers: int, losers: int) -> str: """Određuje sentiment tržišta.""" if cap_change > 5 and gainers > losers * 1.5: return "🟢 EXTREME GREED (Preterano optimista)" elif cap_change > 2: return "🟢 GREED (Optimizam)" elif cap_change > -2 and gainers >= losers: return "⚪ NEUTRAL (Uravnoteženo)" elif cap_change > -5: return "🔴 FEAR (Strah)" else: return "🔴 EXTREME FEAR (Panika)" def find_opportunities(self, top_n: int = 10) -> List[Dict]: """ Pronalazi potencijalne prilike (top coins sa jakim signalima). """ top_coins = self.api.get_top_coins(limit=100) opportunities = [] print(f"🔍 Analiziram {len(top_coins)} kriptovaluta...") for i, coin in enumerate(top_coins[:50], 1): try: print(f" [{i}/50] {coin['symbol'].upper()}...", end="\r") analysis = self.analyze_coin(coin, detailed=True) score = analysis.get("score", 0) if score >= 70: opportunities.append({ "coin": coin, "analysis": analysis }) except Exception: continue # Sortiraj po score-u opportunities.sort( key=lambda x: x["analysis"]["score"], reverse=True ) return opportunities[:top_n] def get_alerts(self, change_threshold: float = 5.0) -> List[Dict]: """Generiše alerte za velike promene cena.""" top_coins = self.api.get_top_coins(limit=50) alerts = [] for coin in top_coins: change_24h = coin.get("price_change_percentage_24h", 0) or 0 change_1h = coin.get("price_change_percentage_1h_in_currency", 0) or 0 if abs(change_24h) >= change_threshold: alerts.append({ "type": "24h_pump" if change_24h > 0 else "24h_dump", "coin": coin["symbol"].upper(), "name": coin["name"], "change": change_24h, "current_price": coin["current_price"], "volume": coin.get("total_volume") }) return alerts ``` --- ## 7. `modules/visualizer.py` ```python """ Modul za vizualizaciju podataka. """ import pandas as pd import numpy as np import matplotlib.pyplot as plt import matplotlib.dates as mdates from typing import Dict, Optional try: import plotly.graph_objects as go from plotly.subplots import make_subplots PLOTLY_AVAILABLE = True except ImportError: PLOTLY_AVAILABLE = False import config class Visualizer: """Klasa za vizualizaciju kripto podataka.""" def __init__(self, style: str = "seaborn-v0_8-darkgrid"): try: plt.style.use(style) except Exception: plt.style.use("default") def plot_price_history(self, history: Dict, coin_name: str, days: int = 30, save_path: Optional[str] = None): """Crta istoriju cena sa MA linijama.""" price_data = [p[1] for p in history["prices"]] dates = pd.to_datetime( [p[0] for p in history["prices"]], unit="ms" ) prices = pd.Series(price_data, index=dates) sma_20 = prices.rolling(window=20).mean() sma_50 = prices.rolling(window=50).mean() fig, ax = plt.subplots(figsize=(14, 7)) ax.plot(prices.index, prices.values, label="Cena", linewidth=2, color="#2196F3") ax.plot(sma_20.index, sma_20.values, label="SMA 20", linewidth=1.5, color="#FF9800", alpha=0.8) ax.plot(sma_50.index, sma_50.values, label="SMA 50", linewidth=1.5, color="#F44336", alpha=0.8) ax.set_title(f"{coin_name} - Istorija cena ({days} dana)", fontsize=16, fontweight="bold") ax.set_xlabel("Datum", fontsize=12) ax.set_ylabel("Cena (USD)", fontsize=12) ax.legend(loc="best", fontsize=11) ax.grid(True, alpha=0.3) fig.autofmt_xdate() fig.tight_layout() if save_path: fig.savefig(save_path, dpi=100, bbox_inches="tight") print(f"✅ Grafikon sačuvan: {save_path}") else: plt.show() plt.close(fig) def plot_technical_analysis(self, history: Dict, coin_name: str, save_path: Optional[str] = None): """Višestruki panel sa tehničkim indikatorima.""" prices = pd.Series( [p[1] for p in history["prices"]], index=pd.to_datetime([p[0] for p in history["prices"]], unit="ms") ) volumes = pd.Series( [v[1] for v in history["total_volumes"]], index=pd.to_datetime([v[0] for v in history["total_volumes"]], unit="ms") ) # Izračunaj indikatore sma_20 = prices.rolling(window=20).mean() ema_20 = prices.ewm(span=20, adjust=False).mean() # RSI delta = prices.diff() gain = delta.where(delta > 0, 0).rolling(window=14).mean() loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean() rs = gain / loss.replace(0, np.inf) rsi = 100 - (100 / (1 + rs)) # MACD ema_12 = prices.ewm(span=12, adjust=False).mean() ema_26 = prices.ewm(span=26, adjust=False).mean() macd_line = ema_12 - ema_26 signal_line = macd_line.ewm(span=9, adjust=False).mean() histogram = macd_line - signal_line fig, axes = plt.subplots(4, 1, figsize=(14, 12), sharex=True, gridspec_kw={"height_ratios": [3, 1, 1, 1]}) # 1. Panel: Cena + MA axes[0].plot(prices.index, prices.values, label="Cena", color="#2196F3", linewidth=1.5) axes[0].plot(sma_20.index, sma_20.values, label="SMA 20", color="#FF9800", linewidth=1) axes[0].plot(ema_20.index, ema_20.values, label="EMA 20", color="#9C27B0", linewidth=1) axes[0].set_title(f"{coin_name} - Tehnička analiza", fontsize=14, fontweight="bold") axes[0].set_ylabel("Cena (USD)") axes[0].legend(loc="upper left") axes[0].grid(True, alpha=0.3) # 2. Panel: Volume colors = ["green" if p > 0 else "red" for p in prices.pct_change().fillna(0)] axes[1].bar(volumes.index, volumes.values, color=colors, alpha=0.5) axes[1].set_ylabel("Volume") axes[1].grid(True, alpha=0.3) # 3. Panel: RSI axes[2].plot(rsi.index, rsi.values, color="#9C27B0", linewidth=1.5) axes[2].axhline(y=70, color="r", linestyle="--", alpha=0.5, label="Overbought") axes[2].axhline(y=30, color="g", linestyle="--", alpha=0.5, label="Oversold") axes[2].fill_between(rsi.index, 70, 100, color="r", alpha=0.1) axes[2].fill_between(rsi.index, 0, 30, color="g", alpha=0.1) axes[2].set_ylabel("RSI") axes[2].set_ylim(0, 100) axes[2].legend(loc="upper left") axes[2].grid(True, alpha=0.3) # 4. Panel: MACD colors_hist = ["green" if h > 0 else "red" for h in histogram.fillna(0)] axes[3].bar(histogram.index, histogram.values, color=colors_hist, alpha=0.5) axes[3].plot(macd_line.index, macd_line.values, label="MACD", color="#2196F3", linewidth=1.5) axes[3].plot(signal_line.index, signal_line.values, label="Signal", color="#FF9800", linewidth=1.5) axes[3].axhline(y=0, color="gray", linestyle="-", linewidth=0.5) axes[3].set_ylabel("MACD") axes[3].set_xlabel("Datum") axes[3].legend(loc="upper left") axes[3].grid(True, alpha=0.3) fig.autofmt_xdate() fig.tight_layout() if save_path: fig.savefig(save_path, dpi=100, bbox_inches="tight") print(f"✅ Tehnička analiza sačuvana: {save_path}") else: plt.show() plt.close(fig) def plot_market_overview(self, market_data: Dict, save_path: Optional[str] = None): """Vizualizacija pregleda tržišta.""" fig, axes = plt.subplots(2, 2, figsize=(14, 10)) fig.suptitle("Pregled Kripto Tržišta", fontsize=16, fontweight="bold") # 1. Pie chart - Dominance btc_dom = market_data.get("btc_dominance", 0) eth_dom = market_data.get("eth_dominance", 0) other_dom = 100 - btc_dom - eth_dom axes[0, 0].pie( [btc_dom, eth_dom, other_dom], labels=["BTC", "ETH", "Ostali"], autopct="%1.1f%%", colors=["#F7931A", "#627EEA", "#9E9E9E"], startangle=90 ) axes[0, 0].set_title("Tržišna Dominanca") # 2. Bar - Metric scores metrics = { "Tržišna kap. (T$)": market_data.get("total_market_cap", 0) / 1e12, "Volume 24h (B$)": market_data.get("total_volume_24h", 0) / 1e9, "Broj coina (T)": market_data.get("active_cryptocurrencies", 0) / 1000 } axes[0, 1].bar(metrics.keys(), metrics.values(), color=["#2196F3", "#4CAF50", "#FF9800"]) axes[0, 1].set_title("Tržišni Metrički") axes[0, 1].tick_params(axis="x", rotation=30) # 3. Sentiment change = market_data.get("market_cap_change_24h_pct", 0) color = "green" if change > 0 else "red" axes[1, 0].barh(["24h promena"], [change], color=color, alpha=0.7) axes[1, 0].axvline(x=0, color="black", linewidth=0.5) axes[1, 0].set_title(f"Promena: {change:.2f}%") axes[1, 0].set_xlim(-15, 15) axes[1, 0].grid(True, alpha=0.3) # 4. Gainers vs Losers gainers = market_data.get("gainers_count", 0) losers = market_data.get("losers_count", 0) axes[1, 1].pie( [gainers, losers], labels=[f"Gaineri\n({gainers})", f"Losersi\n({losers})"], autopct="%1.1f%%", colors=["#4CAF50", "#F44336"], startangle=90 ) axes[1, 1].set_title(f"Top 100: 24h distribucija") fig.tight_layout() if save_path: fig.savefig(save_path, dpi=100, bbox_inches="tight") print(f"✅ Pregled sačuvan: {save_path}") else: plt.show() plt.close(fig) def plot_top_coins_comparison(self, top_coins: list, metric: str = "price_change_percentage_24h", top_n: int = 20, save_path: Optional[str] = None): """Bar chart za poređenje promene cena.""" coins_sorted = sorted( [c for c in top_coins if c.get(metric) is not None], key=lambda x: x[metric], reverse=True )[:top_n] names = [c["symbol"].upper() for c in coins_sorted] values = [c[metric] for c in coins_sorted] colors = ["#4CAF50" if v > 0 else "#F44336" for v in values] fig, ax = plt.subplots(figsize=(12, 8)) bars = ax.barh(names[::-1], values[::-1], color=colors[::-1]) ax.set_xlabel(f"{metric} (%)", fontsize=12) ax.set_title(f"Top {top_n} - Promena cena (24h)", fontsize=14, fontweight="bold") ax.axvline(x=0, color="black", linewidth=0.8) ax.grid(True, alpha=0.3, axis="x") for bar, val in zip(bars, values[::-1]): width = bar.get_width() ax.text(width, bar.get_y() + bar.get_height()/2, f"{val:+.2f}%", ha="left" if width > 0 else "right", va="center", fontsize=9) fig.tight_layout() if save_path: fig.savefig(save_path, dpi=100, bbox_inches="tight") print(f"✅ Poređenje sačuvano: {save_path}") else: plt.show() plt.close(fig) ``` --- ## 8. `main.py` ```python """ Crypto Market Analyzer - Glavna aplikacija. Pokrenite: python main.py """ import sys import os from datetime import datetime from tabulate import tabulate from colorama import init, Fore, Style from modules.api_client import CoinGeckoClient from modules.analyzer import MarketAnalyzer from modules.visualizer import Visualizer import config init(autoreset=True) class CryptoAnalyzerApp: """Glavna aplikacija.""" BANNER = f""" {Fore.CYAN}╔══════════════════════════════════════════════════════╗ ║ 🚀 CRYPTO MARKET ANALYZER v1.0 🚀 ║ ║ Analiza kripto tržišta u realnom vremenu ║ ╚══════════════════════════════════════════════════════╝{Style.RESET_ALL} """ MENU = f""" {Fore.YELLOW}╔════════════════════════════════════╗ ║ GLAVNI MENI ║ ╠════════════════════════════════════╣ ║ 1. 📊 Pregled tržišta ║ ║ 2. 🏆 Top kriptovalute ║ ║ 3. 🔍 Analiza konkretnog coina ║ ║ 4. 🎯 Pronađi prilike ║ ║ 5. 🚨 Alarmi (price alerts) ║ ║ 6. 📈 Trending coini ║ ║ 7. 🔎 Pretraži coine ║ ║ 8. 📉 Vizualizacija ║ ║ 0. ❌ Izlaz ║ ╚════════════════════════════════════╝{Style.RESET_ALL} """ def __init__(self): print(self.BANNER) print(f"{Fore.GREEN}⏳ Inicijalizacija...", end=" ") self.api = CoinGeckoClient() self.analyzer = MarketAnalyzer(self.api) self.viz = Visualizer() self.output_dir = "charts" os.makedirs(self.output_dir, exist_ok=True) print(f"{Fore.GREEN}Gotovo!{Style.RESET_ALL}\n") def run(self): """Glavna petlja aplikacije.""" while True: print(self.MENU) choice = input(f"{Fore.CYAN}🎯 Izbor: {Style.RESET_ALL}").strip() try: if choice == "1": self.market_overview() elif choice == "2": self.show_top_coins() elif choice == "3": self.analyze_specific_coin() elif choice == "4": self.find_opportunities() elif choice == "5": self.show_alerts() elif choice == "6": self.show_trending() elif choice == "7": self.search_coins() elif choice == "8": self.visualization_menu() elif choice == "0": print(f"\n{Fore.GREEN}👋 Hvala na korišćenju!{Style.RESET_ALL}\n") break else: print(f"{Fore.RED}❌ Nepoznata opcija!{Style.RESET_ALL}") except KeyboardInterrupt: print(f"\n{Fore.YELLOW}⚠️ Prekinuto od strane korisnika{Style.RESET_ALL}") except Exception as e: print(f"{Fore.RED}❌ Greška: {e}{Style.RESET_ALL}") input(f"\n{Fore.CYAN}⏎ Pritisnite ENTER za nastavak...{Style.RESET_ALL}") def market_overview(self): """Prikaz pregleda celokupnog tržišta.""" print(f"\n{Fore.CYAN}📊 Učitavam podatke o tržištu...{Style.RESET_ALL}") overview = self.analyzer.analyze_market_overview() print(f"\n{Fore.YELLOW}{'='*60}") print(f" 📊 PREGLED TRŽIŠTA - {datetime.now().strftime('%d.%m.%Y %H:%M')}") print(f"{'='*60}{Style.RESET_ALL}\n") # Osnovni metrički total_cap_t = overview['total_market_cap'] / 1e12 total_vol_b = overview['total_volume_24h'] / 1e9 change = overview['market_cap_change_24h_pct'] change_color = Fore.GREEN if change > 0 else Fore.RED data = [ ["💰 Ukupna tržišna kapitalizacija", f"${total_cap_t:,.2f}T"], ["📊 24h Volume", f"${total_vol_b:,.2f}B"], ["📈 Promena (24h)", f"{change_color}{change:+.2f}%{Style.RESET_ALL}"], ["₿ BTC Dominance", f"{overview['btc_dominance']:.2f}%"], ["Ξ ETH Dominance", f"{overview['eth_dominance']:.2f}%"], ["🪙 Aktivnih coina", f"{overview['active_cryptocurrencies']:,}"], ["📍 Berze", f"{overview['markets']:,}"], ["🟢 Gaineri (Top 100)", f"{overview['gainers_count']}"], ["🔴 Loseri (Top 100)", f"{overview['losers_count']}"], ["📊 Avg promena (24h)", f"{overview['avg_change_24h']:+.2f}%"], ] print(tabulate(data, headers=["Metrika", "Vrednost"], tablefmt="double_grid")) print(f"\n{Fore.MAGENTA}🎭 Sentiment: {overview['market_sentiment']}{Style.RESET_ALL}") # Sačuvaj grafikon filename = f"{self.output_dir}/market_overview_{datetime.now().strftime('%Y%m%d_%H%M')}.png" self.viz.plot_market_overview(overview, save_path=filename) def show_top_coins(self): """Prikaz top kriptovaluta.""" print(f"\n{Fore.CYAN}🏆 Učitavam top 50 kriptovaluta...{Style.RESET_ALL}") coins = self.api.get_top_coins(limit=50) print(f"\n{Fore.YELLOW}🏆 TOP 50 KRIPTOVALUTA{Style.RESET_ALL}\n") data = [] for i, c in enumerate(coins[:20], 1): change_24h = c.get("price_change_percentage_24h", 0) or 0 color = Fore.GREEN if change_24h > 0 else Fore.RED data.append([ i, f"{c['symbol'].upper()}", f"${c['current_price']:,.4f}" if c['current_price'] < 1 else f"${c['current_price']:,.2f}", f"{color}{change_24h:+.2f}%{Style.RESET_ALL}", f"${c['market_cap']/1e9:,.2f}B", f"${c['total_volume']/1e6:,.1f}M" ]) print(tabulate(data, headers=["#", "Simbol", "Cena", "24h%", "Market Cap", "Volume"], tablefmt="grid")) # Plot filename = f"{self.output_dir}/top_coins_{datetime.now().strftime('%Y%m%d_%H%M')}.png" self.viz.plot_top_coins_comparison(coins, save_path=filename) def analyze_specific_coin(self): """Detaljna analiza određenog coina.""" coin_id = input(f"\n{Fore.CYAN}🔍 Unesite ID coina (npr. bitcoin, ethereum): {Style.RESET_ALL}").strip().lower() if not coin_id: print(f"{Fore.RED}❌ Morate uneti ID coina!{Style.RESET_ALL}") return print(f"{Fore.CYAN}⏳ Analiziram {coin_id}...{Style.RESET_ALL}") try: coins = self.api.get_top_coins(limit=250) coin_data = next((c for c in coins if c["id"] == coin_id), None) if not coin_data: # Pretraži search_results = self.api.search_coins(coin_id) if search_results: print(f"\n{Fore.YELLOW}🔎 Pronađeni rezultati:{Style.RESET_ALL}") for i, r in enumerate(search_results[:5], 1): print(f" {i}. {r['name']} ({r['symbol']}) - ID: {r['id']}") choice = input(f"\n{Fore.CYAN}Izaberite broj: {Style.RESET_ALL}") try: idx = int(choice) - 1 if 0 <= idx < len(search_results[:5]): coin_id = search_results[idx]["id"] coin_data = next( (c for c in coins if c["id"] == coin_id), None ) except (ValueError, IndexError): pass if not coin_data: print(f"{Fore.RED}❌ Coin nije pronađen!{Style.RESET_ALL}") return # Analiza analysis = self.analyzer.analyze_coin(coin_data) self._print_coin_analysis(analysis) # Vizualizacija history = self.api.get_coin_history(coin_id, days=90) filename = f"{self.output_dir}/{coin_id}_{datetime.now().strftime('%Y%m%d_%H%M')}.png" self.viz.plot_technical_analysis( history, coin_data["name"], save_path=filename ) except Exception as e: print(f"{Fore.RED}❌ Greška pri analizi: {e}{Style.RESET_ALL}") def _print_coin_analysis(self, analysis: Dict): """Formatiran ispis analize coina.""" info = analysis["basic_info"] pc = analysis["price_changes"] mm = analysis["market_metrics"] print(f"\n{Fore.YELLOW}{'='*60}") print(f" 🪙 {info['name']} ({info['symbol']}) - Rank #{info['rank']}") print(f"{'='*60}{Style.RESET_ALL}\n") # Score i preporuka score = analysis.get("score", 0) rec = analysis.get("recommendation", "N/A") if score >= 60: score_color = Fore.GREEN elif score >= 40: score_color = Fore.YELLOW else: score_color = Fore.RED print(f"{score_color}🎯 SCORE: {score}/100{Style.RESET_ALL}") print(f"{score_color}💡 PREPORUKA: {rec}{Style.RESET_ALL}\n") # Cene print(f"{Fore.CYAN}💰 CENE I PROMENE:{Style.RESET_ALL}") price_data = [ ["Trenutna cena", f"${pc['current_price']:,.4f}" if pc['current_price'] and pc['current_price'] < 1 else f"${pc['current_price']:,.2f}" if pc['current_price'] else "N/A"], ["Promena 1h", f"{pc.get('change_1h', 0):+.2f}%"], ["Promena 24h", f"{pc.get('change_24h', 0):+.2f}%"], ["Promena 7d", f"{pc.get('change_7d', 0):+.2f}%"], ["Promena 30d", f"{pc.get('change_30d', 0):+.2f}%"], ["ATH", f"${pc['ath']:,.2f}"], ["Razlika od ATH", f"{pc['ath_change_pct']:.2f}%"] ] print(tabulate(price_data, tablefmt="simple")) # Metriki tržišta print(f"\n{Fore.CYAN}📊 METRIČKI TRŽIŠTA:{Style.RESET_ALL}") market_data = [ ["Tržišna kapitalizacija", f"${mm['market_cap']/1e9:,.2f}B"], ["24h Volume", f"${mm['total_volume']/1e6:,.2f}M"], ["Vol/MCap ratio", f"{mm['volume_to_mcap_ratio']:.2f}%"], ["Circulating Supply", f"{mm['circulating_supply']:,.0f}"], ["Total Supply", f"{mm['total_supply']:,.0f}" if mm['total_supply'] else "∞"], ["Supply ratio", f"{mm['supply_ratio']:.2f}%" if mm['supply_ratio'] else "N/A"] ] print(tabulate(market_data, tablefmt="simple")) # Tehnička analiza if "technical" in analysis: tech = analysis["technical"] print(f"\n{Fore.CYAN}📈 TEHNIČKA ANALIZA:{Style.RESET_ALL}") tech_data = [ ["RSI (14)", f"{tech['rsi']:.2f}"], ["SMA 20", f"${tech['sma_20']:,.2f}" if tech['sma_20'] > 1 else f"${tech['sma_20']:.6f}"], ["SMA 50", f"${tech['sma_50']:,.2f}" if tech['sma_50'] > 1 else f"${tech['sma_50']:.6f}"], ["Volatilnost (godišnja)", f"{tech['volatility']:.2f}%"], ["Trend", tech['trend']], ["MACD histogram", f"{tech['macd']['histogram']:.4f}"], ["MACD signal", tech['macd']['interpretation']], ["Bollinger pozicija", tech['bollinger_bands']['position']] ] print(tabulate(tech_data, tablefmt="simple")) # Signali if "signals" in analysis: signals = analysis["signals"] print(f"\n{Fore.GREEN}✅ KUPOVINA SIGNALI ({len(signals.get('buy_signals', []))}):{Style.RESET_ALL}") for s in signals.get("buy_signals", []): print(f" 🟢 {s}") print(f"\n{Fore.RED}❌ PRODAJA SIGNALI ({len(signals.get('sell_signals', []))}):{Style.RESET_ALL}") for s in signals.get("sell_signals", []): print(f" 🔴 {s}") if signals.get("neutral_signals"): print(f"\n{Fore.YELLOW}⚠️ NEUTRALNI:{Style.RESET_ALL}") for s in signals["neutral_signals"]: print(f" ⚪ {s}") def find_opportunities(self): """Pronalaženje prilika za ulaganje.""" print(f"\n{Fore.CYAN}🎯 Tražim prilike (score >= 70)...{Style.RESET_ALL}\n") opportunities = self.analyzer.find_opportunities(top_n=10) if not opportunities: print(f"{Fore.YELLOW}⚠️ Trenutno nema jakih prilika na tržištu.{Style.RESET_ALL}") return print(f"{Fore.GREEN}✨ PRONAĐENE PRILIKE (Top {len(opportunities)}):{Style.RESET_ALL}\n") data = [] for i, opp in enumerate(opportunities, 1): coin = opp["coin"] analysis = opp["analysis"] score = analysis["score"] change = coin.get("price_change_percentage_24h", 0) or 0 data.append([ i, f"{coin['symbol'].upper()}", coin["name"], f"${coin['current_price']:,.2f}" if coin['current_price'] > 1 else f"${coin['current_price']:.4f}", f"{change:+.2f}%", f"{Fore.GREEN}{score}{Style.RESET_ALL}", f"${coin['market_cap']/1e9:.2f}B" ]) print(tabulate(data, headers=["#", "Simbol", "Ime", "Cena", "24h%", "Score", "MCap"], tablefmt="fancy_grid")) def show_alerts(self): """Prikaz alerta za velike promene.""" threshold = input(f"{Fore.CYAN}⚙️ Prag alarma u % (default 5): {Style.RESET_ALL}").strip() threshold = float(threshold) if threshold else 5.0 print(f"\n{Fore.CYAN}🚨 Tražim promene > ±{threshold}%...{Style.RESET_ALL}\n") alerts = self.analyzer.get_alerts(change_threshold=threshold) if not alerts: print(f"{Fore.YELLOW}⚠️ Nema značajnih promena.{Style.RESET_ALL}") return # Razdvoj positive i negative pumps = [a for a in alerts if a["type"] == "24h_pump"] dumps = [a for a in alerts if a["type"] == "24h_dump"] if pumps: print(f"{Fore.GREEN}🚀 PUMPS (Top {min(5, len(pumps))}):{Style.RESET_ALL}") data = [[a["coin"], a["name"], f"${a['current_price']:,.2f}" if a['current_price'] > 1 else f"${a['current_price']:.4f}", f"{Fore.GREEN}+{a['change']:.2f}%{Style.RESET_ALL}", f"${a['volume']/1e6:.1f}M"] for a in pumps[:5]] print(tabulate(data, headers=["Coin", "Ime", "Cena", "24h%", "Volume"], tablefmt="fancy_grid")) if dumps: print(f"\n{Fore.RED}💥 DUMPS (Top {min(5, len(dumps))}):{Style.RESET_ALL}") data = [[a["coin"], a["name"], f"${a['current_price']:,.2f}" if a['current_price'] > 1 else f"${a['current_price']:.4f}", f"{Fore.RED}{a['change']:.2f}%{Style.RESET_ALL}", f"${a['volume']/1e6:.1f}M"] for a in dumps[:5]] print(tabulate(data, headers=["Coin", "Ime", "Cena", "24h%", "Volume"], tablefmt="fancy_grid")) def show_trending(self): """Prikaz trending coina.""" print(f"\n{Fore.CYAN}📈 Učitavam trending coine...{Style.RESET_ALL}\n") trending = self.api.get_trending_coins() print(f"{Fore.YELLOW}🔥 TRENDING NA COINGECKO:{Style.RESET_ALL}\n") data = [] for i, t in enumerate(trending[:7], 1): data.append([ i, t["symbol"], t["name"], f"#{t.get('market_cap_rank', 'N/A')}", t.get("price_btc", "N/A") ]) print(tabulate(data, headers=["#", "Simbol", "Ime", "Rank", "BTC cena"], tablefmt="fancy_grid")) def search_coins(self): """Pretraga coina.""" query = input(f"\n{Fore.CYAN}🔎 Pretraži: {Style.RESET_ALL}").strip() if not query: return results = self.api.search_coins(query) if not results: print(f"{Fore.RED}❌ Nema rezultata za '{query}'{Style.RESET_ALL}") return print(f"\n{Fore.YELLOW}🔎 REZULTATI ZA '{query}':{Style.RESET_ALL}\n") data = [[i+1, r["name"], r["symbol"], r["id"], f"#{r.get('market_cap_rank', 'N/A')}"] for i, r in enumerate(results[:15])] print(tabulate(data, headers=["#", "Ime", "Simbol", "ID", "Rank"], tablefmt="grid")) def visualization_menu(self): """Meni za vizualizaciju.""" print(f"\n{Fore.CYAN}📉 VIZUALIZACIJA{Style.RESET_ALL}") print("1. 📊 Pregled tržišta") print("2. 📊 Tehnička analiza coina") print("3. 📊 Poređenje top coina") print("4. 📊 Cena coina (istorija)") choice = input(f"\n{Fore.CYAN}Izbor: {Style.RESET_ALL}").strip() try: if choice == "1": overview = self.analyzer.analyze_market_overview() filename = f"{self.output_dir}/market_{datetime.now().strftime('%Y%m%d_%H%M')}.png" self.viz.plot_market_overview(overview, save_path=filename) elif choice == "2": coin_id = input(f"{Fore.CYAN}Coin ID: {Style.RESET_ALL}").strip() history = self.api.get_coin_history(coin_id, days=90) coins = self.api.get_top_coins(limit=250) coin = next((c for c in coins if c["id"] == coin_id), None) name = coin["name"] if coin else coin_id filename = f"{self.output_dir}/tech_{coin_id}.png" self.viz.plot_technical_analysis(history, name, save_path=filename) elif choice == "3": coins = self.api.get_top_coins(limit=50) filename = f"{self.output_dir}/comparison.png" self.viz.plot_top_coins_comparison(coins, save_path=filename) elif choice == "4": coin_id = input(f"{Fore.CYAN}Coin ID: {Style.RESET_ALL}").strip() history = self.api.get_coin_history(coin_id, days=30) filename = f"{self.output_dir}/price_{coin_id}.png" self.viz.plot_price_history(history, coin_id, save_path=filename) except Exception as e: print(f"{Fore.RED}❌ Greška: {e}{Style.RESET_ALL}") if __name__ == "__main__": try: app = CryptoAnalyzerApp() app.run() except KeyboardInterrupt: print(f"\n{Fore.GREEN}👋 Doviđenja!{Style.RESET_ALL}") sys.exit(0) ``` --- ## 🚀 Kako Pokrenuti ```bash # 1. Kreiraj direktorijum mkdir crypto_analyzer cd crypto_analyzer # 2. Kreiraj strukturu mkdir modules touch modules/__init__.py # 3. Instaliraj dependencies pip install -r requirements.txt # 4. Pokreni aplikaciju python main.py ``` --- ## ✨ Funkcionalnosti | Modul | Šta radi | |-------|----------| | **📊 Market Overview** | Globalna statistika tržišta, dominanca, sentiment | | **🏆 Top Coins** | Rang lista sa cenama, promenama, metrikom | | **🔍 Coin Analyzer** | Detaljna analiza pojedinačnog coina sa svim indikatorima | | **🎯 Opportunities** | AI-like scoring sistem pronalazi prilike (score 0-100) | | **🚨 Alerts** | Notifikacije za velike pumpe/dump-ove | | **📈 Trending** | Najpopularniji coini na CoinGecko | | **🔎 Search** | Pretraga coina po imenu/simbolu | | **📉 Vizualizacija** | Grafikoni: cena, indikatori, BB, MACD, RSI | ## 🎯 Scoring Sistem Svaki coin dobija **score 0-100** sa preporukom: - 🚀 **75-100**: STRONG BUY (jaki signali + bullish trend) - 🟢 **60-75**: BUY - ⚪ **40-60**: HOLD - 🔴 **25-40**: SELL - 💥 **0-25**: STRONG SELL Koristi **RSI, MACD, Bollinger Bands, SMA/EMA crossovere** i volume analizu za generisanje signala! ## 📝 Napomene - **CoinGecko** besplatan API — ne treba ti ključ (rate limit: ~10-30 req/min) - Svi grafikoni se čuvaju u `charts/` direktorijumu - Aplikacija kešira podatke gde god može da smanji API pozive - `colorama` + `tabulate` za lep CLI prikaz Javi mi ako hoćeš da dodam još nešto (backtesting, portfolio tracker, webhook alerts, bazu podataka, ili web interfejs sa Flask/Streamlit)! 🚀

Ti si ekspert za programiranje aplikacija. uradi mi aplikaci...