wiz-trader 0.17.0__tar.gz → 0.19.0__tar.gz

{wiz_trader-0.17.0/src/wiz_trader.egg-info → wiz_trader-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wiz_trader
-Version: 0.17.0
+Version: 0.19.0
 Summary: A Python SDK for connecting to the Wizzer.
 Home-page: https://bitbucket.org/wizzer-tech/quotes_sdk.git
 Author: Pawan Wagh
@@ -388,29 +388,388 @@ for component in components[:5]:
 ```
 
 #### Get Historical OHLCV Data
+## Overview
 
-Fetch historical price data for instruments:
+The `get_historical_ohlcv` method supports multiple time intervals for historical data retrieval, from 1-minute intraday data to monthly aggregated data.
+
+## Supported Intervals
+
+### Intraday Intervals
+- `1m` - 1 minute
+- `2m` - 2 minutes  
+- `3m` - 3 minutes
+- `5m` - 5 minutes
+- `10m` - 10 minutes
+- `15m` - 15 minutes
+- `30m` - 30 minutes
+- `45m` - 45 minutes
+- `1h` - 1 hour
+
+### Daily/Monthly Intervals
+- `1d` - 1 day (default)
+- `1M` - 1 month (last trading day of month)
+
+## Date Format Requirements
+
+### For Daily and Monthly Intervals (`1d`, `1M`)
+- **Format**: `YYYY-MM-DD`
+- **Example**: `"2024-01-15"`
+
+### For Intraday Intervals (all minute/hour intervals)
+- **Format**: `YYYY-MM-DD HH:MM:SS`
+- **Example**: `"2024-01-15 09:30:00"`
+
+## Using Constants
+
+The client provides constants for all intervals:
+
+```python
+from wiz_trader import WizzerClient
+
+client = WizzerClient(...)
+
+# Intraday intervals
+client.INTERVAL_1_MINUTE     # "1m"
+client.INTERVAL_2_MINUTES    # "2m"
+client.INTERVAL_3_MINUTES    # "3m"
+client.INTERVAL_5_MINUTES    # "5m"
+client.INTERVAL_10_MINUTES   # "10m"
+client.INTERVAL_15_MINUTES   # "15m"
+client.INTERVAL_30_MINUTES   # "30m"
+client.INTERVAL_45_MINUTES   # "45m"
+client.INTERVAL_1_HOUR       # "1h"
+
+# Daily/Monthly intervals
+client.INTERVAL_1_DAY        # "1d"
+client.INTERVAL_1_MONTH      # "1M"
+```
+
+## Usage Examples
+
+### 1. Get 5-minute intraday data
+
+```python
+# Get 5-minute candles for a trading session
+intraday_data = client.get_historical_ohlcv(
+    instruments=["NSE:SBIN:3045"],
+    start_date="2024-01-15 09:15:00",  # Market open
+    end_date="2024-01-15 15:30:00",    # Market close
+    ohlcv=["open", "high", "low", "close", "volume"],
+    interval=client.INTERVAL_5_MINUTES
+)
+
+# Response will have date field as: "2024-01-15 09:15:00", "2024-01-15 09:20:00", etc.
+```
+
+### 2. Get 1-minute data for scalping
+
+```python
+# Get 1-minute data for the first hour of trading
+scalping_data = client.get_historical_ohlcv(
+    instruments=["NSE:RELIANCE:2885", "NSE:TCS:2953"],
+    start_date="2024-01-15 09:15:00",
+    end_date="2024-01-15 10:15:00",
+    ohlcv=["open", "high", "low", "close", "volume"],
+    interval=client.INTERVAL_1_MINUTE
+)
+```
+
+### 3. Get hourly data for swing trading
+
+```python
+# Get hourly data for a week
+hourly_data = client.get_historical_ohlcv(
+    instruments=["NSE:NIFTY 50:26000"],
+    start_date="2024-01-15 09:15:00",
+    end_date="2024-01-19 15:30:00",
+    ohlcv=["open", "high", "low", "close", "volume"],
+    interval=client.INTERVAL_1_HOUR
+)
+```
+
+### 4. Get daily data (traditional)
 
 ```python
-# Get daily data
+# Get daily data for a month
 daily_data = client.get_historical_ohlcv(
     instruments=["NSE:SBIN:3045"],
-    start_date="2024-01-01",
+    start_date="2024-01-01",  # Note: No time component
     end_date="2024-01-31",
     ohlcv=["open", "high", "low", "close", "volume"],
-    interval="1d"  # Daily data (default)
+    interval=client.INTERVAL_1_DAY
 )
 
-# Get monthly data
+# Response will have date field as: "2024-01-01", "2024-01-02", etc.
+```
+
+### 5. Get monthly data for long-term analysis
+
+```python
+# Get monthly data for a year
 monthly_data = client.get_historical_ohlcv(
-    instruments=["NSE:SBIN:3045", "NSE:ICICIBANK:4963"],
+    instruments=["NSE:SBIN:3045"],
     start_date="2023-01-01",
-    end_date="2024-01-01",
+    end_date="2023-12-31",
     ohlcv=["close", "volume"],
-    interval="1M"  # Monthly data
+    interval=client.INTERVAL_1_MONTH
+)
+```
+
+## Response Structure
+
+The response structure remains the same, but the `date` field format varies:
+
+### For Daily/Monthly Intervals
+```json
+{
+  "instrument": {
+    "exchange": "NSE",
+    "tradingSymbol": "SBIN",
+    "exchangeToken": 3045,
+    "identifier": "NSE:SBIN:3045"
+  },
+  "data": [
+    {
+      "date": "2024-01-15",  // YYYY-MM-DD format
+      "open": 750.0,
+      "high": 765.0,
+      "low": 745.0,
+      "close": 760.0,
+      "volume": 1000000
+    }
+  ]
+}
+```
+
+### For Intraday Intervals
+```json
+{
+  "instrument": {
+    "exchange": "NSE",
+    "tradingSymbol": "SBIN",
+    "exchangeToken": 3045,
+    "identifier": "NSE:SBIN:3045"
+  },
+  "data": [
+    {
+      "date": "2024-01-15 09:15:00",  // YYYY-MM-DD HH:MM:SS format
+      "open": 750.0,
+      "high": 752.0,
+      "low": 749.0,
+      "close": 751.0,
+      "volume": 50000
+    }
+  ]
+}
+```
+
+## Advanced Usage Examples
+
+### Multiple Timeframe Analysis
+
+```python
+def get_multi_timeframe_data(symbol, date):
+    """Get data across multiple timeframes for comprehensive analysis"""
+    
+    # 1-minute data for entry/exit precision
+    minute_data = client.get_historical_ohlcv(
+        instruments=[symbol],
+        start_date=f"{date} 09:15:00",
+        end_date=f"{date} 15:30:00",
+        ohlcv=["open", "high", "low", "close", "volume"],
+        interval=client.INTERVAL_1_MINUTE
+    )
+    
+    # 5-minute data for short-term trends
+    five_min_data = client.get_historical_ohlcv(
+        instruments=[symbol],
+        start_date=f"{date} 09:15:00",
+        end_date=f"{date} 15:30:00",
+        ohlcv=["open", "high", "low", "close", "volume"],
+        interval=client.INTERVAL_5_MINUTES
+    )
+    
+    # 15-minute data for medium-term trends
+    fifteen_min_data = client.get_historical_ohlcv(
+        instruments=[symbol],
+        start_date=f"{date} 09:15:00",
+        end_date=f"{date} 15:30:00",
+        ohlcv=["open", "high", "low", "close", "volume"],
+        interval=client.INTERVAL_15_MINUTES
+    )
+    
+    # Hourly data for major trend
+    hourly_data = client.get_historical_ohlcv(
+        instruments=[symbol],
+        start_date=f"{date} 09:15:00",
+        end_date=f"{date} 15:30:00",
+        ohlcv=["open", "high", "low", "close", "volume"],
+        interval=client.INTERVAL_1_HOUR
+    )
+    
+    return {
+        "1m": minute_data,
+        "5m": five_min_data,
+        "15m": fifteen_min_data,
+        "1h": hourly_data
+    }
+
+# Usage
+multi_data = get_multi_timeframe_data("NSE:SBIN:3045", "2024-01-15")
+```
+
+### Building OHLC Candlestick Data
+
+```python
+import pandas as pd
+import matplotlib.pyplot as plt
+from mplfinance import plot as mpf
+
+def plot_candlestick_chart(symbol, start_date, end_date, interval):
+    """Create a candlestick chart from historical data"""
+    
+    # Get historical data
+    data = client.get_historical_ohlcv(
+        instruments=[symbol],
+        start_date=start_date,
+        end_date=end_date,
+        ohlcv=["open", "high", "low", "close", "volume"],
+        interval=interval
+    )
+    
+    if not data or not data[0].get('data'):
+        print("No data available")
+        return
+    
+    # Convert to DataFrame
+    df = pd.DataFrame(data[0]['data'])
+    df['date'] = pd.to_datetime(df['date'])
+    df.set_index('date', inplace=True)
+    
+    # Rename columns for mplfinance
+    df.columns = ['Open', 'High', 'Low', 'Close', 'Volume']
+    
+    # Create candlestick chart
+    mpf.plot(df, type='candle', volume=True, 
+             title=f'{symbol} - {interval} Chart',
+             style='charles')
+
+# Plot 5-minute chart
+plot_candlestick_chart(
+    "NSE:SBIN:3045", 
+    "2024-01-15 09:15:00", 
+    "2024-01-15 15:30:00",
+    client.INTERVAL_5_MINUTES
+)
+```
+
+### Backtesting with Different Intervals
+
+```python
+def backtest_strategy_multiple_intervals(symbol, start_date, end_date):
+    """Backtest a strategy across different intervals"""
+    
+    intervals = [
+        (client.INTERVAL_5_MINUTES, "5m"),
+        (client.INTERVAL_15_MINUTES, "15m"),
+        (client.INTERVAL_30_MINUTES, "30m"),
+        (client.INTERVAL_1_HOUR, "1h")
+    ]
+    
+    results = {}
+    
+    for interval_code, interval_name in intervals:
+        # For intraday intervals, use datetime format
+        data = client.get_historical_ohlcv(
+            instruments=[symbol],
+            start_date=f"{start_date} 09:15:00",
+            end_date=f"{end_date} 15:30:00",
+            ohlcv=["open", "high", "low", "close", "volume"],
+            interval=interval_code
+        )
+        
+        if data and data[0].get('data'):
+            df = pd.DataFrame(data[0]['data'])
+            df['date'] = pd.to_datetime(df['date'])
+            
+            # Simple moving average crossover strategy
+            df['sma_10'] = df['close'].rolling(10).mean()
+            df['sma_20'] = df['close'].rolling(20).mean()
+            
+            # Generate signals
+            df['signal'] = 0
+            df.loc[df['sma_10'] > df['sma_20'], 'signal'] = 1
+            df.loc[df['sma_10'] < df['sma_20'], 'signal'] = -1
+            
+            # Calculate returns
+            df['returns'] = df['close'].pct_change()
+            df['strategy_returns'] = df['signal'].shift(1) * df['returns']
+            
+            # Calculate total return
+            total_return = (1 + df['strategy_returns']).prod() - 1
+            
+            results[interval_name] = {
+                'total_return': total_return,
+                'num_trades': df['signal'].diff().abs().sum() / 2,
+                'num_candles': len(df)
+            }
+    
+    return results
+
+# Compare strategy performance across intervals
+performance = backtest_strategy_multiple_intervals(
+    "NSE:SBIN:3045",
+    "2024-01-01",
+    "2024-01-31"
 )
+
+for interval, metrics in performance.items():
+    print(f"{interval}: Return={metrics['total_return']:.2%}, "
+          f"Trades={metrics['num_trades']:.0f}, "
+          f"Candles={metrics['num_candles']}")
+```
+
+## Error Handling
+
+```python
+try:
+    data = client.get_historical_ohlcv(
+        instruments=["NSE:SBIN:3045"],
+        start_date="2024-01-15 09:15:00",
+        end_date="2024-01-15 15:30:00",
+        ohlcv=["open", "high", "low", "close", "volume"],
+        interval=client.INTERVAL_5_MINUTES
+    )
+except ValueError as e:
+    print(f"Date format error: {e}")
+except Exception as e:
+    print(f"API error: {e}")
 ```
 
+## Best Practices
+
+1. **Use appropriate intervals for your strategy**:
+   - Scalping: 1m, 2m, 3m
+   - Day trading: 5m, 15m, 30m
+   - Swing trading: 1h, 1d
+   - Position trading: 1d, 1M
+
+2. **Be mindful of data volume**:
+   - 1-minute data generates a lot of candles
+   - Use shorter date ranges for minute-level data
+
+3. **Validate date formats**:
+   - The client will validate formats automatically
+   - Use datetime strings consistently
+
+4. **Consider market hours**:
+   - For intraday data, use market hours: 09:15:00 to 15:30:00
+   - Weekend dates won't have intraday data
+
+5. **Cache data when possible**:
+   - Historical data doesn't change
+   - Store frequently used datasets locally
+
 ### Order Management
 
 #### Place Regular Order
@@ -643,13 +1002,13 @@ Fetch detailed information and metrics for specific instruments:
 
 ```python
 # Get metrics for a single equity instrument
-equity_info = client.get_instrument_metrics(instrument_identifiers=["NSE:SBIN:3045"])
+equity_info = client.get_instrument_metrics(identifiers=["NSE:SBIN:3045"])
 print(f"SBIN Last Price: {equity_info[0]['ltp']}")
 print(f"SBIN 52-week High: {equity_info[0]['week52High']}")
 
 # Get metrics for multiple instruments of different types
 instruments_info = client.get_instrument_metrics(
-    instrument_identifiers=[
+    identifiers=[
         "NSE:AARTIIND:7",              # Equity
         "NSE:NIFTY26DEC11000CE:61009", # Option
         "NSE:SBIN25MAYFUT:57515"       # Future
@@ -831,12 +1190,150 @@ Note that certain fields may have zero or empty values if the data is not availa
 
 ### Options Chain
 
+#### Get Option Expiry List
+
+Fetch available expiry dates for an instrument's options:
+
+```python
+# For a stock
+expiry_list = client.get_option_expiry_list("NSE:SBIN:3045")
+
+# For an index
+nifty_expiry = client.get_option_expiry_list("NSE:NIFTY 50:26000")
+
+# Print all available expiry dates
+for expiry in expiry_list.get('expiryList', []):
+    print(f"{expiry['date']} - {expiry['contract']} " +
+          f"(Futures: {'Yes' if expiry['isFuturesExpiry'] else 'No'}, " +
+          f"Options: {'Yes' if expiry['isOptionsExpiry'] else 'No'})")
+```
+
+#### Response Structure
+
+The response is a JSON object with the following structure:
+
+```json
+{
+  "exchange": "NSE",                // Exchange of the instrument
+  "tradingSymbol": "SBIN",          // Trading symbol
+  "exchangeToken": 3045,            // Exchange token
+  "identifier": "NSE:SBIN:3045",    // Full identifier
+  "expiryList": [                   // Array of expiry objects
+    {
+      "date": "2025-05-29",         // Expiry date in YYYY-MM-DD format
+      "contract": "near_month",     // Contract type (see below)
+      "isFuturesExpiry": true,      // Whether futures expire on this date
+      "isOptionsExpiry": true       // Whether options expire on this date
+    },
+    // More expiry objects...
+  ]
+}
+```
+
+For index options like NIFTY, the response will typically include more expiry dates, including weekly options and longer-dated quarterly options.
+
+The `expiryList` array contains objects with the following fields:
+- `date`: The expiry date in YYYY-MM-DD format
+- `contract`: The type of contract (e.g., "near_month", "current_weekly")
+- `isFuturesExpiry`: Boolean indicating if futures expire on this date
+- `isOptionsExpiry`: Boolean indicating if options expire on this date
+
+#### Contract Types
+
+Each expiry date is categorized with a `contract` field that indicates the type of expiry. The possible contract types are:
+
+1. **Weekly Expiries (Thursdays/Wednesdays)**
+   - `current_weekly`: The first non-expiry Thursday of the current week
+
+2. **Monthly Expiries (last Wed/Thu of month)**
+   - `near_month`: Last Wed/Thu of this month (current month)
+   - `mid_month`: Last Wed/Thu of next month
+   - `far_month`: Last Wed/Thu of month after next
+
+3. **Weekly Ordinals Within Current Month**
+   - `first_weekly`: 1st non-expiry Thursday of current month
+   - `second_weekly`: 2nd non-expiry Thursday
+   - `third_weekly`: 3rd non-expiry Thursday
+   - `fourth_weekly`: 4th non-expiry Thursday
+   - `fifth_weekly`: 5th non-expiry Thursday (rare)
+
+4. **Weekly Ordinals in Mid-Month Slot (next month's week-trade dates)**
+   - `first_weekly_mid_month`: 1st Thursday of next month
+   - `second_weekly_mid_month`: 2nd Thursday of next month
+   - `third_weekly_mid_month`: 3rd Thursday of next month
+   - `fourth_weekly_mid_month`: 4th Thursday of next month
+   - `fifth_weekly_mid_month`: 5th Thursday of next month (rare)
+
+5. **Weekly Ordinals in Far-Month Slot (month-after-next)**
+   - `first_weekly_far_month`: 1st Thursday of month after next
+   - `second_weekly_far_month`: 2nd Thursday of month after next
+   - `third_weekly_far_month`: 3rd Thursday of month after next
+   - `fourth_weekly_far_month`: 4th Thursday of month after next
+   - `fifth_weekly_far_month`: 5th Thursday of month after next (rare)
+
+6. **Quarterly Expiries (last-Thu of Mar/Jun/Sep/Dec)**
+   - `first_quarter`: Last Thu of March (Q1)
+   - `second_quarter`: Last Thu of June (Q2)
+   - `third_quarter`: Last Thu of September (Q3)
+   - `fourth_quarter`: Last Thu of December (Q4)
+
+7. **Half-Yearly Expiries**
+   - `first_half_yearly`: Last Thu of June (H1)
+   - `second_half_yearly`: Last Thu of December (H2)
+
+8. **Year-Plus-N Quarterly/Half-Yearly (N = years ahead)**
+   - For quarterly options in future years:
+     - `first_quarter_1`: Q1 (March) of next year
+     - `second_quarter_1`: Q2 (June) of next year
+     - `third_quarter_1`: Q3 (September) of next year
+     - `fourth_quarter_1`: Q4 (December) of next year
+   - For half-yearly options in future years:
+     - `first_half_yearly_1`: H1 (June) of next year
+     - `second_half_yearly_1`: H2 (December) of next year
+   - This pattern continues with `_2`, `_3`, and `_4` suffixes for up to 4 years ahead
+
+9. **Special Case**
+   - `none`: No matching expiry category
+
+### Get Options Chain
+
+The Options Chain API provides detailed information about available option contracts for a specified instrument, including strike prices, premiums, and option Greeks.
+
+#### Constants
+
+The SDK provides constants for option types, moneyness, and expiry preferences to make your code more readable and type-safe:
+
+**Option Types:**
+```python
+client.OPTION_TYPE_CE  # Call option
+client.OPTION_TYPE_PE  # Put option
+```
+
+**Moneyness Types:**
+```python
+client.MONEYNESS_ATM  # At-the-money
+client.MONEYNESS_ITM  # In-the-money
+client.MONEYNESS_OTM  # Out-of-the-money
+```
+
+**Expiry Preferences:**
+```python
+# Common expiry preferences
+client.EXPIRY_CURRENT_WEEKLY  # Current week's expiry
+client.EXPIRY_NEAR_MONTH      # Current month's expiry
+client.EXPIRY_MID_MONTH       # Next month's expiry
+client.EXPIRY_FAR_MONTH       # Month after next expiry
+
+# Many more constants available for weekly, monthly, 
+# quarterly, and yearly expiries
+```
+
 #### Get Option Chain
 
-Fetch the option chain for a specific instrument and expiry date:
+Fetch the option chain for a specific instrument using either an exact expiry date or a expiry preference:
 
 ```python
-# Get ATM call options for SBIN
+# Get ATM call options for SBIN with specific expiry date
 options = client.get_option_chain(
     identifier="NSE:SBIN:3045",
     expiry_date="2025-05-30",
@@ -846,10 +1343,10 @@ options = client.get_option_chain(
 print(f"Found {len(options['strikes'])} strikes")
 print(f"Current underlying price: {options['underlyingPrice']}")
 
-# Get both call and put options, with various moneyness
+# Get both call and put options with expiry preference
 all_options = client.get_option_chain(
-    identifier="NSE:SBIN:3045",
-    expiry_date="2025-05-30",
+    identifier="NSE:NIFTY 50:26000",
+    expiry_preference=client.EXPIRY_CURRENT_WEEKLY,  # Current week's expiry
     option_type=[client.OPTION_TYPE_CE, client.OPTION_TYPE_PE],  # Both calls and puts
     moneyness=[client.MONEYNESS_ATM, client.MONEYNESS_ITM, client.MONEYNESS_OTM]  # All moneyness types
 )
@@ -864,7 +1361,7 @@ for strike in all_options['strikes']:
     print(f"{strike['tradingSymbol']} ({strike['moneyness']}): {strike['ltp']}")
 ```
 
-#### Response Structure for Option Chain
+#### Response Structure
 
 The `get_option_chain` method returns a dictionary with the following structure:
 
@@ -938,133 +1435,143 @@ The `get_option_chain` method returns a dictionary with the following structure:
 }
 ```
 
-Note that some fields like metrics may have zero values if the data is not available from the exchange or if there's no recent trading activity in those contracts.
+#### Advanced Examples
 
-#### Advanced Option Chain Analysis Example
-
-Here's an example of how to use the option chain API for more advanced analysis:
+##### Finding a Straddle/Strangle
 
 ```python
-def analyze_option_chain(underlying, expiry_date):
-    """
-    Analyze an option chain to find interesting trading opportunities.
+def find_straddle_strangle(identifier, expiry):
+    """Find and analyze straddle/strangle opportunities."""
+    # Get the option chain
+    option_chain = client.get_option_chain(
+        identifier=identifier,
+        expiry_date=expiry,
+        option_type=[client.OPTION_TYPE_CE, client.OPTION_TYPE_PE],
+        moneyness=[client.MONEYNESS_ATM]
+    )
+    
+    # Find ATM call and put
+    calls = [s for s in option_chain["strikes"] if s["optionType"] == "CE"]
+    puts = [s for s in option_chain["strikes"] if s["optionType"] == "PE"]
+    
+    if not calls or not puts:
+        print("Couldn't find both call and put options")
+        return
+    
+    # For a straddle, we want the same strike price
+    atm_strike = calls[0]["strikePrice"]
+    atm_call = calls[0]
+    atm_put = next((p for p in puts if p["strikePrice"] == atm_strike), None)
     
-    Args:
-        underlying (str): Instrument identifier (e.g., "NSE:SBIN:3045")
-        expiry_date (str): Expiry date in YYYY-MM-DD format
-    """
-    client = WizzerClient(base_url="https://api-url.in", token="your-jwt-token")
+    if atm_call and atm_put:
+        call_premium = atm_call["ltp"]
+        put_premium = atm_put["ltp"]
+        total_premium = call_premium + put_premium
+        
+        print(f"ATM Straddle Analysis for {identifier} (Expiry: {expiry})")
+        print(f"Underlying Price: {option_chain['underlyingPrice']}")
+        print(f"ATM Strike: {atm_strike}")
+        print(f"Call Premium: {call_premium}")
+        print(f"Put Premium: {put_premium}")
+        print(f"Total Premium: {total_premium}")
+        print(f"Breakeven Upper: {atm_strike + total_premium}")
+        print(f"Breakeven Lower: {atm_strike - total_premium}")
+        
+        # Calculate the percentage move needed for breakeven
+        pct_move = (total_premium / option_chain['underlyingPrice']) * 100
+        print(f"Required % Move for Breakeven: {pct_move:.2f}%")
     
-    # Get the full option chain
+    # For a strangle, we want OTM call and put
+    otm_options = client.get_option_chain(
+        identifier=identifier,
+        expiry_date=expiry,
+        option_type=[client.OPTION_TYPE_CE, client.OPTION_TYPE_PE],
+        moneyness=[client.MONEYNESS_OTM]
+    )
+    
+    otm_calls = sorted([s for s in otm_options["strikes"] if s["optionType"] == "CE"], 
+                       key=lambda x: x["strikePrice"])
+    otm_puts = sorted([s for s in otm_options["strikes"] if s["optionType"] == "PE"], 
+                      key=lambda x: x["strikePrice"], reverse=True)
+    
+    if otm_calls and otm_puts:
+        otm_call = otm_calls[0]  # First OTM call
+        otm_put = otm_puts[0]    # First OTM put
+        
+        call_premium = otm_call["ltp"]
+        put_premium = otm_put["ltp"]
+        total_premium = call_premium + put_premium
+        
+        print(f"\nOTM Strangle Analysis for {identifier} (Expiry: {expiry})")
+        print(f"Call Strike: {otm_call['strikePrice']} (Premium: {call_premium})")
+        print(f"Put Strike: {otm_put['strikePrice']} (Premium: {put_premium})")
+        print(f"Total Premium: {total_premium}")
+        print(f"Breakeven Upper: {otm_call['strikePrice'] + total_premium}")
+        print(f"Breakeven Lower: {otm_put['strikePrice'] - total_premium}")
+    
+    return option_chain
+
+# Example usage
+find_straddle_strangle("NSE:SBIN:3045", "2025-05-30")
+```
+
+##### Option Chain Visualization
+
+```python
+def visualize_option_chain(identifier, expiry):
+    """Create a visualization of the option chain."""
+    import matplotlib.pyplot as plt
+    import numpy as np
+    
+    # Get the option chain
     option_chain = client.get_option_chain(
-        identifier=underlying,
-        expiry_date=expiry_date,
+        identifier=identifier,
+        expiry_date=expiry,
         option_type=[client.OPTION_TYPE_CE, client.OPTION_TYPE_PE],
         moneyness=[client.MONEYNESS_ATM, client.MONEYNESS_ITM, client.MONEYNESS_OTM]
     )
     
-    # Extract key data
+    # Extract data
     underlying_price = option_chain["underlyingPrice"]
-    future_price = option_chain["futurePrice"]
-    resolved_expiry = option_chain["resolvedExpiry"]
     
     # Separate calls and puts
-    calls = [s for s in option_chain["strikes"] if s["optionType"] == "CE"]
-    puts = [s for s in option_chain["strikes"] if s["optionType"] == "PE"]
+    calls = sorted([s for s in option_chain["strikes"] if s["optionType"] == "CE"], 
+                  key=lambda x: x["strikePrice"])
+    puts = sorted([s for s in option_chain["strikes"] if s["optionType"] == "PE"], 
+                 key=lambda x: x["strikePrice"])
+    
+    # Extract strike prices and premiums
+    call_strikes = [c["strikePrice"] for c in calls]
+    call_premiums = [c["ltp"] for c in calls]
+    
+    put_strikes = [p["strikePrice"] for p in puts]
+    put_premiums = [p["ltp"] for p in puts]
+    
+    # Create figure and axis
+    fig, ax = plt.subplots(figsize=(12, 8))
+    
+    # Plot calls and puts
+    ax.plot(call_strikes, call_premiums, 'b-', marker='o', label='Calls')
+    ax.plot(put_strikes, put_premiums, 'r-', marker='o', label='Puts')
+    
+    # Add vertical line for current price
+    ax.axvline(x=underlying_price, color='g', linestyle='--', 
+               label=f'Current Price ({underlying_price})')
+    
+    # Add labels and title
+    ax.set_xlabel('Strike Price')
+    ax.set_ylabel('Premium')
+    ax.set_title(f'Option Chain for {identifier} (Expiry: {expiry})')
+    ax.legend()
+    ax.grid(True)
+    
+    plt.tight_layout()
+    plt.show()
     
-    # Sort by strike price
-    calls.sort(key=lambda x: x["strikePrice"])
-    puts.sort(key=lambda x: x["strikePrice"])
-    
-    # Find ATM options
-    atm_call = next((s for s in calls if s["moneyness"] == "ATM"), None)
-    atm_put = next((s for s in puts if s["moneyness"] == "ATM"), None)
-    atm_strike = atm_call["strikePrice"] if atm_call else None
-    
-    print(f"Analysis for Option Chain (Expiry: {resolved_expiry})")
-    print(f"Underlying Price: {underlying_price}")
-    print(f"Future Price: {future_price}")
-    print(f"ATM Strike: {atm_strike}")
-    print(f"Days to Expiry: {(datetime.strptime(resolved_expiry, '%Y-%m-%d') - datetime.now()).days}")
-    print("=" * 60)
-    
-    # Find interesting spreads
-    if len(calls) >= 2 and len(puts) >= 2:
-        # Vertical spreads
-        bull_call_spread = {
-            'long': atm_call,
-            'short': next((c for c in calls if c["strikePrice"] > atm_strike), None)
-        }
-        
-        bear_put_spread = {
-            'long': atm_put,
-            'short': next((p for p in puts if p["strikePrice"] < atm_strike), None)
-        }
-        
-        # Iron condor
-        iron_condor = {
-            'long_put': next((p for p in puts if p["strikePrice"] < atm_strike and p["moneyness"] == "OTM"), None),
-            'short_put': atm_put,
-            'short_call': atm_call,
-            'long_call': next((c for c in calls if c["strikePrice"] > atm_strike and c["moneyness"] == "OTM"), None)
-        }
-        
-        # Print potential strategies
-        print("Potential Strategies:")
-        
-        # Bull Call Spread
-        if bull_call_spread['long'] and bull_call_spread['short']:
-            long_premium = bull_call_spread['long']['ltp']
-            short_premium = bull_call_spread['short']['ltp']
-            net_premium = long_premium - short_premium
-            max_profit = bull_call_spread['short']['strikePrice'] - bull_call_spread['long']['strikePrice'] - net_premium
-            
-            print(f"Bull Call Spread: Buy {bull_call_spread['long']['tradingSymbol']} @ {long_premium}, "
-                  f"Sell {bull_call_spread['short']['tradingSymbol']} @ {short_premium}")
-            print(f"  Net Premium: {net_premium}")
-            print(f"  Max Profit: {max_profit}")
-            print(f"  Break-even: {bull_call_spread['long']['strikePrice'] + net_premium}")
-        
-        # Bear Put Spread
-        if bear_put_spread['long'] and bear_put_spread['short']:
-            long_premium = bear_put_spread['long']['ltp']
-            short_premium = bear_put_spread['short']['ltp']
-            net_premium = long_premium - short_premium
-            max_profit = bear_put_spread['long']['strikePrice'] - bear_put_spread['short']['strikePrice'] - net_premium
-            
-            print(f"Bear Put Spread: Buy {bear_put_spread['long']['tradingSymbol']} @ {long_premium}, "
-                  f"Sell {bear_put_spread['short']['tradingSymbol']} @ {short_premium}")
-            print(f"  Net Premium: {net_premium}")
-            print(f"  Max Profit: {max_profit}")
-            print(f"  Break-even: {bear_put_spread['long']['strikePrice'] - net_premium}")
-        
-        # Iron Condor
-        if all(iron_condor.values()):
-            long_put_premium = iron_condor['long_put']['ltp']
-            short_put_premium = iron_condor['short_put']['ltp']
-            short_call_premium = iron_condor['short_call']['ltp']
-            long_call_premium = iron_condor['long_call']['ltp']
-            
-            net_premium = (short_put_premium + short_call_premium) - (long_put_premium + long_call_premium)
-            put_wing_width = iron_condor['short_put']['strikePrice'] - iron_condor['long_put']['strikePrice']
-            call_wing_width = iron_condor['long_call']['strikePrice'] - iron_condor['short_call']['strikePrice']
-            
-            max_risk = max(put_wing_width, call_wing_width) - net_premium
-            
-            print(f"Iron Condor Strategy:")
-            print(f"  Long Put: {iron_condor['long_put']['tradingSymbol']} @ {long_put_premium}")
-            print(f"  Short Put: {iron_condor['short_put']['tradingSymbol']} @ {short_put_premium}")
-            print(f"  Short Call: {iron_condor['short_call']['tradingSymbol']} @ {short_call_premium}")
-            print(f"  Long Call: {iron_condor['long_call']['tradingSymbol']} @ {long_call_premium}")
-            print(f"  Net Premium Received: {net_premium}")
-            print(f"  Max Risk: {max_risk}")
-            print(f"  Max Profit: {net_premium}")
-    
-    # Return the option chain for further analysis
     return option_chain
 
-# Example usage:
-analyze_option_chain("NSE:SBIN:3045", "2025-05-30")
+# Example usage
+visualize_option_chain("NSE:NIFTY 50:26000", "2025-05-30")
 ```
 
 ### Wizzer Client Examples