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.

Next - the development of the PromptsWriter class.

The main functionality for this class is already written in the ScriptWriter class. We will discuss how to avoid code duplication and leverage this functionality through composition.

Result of the execute method of the ScriptDivider class:

1. Each scene is extracted from the dictionary and written to a separate row in the CSV file script_scenes.csv.

2. Each script is either in a separate column of the same file or in a separate file.

3. These scenes will be needed later for prompt and voiceover generation.

PromptsWriter

Previously, in the ScriptWriter class, we already implemented the functionality for generating texts. So, when we start writing the PromptsWriter class, we face the question: how can we reuse this functionality to avoid code duplication?

We'll solve this by doing the following:

We will extract the common functionality for text generation into a separate class, and then include it in both the ScriptWriter and PromptsWriter classes using composition.

So, in the modules package, we will create another file called writer.py.

In this file, we will declare a class called Writer.

This class will not act as a full actor in our bot. Instead, it will serve as an interface through which other classes (ScriptWriter and PromptsWriter) will interact with the methods for text generation.

It doesn't depend on project folders or the base class methods, and simply provides standalone functionality. Hence, it won’t inherit from the BaseGenerator class and will be independent.

Let’s create the constructor for this class. We’ll take the constructor from the ScriptWriter class and move it here, but we’ll remove the project_folder parameter and the super() call.

We will also move the generate_text method from the ScriptWriter class into this class.

Now we can include this class in other classes.

To do this, in the constructors of the ScriptWriter and PromptsWriter classes, we will create an instance of this class (self.writer) and pass the necessary arguments to it.

Then, in the execute method, we will simply call the generate_text method on this object.

Composition

In our example, the classes ScriptWriter and PromptsWriter create an instance of the Writer class and use it to perform text generation tasks. This is a classic example of composition.

Composition is a principle where one class includes another class as a component and uses it to accomplish its tasks.

Composition creates a "has-a" relationship. One object contains (has) another object and utilizes its functionality.

"Is-a" or "Has-a"

These principles help determine when to use inheritance and when to use composition.

1. Inheritance (is-a). If one class is a specialized or extended version of another, use inheritance.

Example: ScriptWriter, ScriptDivider, PromptsWriter, and other classes are (is-a) types of BaseGenerator. These classes have the functionality of BaseGenerator and extend it by adding their own logic.

✔️ Inheritance is suitable when classes have a "generalization-specialization" relationship: BaseGenerator (generalization) - ScriptWriter (specialization).

2. Composition (has-a). If one class contains or uses another class as a component, use composition.

Example: ScriptWriter and PromptsWriter include (has-a) an instance of Writer and use its functionality for text generation.

✔️ Composition is preferred when classes have a "part-whole" relationship: Writer (part) - ScriptWriter (whole).

* Despite the name Writer, it may seem like ScriptWriter is a type of Writer, but this is not the case. ScriptWriter (whole) simply uses Writer (part) as a component.