Documenting undocumented python scripts using Python-OpenAI

Today, I will discuss another very impressive & innovative new AI, which is now operational in Python. We’ll document a dummy python code with no comment captured through OpenAI’s ChatGPT model. But before we start, don’t we see the demo first?

---

Great! Let us understand we can leverage this by writing a tiny snippet using this new AI model.

Architecture:

Let us understand the flow of events –

The above diagram represents the newly released OpenAI ChatGPT, where one needs to supply the code, which was missed to capture the logic earlier due to whatever may be the reasons. We need to provide these scripts (maybe in parts) as source code to be analyzed. Then it will use this new model & translate that into English-like language & capture the logic/comments for that specific snippet.

---

Python Packages:

Following are the python packages that are necessary to develop this brilliant use case –

pip install pandas
pip install openai

To know more, please click the below – “Continue Reading” link –

CODE:

Let us now understand the code. For this use case, we will only discuss three python scripts. However, we need more than these three. However, we have already discussed them in some of the early posts. Hence, we will skip them here.

• clsConfigClient.py (Configuration file)

Let us understand a few important entries –

'OPENAI_API_KEY': "sk-gfjrjIIYRED%KKLkw8373hdtYdevGKdjd734BH",
'MODEL_NAME': "code-davinci-002",
"KEY_Q":"What the above class is doing?"

As one can see that the following entries are extremely important for the main application. I’ve shown the process to extract the API Key in the next part. And, by default, the application will be using “code-davinci-002”. And finally, the Key_Q is the main variable, which contains the question that the application will ask OpenAI ChatGPT.

• writeDoc.py (Main application to invoke the OpenAI API)

Let us understand the key snippets –

def readFile(inputFile):
    try:
        data = Path(inputFile).read_text()
        return data + '""" ' + KEY_Q
    except Exception as e:
        x = str(e)
        print(x)

        data = ''

        return data

This function appears to read the contents of a file and return it as a string, with some additional text appended to the end. The function also includes a try-except block to handle any exceptions that might occur while trying to read the file & it will append the string'” “”‘and the value of the variable KEY_Q to the end of the file contents and then return and print the resulting string.

If an exception occurs while trying to read the file, the function will print the error message and return an empty string.

Let us understand the process of acquiring API Key –

Please go to the above-mentioned page & under the API_keys (highlighted in Red), and click – “Create new secret key.”

This key will be used later in the next snippet.

def main():
    try:
        # Other useful variables
        debugInd = 'Y'
        var = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
        var1 = datetime.datetime.now()

        print('Start Time: ', str(var))
        # End of useful variables

        # Initiating Log Class
        general_log_path = str(cf.conf['LOG_PATH'])

        # Enabling Logging Info
        logging.basicConfig(filename=general_log_path + 'predCode.log', level=logging.INFO)

        print('Started predicting & documenting code!')
        print('Read Class Name: ')
        print(str(FILE_NAME))

        FileNameWithPath = CODE_PATH + FILE_NAME

        data = readFile(FileNameWithPath)

        print('#'*120)
        print(data)
        print(type(data))
        print('#'*120)

        # ChatGPT API_KEY
        openai.api_key = OPENAI_API_KEY

        # Getting response from ChatGPT
        response = openai.Completion.create(
        model=MODEL_NAME,
        prompt=data,
        temperature=0,
        max_tokens=64,
        top_p=1.0,
        frequency_penalty=0.0,
        presence_penalty=0.0,
        stop=["\"\"\""]
        )

        print('Final Result:')
        print('*'*120)
        #print(response)
        print(response.choices[0].text)
        print('*'*120)

        var2 = datetime.datetime.now()

        c = var2 - var1
        minutes = c.total_seconds() / 60
        print('Total difference in minutes: ', str(minutes))

        print('End Time: ', str(var1))

    except Exception as e:
        x = str(e)
        print('Error: ', x)

This function uses the OpenAI API to generate text based on a prompt. The function reads a file, processes the contents of the file, and then sends the processed data to the OpenAI API as a prompt and also includes a try-except block to handle any exceptions that might occur while processing the file or using the OpenAI API.

Here is a brief overview of what the function does:

1. Initializes all the variables, including a log file and the current time.
2.  Reads in the contents of a file using the readFile, a function defined earlier.
3.  Sends the file’s contents to the OpenAI API as a prompt using the “openai.Completion.create” method.
4.  It prints the response from the OpenAI API.
5.  Calculates the time taken to process the file and send the prompt to the OpenAI API.

If an exception occurs at any point during the execution of the function, it will be caught, and the error message will be printed.

---

FOLDER STRUCTURE:

Let us understand the directory structure –

ANALYZING OUTPUT:

Let us first explore the dummy code, which we’ve considered for this use case –

So, finally, we’ve done it.

You will get the complete codebase in the following GitHub link.

I’ll bring some more exciting topics in the coming days from the Python verse. Please share & subscribe to my post & let me know your feedback.

Till then, Happy Avenging! 😀

Note: All the data & scenarios posted here are representational data & scenarios & available over the internet & for educational purposes only. Some of the images (except my photo) we’ve used are available over the net. We don’t claim ownership of these images. There is always room for improvement & especially in the prediction quality.