Merge pull request #14 from options-testing-org/create-butterfly-position

Create butterfly position

Author: Bougiefever

src/options_framework/data/data_loader.py

@@ -26,7 +26,7 @@ def __init__(self, *, start: datetime.datetime | datetime.date, end: datetime.da
     def next_option_chain(self, quote_datetime: datetime.datetime | datetime.date):
         if self.last_loaded_date < quote_datetime:
             self.load_cache(quote_datetime)
-        self.get_next_option_chain(quote_datetime)
+        self.get_option_chain(quote_datetime)
 
     @abstractmethod
     def load_cache(self, quote_datetime: datetime.datetime):
@@ -37,7 +37,11 @@ def on_option_chain_loaded_loaded(self, quote_datetime: datetime.datetime | date
         self.emit('option_chain_loaded', quote_datetime=quote_datetime, option_chain=option_chain)
 
     @abstractmethod
-    def get_next_option_chain(self, quote_datetime: datetime.datetime):
+    def get_option_chain(self, quote_datetime: datetime.datetime):
+        pass
+
+    @abstractmethod
+    def get_expirations(self):
         pass
 
     @abstractmethod

src/options_framework/data/file_data_loader.py

@@ -7,7 +7,6 @@
 from options_framework.option import Option
 from options_framework.option_types import OptionType, SelectFilter
 
-
 def map_data_file_fields() -> dict:
     columns_idx = settings.COLUMN_ORDER
     column_field_mapping = settings.FIELD_MAPPING
@@ -32,7 +31,7 @@ def __init__(self, *, start: datetime.datetime, end: datetime.datetime, select_f
         self.data_root_folder = settings.DATA_IMPORT_FILE_PROPERTIES.data_files_folder
         self.last_loaded_date = start
 
-    def get_next_option_chain(self, quote_datetime: datetime.datetime):
+    def get_option_chain(self, quote_datetime: datetime.datetime):
         filename = settings.DATA_IMPORT_FILE_PROPERTIES.data_file_name_format.replace('{year}', str(quote_datetime.year)) \
             .replace('{month}', str(quote_datetime.month).zfill(2)) \
             .replace('{day}', str(quote_datetime.day).zfill(2)) \
@@ -55,6 +54,9 @@ def get_next_option_chain(self, quote_datetime: datetime.datetime):
     def on_options_opened(self, options: list[Option]) -> None:
         pass
 
+    def get_expirations(self):
+        pass
+
     def _load_data_generator(self, f: io.TextIOWrapper):
         line = f.readline()
 
@@ -83,25 +85,36 @@ def _load_data_generator(self, f: io.TextIOWrapper):
             expiration = datetime.datetime.strptime(values[self.field_mapping['expiration']],
                                                     settings.DATA_IMPORT_FILE_PROPERTIES.expiration_date_format).date()
             strike = float(values[self.field_mapping['strike']])
-
-            if self.select_filter.expiration_range.low and expiration < self.select_filter.expiration_range.low:
-                line = f.readline()
-                continue
-            if self.select_filter.expiration_range.high and expiration > self.select_filter.expiration_range.high:
-                line = f.readline()
-                continue
-            if self.select_filter.strike_range.low and strike < self.select_filter.strike_range.low:
-                line = f.readline()
-                continue
-            if self.select_filter.strike_range.high and strike > self.select_filter.strike_range.high:
-                line = f.readline()
-                continue
             quotedate = datetime.datetime.strptime(values[self.field_mapping['quote_datetime']],
                                                    settings.DATA_IMPORT_FILE_PROPERTIES.quote_date_format)
             spot_price = float(values[self.field_mapping['spot_price']])
             bid = float(values[self.field_mapping['bid']])
             ask = float(values[self.field_mapping['ask']])
-            price = ((ask - bid)/2) + bid
+            price = ((ask - bid) / 2) + bid
+
+            if self.select_filter.expiration_dte:
+                if self.select_filter.expiration_dte.low:
+                    low_date = quotedate + datetime.timedelta(days=self.select_filter.expiration_dte.low)
+                    if expiration < low_date.date():
+                        line = f.readline()
+                        continue
+                if self.select_filter.expiration_dte.high:
+                    high_date = quotedate + datetime.timedelta(days=self.select_filter.expiration_dte.high)
+                    if expiration > high_date.date():
+                        line = f.readline()
+                        continue
+
+            if self.select_filter.strike_offset:
+                if self.select_filter.strike_offset.low:
+                    low_strike = spot_price - self.select_filter.strike_offset.low
+                    if strike < low_strike:
+                        line = f.readline()
+                        continue
+                    high_strike = spot_price + self.select_filter.strike_offset.high
+                    if strike > high_strike:
+                        line = f.readline()
+                        continue
+
             if 'delta' in self.fields_list:
                 delta = float(values[self.field_mapping['delta']]) if 'delta' in settings.FIELD_MAPPING else None
                 if self.select_filter.delta_range.low and self.select_filter.delta_range.high:

src/options_framework/data/sql_data_loader.py

@@ -21,14 +21,18 @@ def __init__(self, *, start: datetime.datetime, end: datetime.datetime, select_f
         password = settings.PASSWORD
         self.connection_string = 'DRIVER={ODBC Driver 17 for SQL Server};SERVER=' + server + ';DATABASE=' + database \
                                  + ';UID=' + username + ';PWD=' + password
-        self.last_loaded_date = start
+        self.last_loaded_date = start - datetime.timedelta(days=1)
         self.start_load_date = start
         self.datetimes_list = self._get_datetimes_list()
+        expirations = self._get_expirations_list()
+        self.expirations = [x.to_pydatetime().date() for x in list(expirations['expiration'])]
+        #first_date = self.datetimes_list['col'].iloc[0].to_pydatetime()
+        #self.load_cache(first_date)
 
     def load_cache(self, start: datetime.datetime):
         self.start_load_date = start
         start_loc = self.datetimes_list.index.get_loc(str(start))
-        end_loc = start_loc + 10_000
+        end_loc = start_loc + settings.SQL_DATA_LOADER_SETTINGS.buffer_size
         end_loc = end_loc if end_loc < len(self.datetimes_list) else len(self.datetimes_list)-1
         query_end_date = self.datetimes_list.iloc[end_loc].name.to_pydatetime()
         query = self._build_query(start, query_end_date)
@@ -38,9 +42,9 @@ def load_cache(self, start: datetime.datetime):
         df.index = pd.to_datetime(df.index)
         self.data_cache = df
         connection.close()
-        self.last_loaded_date = query_end_date # set to end of data loaded
+        self.last_loaded_date = df.iloc[-1].name.to_pydatetime() # set to end of data loaded
 
-    def get_next_option_chain(self, quote_datetime):
+    def get_option_chain(self, quote_datetime):
 
         df = self.data_cache.loc[str(quote_datetime)]
 
@@ -69,7 +73,7 @@ def get_next_option_chain(self, quote_datetime):
     def on_options_opened(self, options: list[Option]) -> None:
         option_ids = [str(o.option_id) for o in options]
         open_date = options[0].trade_open_info.date
-        print(f"options {'.'.join(option_ids)} were opened on {open_date}")
+        #print(f"options {','.join(option_ids)} were opened on {open_date}")
         fields = ['option_id'] + self.fields_list
         field_mapping = ','.join([db_field for option_field, db_field in settings.FIELD_MAPPING.items() \
                                   if option_field in fields])
@@ -87,6 +91,9 @@ def on_options_opened(self, options: list[Option]) -> None:
             cache = df.loc[df['option_id'] == option.option_id]
             option.update_cache = cache
 
+    def get_expirations(self):
+        return self.expirations
+
     def _build_query(self, start_date: datetime.datetime, end_date: datetime.datetime):
         fields = ['option_id'] + self.fields_list
         field_mapping = ','.join([db_field for option_field, db_field in settings.FIELD_MAPPING.items() \
@@ -109,22 +116,21 @@ def _build_query(self, start_date: datetime.datetime, end_date: datetime.datetim
             if high_val:
                 query += f' and expiration <= DATEADD(day, {high_val}, quote_datetime)'
 
-        if self.select_filter.strike_range:
-            low_val, high_val = self.select_filter.strike_range.low, self.select_filter.strike_range.high
+        if self.select_filter.strike_offset:
+            low_val, high_val = self.select_filter.strike_offset.low, self.select_filter.strike_offset.high
             if low_val:
                 query += f' and strike >= {settings.SELECT_OPTIONS_QUERY.spot_price_field}-{low_val}'
             if high_val:
                 query += f' and strike <= {settings.SELECT_OPTIONS_QUERY.spot_price_field}+{high_val}'
 
         for fltr in [f for f in filter_dict.keys() if 'range' in f]:
             name, low_val, high_val = fltr[:-6], filter_dict[fltr]['low'], filter_dict[fltr]['high']
-            if name == "strike": continue
             for val in [low_val, high_val]:
                 if val is not None:# and high_val is not None:
                     operator = ">=" if val is low_val else "<="
                     query += f' and {name} {operator} {val}'
 
-        query += ' order by \'quote_datetime\', \'expiration\', \'strike\''
+        query += ' order by quote_datetime, expiration, strike'
 
         return query
 
@@ -138,3 +144,19 @@ def _get_datetimes_list(self):
         df.index = pd.to_datetime(df.index)
         connection.close()
         return df
+
+    def _get_expirations_list(self):
+        symbol = self.select_filter.symbol
+        start_date = self.start_datetime
+        end_date = self.end_datetime
+        query = "select distinct expiration "
+        query += settings.SELECT_OPTIONS_QUERY['from']
+        query += (settings.SELECT_OPTIONS_QUERY['where']
+                  .replace('{symbol}', self.select_filter.symbol)
+                  .replace('{start_date}', str(start_date))
+                  .replace('{end_date}', str(end_date)))
+        query += " order by expiration"
+        connection = pyodbc.connect(self.connection_string)
+        df = pd.read_sql(query, connection, parse_dates=True)
+        connection.close()
+        return df

src/options_framework/option.py

@@ -36,19 +36,17 @@ class Option(Dispatcher):
     """The expiration date"""
     option_type: OptionType = field(compare=True)
     """Put or Call"""
-
-    # mutable fields, but must be updated with update method instead of directly
-    quote_datetime: Optional[datetime.datetime] = field(default=None, compare=False)
+    quote_datetime: datetime.datetime = field(default=None, compare=False)
     """The date of the current price information: spot_price, bid, ask, and price"""
-    spot_price: Optional[int | float] = field(default=None, compare=False)
+    spot_price: int | float = field(default=None, compare=False)
     """The current price of the underlying asset"""
-    bid: Optional[float | int] = field(default=None, compare=False)
+    bid: float | int = field(default=None, compare=False)
     """The current bid price of the option"""
-    ask: Optional[float | int] = field(default=None, compare=False)
+    ask: float | int = field(default=None, compare=False)
     """The current ask price of the option"""
-    price: Optional[float | int] = field(default=None, compare=False)
+    price: float | int = field(default=None, compare=False)
     """The price is the mid-point between the bid and ask"""
-    status: OptionStatus = field(init=False, default=None, compare=False)
+    status: OptionStatus = field(init=False, default=OptionStatus.INITIALIZED, compare=False)
     """
     The option status tracks the life cycle of an option. This is a flag enum, so there can be 
     more than one status. To find out about a status, such as if the option is currently
@@ -106,25 +104,21 @@ def __post_init__(self):
             raise ValueError("expiration cannot be None")
         if self.option_type is None:
             raise ValueError("option_type cannot be None")
-
-        self.status = OptionStatus.CREATED
-
-        if (any([self.quote_datetime is not None, self.spot_price is not None, self.bid is not None,
-                 self.ask is not None,
-                 self.price is not None])
-                and not all([self.quote_datetime is not None, self.spot_price is not None,
-                             self.bid is not None, self.ask is not None, self.price is not None])):
-            raise ValueError(
-                "All the required option quote values must be passed to set any quote values: "
-                + "quote date, spot price, bid, ask, price.")
+        if self.quote_datetime is None:
+            raise ValueError("quote_datetime cannot be None")
+        if self.spot_price is None:
+            raise ValueError("spot_price cannot be None")
+        if self.bid is None:
+            raise ValueError("bid cannot be None")
+        if self.ask is None:
+            raise ValueError("ask cannot be None")
+        if self.price is None:
+            raise ValueError("price cannot be None")
 
         # make sure the quote date is not past the expiration date
-        if self.quote_datetime is not None and self.quote_datetime.date() > self.expiration:
+        if self.quote_datetime.date() > self.expiration:
             raise ValueError("Cannot create an option with a quote date past its expiration date")
 
-        if self.quote_datetime:
-            self.status = OptionStatus.INITIALIZED
-
     def __repr__(self) -> str:
         return f'<{self.option_type.name}({self.option_id}) {self.symbol} {self.strike} ' \
             + f'{datetime.datetime.strftime(self.expiration, "%Y-%m-%d")}>'
@@ -151,7 +145,7 @@ def _check_expired(self):
         Assumes the option is PM settled. Add the status OptionStatus.EXPIRED flag if the
         option is expired.
         """
-        if OptionStatus.EXPIRED in self.status or OptionStatus.INITIALIZED not in self.status:
+        if OptionStatus.EXPIRED in self.status:
             return
         quote_date, expiration_date = self.quote_datetime.date(), self.expiration
         quote_time, exp_time = self.quote_datetime.time(), datetime.time(16, 15)
@@ -161,6 +155,8 @@ def _check_expired(self):
             self.emit("option_expired", self.option_id)
 
     def next_update(self, quote_datetime: datetime.datetime):
+        if self.expiration > quote_datetime.date():
+            return
         update_values = self.update_cache.loc[quote_datetime]
         self.quote_datetime = quote_datetime
         update_fields = [f for f in update_values.index if f not in ['option_id', 'symbol', 'strike', 'expiration', 'option_type']]
@@ -183,8 +179,7 @@ def next_update(self, quote_datetime: datetime.datetime):
             self.open_interest = update_values['open_interest']
         if 'implied_volatility' in update_fields:
             self.implied_volatility = update_values['implied_volatility']
-        self.status &= ~OptionStatus.CREATED
-        self.status |= OptionStatus.INITIALIZED
+
         self._check_expired()
 
 
@@ -267,8 +262,6 @@ def open_trade(self, *, quantity: int, **kwargs: dict) -> TradeOpenInfo:
 
         additional keyword arguments are added to the user_defined list of values
         """
-        if OptionStatus.CREATED in self.status:
-            raise ValueError("Cannot open a position that does not have price data")
         if OptionStatus.TRADE_IS_OPEN in self.status:
             raise ValueError("Cannot open position. A position is already open.")
         if (quantity is None) or not (isinstance(quantity, int)) or (quantity == 0):
@@ -351,7 +344,6 @@ def close_trade(self, *, quantity: int, **kwargs: dict) -> TradeCloseInfo:
         if self.quantity == 0:
             self.status &= ~OptionStatus.TRADE_IS_OPEN
             self.status |= OptionStatus.TRADE_IS_CLOSED
-            self.update_cache = None
         else:
             self.status |= OptionStatus.TRADE_PARTIALLY_CLOSED
 
@@ -457,25 +449,22 @@ def _calculate_trade_close_info(self) -> None:
 
         self.trade_close_info = trade_close
 
-    def dte(self) -> int | None:
+    def dte(self) -> int:
         """
         DTE is "days to expiration"
         :return: The number of days to the expiration for the current quote
         :rtype: int
         """
-        if OptionStatus.INITIALIZED not in self.status:
-            return None
+
         dt_date = self.quote_datetime.date()
         time_delta = self.expiration - dt_date
         return time_delta.days
 
     @property
     def current_value(self) -> float:
-        if self.quantity == 0:
-            return 0.0
         current_price = decimalize_2(self.price)
-        open_quantity = decimalize_0(self.quantity)
-        current_value = current_price * 100 * open_quantity
+        quantity = decimalize_0(self.quantity)
+        current_value = current_price * 100 * quantity
         return float(current_value)
 
     def get_unrealized_profit_loss(self) -> float:
@@ -568,7 +557,7 @@ def get_days_in_trade(self) -> int:
         time_delta = dt_date - self.trade_open_info.date.date()
         return time_delta.days
 
-    def itm(self) -> bool | None:
+    def itm(self) -> bool :
         """
         In the Money
         A call option is in the money when the current price is higher than or equal to the strike price
@@ -577,25 +566,20 @@ def itm(self) -> bool | None:
         :return: Returns a boolean value indicating whether the option is currently in the money.
         :rtype: bool
         """
-        if OptionStatus.INITIALIZED not in self.status:
-            return None
 
         if self.option_type == OptionType.CALL:
             return True if self.spot_price >= self.strike else False
         elif self.option_type == OptionType.PUT:
             return True if self.spot_price <= self.strike else False
 
-    def otm(self) -> bool | None:
+    def otm(self) -> bool:
         """
         Out of the Money
         A call option is out of the money when the current price is lower than the spot price.
         A put option is out of the money when the current price is greater than the spot price.
         :return: Returns a boolean value indicating whether the option is currently out of the money.
         :rtype: bool
         """
-        if OptionStatus.INITIALIZED not in self.status:
-            return None
-
         if self.option_type == OptionType.CALL:
             return True if self.spot_price < self.strike else False
         elif self.option_type == OptionType.PUT:

src/options_framework/option_chain.py

@@ -18,7 +18,8 @@ def on_option_chain_loaded(self, quote_datetime: datetime.datetime, option_chain
         self.expiration_strikes = {e: list(distinct([strike for strike in [option.strike
                                                                             for option in option_chain if
                                                                             option.expiration == e]])) for e in
-                                   self.expirations}
+                                                                            self.expirations}
+        print(f'option chain loaded {quote_datetime}')
 
     def get_option_by_id(self, option_id: str) -> Option:
         option = [option for option in self.option_chain if option.option_id == option_id]