quantflow-finance 0.1.0__tar.gz

quantflow_finance-0.1.0/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: quantflow-finance
+Version: 0.1.0
+Summary: Essential quantitative finance tools for modern portfolio management
+Home-page: https://github.com/jeevanba273/quantflow
+Author: JEEVAN B A
+Author-email: jeevanba273@gmail.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: matplotlib>=3.3.0
+Requires-Dist: yfinance>=0.1.70
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+A comprehensive Python package for options pricing, risk analytics, and market data processing.

quantflow_finance-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

quantflow_finance-0.1.0/setup.py

@@ -0,0 +1,41 @@
+"""
+Setup configuration for QuantFlow package.
+"""
+
+from setuptools import setup, find_packages
+
+setup(
+    name="quantflow-finance",
+    version="0.1.0",
+    author="JEEVAN B A",
+    author_email="jeevanba273@gmail.com",
+    description="Essential quantitative finance tools for modern portfolio management",
+    long_description="A comprehensive Python package for options pricing, risk analytics, and market data processing.",
+    long_description_content_type="text/markdown",
+    url="https://github.com/jeevanba273/quantflow",
+    package_dir={"": "src"},
+    packages=find_packages(where="src"),
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Financial and Insurance Industry",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
+    ],
+    python_requires=">=3.8",
+    install_requires=[
+        "numpy>=1.20.0",
+        "scipy>=1.7.0",
+        "pandas>=1.3.0",
+        "matplotlib>=3.3.0",
+        "yfinance>=0.1.70",
+    ],
+    extras_require={
+        "dev": [
+            "pytest>=6.0",
+            "black",
+            "flake8",
+        ],
+    },
+)

quantflow_finance-0.1.0/src/quantflow/__init__.py

@@ -0,0 +1,16 @@
+"""
+QuantFlow: Essential quantitative finance tools for modern portfolio management.
+
+A comprehensive Python package for options pricing, risk analytics, and market data processing.
+"""
+
+__version__ = "0.1.0"
+__author__ = "JEEVAN B A"
+__email__ = "jeevanba273@gmail.com"
+
+# Import main classes for easy access
+from .options.black_scholes import BlackScholes
+from .risk.metrics import RiskMetrics
+from .data.fetcher import MarketData
+
+__all__ = ['BlackScholes', 'RiskMetrics', 'MarketData']

quantflow_finance-0.1.0/src/quantflow/options/__init__.py

@@ -0,0 +1,10 @@
+"""
+Options pricing and Greeks calculation module.
+
+This module provides implementations of various option pricing models including
+the Black-Scholes-Merton model for European options.
+"""
+
+from .black_scholes import BlackScholes
+
+__all__ = ['BlackScholes']

quantflow_finance-0.1.0/src/quantflow/options/black_scholes.py

@@ -0,0 +1,89 @@
+"""
+Black-Scholes option pricing model implementation.
+"""
+
+import numpy as np
+from scipy.stats import norm
+
+
+class BlackScholes:
+    """
+    Black-Scholes option pricing model.
+    
+    Parameters:
+    S: Current stock price
+    K: Strike price  
+    T: Time to expiration in years
+    r: Risk-free interest rate
+    sigma: Volatility
+    option_type: 'call' or 'put'
+    """
+    
+    def __init__(self, S, K, T, r, sigma, option_type='call'):
+        self.S = float(S)
+        self.K = float(K)
+        self.T = float(T)
+        self.r = float(r)
+        self.sigma = float(sigma)
+        self.option_type = option_type.lower()
+    
+    def price(self):
+        """Calculate option price using Black-Scholes formula."""
+        # Calculate d1 and d2 parameters
+        d1 = (np.log(self.S / self.K) + (self.r + 0.5 * self.sigma**2) * self.T) / (self.sigma * np.sqrt(self.T))
+        d2 = d1 - self.sigma * np.sqrt(self.T)
+        
+        if self.option_type == 'call':
+            # Call option formula: S*N(d1) - K*e^(-rT)*N(d2)
+            return self.S * norm.cdf(d1) - self.K * np.exp(-self.r * self.T) * norm.cdf(d2)
+        else:
+            # Put option formula: K*e^(-rT)*N(-d2) - S*N(-d1)
+            return self.K * np.exp(-self.r * self.T) * norm.cdf(-d2) - self.S * norm.cdf(-d1)
+        
+    def delta(self):
+        """Calculate option delta (price sensitivity to stock price)."""
+        d1 = (np.log(self.S / self.K) + (self.r + 0.5 * self.sigma**2) * self.T) / (self.sigma * np.sqrt(self.T))
+        
+        if self.option_type == 'call':
+            return norm.cdf(d1)
+        else:
+            return norm.cdf(d1) - 1
+    
+    def gamma(self):
+        """Calculate option gamma (rate of change of delta)."""
+        d1 = (np.log(self.S / self.K) + (self.r + 0.5 * self.sigma**2) * self.T) / (self.sigma * np.sqrt(self.T))
+        
+        # Gamma is the same for both calls and puts
+        return norm.pdf(d1) / (self.S * self.sigma * np.sqrt(self.T))
+    
+    def theta(self):
+        """Calculate option theta (time decay per year)."""
+        d1 = (np.log(self.S / self.K) + (self.r + 0.5 * self.sigma**2) * self.T) / (self.sigma * np.sqrt(self.T))
+        d2 = d1 - self.sigma * np.sqrt(self.T)
+        
+        first_term = -(self.S * norm.pdf(d1) * self.sigma) / (2 * np.sqrt(self.T))
+        
+        if self.option_type == 'call':
+            second_term = -self.r * self.K * np.exp(-self.r * self.T) * norm.cdf(d2)
+        else:
+            second_term = self.r * self.K * np.exp(-self.r * self.T) * norm.cdf(-d2)
+            
+        return first_term + second_term
+    
+    def vega(self):
+        """Calculate option vega (sensitivity to volatility change)."""
+        d1 = (np.log(self.S / self.K) + (self.r + 0.5 * self.sigma**2) * self.T) / (self.sigma * np.sqrt(self.T))
+        
+        # Vega is the same for both calls and puts
+        # Divide by 100 to get sensitivity per 1% volatility change
+        return (self.S * norm.pdf(d1) * np.sqrt(self.T)) / 100
+    
+    def greeks(self):
+        """Calculate all Greeks at once."""
+        return {
+            'price': self.price(),
+            'delta': self.delta(),
+            'gamma': self.gamma(),
+            'theta': self.theta(),
+            'vega': self.vega()
+        }

quantflow_finance-0.1.0/src/quantflow_finance.egg-info/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: quantflow-finance
+Version: 0.1.0
+Summary: Essential quantitative finance tools for modern portfolio management
+Home-page: https://github.com/jeevanba273/quantflow
+Author: JEEVAN B A
+Author-email: jeevanba273@gmail.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: matplotlib>=3.3.0
+Requires-Dist: yfinance>=0.1.70
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+A comprehensive Python package for options pricing, risk analytics, and market data processing.

quantflow_finance-0.1.0/src/quantflow_finance.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+setup.py
+src/quantflow/__init__.py
+src/quantflow/options/__init__.py
+src/quantflow/options/black_scholes.py
+src/quantflow_finance.egg-info/PKG-INFO
+src/quantflow_finance.egg-info/SOURCES.txt
+src/quantflow_finance.egg-info/dependency_links.txt
+src/quantflow_finance.egg-info/requires.txt
+src/quantflow_finance.egg-info/top_level.txt
+tests/test_black_scholes.py
+tests/test_market_data.py
+tests/test_risk_metrics.py

quantflow_finance-0.1.0/src/quantflow_finance.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

quantflow_finance-0.1.0/src/quantflow_finance.egg-info/requires.txt

@@ -0,0 +1,10 @@
+numpy>=1.20.0
+scipy>=1.7.0
+pandas>=1.3.0
+matplotlib>=3.3.0
+yfinance>=0.1.70
+
+[dev]
+pytest>=6.0
+black
+flake8

quantflow_finance-0.1.0/src/quantflow_finance.egg-info/top_level.txt

@@ -0,0 +1 @@
+quantflow

quantflow_finance-0.1.0/tests/test_black_scholes.py

@@ -0,0 +1,106 @@
+"""
+Test the Black-Scholes implementation.
+"""
+
+import sys
+import os
+
+# Add the src folder to Python path so we can import our code
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../src'))
+
+from quantflow.options.black_scholes import BlackScholes
+
+
+def test_basic_call_option():
+    """Test a basic call option price."""
+    # Create a call option: Stock=$100, Strike=$100, 1 year, 5% rate, 20% volatility
+    option = BlackScholes(S=100, K=100, T=1, r=0.05, sigma=0.2, option_type='call')
+    price = option.price()
+    
+    print(f"Call option price: ${price:.2f}")
+    
+    # The theoretical price should be around $10.45
+    assert 10.0 < price < 11.0, f"Price {price} seems wrong for this call option"
+    print("✓ Call option test passed!")
+
+def test_delta_calculation():
+    """Test delta calculation."""
+    # Same option as before
+    option = BlackScholes(S=100, K=100, T=1, r=0.05, sigma=0.2, option_type='call')
+    delta = option.delta()
+    
+    print(f"Call option delta: {delta:.3f}")
+    
+    # Delta for ATM call should be around 0.6
+    assert 0.55 < delta < 0.65, f"Delta {delta} seems wrong"
+    print("✓ Delta test passed!")
+
+def test_gamma_calculation():
+    """Test gamma calculation."""
+    # Same option as before
+    option = BlackScholes(S=100, K=100, T=1, r=0.05, sigma=0.2, option_type='call')
+    gamma = option.gamma()
+    
+    print(f"Call option gamma: {gamma:.4f}")
+    
+    # Gamma for ATM options should be around 0.02
+    assert 0.015 < gamma < 0.025, f"Gamma {gamma} seems wrong"
+    print("✓ Gamma test passed!")
+
+def test_theta_calculation():
+    """Test theta calculation."""
+    # Same option as before
+    option = BlackScholes(S=100, K=100, T=1, r=0.05, sigma=0.2, option_type='call')
+    theta = option.theta()
+    
+    print(f"Call option theta: ${theta:.2f} per year")
+    print(f"Daily theta: ${theta/365:.3f} per day")
+    
+    # Theta should be negative for long options (time decay)
+    assert theta < 0, f"Theta {theta} should be negative for long options"
+    assert -10 < theta < -1, f"Theta {theta} seems out of reasonable range"
+    print("✓ Theta test passed!")
+
+
+def test_vega_calculation():
+    """Test vega calculation."""
+    # Same option as before
+    option = BlackScholes(S=100, K=100, T=1, r=0.05, sigma=0.2, option_type='call')
+    vega = option.vega()
+    
+    print(f"Call option vega: ${vega:.2f} per 1% volatility change")
+    
+    # Vega should be positive (higher volatility = higher option value)
+    assert vega > 0, f"Vega {vega} should be positive"
+    assert 0.2 < vega < 0.6, f"Vega {vega} seems out of reasonable range"
+    print("✓ Vega test passed!")
+
+def test_greeks_summary():
+    """Test the convenient Greeks summary function."""
+    option = BlackScholes(S=100, K=100, T=1, r=0.05, sigma=0.2, option_type='call')
+    greeks = option.greeks()
+    
+    print("\n📊 Complete Greeks Summary:")
+    print(f"Price: ${greeks['price']:.2f}")
+    print(f"Delta: {greeks['delta']:.3f}")
+    print(f"Gamma: {greeks['gamma']:.4f}")
+    print(f"Theta: ${greeks['theta']:.2f}")
+    print(f"Vega: ${greeks['vega']:.2f}")
+    
+    # Check that all values are present
+    assert 'price' in greeks
+    assert 'delta' in greeks
+    assert 'gamma' in greeks
+    assert 'theta' in greeks
+    assert 'vega' in greeks
+    print("✓ Greeks summary test passed!")
+
+
+if __name__ == "__main__":
+    test_basic_call_option()
+    test_delta_calculation()
+    test_gamma_calculation()
+    test_theta_calculation()
+    test_vega_calculation()
+    test_greeks_summary()
+    print("All tests passed! 🎉")

quantflow_finance-0.1.0/tests/test_market_data.py

@@ -0,0 +1,52 @@
+"""
+Test the market data implementation.
+"""
+
+import sys
+import os
+
+# Add the src folder to Python path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../src'))
+
+from quantflow.data.fetcher import MarketData
+
+
+def test_single_stock_fetch():
+    """Test fetching data for a single stock."""
+    print("📈 Fetching AAPL data...")
+    
+    # Fetch Apple stock data for 6 months
+    data = MarketData.fetch_stock_data('AAPL', period='6mo')
+    
+    print(f"Data shape: {data.shape}")
+    print(f"Date range: {data.index[0].date()} to {data.index[-1].date()}")
+    print(f"Latest price: ${data.iloc[-1, 0]:.2f}")
+    
+    # Check that we got reasonable data
+    assert len(data) > 100, f"Expected more data points, got {len(data)}"
+    assert data.iloc[-1, 0] > 0, "Stock price should be positive"
+    print("✓ Single stock fetch test passed!")
+
+
+def test_returns_calculation():
+    """Test returns calculation."""
+    print("\n📊 Testing returns calculation...")
+    
+    # Fetch data and calculate returns
+    data = MarketData.fetch_stock_data('MSFT', period='3mo')
+    returns = MarketData.calculate_returns(data)
+    
+    print(f"Returns data shape: {returns.shape}")
+    print(f"Average daily return: {returns.mean().iloc[0]:.4f} ({returns.mean().iloc[0]*100:.2f}%)")
+    print(f"Daily volatility: {returns.std().iloc[0]:.4f} ({returns.std().iloc[0]*100:.2f}%)")
+    
+    # Check returns are reasonable
+    assert len(returns) == len(data) - 1, "Returns should have one less observation than prices"
+    assert not returns.isna().any().any(), "Returns should not contain NaN values"
+    print("✓ Returns calculation test passed!")
+
+
+if __name__ == "__main__":
+    test_single_stock_fetch()
+    test_returns_calculation()
+    print("\nAll market data tests passed! 🎉")

quantflow_finance-0.1.0/tests/test_risk_metrics.py

@@ -0,0 +1,82 @@
+"""
+Test the risk metrics implementation.
+"""
+
+import sys
+import os
+import numpy as np
+
+# Add the src folder to Python path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../src'))
+
+from quantflow.risk.metrics import RiskMetrics
+
+
+def test_var_calculation():
+    """Test Value at Risk calculation."""
+    # Create sample returns (daily returns for 1 year)
+    np.random.seed(42)  # For reproducible results
+    returns = np.random.normal(0.001, 0.02, 252)  # 1% annual return, 20% volatility
+    
+    risk_metrics = RiskMetrics(returns)
+    var_5 = risk_metrics.var_historical(0.05)  # 5% VaR
+    
+    print(f"5% VaR: {var_5:.4f} ({var_5*100:.2f}%)")
+    
+    # VaR should be negative (worst 5% of returns)
+    assert var_5 < 0, f"VaR should be negative, got {var_5}"
+    print("✓ VaR test passed!")
+
+
+def test_sharpe_ratio():
+    """Test Sharpe ratio calculation."""
+    np.random.seed(42)
+    returns = np.random.normal(0.001, 0.02, 252)
+    
+    risk_metrics = RiskMetrics(returns)
+    sharpe = risk_metrics.sharpe_ratio(risk_free_rate=0.02)
+    
+    print(f"Sharpe ratio: {sharpe:.3f}")
+    
+    # Sharpe ratio should be reasonable (between -2 and 3 for most portfolios)
+    assert -2 < sharpe < 3, f"Sharpe ratio {sharpe} seems unreasonable"
+    print("✓ Sharpe ratio test passed!")
+
+def test_expected_shortfall():
+    """Test Expected Shortfall calculation."""
+    np.random.seed(42)
+    returns = np.random.normal(0.001, 0.02, 252)
+    
+    risk_metrics = RiskMetrics(returns)
+    var_5 = risk_metrics.var_historical(0.05)
+    es_5 = risk_metrics.expected_shortfall(0.05)
+    
+    print(f"5% Expected Shortfall: {es_5:.4f} ({es_5*100:.2f}%)")
+    print(f"VaR vs ES: VaR={var_5:.4f}, ES={es_5:.4f}")
+    
+    # Expected Shortfall should be worse (more negative) than VaR
+    assert es_5 < var_5, f"Expected Shortfall {es_5} should be worse than VaR {var_5}"
+    print("✓ Expected Shortfall test passed!")
+
+
+def test_max_drawdown():
+    """Test Maximum Drawdown calculation."""
+    np.random.seed(42)
+    returns = np.random.normal(0.001, 0.02, 252)
+    
+    risk_metrics = RiskMetrics(returns)
+    max_dd = risk_metrics.max_drawdown()
+    
+    print(f"Maximum Drawdown: {max_dd:.4f} ({max_dd*100:.2f}%)")
+    
+    # Max drawdown should be negative (loss from peak)
+    assert max_dd <= 0, f"Max drawdown should be negative, got {max_dd}"
+    print("✓ Max drawdown test passed!")
+
+
+if __name__ == "__main__":
+    test_var_calculation()
+    test_sharpe_ratio()
+    test_expected_shortfall()
+    test_max_drawdown()
+    print("All risk metrics tests passed! 🎉")