thetagang.toml

# NOTE: It is STRONGLY recommended you read through all notes, config options,
# and documentation before proceeding. Be sure to update the configuration
# values according to your preferences. Additionally, any default values in
# this config do not constitute a recommendation or endorsement, or any provide
# claims abount returns or performance.
#
# Should you decide to use ThetaGang, please experiment with a paper trading
# account before trying on a live account.
[account]
# The account number to operate on
number = "DU1234567"

# Cancel any existing orders for the symbols configured at startup
cancel_orders = true

# Maximum amount of margin to use, as a ratio of net liquidation. IB lets
# you use varying amounts of margin, depending on the assets. To use up to 4x
# margin, set this to 4. It's recommended you always leave some additional
# cushion. IB will start to close positions if you go below certain thresholds
# of available margin in your account.
#
# For details on margin usage, see:
#   https://www.interactivebrokers.com/en/index.php?f=24176
#
# The default value uses 50% of your available net liquidation value
# (i.e., half of your funds). Set this to 1.0 to use all your funds,
# or 1.5 to use 150% (which may incur margin interest charges).
#
# In other words, ThetaGang's buying power is calculated by taking your NLV and
# multiplying it by margin_usage.
margin_usage = 0.5

# Market data type (see
# https://interactivebrokers.github.io/tws-api/market_data_type.html)
market_data_type = 1

[constants]
# Refer to `durationString` at
# https://interactivebrokers.github.io/tws-api/historical_bars.html for details.
# Valid values include "30 D", "60 D", "6 M", "1 Y", etc.
daily_stddev_window = "30 D"

# Optionally, specify a write threshold either as percent, or sigma, either for
# all contracts, or separately for puts/calls. Refer to the comments for
# `write_threshold` and `write_threshold_sigma` under `symbols` for details.
#
# # Applies to both puts and calls
# write_threshold = 0.01 # 1%
# write_threshold_sigma = 1.0 # 1𝜎
# [puts] # Applies only to puts
# write_threshold = 0.01 # 1%
# write_threshold_sigma = 1.0 # 1𝜎
# [calls] # Applies only to calls
# write_threshold = 0.01 # 1%
# write_threshold_sigma = 1.0 # 1𝜎

[orders]
# The exchange to route orders to. Can be overridden if desired. This is also
# used for fetching tickers/prices.
exchange = "SMART"

# Range of time to delay, in seconds, before resubmitting an order with updated
# midpoint price if `symbol.<symbol>.adjust_midpoint_after_delay = true`.
price_update_delay = [30, 60]

[orders.algo]
# By default we use adaptive orders with patient priority which gives reasonable
# results. You can also experiment with TWAP or other options, however the
# available order algos vary depending on what you trade.
#
# Note that the algo orders don't seem to work with combo orders, which are used
# when rolling positions, so AFAIK this has no effect for those orders. It only
# seems to take effect with regular open/close orders.
# Optional IBKR algo strategy. See
# https://interactivebrokers.github.io/tws-api/ibalgos.html for option details.
strategy = "Adaptive"

# For `algoParams`, the TagValue parameter has 2 values, so any values with
# anything other than 2 parameters are invalid. Pass an empty list to use the
# defaults (i.e., params = []).
params = [["adaptivePriority", "Patient"]]

[option_chains]
# The option chains are lazy loaded, and before you can determine the greeks
# (delta) or prices, you need to scan the chains. The settings here tell
# thetagang how many contracts to load. Don't make these values too high, as
# they will cause the chain scanning process to take too long, and it may fail.
#
# If you have issues where thetagang can't find suitable contracts, try
# increasing these values slightly.
#
# Number of expirations to load from option chains
expirations = 4

# Number of strikes to load from option chains
strikes = 15

[roll_when]
# Roll when P&L reaches 90%
pnl = 0.9
# Or, roll options when there are <= 15 days to expiry and P&L is at least
# min_pnl (min_pnl defaults to 0)
#
# NOTE: For cases where an option ends up deep ITM, notably when selling
# covered calls, it's possible that the P&L would be significantly negative,
# i.e., -100%. If you want to roll anyway in these situations, set min_pnl to a
# negative value such as -1 (for -100%).
dte = 15
min_pnl = 0.0

# Optional: Don't roll contracts when the current DTE is greater than this
# number of days. This helps avoid cases where you end up rolling out to LEAPs.
# max_dte = 180
# Optional: Create a closing order when the P&L reaches this threshold. This
# overrides the other parameters, i.e., it ignores DTE and everything else.
# If not specified, it has no effect. This can handle the case where you have
# long-dated options that have slowly become worthless and you just want to get
# them out of your portfolio.
# close_at_pnl = 0.99
[roll_when.calls]
# Roll calls to the next expiration even if they're in the money. Defaults to
# true if not specified.
itm = true

# Only roll when there's a suitable contract available that will result in a
# credit. Enabling this may result in the target delta value being ignored in
# circumstances where we can't find a contract that will result in both a
# credit _and_ satisfying the target delta (i.e., having a credit takes
# precedence).
credit_only = false

# If set to false, calls will not be rolled if there are any number of calls in
# excess of the target call quantity. A truthy value means thetagang will keep
# rolling calls regardless of the total quantity.
has_excess = true

[roll_when.puts]
# Roll puts if they're in the money. Defaults to false if not specified.
itm = false

# Only roll when there's a suitable contract available that will result in a
# credit. Enabling this may result in the target delta value being ignored in
# circumstances where we can't find a contract that will result in both a
# credit _and_ satisfying the target delta (i.e., having a credit takes
# precedence).
credit_only = false

# If set to false, puts will not be rolled if there are any number of puts in
# excess of the target put quantity. A truthy value means thetagang will keep
# rolling puts regardless of the total quantity.
has_excess = true

[write_when.calls]
# Optionally, only write calls when the underlying is green
green = true

# With covered calls, we can cap the number of calls to write by this factor. At
# 1.0, we write covered calls on 100% of our positions. At 0.5, we'd only write
# on 50% of our positions. This value must be between 1 and 0 inclusive.
cap_factor = 1.0

# We may want to leave some percentage of our underlying stock perpetually
# uncovered so we don't miss out on big upside movements. For example, if our
# target number of shares for a given symbol is 1,000, we may want to ensure
# 500 shares are _always_ uncovered. This is a bit different from `cap_factor`,
# as it applies to the _target_ number of shares, as opposed to the current
# positions. A value of 0.5 (50%) means that we always leave 50% (half) of the
# target shares uncovered. A bigger number (up to 1.0, 100%) is more bullish,
# and a smaller number (down to 0.0, 0%) is more bearish (i.e., cover all
# positions with calls). This essentially sets a floor on the number of shares
# we try to hold on to in order to avoid missing out on potential upside.
cap_target_floor = 0.0

[write_when.puts]
# Optionally, only write puts when the underlying is red
red = true

[target]
# Target 45 or more days to expiry
dte = 45
# Target delta of 0.3 or less. Defaults to 0.3 if not specified.
delta = 0.3
# When writing new contracts (either covered calls or naked puts), or rolling
# before `roll_when.dte` is reached, never write more than this amount of
# contracts at once. This can be useful to avoid bunching by spreading contract
# placement out over time (and possibly expirations) in order to protect
# yourself from large swings. This value does not affect rolling existing
# contracts to the next expiration. This value is expressed as a percentage of
# buying power based on the market price of the underlying ticker, as a range
# from [0.0-1.0].
#
# Once the `roll_when.dte` date is reached, all the remaining positions are
# rolled regardless of the current position quantity.
#
# Defaults to 5% of buying power. Set this to 1.0 to effectively disable the
# limit.
maximum_new_contracts_percent = 0.05
# Minimum amount of open interest for a contract to qualify
minimum_open_interest = 10

# Optional: specify delta separately for puts/calls. Takes precedent over
# target.delta.
#
#  [target.puts]
#  delta = 0.5
#  [target.calls]
#  delta = 0.3
[symbols]
# NOTE: Please change these symbols and weights according to your preferences.
# These are provided only as an example for the purpose of configuration. These
# values were chosen as sane values should someone decide to run this code
# without changes, however it is in no way a recommendation or endorsement.
#
# You can specify the weight either as a percentage of your buying power (which
# is calculated as your NLV * account.margin_usage), or in terms of parts. Parts
# are summed from all symbols, then the weight is calculated by dividing the
# parts by the total parts.
#
# You should try to choose ETFs or stocks that:
#
#  1) Have sufficient trading volume for the underlying
#  2) Have standard options contracts (100 shares per contract)
#  3) Have options with sufficient open interest and trading volume
#
# The target delta may also be specified per-symbol, and takes precedence over
# `target.delta` or `target.puts/calls.delta`. You can specify a value for the
# symbol, or override individually for puts/calls.
[symbols.SPY]
weight = 0.4

# OR: specify in terms of parts. Must use either weight or parts, but cannot mix
# both.
# parts = 40

# Sometimes, particularly for stocks/ETFs with limited liquidity, the spreads
# are too wide to get an order filled at the midpoint on the first attempt. For
# those, you can try setting this to `true`, and thetagang will wait a random
# amount of time, then resubmit orders that haven't filled (but only for the
# symbols with this set to true). The amount of time we'll wait is chosen
# randomly from the range defined by `orders.price_update_delay`.
adjust_price_after_delay = false

[symbols.QQQ]
weight = 0.3

# parts = 30
[symbols.QQQ.puts]
# Override delta just for QQQ puts
delta = 0.5
# Also, optionally specify a strike limit, for either puts or calls.
# Interpreted as an upper bound for puts, and a lower bound for calls.
strike_limit = 1000.0 # never write a put with a strike above $1000

# Optionally, if we only write new contracts when the underlying is green or
# red (`write_when.calls.green=true` or `write_when.puts.red=true`), specify a
# minimum threshold as an absolute value daily percentage change (in this
# example, use 1% for puts only, but could also be specified as
# `symbols.QQQ.write_threshold`). This can also be specified under
# `constants.write_threshold` and `constants.puts/calls.write_threshold` to
# apply to all symbols, either for both puts or calls, or individually.
#
# In this example, we'd only write puts on QQQ when the daily change is -1% or
# greater (provided that we also set `write_when.puts.red=true`).
write_threshold = 0.01 # 1%, absolute value

# Alternatively, you can express write threshold value in terms of sigma with
# `write_threshold_sigma`. A value of 2.0 means that we'll write new contracts
# when the daily change is twice the standard deviation of the log returns.
#
# If write_threshold_sigma is specified, it supersedes (overrides) the value of
# write_threshold.
#
# The daily standard deviation of log returns is calculated based on the past
# 30 days of data by default, but you can adjust this by altering the value of
# `constants.daily_stddev_window`.
#
# Note that we'll need to retrieve this historical data for every execution to
# calculate this value, so you should be sure there's 1) sufficient history
# available and 2) the data can be retrieved sufficiently fast.
#
# write_threshold_sigma = 1.0 # 1x the standard devation of log returns for the daily stddev window

[symbols.QQQ.calls]
strike_limit = 100.0 # never write a call with a strike below $100

[symbols.TLT]
weight = 0.2
# parts = 20
# Override delta for this particular symbol, for both puts and calls.
delta = 0.4

[symbols.ABNB]
# For symbols that require an exchange, which is typically any company stock,
# you must specify the primary exchange.
primary_exchange = "NASDAQ"
weight = 0.05

# parts = 5
# Sometimes you may need to wrap the symbol in quotes.
[symbols."BRK B"]
# For symbols that require an exchange, which is typically any company stock,
# you must specify the primary exchange.
primary_exchange = "NYSE"
weight = 0.05

# parts = 5
[ib_insync]
logfile = '/etc/thetagang/ib_insync.log'

# Typically the amount of time needed when waiting on data from the IBKR API.
# Sometimes it can take a while to retrieve data, and it's lazy-loaded by the
# API, so getting this number right is largely a matter of guesswork.
api_response_wait_time = 60

[ibc]
# IBC configuration parameters. See
# https://ib-insync.readthedocs.io/api.html#ibc for details.
gateway = true
ibcPath = '/opt/ibc'
tradingMode = 'paper'
# Set this to true if you want to raise an exception on request errors. Under
# normal operation this should be false because we often try to make "invalid"
# requests when scanning option chains for example.
RaiseRequestErrors = false
password = 'demo'
userid = 'demo'
# Change this to point to your config.ini for IBC
ibcIni = '/etc/thetagang/config.ini'
# Change or unset this to use something other than the Docker bundled OpenJDK.
javaPath = '/opt/java/openjdk/bin'

# twsPath         = ''
# twsSettingsPath = ''
# fixuserid       = ''
# fixpassword     = ''
[watchdog]
# Watchdog configuration params. See
# https://ib-insync.readthedocs.io/api.html#watchdog for details.
appStartupTime = 30
appTimeout = 20
clientId = 1
connectTimeout = 2
host = '127.0.0.1'
port = 7497
probeTimeout = 4
readonly = false
retryDelay = 2

[watchdog.probeContract]
currency = 'USD'
exchange = 'SMART'
secType = 'STK'
symbol = 'SPY'

# Optional VIX call hedging, based on the methodology described by the Cboe VIX
# Tail Hedge Index, described here:
# https://www.cboe.com/us/indices/dashboard/vxth/
[vix_call_hedge]
enabled = false
# Target delta for calls that are purchased
delta = 0.30
# Target DTE for new positions
target_dte = 30
# If the current spot VIX exceeds this value, long VIX call positions will be
# closed. Comment out to disable.
close_hedges_when_vix_exceeds = 50.0

# Don't count any VIX positions where the DTE is <= this value. Increase this
# value to create a call ladder. For example, if you set this to 5, thetagang
# will ignore current VIX positions starting 5 days before expiry, and
# potentially adding more. This allows you to create a simple call ladder.
ignore_dte = 0

# The allocations are specified as an ordered list of allocation weights
# according to an upper/lower bound on VIXMO (the 30 day VIX). Default values
# are the same as those described in the VXTH methodology. These are evaluated
# in order, and the weight from the first allocation that matches will be
# applied. The lower bound is inclusive, and the upper bound is exclusive
# (.i.e., the code checks that lower <= VIXMO < upper). The upper/lower bounds
# are only checked if they're present.
#
# The allocation weights are multiplied by the account's net liquidation value,
# and that amount is allocated to purchasing VIX calls.
[[vix_call_hedge.allocation]]
upper_bound = 15.0
weight = 0.00

[[vix_call_hedge.allocation]]
lower_bound = 15.0
upper_bound = 30.0
weight = 0.01

[[vix_call_hedge.allocation]]
lower_bound = 30.0
upper_bound = 50.0
weight = 0.005

[[vix_call_hedge.allocation]]
lower_bound = 50.0
weight = 0.00

[cash_management]
# Cash management gives us a way to earn a little extra yield from excess cash
# sitting in your account. When the cash balance exceeds a threshold, we buy
# the cash fund, and when the cash balance drops below the cash threshold we
# sell the cash fund to get back to the target cash balance.
#
# Enables cash management
enabled = false

# The fund to purchase with your cash. Example of cash funds are SGOV or SHV,
# which are short-term treasury ETFs with reasonable fees. Be sure to check the
# expense ratio before jumping in on ETFs that appear juicier.
cash_fund = "SGOV"

# You don't usually need to specify the primary exchange for ETFs, but if you
# do, you can do so with this:
# primary_exchange = "NYSE"

# The cash balance to target. This is used as a lower bound, so with a value of
# 0, we try not to let the cash balance go below zero. Simple enough.
target_cash_balance = 0

# We don't want to transact too frequently because of commissions, so the buy
# threshold is the amount above target_cash_balance we need to reach before
# placing a buy order.
buy_threshold = 10000

# The sell threshold is the amount below target_cash_balance where we'll place
# a sell order to shore up cash.
sell_threshold = 10000

[cash_management.orders]
# The exchange to route orders to. Can be overridden if desired. This is also
# used for fetching tickers/prices.
exchange = "SMART"

[cash_management.orders.algo]
# By default, use a VWAP order for cash trades. You can comment out the whole
# `cash_management.orders` section to use the same value as `orders` and
# `orders.algo`.
strategy = "Vwap"
params = [
    # Optionally, uncomment the following line to be opportunistic by avoiding
    # taking liquidity. This gives us somewhat better pricing and lower
    # commissions, at the expense of possibly not getting the order filled in
    # the day.
    # ["noTakeLiq", "1"],
]