diff --git a/.Jules/palette.md b/.Jules/palette.md index 231399f..018831f 100644 --- a/.Jules/palette.md +++ b/.Jules/palette.md @@ -1,7 +1,3 @@ -## 2024-05-22 - Visual Hierarchy in CLI Output -**Learning:** Adding color-coded indicators (Green/Red) and emojis (💰, 📉) in CLI tools significantly reduces cognitive load when parsing financial data streams. It transforms a wall of text into a scannable narrative. -**Action:** For data-heavy CLI applications, always implement a semantic color system and visual anchors (icons/emojis) for key events. - -## 2024-05-23 - Accessibility and Control in CLI Tools -**Learning:** While color and emojis improve scannability, they can be distracting or inaccessible (e.g., for color-blind users or automated parsing). Providing `--no-color` and `--quiet` flags is essential for accessibility and flexibility. -**Action:** Always include flags to disable visual enhancements and suppress verbose output in CLI tools to respect user preferences and support automation. +## 2024-05-23 - CLI UX Enhancement +**Learning:** Even in CLI apps, visual distinction (colors, emojis) significantly reduces cognitive load when scanning logs. +**Action:** Use ANSI colors and consistent emojis for key events (success/failure) in future CLI tools. diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml new file mode 100644 index 0000000..36232fc --- /dev/null +++ b/.github/workflows/codeql.yml @@ -0,0 +1,101 @@ +# For most projects, this workflow file will not need changing; you simply need +# to commit it to your repository. +# +# You may wish to alter this file to override the set of languages analyzed, +# or to provide custom queries or build logic. +# +# ******** NOTE ******** +# We have attempted to detect the languages in your repository. Please check +# the `language` matrix defined below to confirm you have the correct set of +# supported CodeQL languages. +# +name: "CodeQL Advanced" + +on: + push: + branches: [ "main" ] + pull_request: + branches: [ "main" ] + schedule: + - cron: '42 16 * * 6' + +jobs: + analyze: + name: Analyze (${{ matrix.language }}) + # Runner size impacts CodeQL analysis time. To learn more, please see: + # - https://gh.io/recommended-hardware-resources-for-running-codeql + # - https://gh.io/supported-runners-and-hardware-resources + # - https://gh.io/using-larger-runners (GitHub.com only) + # Consider using larger runners or machines with greater resources for possible analysis time improvements. + runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }} + permissions: + # required for all workflows + security-events: write + + # required to fetch internal or private CodeQL packs + packages: read + + # only required for workflows in private repositories + actions: read + contents: read + + strategy: + fail-fast: false + matrix: + include: + - language: actions + build-mode: none + - language: python + build-mode: none + # CodeQL supports the following values keywords for 'language': 'actions', 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'rust', 'swift' + # Use `c-cpp` to analyze code written in C, C++ or both + # Use 'java-kotlin' to analyze code written in Java, Kotlin or both + # Use 'javascript-typescript' to analyze code written in JavaScript, TypeScript or both + # To learn more about changing the languages that are analyzed or customizing the build mode for your analysis, + # see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning. + # If you are analyzing a compiled language, you can modify the 'build-mode' for that language to customize how + # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + # Add any setup steps before running the `github/codeql-action/init` action. + # This includes steps like installing compilers or runtimes (`actions/setup-node` + # or others). This is typically only required for manual builds. + # - name: Setup runtime (example) + # uses: actions/setup-example@v1 + + # Initializes the CodeQL tools for scanning. + - name: Initialize CodeQL + uses: github/codeql-action/init@v4 + with: + languages: ${{ matrix.language }} + build-mode: ${{ matrix.build-mode }} + # If you wish to specify custom queries, you can do so here or in a config file. + # By default, queries listed here will override any specified in a config file. + # Prefix the list here with "+" to use these queries and those in the config file. + + # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs + # queries: security-extended,security-and-quality + + # If the analyze step fails for one of the languages you are analyzing with + # "We were unable to automatically build your code", modify the matrix above + # to set the build mode to "manual" for that language. Then modify this step + # to build your code. + # ℹī¸ Command-line programs to run using the OS shell. + # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun + - name: Run manual build steps + if: matrix.build-mode == 'manual' + shell: bash + run: | + echo 'If you are using a "manual" build mode for one or more of the' \ + 'languages you are analyzing, replace this with the commands to build' \ + 'your code, for example:' + echo ' make bootstrap' + echo ' make release' + exit 1 + + - name: Perform CodeQL Analysis + uses: github/codeql-action/analyze@v4 + with: + category: "/language:${{matrix.language}}" diff --git a/.gitignore b/.gitignore index 2e049dd..907591b 100644 --- a/.gitignore +++ b/.gitignore @@ -43,4 +43,3 @@ # Python __pycache__/ *.pyc -.pytest_cache/ diff --git a/README.md b/README.md index be561ef..4cd8db6 100644 --- a/README.md +++ b/README.md @@ -4,10 +4,11 @@ A Python-based CLI tool that simulates Bitcoin trading using a 'Golden Cross' mo ## Features -- **Price Simulation:** Uses Geometric Brownian Motion to simulate 60 days of Bitcoin prices. +- **Price Simulation:** Uses Geometric Brownian Motion to simulate Bitcoin prices. - **Trading Strategy:** Implements a Golden Cross strategy (Short MA > Long MA = Buy, Short MA < Long MA = Sell). -- **Rich CLI Output:** features color-coded logs (Green for Buy/Profit, Red for Sell/Loss) and emojis for better readability. +- **Rich CLI Output:** Features color-coded logs (Green for Buy/Profit, Red for Sell/Loss) and emojis for better readability. - **Performance metrics:** Compares the strategy's performance against a "Buy and Hold" approach. +- **Customizable:** Configure simulation parameters via command-line arguments. ## Installation @@ -20,16 +21,36 @@ pip install -r requirements.txt ## Usage -Run the simulation script: +Run the simulation script with default settings (60 days, $10k initial cash): ```bash python bitcoin_trading_simulation.py ``` +### Options + +Customize the simulation with the following arguments: + +```bash +python bitcoin_trading_simulation.py --days 100 --initial-cash 5000 --initial-price 60000 --volatility 0.03 +``` + +- `--days`: Number of days to simulate (default: 60) +- `--initial-cash`: Initial cash amount (default: 10000) +- `--initial-price`: Initial Bitcoin price (default: 50000) +- `--volatility`: Price volatility (default: 0.02) +- `--quiet`: Suppress daily portfolio log (only show final result) +- `--no-color`: Disable colored output (for accessibility or logging) + +Example: +```bash +python bitcoin_trading_simulation.py --days 30 --quiet --no-color +``` + ## Tests -Run the test suite: +Run the test suite using `pytest`: ```bash -python test.py +pytest ``` diff --git a/__pycache__/bitcoin_trading_simulation.cpython-312.pyc b/__pycache__/bitcoin_trading_simulation.cpython-312.pyc new file mode 100644 index 0000000..52abfc2 Binary files /dev/null and b/__pycache__/bitcoin_trading_simulation.cpython-312.pyc differ diff --git a/__pycache__/test_bitcoin_trading.cpython-312.pyc b/__pycache__/test_bitcoin_trading.cpython-312.pyc new file mode 100644 index 0000000..ecc297a Binary files /dev/null and b/__pycache__/test_bitcoin_trading.cpython-312.pyc differ diff --git a/bitcoin_trading_simulation.py b/bitcoin_trading_simulation.py index 6706418..c86be3e 100644 --- a/bitcoin_trading_simulation.py +++ b/bitcoin_trading_simulation.py @@ -1,7 +1,9 @@ +import argparse import numpy as np import pandas as pd import argparse + class Colors: HEADER = '\033[95m' BLUE = '\033[94m' @@ -19,6 +21,18 @@ def disable(cls): cls.ENDC = '' cls.BOLD = '' + +class Colors: + HEADER = '\033[95m' + BLUE = '\033[94m' + CYAN = '\033[96m' + GREEN = '\033[92m' + WARNING = '\033[93m' + FAIL = '\033[91m' + ENDC = '\033[0m' + BOLD = '\033[1m' + UNDERLINE = '\033[4m' + def simulate_bitcoin_prices(days=60, initial_price=50000, volatility=0.02): """ Simulates Bitcoin prices for a given number of days using Geometric Brownian Motion. @@ -33,6 +47,7 @@ def simulate_bitcoin_prices(days=60, initial_price=50000, volatility=0.02): prices.append(prices[-1] + price_change) return pd.Series(prices, name='Price') + def calculate_moving_averages(prices, short_window=7, long_window=30): """ Calculates short and long moving averages for a given price series. @@ -43,6 +58,7 @@ def calculate_moving_averages(prices, short_window=7, long_window=30): signals['long_mavg'] = prices.rolling(window=long_window, min_periods=1, center=False).mean() return signals + def generate_trading_signals(signals): """ Generates trading signals based on the Golden Cross strategy. @@ -54,11 +70,12 @@ def generate_trading_signals(signals): signals.loc[signals['short_mavg'] > signals['long_mavg'], 'signal'] = 1.0 # A Death Cross (sell signal) signals.loc[signals['short_mavg'] < signals['long_mavg'], 'signal'] = -1.0 - + # We create 'positions' to represent the trading action: 1 for buy, -1 for sell, 0 for hold signals['positions'] = signals['signal'].diff().shift(1) return signals + def simulate_trading(signals, initial_cash=10000, quiet=False): """ Simulates trading based on signals and prints a daily ledger. @@ -71,6 +88,8 @@ def simulate_trading(signals, initial_cash=10000, quiet=False): if not quiet: print(f"{Colors.HEADER}{Colors.BOLD}------ Daily Trading Ledger ------{Colors.ENDC}") + + print(f"\n{Colors.HEADER}{Colors.BOLD}------ Daily Trading Ledger ------{Colors.ENDC}") for i, row in signals.iterrows(): if i > 0: portfolio.loc[i, 'cash'] = portfolio.loc[i-1, 'cash'] @@ -81,30 +100,33 @@ def simulate_trading(signals, initial_cash=10000, quiet=False): btc_to_buy = portfolio.loc[i, 'cash'] / row['price'] portfolio.loc[i, 'btc'] += btc_to_buy portfolio.loc[i, 'cash'] -= btc_to_buy * row['price'] - print(f"{Colors.GREEN}Day {i}: 💰 Buy {btc_to_buy:.4f} BTC at ${row['price']:.2f}{Colors.ENDC}") + print(f"{Colors.GREEN}đŸŸĸ Day {i}: Buy {btc_to_buy:.4f} BTC at ${row['price']:.2f}{Colors.ENDC}") # Sell signal elif row['positions'] == -2.0: if portfolio.loc[i, 'btc'] > 0: cash_received = portfolio.loc[i, 'btc'] * row['price'] portfolio.loc[i, 'cash'] += cash_received - print(f"{Colors.RED}Day {i}: 📉 Sell {portfolio.loc[i, 'btc']:.4f} BTC at ${row['price']:.2f}{Colors.ENDC}") + print(f"{Colors.FAIL}🔴 Day {i}: Sell {portfolio.loc[i, 'btc']:.4f} BTC at ${row['price']:.2f}{Colors.ENDC}") portfolio.loc[i, 'btc'] = 0 portfolio.loc[i, 'total_value'] = portfolio.loc[i, 'cash'] + portfolio.loc[i, 'btc'] * row['price'] + if not quiet: - print(f"Day {i}: Portfolio Value: ${portfolio.loc[i, 'total_value']:.2f}, Cash: ${portfolio.loc[i, 'cash']:.2f}, BTC: {portfolio.loc[i, 'btc']:.4f}") - + print(f"Day {i}: Portfolio Value: ${portfolio.loc[i, 'total_value']:.2f}, " + f"Cash: ${portfolio.loc[i, 'cash']:.2f}, BTC: {portfolio.loc[i, 'btc']:.4f}") + return portfolio + if __name__ == "__main__": - parser = argparse.ArgumentParser(description='Bitcoin Trading Simulation') - parser.add_argument('--days', type=int, default=60, help='Number of days to simulate') - parser.add_argument('--initial-cash', type=float, default=10000, help='Initial cash in portfolio') - parser.add_argument('--initial-price', type=float, default=50000, help='Initial Bitcoin price') - parser.add_argument('--volatility', type=float, default=0.02, help='Volatility of price changes') - parser.add_argument('--quiet', '-q', action='store_true', help='Suppress daily portfolio logs') - parser.add_argument('--no-color', action='store_true', help='Disable colored output') + parser = argparse.ArgumentParser(description="Bitcoin Trading Simulation") + parser.add_argument("--days", type=int, default=60, help="Number of days to simulate") + parser.add_argument("--initial-cash", type=float, default=10000, help="Initial cash amount") + parser.add_argument("--initial-price", type=float, default=50000, help="Initial Bitcoin price") + parser.add_argument("--volatility", type=float, default=0.02, help="Price volatility") + parser.add_argument("--quiet", action="store_true", help="Suppress daily portfolio log") + parser.add_argument("--no-color", action="store_true", help="Disable colored output") args = parser.parse_args() @@ -113,33 +135,31 @@ def simulate_trading(signals, initial_cash=10000, quiet=False): # Simulate prices prices = simulate_bitcoin_prices(days=args.days, initial_price=args.initial_price, volatility=args.volatility) - + # Calculate moving averages signals = calculate_moving_averages(prices) - + # Generate trading signals signals = generate_trading_signals(signals) - + # Simulate trading portfolio = simulate_trading(signals, initial_cash=args.initial_cash, quiet=args.quiet) - + # Final portfolio performance final_value = portfolio['total_value'].iloc[-1] initial_cash = args.initial_cash profit = final_value - initial_cash - + # Compare with buy and hold strategy - buy_and_hold_btc = initial_cash / prices.iloc[0] + buy_and_hold_btc = args.initial_cash / prices.iloc[0] buy_and_hold_value = buy_and_hold_btc * prices.iloc[-1] print(f"\n{Colors.HEADER}{Colors.BOLD}------ Final Portfolio Performance ------{Colors.ENDC}") print(f"Initial Cash: ${initial_cash:.2f}") print(f"Final Portfolio Value: ${final_value:.2f}") - if profit >= 0: - print(f"Profit/Loss: {Colors.GREEN}📈 ${profit:.2f}{Colors.ENDC}") + print(f"{Colors.GREEN}💰 Profit/Loss: ${profit:.2f}{Colors.ENDC}") else: - print(f"Profit/Loss: {Colors.RED}📉 ${profit:.2f}{Colors.ENDC}") - + print(f"{Colors.FAIL}📉 Profit/Loss: ${profit:.2f}{Colors.ENDC}") print(f"Buy and Hold Strategy Value: ${buy_and_hold_value:.2f}") print(f"{Colors.HEADER}-----------------------------------------{Colors.ENDC}") diff --git a/test.py b/test.py deleted file mode 100644 index b326d87..0000000 --- a/test.py +++ /dev/null @@ -1,3 +0,0 @@ -# Filename: tests/test_sample.py -def test_example(): - assert 1 + 1 == 2 diff --git a/test_bitcoin.py b/test_bitcoin.py new file mode 100644 index 0000000..163248c --- /dev/null +++ b/test_bitcoin.py @@ -0,0 +1,35 @@ +import pytest +from unittest.mock import patch +from bitcoin import get_bitcoin_price, calculate_value + +# Test 1: Verify the calculation logic +def test_calculate_value(): + """Ensure BTC to USD conversion math is correct.""" + price = 50000.0 + amount = 2.5 + expected = 125000.0 + assert calculate_value(amount, price) == expected + +# Test 2: Verify handling of zero amount +def test_calculate_value_zero(): + assert calculate_value(0, 50000.0) == 0.0 + +# Test 3: Mocking an API response +@patch('bitcoin.requests.get') +def test_get_bitcoin_price(mock_get): + """Simulate a successful API response from CoinDesk or similar.""" + # Mock the JSON return value + mock_get.return_value.json.return_value = { + "bpi": {"USD": {"rate_float": 62000.50}} + } + mock_get.return_value.status_code = 200 + + price = get_bitcoin_price() + assert price == 62000.50 + +# Test 4: Handling API failure +@patch('bitcoin.requests.get') +def test_get_price_api_error(mock_get): + mock_get.return_value.status_code = 404 + with pytest.raises(ConnectionError): + get_bitcoin_price() diff --git a/test_bitcoin_trading.py b/test_bitcoin_trading.py new file mode 100644 index 0000000..e7eac6f --- /dev/null +++ b/test_bitcoin_trading.py @@ -0,0 +1,74 @@ +import pytest +import pandas as pd +from bitcoin_trading_simulation import ( + simulate_trading, Colors, calculate_moving_averages, + generate_trading_signals, simulate_bitcoin_prices +) + + +@pytest.fixture +def reset_colors(): + # Save original colors + original_colors = { + 'HEADER': Colors.HEADER, + 'BLUE': Colors.BLUE, + 'GREEN': Colors.GREEN, + 'RED': Colors.RED, + 'ENDC': Colors.ENDC, + 'BOLD': Colors.BOLD, + } + yield + # Restore colors + Colors.HEADER = original_colors['HEADER'] + Colors.BLUE = original_colors['BLUE'] + Colors.GREEN = original_colors['GREEN'] + Colors.RED = original_colors['RED'] + Colors.ENDC = original_colors['ENDC'] + Colors.BOLD = original_colors['BOLD'] + + +def test_simulate_trading_quiet_mode(capsys): + """Test that quiet mode suppresses output.""" + signals = pd.DataFrame(index=range(5)) + signals['price'] = [100.0, 101.0, 102.0, 103.0, 104.0] + signals['positions'] = [0.0] * 5 + + simulate_trading(signals, initial_cash=1000, quiet=True) + + captured = capsys.readouterr() + assert captured.out == "" + + +def test_simulate_trading_verbose_mode(capsys): + """Test that verbose mode prints daily ledger.""" + signals = pd.DataFrame(index=range(2)) + signals['price'] = [100.0, 101.0] + signals['positions'] = [0.0, 0.0] + + simulate_trading(signals, initial_cash=1000, quiet=False) + + captured = capsys.readouterr() + assert "Daily Trading Ledger" in captured.out + assert "Portfolio Value" in captured.out + + +def test_colors_disable(reset_colors): + """Test that Colors.disable() clears color codes.""" + assert Colors.HEADER != "" + Colors.disable() + assert Colors.HEADER == "" + assert Colors.GREEN == "" + assert Colors.RED == "" + + +def test_simulation_integration(): + """Test full simulation pipeline with small parameters.""" + prices = simulate_bitcoin_prices(days=10, initial_price=100) + signals = calculate_moving_averages(prices, short_window=2, long_window=5) + signals = generate_trading_signals(signals) + portfolio = simulate_trading(signals, quiet=True) + + assert len(portfolio) == 10 + assert 'total_value' in portfolio.columns + assert 'btc' in portfolio.columns + assert 'cash' in portfolio.columns diff --git a/test_simulation.py b/test_simulation.py index 05a5106..0f4f1f8 100644 --- a/test_simulation.py +++ b/test_simulation.py @@ -4,29 +4,30 @@ from bitcoin_trading_simulation import simulate_bitcoin_prices, calculate_moving_averages, generate_trading_signals def test_simulate_bitcoin_prices(): - prices = simulate_bitcoin_prices(days=10, initial_price=100, volatility=0.01) - assert len(prices) == 10 + days = 10 + prices = simulate_bitcoin_prices(days=days, initial_price=50000) + assert len(prices) == days assert isinstance(prices, pd.Series) - assert prices.iloc[0] == 100 + assert prices.name == 'Price' def test_calculate_moving_averages(): - prices = pd.Series([10, 11, 12, 13, 14, 15, 16, 17, 18, 19], name='Price') + prices = pd.Series([100, 101, 102, 103, 104, 105, 106, 107, 108, 109], name='Price') signals = calculate_moving_averages(prices, short_window=3, long_window=5) assert 'short_mavg' in signals.columns assert 'long_mavg' in signals.columns - assert len(signals) == 10 + assert not signals['short_mavg'].isnull().all() def test_generate_trading_signals(): - # create dummy signals dataframe - signals = pd.DataFrame({ + # Create dummy signals DataFrame + data = { 'price': [100, 101, 102, 103, 104], - 'short_mavg': [100, 101, 102, 103, 104], - 'long_mavg': [99, 100, 101, 102, 103] - }) - # Here short > long, so signal should be 1.0 (buy) + 'short_mavg': [100, 101, 105, 102, 100], + 'long_mavg': [100, 100, 100, 103, 105] + } + signals = pd.DataFrame(data) + signals = generate_trading_signals(signals) - signals_with_logic = generate_trading_signals(signals) - assert 'signal' in signals_with_logic.columns - assert 'positions' in signals_with_logic.columns - # Check if logic is applied (dummy check) - assert (signals_with_logic['signal'] == 1.0).all() + assert 'signal' in signals.columns + assert 'positions' in signals.columns + # Check that positions are calculated (not all nan, though first might be) + assert signals['positions'].isin([0, 1, -1, 2, -2, np.nan]).any()