GPT-4 and Financial Tools, Part 2

11 May, 2023

A Continuation...

Me

Lets start over with a new python program for a sector rotation tracker, item 4. I want to know which sectors are losing momentum and which are gaining so I can search for volatility in those sectors to sell stock options on. How do you propose we obtain the sector data?

ChatGPT

Sector data can be obtained from various APIs that offer stock market data. Yahoo Finance, Alpha Vantage, and IEX Cloud all provide sector performance data.

Yahoo Finance: Yahoo Finance provides sector performance data for free. However, they do not provide a specific API for this and it would need to be obtained by web scraping, which as you've experienced, can be problematic due to changes in web page structure.
Alpha Vantage: Alpha Vantage provides sector performance data through their "Sector Performances" API. This API provides the real-time and historical equity sector performances calculated from S&P500 incumbents. They offer a free tier that allows up to 5 API requests per minute and up to 500 requests per day, which should be sufficient for your use case.
IEX Cloud: IEX Cloud provides various stock market data, including sector performance. However, the sector performance data is part of their paid plans.

Given your requirements, it seems like Alpha Vantage would be the best fit. Their API provides both real-time and historical sector performance data, which can be used to track sector momentum over time.

You would need to register for a free API key, which can then be used to make requests to the "Sector Performances" API. The API returns data in JSON format, which can easily be parsed in Python.

Once you have the sector performance data, you can calculate momentum using various methods. A simple method would be to calculate the rate of change over a certain period, such as the past week or month. Sectors with a positive rate of change are gaining momentum, while sectors with a negative rate of change are losing momentum.

Then, you can look for stocks in the sectors with high positive or negative momentum for potential stock option trading opportunities. This could be done using another API that provides stock data filtered by sector, or by maintaining a list of stocks for each sector.

Lets Do It!

Me

I have a brand new Alpha Vantage API key. Lets make a program that calculates sector momentum for each sector.

Use command line arguments for configuration.
Give useful help text for command line arguments.
Use markdown format for output.
Use the terminal for the output and display it in markdown using the python rich module.
Use python logging to give debug messages throughout the program.
Query the Alpha Vantage API for data using an API key given by command line argument.
Make up and report other requirements as necessary to make a useful program.
Normalize sector momentum in order to give a comparable metric between sectors.

Please write the program and provide a short explanation for how it works. I don't need instructions for how to install the python modules.

ChatGPT

Sure, here's a Python script that uses the Alpha Vantage API to calculate sector momentum:

import requests
import argparse
import logging
from rich.console import Console
from rich.table import Table
import pandas as pd

# Set up logging
logging.basicConfig(level=logging.DEBUG)

def get_sector_data(api_key):
    """Fetch sector performance data from Alpha Vantage"""
    logging.debug('Fetching sector data from Alpha Vantage')
    response = requests.get(f'https://www.alphavantage.co/query?function=SECTOR&apikey={api_key}')
    response.raise_for_status()
    data = response.json()
    logging.debug('Successfully fetched sector data')
    return data['Rank A: Real-Time Performance'], data['Rank B: 1 Day Performance']

def calculate_momentum(real_time_performance, one_day_performance):
    """Calculate sector momentum"""
    logging.debug('Calculating sector momentum')
    momentum = {sector: (float(real_time_performance[sector]) - float(one_day_performance[sector]))
                for sector in real_time_performance}
    # Normalize the momentum values
    df = pd.DataFrame(list(momentum.items()), columns=['Sector', 'Momentum'])
    df['Normalized Momentum'] = (df['Momentum'] - df['Momentum'].min()) / (df['Momentum'].max() - df['Momentum'].min())
    return df

def display_data(df):
    """Display the data in a markdown table"""
    console = Console()
    table = Table(show_header=True, header_style="bold magenta")
    table.add_column("Sector")
    table.add_column("Momentum")
    table.add_column("Normalized Momentum")
    for i in range(len(df)):
        table.add_row(df.iloc[i, 0], str(df.iloc[i, 1]), str(df.iloc[i, 2]))
    console.print(table)

def main(api_key):
    real_time_performance, one_day_performance = get_sector_data(api_key)
    df = calculate_momentum(real_time_performance, one_day_performance)
    display_data(df)

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Calculate and display sector momentum.')
    parser.add_argument('--api_key', required=True, help='Alpha Vantage API Key')
    args = parser.parse_args()
    main(args.api_key)

This script does the following:

It fetches sector performance data from Alpha Vantage. It gets both real-time performance and one-day performance.
It calculates sector momentum by subtracting the one-day performance from the real-time performance. This gives a measure of how much each sector's performance has changed in the last day.
It normalizes the momentum values. This is done by subtracting the minimum momentum value from each momentum value, and then dividing by the range of the momentum values. This scales all the momentum values to be between 0 and 1, making them comparable across sectors.
It displays the sector momentum data in a markdown table using the rich module.
It uses command line arguments to specify the Alpha Vantage API key. The script will not run without an API key.
It uses the Python logging module to provide debug messages throughout the program. The logging level is set to DEBUG, so all debug messages will be displayed.
It uses a main function and checks if the script is being executed or included. If the script is being executed, it will run the main function. If it is being included in another script, it will not run the main function.

Me

I get the error: DEBUG:root:Fetching sector data from Alpha Vantage DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): www.alphavantage.co:443 DEBUG:urllib3.connectionpool:https://www.alphavantage.co:443 "GET /query?function=SECTOR&apikey=XXX HTTP/1.1" 200 None DEBUG:root:Successfully fetched sector data DEBUG:root:Calculating sector momentum Traceback (most recent call last): File "./sectors.py", line 50, in main(args.api_key) File "./sectors.py", line 43, in main df = calculate_momentum(real_time_performance, one_day_performance) File "./sectors.py", line 23, in calculate_momentum momentum = {sector: (float(real_time_performance[sector]) - float(one_day_performance[sector])) File "./sectors.py", line 23, in momentum = {sector: (float(real_time_performance[sector]) - float(one_day_performance[sector])) ValueError: could not convert string to float: '1.69%'

ChatGPT

I apologize for the oversight. The sector performance data returned by Alpha Vantage is in percentage format as strings, and we need to convert these strings to floats before performing calculations.

Here's the corrected calculate_momentum function:

def calculate_momentum(real_time_performance, one_day_performance):
    """Calculate sector momentum"""
    logging.debug('Calculating sector momentum')
    momentum = {sector: (float(real_time_performance[sector].rstrip('%')) - float(one_day_performance[sector].rstrip('%')))
                for sector in real_time_performance}
    # Normalize the momentum values
    df = pd.DataFrame(list(momentum.items()), columns=['Sector', 'Momentum'])
    df['Normalized Momentum'] = (df['Momentum'] - df['Momentum'].min()) / (df['Momentum'].max() - df['Momentum'].min())
    return df

In this updated code, the rstrip('%') function is used to remove the percentage sign from the end of each string, and then the string is converted to a float.

Me

I get erroneous output. I don't believe the data is being downloaded: DEBUG:root:Fetching sector data from Alpha Vantage DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): www.alphavantage.co:443 DEBUG:urllib3.connectionpool:https://www.alphavantage.co:443 "GET /query?function=SECTOR&apikey=XXX HTTP/1.1" 200 None DEBUG:root:Successfully fetched sector data DEBUG:root:Calculating sector momentum ┏━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┓ ┃ Sector ┃ Momentum ┃ Normalized Momentum ┃ ┡━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━┩ │ Communication Services │ 0.0 │ nan │ │ Information Technology │ 0.0 │ nan │ │ Real Estate │ 0.0 │ nan │ │ Utilities │ 0.0 │ nan │ │ Consumer Discretionary │ 0.0 │ nan │ │ Health Care │ 0.0 │ nan │ │ Materials │ 0.0 │ nan │ │ Consumer Staples │ 0.0 │ nan │ │ Industrials │ 0.0 │ nan │ │ Financials │ 0.0 │ nan │ │ Energy │ 0.0 │ nan │ └────────────────────────┴──────────┴─────────────────────┘

ChatGPT

I apologize for the confusion. It seems like there could be an issue with the data being fetched or the way we're processing it.

To debug the issue, let's print the raw data we're receiving from Alpha Vantage. This will help us understand if the data is being downloaded correctly and if it's in the expected format.

Please add this debug print statement in the get_sector_data function, just before the return statement:

def get_sector_data(api_key):
    """Fetch sector performance data from Alpha Vantage"""
    logging.debug('Fetching sector data from Alpha Vantage')
    response = requests.get(f'https://www.alphavantage.co/query?function=SECTOR&apikey={api_key}')
    response.raise_for_status()
    data = response.json()
    logging.debug('Successfully fetched sector data')
    print(data)  # Add this line
    return data['Rank A: Real-Time Performance'], data['Rank B: 1 Day Performance']

Run the program again and share the output of the print statement. This will give us a better understanding of what's going wrong.

Me

Here is the new output: DEBUG:root:Fetching sector data from Alpha Vantage DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): www.alphavantage.co:443 DEBUG:urllib3.connectionpool:https://www.alphavantage.co:443 "GET /query?function=SECTOR&apikey=XXX HTTP/1.1" 200 None DEBUG:root:Successfully fetched sector data {'Meta Data': {'Information': 'US Sector Performance (realtime & historical)', 'Last Refreshed': '2023-05-11 00:14:46 US/Eastern'}, 'Rank A: Real-Time Performance': {'Communication Services': '1.69%', 'Information Technology': '1.22%', 'Real Estate': '0.98%', 'Utilities': '0.94%', 'Consumer Discretionary': '0.63%', 'Health Care': '0.27%', 'Materials': '0.05%', 'Consumer Staples': '-0.15%', 'Industrials': '-0.32%', 'Financials': '-0.58%', 'Energy': '-1.15%'}, 'Rank B: 1 Day Performance': {'Communication Services': '1.69%', 'Information Technology': '1.22%', 'Real Estate': '0.98%', 'Utilities': '0.94%', 'Consumer Discretionary': '0.63%', 'Health Care': '0.27%', 'Materials': '0.05%', 'Consumer Staples': '-0.15%', 'Industrials': '-0.32%', 'Financials': '-0.58%', 'Energy': '-1.15%'}, 'Rank C: 5 Day Performance': {'Information Technology': '2.56%', 'Real Estate': '2.35%', 'Consumer Discretionary': '2.25%', 'Communication Services': '2.17%', 'Utilities': '1.82%', 'Energy': '0.55%', 'Financials': '0.37%', 'Consumer Staples': '-0.08%', 'Industrials': '-0.13%', 'Materials': '-0.18%', 'Health Care': '-0.53%'}, 'Rank D: 1 Month Performance': {'Consumer Discretionary': '2.63%', 'Information Technology': '2.54%', 'Consumer Staples': '1.38%', 'Communication Services': '1.31%', 'Industrials': '1.18%', 'Real Estate': '0.66%', 'Financials': '0.20%', 'Health Care': '-0.67%', 'Utilities': '-0.81%', 'Materials': '-1.18%', 'Energy': '-6.64%'}, 'Rank E: 3 Month Performance': {'Communication Services': '9.42%', 'Information Technology': '8.67%', 'Consumer Staples': '5.64%', 'Utilities': '4.41%', 'Health Care': '1.17%', 'Consumer Discretionary': '-0.46%', 'Industrials': '-2.37%', 'Materials': '-3.79%', 'Real Estate': '-6.82%', 'Energy': '-8.29%', 'Financials': '-11.74%'}, 'Rank F: Year-to-Date (YTD) Performance': {'Communication Services': '24.59%', 'Information Technology': '23.15%', 'Consumer Discretionary': '15.30%', 'Consumer Staples': '2.46%', 'Materials': '1.23%', 'Real Estate': '0.92%', 'Industrials': '0.74%', 'Utilities': '-1.85%', 'Health Care': '-2.44%', 'Financials': '-6.47%', 'Energy': '-9.16%'}, 'Rank G: 1 Year Performance': {'Information Technology': '13.13%', 'Industrials': '6.30%', 'Energy': '5.62%', 'Health Care': '5.03%', 'Communication Services': '1.70%', 'Consumer Staples': '-0.21%', 'Consumer Discretionary': '-1.49%', 'Utilities': '-3.21%', 'Materials': '-3.54%', 'Financials': '-5.32%', 'Real Estate': '-12.31%'}, 'Rank H: 3 Year Performance': {'Energy': '107.20%', 'Information Technology': '60.62%', 'Industrials': '57.09%', 'Materials': '50.03%', 'Financials': '44.17%', 'Consumer Staples': '34.03%', 'Health Care': '33.64%', 'Utilities': '23.42%', 'Consumer Discretionary': '21.77%', 'Communication Services': '13.96%', 'Real Estate': '13.42%'}, 'Rank I: 5 Year Performance': {'Information Technology': '120.37%', 'Health Care': '65.56%', 'Consumer Staples': '58.11%', 'Communication Services': '40.87%', 'Utilities': '40.05%', 'Consumer Discretionary': '39.68%', 'Materials': '35.44%', 'Industrials': '34.53%', 'Real Estate': '21.21%', 'Financials': '14.59%', 'Energy': '8.81%'}, 'Rank J: 10 Year Performance': {'Information Technology': '435.39%', 'Health Care': '180.13%', 'Consumer Discretionary': '159.88%', 'Industrials': '125.13%', 'Financials': '106.74%', 'Materials': '94.08%', 'Consumer Staples': '88.94%', 'Utilities': '74.83%', 'Communication Services': '19.40%', 'Energy': '2.83%'}} DEBUG:root:Calculating sector momentum ┏━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┓ ┃ Sector ┃ Momentum ┃ Normalized Momentum ┃ ┡━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━┩ │ Communication Services │ 0.0 │ nan │ │ Information Technology │ 0.0 │ nan │ │ Real Estate │ 0.0 │ nan │ │ Utilities │ 0.0 │ nan │ │ Consumer Discretionary │ 0.0 │ nan │ │ Health Care │ 0.0 │ nan │ │ Materials │ 0.0 │ nan │ │ Consumer Staples │ 0.0 │ nan │ │ Industrials │ 0.0 │ nan │ │ Financials │ 0.0 │ nan │ │ Energy │ 0.0 │ nan │ └────────────────────────┴──────────┴─────────────────────┘

ChatGPT

Thank you for sharing the output. The problem seems to be that the "Real-Time Performance" and "1 Day Performance" for each sector are identical. This would result in a calculated momentum of zero for all sectors, which is why the output is showing zero momentum and NaN for the normalized momentum.

In the current implementation, the momentum is calculated as the difference between the real-time performance and the performance from one day ago. If these values are the same (as they seem to be in the data you've fetched), the calculated momentum will be zero.

We could change the calculation to use different performance measures. For example, we could calculate the momentum as the difference between the "1 Day Performance" and the "1 Month Performance". This would give us an indication of how much the performance of each sector has changed over the last month.

Here's how you can modify the calculate_momentum function to do this:

def calculate_momentum(one_day_performance, one_month_performance):
    """Calculate the momentum for each sector"""
    logging.debug('Calculating sector momentum')
    momentum = {sector: (percent_to_float(one_day_performance[sector]) - percent_to_float(one_month_performance[sector]))
                for sector in one_day_performance}
    normalized_momentum = {sector: (value - min(momentum.values())) / (max(momentum.values()) - min(momentum.values()))
                           for sector, value in momentum.items()}
    return momentum, normalized_momentum

And then you need to modify the main function to use the "1 Month Performance" data:

def main(api_key):
    """Main function"""
    real_time_performance, one_day_performance, one_month_performance = get_sector_data(api_key)
    momentum, normalized_momentum = calculate_momentum(one_day_performance, one_month_performance)
    display_momentum(momentum, normalized_momentum)

You also need to modify the get_sector_data function to return the "1 Month Performance" data:

def get_sector_data(api_key):
    """Fetch sector performance data from Alpha Vantage"""
    logging.debug('Fetching sector data from Alpha Vantage')
    response = requests.get(f'https://www.alphavantage.co/query?function=SECTOR&apikey={api_key}')
    response.raise_for_status()
    data = response.json()
    logging.debug('Successfully fetched sector data')
    return data['Rank A: Real-Time Performance'], data['Rank B: 1 Day Performance'], data['Rank D: 1 Month Performance']

This should give you a measure of the momentum of each sector over the last month, normalized to a range of 0 to 1.

Me

I get the error: DEBUG:root:Fetching sector data from Alpha Vantage DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): www.alphavantage.co:443 DEBUG:urllib3.connectionpool:https://www.alphavantage.co:443 "GET /query?function=SECTOR&apikey=XXX HTTP/1.1" 200 None DEBUG:root:Successfully fetched sector data DEBUG:root:Calculating sector momentum Traceback (most recent call last): File "./sectors.py", line 50, in main(args.api_key) File "./sectors.py", line 43, in main momentum, normalized_momentum = calculate_momentum(one_day_performance, one_month_performance) File "./sectors.py", line 23, in calculate_momentum momentum = {sector: (percent_to_float(one_day_performance[sector]) - percent_to_float(one_month_performance[sector])) File "./sectors.py", line 23, in momentum = {sector: (percent_to_float(one_day_performance[sector]) - percent_to_float(one_month_performance[sector])) NameError: name 'percent_to_float' is not defined

ChatGPT

My apologies for that oversight. The percent_to_float function is a helper function to convert percentage strings to float values. I forgot to include this in the initial script. Here is the definition of percent_to_float:

def percent_to_float(percent_str):
    """Convert percentage string to float"""
    return float(percent_str.strip('%')) / 100

You can add this function to your script. This function simply removes the '%' character from the string and converts the remaining number to a float, dividing by 100 to get the decimal representation of the percentage.

Me

ChatGPT

Apologies for the oversight. I seem to have missed defining the display_momentum function. This function should take the momentum and normalized momentum dictionaries and display them in a table using the Rich module. Here's the definition of display_momentum:

from rich.table import Table
from rich.console import Console

def display_momentum(momentum, normalized_momentum):
    """Display the momentum and normalized momentum in a table using Rich"""
    
    # Initialize the console
    console = Console()

    # Initialize the table
    table = Table(show_header=True, header_style="bold magenta")
    table.add_column("Sector")
    table.add_column("Momentum")
    table.add_column("Normalized Momentum")

    for sector in momentum.keys():
        table.add_row(sector, str(momentum[sector]), str(normalized_momentum[sector]))

    # Print the table to the console
    console.print(table)

You can add this function to your existing script. This function makes use of the rich library to display tables in the console. It creates a new Table object, adds columns for sector, momentum, and normalized momentum, then populates the table with the data from the dictionaries. The table is then printed to the console.

Me

Now the program works. I get this output:

DEBUG:root:Fetching sector data from Alpha Vantage DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): www.alphavantage.co:443 DEBUG:urllib3.connectionpool:https://www.alphavantage.co:443 "GET /query?function=SECTOR&apikey=XXX HTTP/1.1" 200 None DEBUG:root:Successfully fetched sector data DEBUG:root:Calculating sector momentum ┏━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┓ ┃ Sector ┃ Momentum ┃ Normalized Momentum ┃ ┡━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━┩ │ Communication Services │ 0.003799999999999998 │ 0.3177570093457943 │ │ Information Technology │ -0.0132 │ 0.09078771695594125 │ │ Real Estate │ 0.0031999999999999997 │ 0.30974632843791716 │ │ Utilities │ 0.0175 │ 0.5006675567423231 │ │ Consumer Discretionary │ -0.02 │ 0.0 │ │ Health Care │ 0.0094 │ 0.3925233644859813 │ │ Materials │ 0.0123 │ 0.43124165554072097 │ │ Consumer Staples │ -0.0153 │ 0.06275033377837116 │ │ Industrials │ -0.015 │ 0.06675567423230976 │ │ Financials │ -0.0078 │ 0.16288384512683576 │ │ Energy │ 0.054900000000000004 │ 1.0 │ └────────────────────────┴───────────────────────┴─────────────────────┘

My issue is that the normalized values all seem positive. I need to see negative momentum as well. Can you change the calculate_momentum function to return a normalized value with the sign preserved?

ChatGPT

You're right. The current normalization method adjusts the values to a [0,1] range, which makes all the values positive. To keep the negative values, we can normalize the data differently by using standardization, where the mean of the data is subtracted from each value and the result is divided by the standard deviation. This will keep the signs and provide values in terms of how many standard deviations away they are from the mean. Here's how you can modify the calculate_momentum function:

def calculate_momentum(one_day_performance, one_month_performance):
    """Calculate the momentum for each sector and return a dictionary."""
    momentum = {sector: (percent_to_float(one_day_performance[sector]) - percent_to_float(one_month_performance[sector]))
                for sector in one_day_performance.keys()}

    # Calculate mean and standard deviation for normalization
    mean_momentum = sum(momentum.values()) / len(momentum)
    std_momentum = (sum((x-mean_momentum)**2 for x in momentum.values()) / len(momentum))**0.5

    # Normalize the momentum
    normalized_momentum = {sector: ((value - mean_momentum) / std_momentum) 
                           for sector, value in momentum.items()}

    return momentum, normalized_momentum

This revised function first calculates the mean and standard deviation of the momentum values, then uses these to standardize the momentum values. The standardized values (in normalized_momentum) will be how many standard deviations each value is from the mean, and will maintain the original signs of the momentum values.

Me

I receive this output, which as far as I can tell is correct: DEBUG:root:Fetching sector data from Alpha Vantage DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): www.alphavantage.co:443 DEBUG:urllib3.connectionpool:https://www.alphavantage.co:443 "GET /query?function=SECTOR&apikey=XXX HTTP/1.1" 200 None DEBUG:root:Successfully fetched sector data ┏━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━┓ ┃ Sector ┃ Momentum ┃ Normalized Momentum ┃ ┡━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━┩ │ Communication Services │ 0.003799999999999998 │ 0.053357938992797116 │ │ Information Technology │ -0.0132 │ -0.7781366103116266 │ │ Real Estate │ 0.0031999999999999997 │ 0.02401107254675872 │ │ Utilities │ 0.0175 │ 0.7234447228440094 │ │ Consumer Discretionary │ -0.02 │ -1.1107344300333961 │ │ Health Care │ 0.0094 │ 0.3272620258224898 │ │ Materials │ 0.0123 │ 0.4691052136450092 │ │ Consumer Staples │ -0.0153 │ -0.8808506428727613 │ │ Industrials │ -0.015 │ -0.8661772096497421 │ │ Financials │ -0.0078 │ -0.5140148122972802 │ │ Energy │ 0.054900000000000004 │ 2.552732731313742 │ └────────────────────────┴───────────────────────┴──────────────────────┘

ChatGPT

Great! I'm glad the updated function is working as expected. The table now shows the momentum of each sector, and the normalized momentum which standardizes the momentum values to show how they deviate from the average. This helps you easily see which sectors are performing above or below average, and by how much.

The normalization now also preserves the sign of the momentum, so you can see which sectors have positive momentum (performing better now than they were a month ago) and which have negative momentum (performing worse now than a month ago).

Energy sector, for instance, has the highest positive momentum, while the Consumer Discretionary sector has the most negative momentum.

If you have any more questions or need further clarification, feel free to ask!

Done!

Ok! So we made a program that successfully, perhaps wrongly, but mostly correctly, calculates the momentum in each sector. All using prompt engineering and no direct coding but some code knowledge. What will be possible tomorrow is anyone's guess.

The Derivatives Menu