Now let's add the option to use gpt4free instead of the official API.

According to the documentation of the g4f library, the method for generating text can be the same as our generate_text method.

However, for g4f, we need to create a separate client, an instance of the Client class:

self.client = Client()

At any given time, the bot will work with only one client, so creating two clients simultaneously in the class constructor would be inefficient.

To avoid creating two clients at once in the class constructor, we will add a new parameter use_g4f to the constructor and initialize only the necessary client based on the value of this parameter.

Thus, the class constructor needs to be modified as follows.

Now the generate_text method will use the self.client chosen in the constructor. Note that the logic of the method for both OpenAI API and g4f is the same in our case.

If the methods for OpenAI API and g4f had different logic, we would need to separate them to maintain the specific logic for each client.

In that case, we would need to implement different methods for working with each API. I'll show an example of this in the next post.

In this example, two separate methods for text generation are created — one for OpenAI, and the other for g4f.

In the execute method, the client type (self.client) is checked to determine which API to use, and then it calls the corresponding method.

Alright. All that’s left is to save the response to the script.csv file in the project folder.

To do this, in the execute method, we'll form the file path and call the write_csv method from the base class, passing the file path and the response.

Example of the write_csv method implementation in the base class.

The work on the ScriptWriter class is complete.

We just need to make some changes to the main.py file to run and test this mode of the bot.

Our course is coming to an end.

Additional recommendations for the class code:

1. File paths will need to be used repeatedly and across different classes, so they can be made into object attributes and moved to the base class.

2. Where necessary, add exception handling using try-except.

3. Add logging (messages about the start and end of tasks or errors).

After writing the ScriptWriter class, we need to prepare the input data (prompts).

One way to structure this data is to create a prompt builder based on Google Sheets.

1. Create a sheet for the prompt builder.
2. Create sheets with different types of prompts, where ready-made prompts from the prompt builder will be parsed.
3. Write a method to read data from Google Sheets.
4. Read the data depending on the sheet. Pass the required sheet as an argument to the method, for example, as shown here.
5. Return a dictionary or list of prompts from the method.

You will need to implement this on your own; we covered it in more detail and wrote the code in Lesson 4 of the Pinterest Money course.

For now, we'll choose another simple method as an example.

For now, we’ll simply declare a list of prompts as an example.

Then, in the run_script_writer function, we will create an instance of the ScriptWriter class, after which we will iterate over the prompts from the list using a for loop, and for each one, call the execute method.

1. Note that the Config.OPENAI_API_KEY argument contains the OpenAI API key, which was retrieved through environment variables from the .env file.

2. Through the named argument model, we specify the model, and through the named argument use_g4f, we indicate the use of the g4f library.

Main GPT models: gpt-4o, gpt-4o-mini, gpt-4-turbo, gpt-4, gpt-3.5-turbo

You can learn about the rest in the OpenAI API documentation.

Tips for using g4f:

1. If you encounter the error 'No module named 'curl_cffi'' when importing the g4f module, fix this by installing the module:

pip install curl-cffi

2. You can enable debug mode to better control the process:

import g4f.debug
g4f.debug.logging = True

After running the bot, a file named script.csv should appear in your project folder with content similar to this.

We can see that the responses may vary in format.

However, the next step will be to divide each script into scenes.

So, how can we standardize the responses to make it easier to split them into scenes?

How can we standardize the responses to make it easier to split them into scenes?

We can specify the desired format directly in the prompt. For example, a list of dictionaries.

The main part of the course is now complete.

We developed the foundation of the bot from scratch and fully developed one class and a bot mode.

You will need to write the remaining classes on your own.

Next, I will provide recommendations and suggest technologies you can use to accomplish this.

* Don’t think that it’s too difficult. You can write the code with the help of ChatGPT or another assistant by providing it with the class skeleton and task decomposition.

Let’s proceed with analyzing the development of the remaining classes. You can consider this section of the course as homework assignment.

ScriptDivider

To standardize the data and simplify splitting the script into scenes, we requested the desired format directly in the prompt — a list of dictionaries.

As a result, the rows in the script.csv file will contain text that includes this list of dictionaries. It may look something like this (image).

Thus, in the ScriptDivider class, we need to write a method that extracts this list of dictionaries from the text and converts it into a Python object.

The task breakdown for the execute method of the ScriptDivider class can look like this:

1. Accept the script text.
2. Extract the list of dictionaries from the text and return it as a Python object.
3. Write the data into a separate CSV file, such as script_scenes.csv. Each dictionary key's value should be written in a separate row.

You can prepare the initial data like this:

1. Open the script.csv file.
2. Read its data and return a list of rows.
3. In a for loop, call the main class method (execute) for each script and pass the script as an argument.

Hint 1: To avoid confusion and problems when parsing dictionaries from text due to quotation marks (double "" or single ''), you can request the necessary quotation marks for dictionary keys and values directly in the prompt (e.g., double quotes).

Hint 2: Think through the logic for writing scenes for each script into a CSV file to make future processing easier. This could be writing in one CSV file with different scripts separated by columns, or writing each script into a separate file.