News Sentiment Trader

What It Does

Installation

pip install -r requirements.txt

import nltk
   nltk.download('vader_lexicon')

Usage

{
       "assets": ["BTC/USD"],
       "news_sources": ["https://example.com/news"],
       "thresholds": {"buy": 0.5, "sell": -0.5},
       "trading_platform": {
           "exchange": "binance",
           "api_key": "your_api_key",
           "secret": "your_secret_key"
       }
   }

python news_sentiment_trader.py --config path_to_your_config.json

Source Code

import json
import logging
import argparse
from nltk.sentiment import SentimentIntensityAnalyzer
import ccxt
from typing import List, Dict
from unittest.mock import patch
import nltk

# Download NLTK data
nltk.download('vader_lexicon', quiet=True)

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

class NewsSentimentTrader:
    def __init__(self, config_path: str):
        self.config = self.load_config(config_path)
        self.sia = SentimentIntensityAnalyzer()
        self.exchange = self.initialize_exchange()

    def load_config(self, config_path: str) -> Dict:
        try:
            with open(config_path, 'r') as file:
                return json.load(file)
        except FileNotFoundError:
            logging.error("Configuration file not found.")
            raise
        except json.JSONDecodeError:
            logging.error("Invalid JSON format in configuration file.")
            raise

    def initialize_exchange(self):
        try:
            exchange_id = self.config['trading_platform']['exchange']
            api_key = self.config['trading_platform']['api_key']
            secret = self.config['trading_platform']['secret']
            exchange_class = getattr(ccxt, exchange_id)
            return exchange_class({
                'apiKey': api_key,
                'secret': secret,
                'enableRateLimit': True,
            })
        except KeyError:
            logging.error("Trading platform configuration is incomplete.")
            raise
        except AttributeError:
            logging.error("Invalid exchange specified.")
            raise

    def fetch_news(self, url: str) -> str:
        # Simulate fetching news content from a URL
        try:
            # Mocked content for testing purposes
            return "Sample news content about Bitcoin."
        except Exception as e:
            logging.error(f"Failed to fetch or parse article: {e}")
            return ""

    def analyze_sentiment(self, text: str) -> float:
        if not text:
            return 0.0
        sentiment = self.sia.polarity_scores(text)
        return sentiment['compound']

    def generate_signal(self, sentiment: float, thresholds: Dict) -> str:
        if sentiment >= thresholds['buy']:
            return 'buy'
        elif sentiment <= thresholds['sell']:
            return 'sell'
        else:
            return 'hold'

    def execute_trade(self, signal: str, asset: str):
        try:
            if signal == 'buy':
                logging.info(f"Executing BUY trade for {asset}.")
                # Example: self.exchange.create_market_buy_order(asset, amount)
            elif signal == 'sell':
                logging.info(f"Executing SELL trade for {asset}.")
                # Example: self.exchange.create_market_sell_order(asset, amount)
            else:
                logging.info(f"HOLD signal for {asset}. No trade executed.")
        except Exception as e:
            logging.error(f"Failed to execute trade: {e}")

    def run(self):
        assets = self.config['assets']
        thresholds = self.config['thresholds']
        news_sources = self.config['news_sources']

        for asset in assets:
            for source in news_sources:
                logging.info(f"Fetching news for {asset} from {source}.")
                article_text = self.fetch_news(source)
                sentiment = self.analyze_sentiment(article_text)
                signal = self.generate_signal(sentiment, thresholds)
                logging.info(f"Sentiment for {asset}: {sentiment}, Signal: {signal}")
                self.execute_trade(signal, asset)

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="News Sentiment Trader")
    parser.add_argument('--config', required=True, help="Path to JSON configuration file")
    args = parser.parse_args()

    try:
        trader = NewsSentimentTrader(args.config)
        trader.run()
    except Exception as e:
        logging.error(f"Error running News Sentiment Trader: {e}")