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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wiz_trader
-Version: 0.17.0
+Version: 0.18.0
 Summary: A Python SDK for connecting to the Wizzer.
 Home-page: https://bitbucket.org/wizzer-tech/quotes_sdk.git
 Author: Pawan Wagh
@@ -643,13 +643,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 +831,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 +984,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 +1002,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 +1076,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 Option Chain Analysis Example
+#### Advanced Examples
 
-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)
+    
+    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}%")
+    
+    # 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)
     
-    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 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}")
     
-    # Get the full option chain
+    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