Add new finance utilities, linting configuration, and GitHub Actions workflow

- Added Beta Calculator utility with levered/unlevered beta, upside/downside beta
- Added Volatility Calculator with historical, Parkinson, Garman-Klass, EWMA methods
- Added Correlation Analysis utility with Pearson, rolling, EWMA, tail correlation
- Set up Ruff linting with pyproject.toml configuration
- Added GitHub Actions workflow for automated linting
- Added requirements.txt and requirements-dev.txt
- Updated README to v1.6.0 with lint status badge
- Formatted all Python files with Ruff
- Added comprehensive tests for new utilities

Author: MeridianAlgo-Developer

.github/workflows/lint.yml

@@ -0,0 +1,30 @@
+name: Lint
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.11'
+    
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install ruff
+    
+    - name: Run Ruff linter
+      run: ruff check . --output-format=github
+    
+    - name: Run Ruff formatter check
+      run: ruff format --check .

README.md

@@ -1,30 +1,22 @@
-# Learn-Quant: Wanna learn quant through code? (v1.5.0)
+# Learn-Quant: Wanna learn quant through code? (v1.6.0)
+
+[![Lint](https://github.com/MeridianAlgo/Learn-Quant/actions/workflows/lint.yml/badge.svg)](https://github.com/MeridianAlgo/Learn-Quant/actions/workflows/lint.yml)
 
 Welcome to **Learn-Quant**, your comprehensive, beginner-friendly toolkit for mastering quantitative finance, algorithmic trading, and Python programming!
 
 ---
 
 ## What is This Repo?
 A massive, curated collection of Python modules, strategies, and reference materials designed to help you:
-- **NEW IN v1.5.0:** Master advanced strategies like **Pairs Trading** and **Kalman Filters**.
-- **NEW IN v1.5.0:** Learn high-frequency data engineering with **AsyncIO**.
+- Master advanced strategies like **Pairs Trading** and **Kalman Filters**.
+- Learn high-frequency data engineering with **AsyncIO**.
 - Understand core quant concepts (Risk, Return, Derivatives, Portfolio Theory).
 - Practice with realistic trading algorithms and backtesting simulators.
 - Learn Python from scratch: from basic loops to advanced OOP and Decorators.
 - Master computer science algorithms (Sorting, Searching, Graphs, DP) tailored for finance.
 
 ---
 
-## NEW: Interactive Learning Platform
-
-**Experience algorithms like never before with our browser-based learning platform!**
-
-### Features
-- **Interactive Algorithm Browser**: Filter by category and difficulty.
-- **In-Browser Python Execution**: Run code directly using PyScript.
-- **Live Code Editor**: Edit and test algorithms in real-time.
-- **Visual Output**: See results instantly in your browser.
-
 ### Quick Start
 ```bash
 # Option 1: Interactive launcher (Recommended)
@@ -65,7 +57,10 @@ python run_learning_platform.py demo
 - `UTILS - Quantitative Methods - Regression/` — Beta calculation and factor models.
 
 ### Finance Utilities & Simulators
-- `UTILS - Strategies - Pairs Trading/` — **(New)** Statistical arbitrage simulation.
+- `UTILS - Strategies - Pairs Trading/` — Statistical arbitrage simulation.
+- `UTILS - Finance - Beta Calculator/` — **(New)** Beta, levered/unlevered beta, upside/downside beta.
+- `UTILS - Finance - Volatility Calculator/` — **(New)** Historical, Parkinson, Garman-Klass, EWMA volatility.
+- `UTILS - Finance - Correlation Analysis/` — **(New)** Pearson, rolling, EWMA, tail correlation.
 - `UTILS - Black-Scholes Option Pricing/` — Valuation of derivatives.
 - `UTILS - Portfolio Optimizer/` — Efficient Frontier and Sharpe Ratio maximization.
 - `UTILS - Monte Carlo Portfolio Simulator/` — Stress testing portfolios.
@@ -118,6 +113,6 @@ We welcome contributions!
 
 ---
 
-**Learn-Quant** v1.5.0
+**Learn-Quant** v1.6.0
 _Quantitative Finance, Algorithms, and Python Mastery._
 _Made by MeridianAlgo_

UTILS - AI Development/chatbot.py

@@ -10,13 +10,13 @@
 
 import os
 import sys
-from typing import Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 if TYPE_CHECKING:
     from google import genai
 
 
-def initialize_client() -> Optional["genai.Client"]:
+def initialize_client() -> Optional[genai.Client]:
     """Initialise the Gemini client when dependencies and keys are available."""
 
     try:
@@ -37,7 +37,7 @@ def initialize_client() -> Optional["genai.Client"]:
         return None
 
 
-def chat_loop(client: "genai.Client") -> None:
+def chat_loop(client: genai.Client) -> None:
     """Interactive chat loop using an initialised Gemini client."""
 
     print("Gemini Chatbot (type 'exit' to quit)")

UTILS - Advanced Python - AsyncIO/async_fetching.py

@@ -8,9 +8,9 @@
 """
 
 import asyncio
-import time
 import random
-from typing import List, Dict
+import time
+from typing import Dict, List
 
 
 async def fetch_ticker(symbol: str) -> Dict[str, float]:

UTILS - Advanced Python - Decorators and Generators/decorators_generators_tutorial.py

@@ -8,10 +8,10 @@
 - Generators: Memory-efficient iteration (streaming data)
 """
 
-import time
 import functools
-from typing import Iterator, List, Callable
 import random
+import time
+from typing import Callable, Iterator, List
 
 
 def intro() -> None:
@@ -178,7 +178,7 @@ def price_stream(start_price: float) -> Iterator[float]:
     # Consume only 5 items from infinite stream
     for i in range(5):
         price = next(stream)
-        print(f"  Tick {i+1}: ${price:.2f}")
+        print(f"  Tick {i + 1}: ${price:.2f}")
 
     # 3. Generator Expression (Memory Efficient)
     print("\n3. Generator Expression vs List Comprehension:")
@@ -241,7 +241,7 @@ def market_data_feed(tickers: List[str], periods: int):
         """Yield market data for each period."""
         for i in range(periods):
             data = {
-                "date": f"2023-01-{i+1:02d}",
+                "date": f"2023-01-{i + 1:02d}",
                 "prices": {t: random.uniform(100, 200) for t in tickers},
             }
             yield data
@@ -301,9 +301,7 @@ def main() -> None:
     generators_demo()
     practical_example_backtest()
     print("\n🎉 Decorators and Generators tutorial complete!")
-    print(
-        "Use decorators for cross-cutting concerns and generators for efficient data pipelines."
-    )
+    print("Use decorators for cross-cutting concerns and generators for efficient data pipelines.")
 
 
 if __name__ == "__main__":

UTILS - Advanced Python - Error Handling/error_handling_tutorial.py

@@ -6,8 +6,8 @@
 This module teaches robust error handling for financial applications.
 """
 
-from typing import Optional, List
 import logging
+from typing import List, Optional
 
 
 def intro() -> None:
@@ -150,9 +150,7 @@ class InsufficientFundsError(TradingError):
         def __init__(self, required: float, available: float):
             self.required = required
             self.available = available
-            super().__init__(
-                f"Insufficient funds: need ${required:,.2f}, have ${available:,.2f}"
-            )
+            super().__init__(f"Insufficient funds: need ${required:,.2f}, have ${available:,.2f}")
 
     class InvalidTickerError(TradingError):
         """Raised when ticker symbol is invalid."""
@@ -162,9 +160,7 @@ def __init__(self, ticker: str):
             super().__init__(f"Invalid ticker symbol: {ticker}")
 
     # Use custom exceptions
-    def execute_trade(
-        ticker: str, price: float, shares: int, account_balance: float
-    ) -> None:
+    def execute_trade(ticker: str, price: float, shares: int, account_balance: float) -> None:
         """Execute trade with custom error handling."""
         # Validate ticker
         valid_tickers = ["AAPL", "GOOGL", "MSFT"]
@@ -323,19 +319,15 @@ def assertion_checking() -> None:
     print("ASSERTIONS")
     print("=" * 60)
 
-    def calculate_sharpe_ratio(
-        returns: List[float], risk_free_rate: float = 0.02
-    ) -> float:
+    def calculate_sharpe_ratio(returns: List[float], risk_free_rate: float = 0.02) -> float:
         """
         Calculate Sharpe ratio with assertions.
 
         Assertions help catch bugs during development.
         """
         # Assertions for debugging (removed in production with -O flag)
         assert len(returns) > 0, "Returns list cannot be empty"
-        assert all(
-            isinstance(r, (int, float)) for r in returns
-        ), "Returns must be numbers"
+        assert all(isinstance(r, (int, float)) for r in returns), "Returns must be numbers"
         assert 0 <= risk_free_rate <= 1, "Risk-free rate must be between 0 and 1"
 
         avg_return = sum(returns) / len(returns)

UTILS - Advanced Python - OOP/oop_tutorial.py

@@ -6,9 +6,9 @@
 This module teaches OOP concepts through building trading and portfolio classes.
 """
 
-from typing import List, Dict, Optional
 from datetime import datetime
 from decimal import Decimal
+from typing import Dict, List, Optional
 
 
 def intro() -> None:
@@ -70,9 +70,7 @@ def __str__(self) -> str:
 
     def __repr__(self) -> str:
         """Developer-friendly representation."""
-        return (
-            f"Stock(ticker='{self.ticker}', price={self.price}, shares={self.shares})"
-        )
+        return f"Stock(ticker='{self.ticker}', price={self.price}, shares={self.shares})"
 
 
 class Portfolio:
@@ -170,10 +168,10 @@ def get_allocation(self) -> Dict[str, float]:
 
     def __str__(self) -> str:
         """String representation of portfolio."""
-        lines = [f"\n{'='*60}"]
+        lines = [f"\n{'=' * 60}"]
         lines.append(f"Portfolio: {self.name}")
         lines.append(f"Created: {self.created_at.strftime('%Y-%m-%d %H:%M:%S')}")
-        lines.append(f"{'='*60}")
+        lines.append(f"{'=' * 60}")
 
         for stock in self.holdings.values():
             lines.append(f"  {stock}")
@@ -194,9 +192,7 @@ class Trade:
 
     trade_counter = 0  # Class variable to track trade IDs
 
-    def __init__(
-        self, ticker: str, entry_price: float, shares: int, direction: str = "LONG"
-    ):
+    def __init__(self, ticker: str, entry_price: float, shares: int, direction: str = "LONG"):
         """
         Initialize a Trade.
 
@@ -283,9 +279,7 @@ def __init__(self, account_id: str, initial_balance: float):
         self.trades: List[Trade] = []
         self.open_positions: Dict[str, Trade] = {}
 
-    def enter_trade(
-        self, ticker: str, entry_price: float, shares: int, direction: str = "LONG"
-    ) -> Optional[Trade]:
+    def enter_trade(self, ticker: str, entry_price: float, shares: int, direction: str = "LONG") -> Optional[Trade]:
         """
         Enter a new trade.
 
@@ -368,15 +362,13 @@ def __str__(self) -> str:
         """String representation."""
         perf = self.get_performance_summary()
 
-        lines = [f"\n{'='*60}"]
+        lines = [f"\n{'=' * 60}"]
         lines.append(f"Trading Account: {self.account_id}")
-        lines.append(f"{'='*60}")
+        lines.append(f"{'=' * 60}")
         lines.append(f"  Balance: ${perf['current_balance']:,.2f}")
         lines.append(f"  Total P&L: ${perf['total_pnl']:,.2f}")
         lines.append(f"  Return: {perf['return_pct']:.2%}")
-        lines.append(
-            f"  Trades: {perf['total_trades']} ({perf['closed_trades']} closed)"
-        )
+        lines.append(f"  Trades: {perf['total_trades']} ({perf['closed_trades']} closed)")
         lines.append(f"  Win Rate: {perf['win_rate']:.1%}")
         lines.append("=" * 60)
 

UTILS - Algorithms - Backtracking/backtracking_algorithms.py

@@ -116,13 +116,7 @@ def backtrack(row, col, index):
         if index == len(word):
             return True
 
-        if (
-            row < 0
-            or row >= rows
-            or col < 0
-            or col >= cols
-            or board[row][col] != word[index]
-        ):
+        if row < 0 or row >= rows or col < 0 or col >= cols or board[row][col] != word[index]:
             return False
 
         temp = board[row][col]

UTILS - Algorithms - Dynamic Programming/dynamic_programming.py

@@ -3,8 +3,8 @@
 A comprehensive collection of DP algorithms with detailed explanations and examples.
 """
 
-from typing import List, Tuple
 import sys
+from typing import List, Tuple
 
 
 def fibonacci_memoization(n: int) -> int:
@@ -167,9 +167,7 @@ def knapsack_01(weights: List[int], values: List[int], capacity: int) -> int:
     for i in range(1, n + 1):
         for w in range(capacity + 1):
             if weights[i - 1] <= w:
-                dp[i][w] = max(
-                    values[i - 1] + dp[i - 1][w - weights[i - 1]], dp[i - 1][w]
-                )
+                dp[i][w] = max(values[i - 1] + dp[i - 1][w - weights[i - 1]], dp[i - 1][w])
             else:
                 dp[i][w] = dp[i - 1][w]
 
@@ -398,11 +396,7 @@ def matrix_chain_multiplication(dimensions: List[int]) -> int:
             dp[i][j] = sys.maxsize
 
             for k in range(i, j):
-                cost = (
-                    dp[i][k]
-                    + dp[k + 1][j]
-                    + dimensions[i - 1] * dimensions[k] * dimensions[j]
-                )
+                cost = dp[i][k] + dp[k + 1][j] + dimensions[i - 1] * dimensions[k] * dimensions[j]
                 dp[i][j] = min(dp[i][j], cost)
 
     return dp[1][n]