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

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

[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

[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
[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`).
#
# 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

[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
# 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

# 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"],
]