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.

Now we need to refine the project structure.

We see that the modules package contains three files related to text generation: writer.py, script_writer.py, and prompts_writer.py.

Let's improve the project structure.

In the modules package, we'll create a separate writer package and move the files writer.py, script_writer.py, and prompts_writer.py into it.

This will create a clear separation of responsibility and make it easier to manage the logic related to text generation.

* Don't forget to update the imports in the main.py file accordingly:

from modules.writer.script_writer import ScriptWriter
from modules.writer.prompts_writer import PromptsWriter

Let's start with the tasks for the PromptsWriter:

The initial data can be prepared like this:

1. Read the data from the file(s) obtained in the previous stage (ScriptDivider).

2. Pack the data into a list of lists. Each script is a list of strings or a list of dictionaries. The scenes of the script are the elements of the list (strings, or the values of the dictionary keys).

3. Iterate over each script (list) in a loop.

4. Iterate over the list elements (scenes) in a loop. For each scene, create a prompt by inserting the scene's value.

5. Pass the prepared prompt to the execute method of the PromptsWriter class.

* Example of a prompt to be passed to the execute method:

For scene [scene] write an image prompt. The goal is to generate visuals for this scene using this prompt.

The work of the execute method:

1. Accept the prompt in the method.

2. Send the request to generate text through the generate_text method of the self.writer object, which was created in the constructor of the class.

3. Receive the response and save the result in a separate CSV file.

Hint 1. The result may look like this (image). There is a separate folder for the generated prompts, and each script has its own CSV file with the generated prompts. The rows in the file represent the prompts for each scene of the script.

Hint 2. To simplify extracting the result, request a dictionary format in the initial prompt. Then, write a method to extract the values of the dictionary keys from the text, similar to what we did in the ScriptDivider class.

The final prompts saved in the CSV file might look like this.

Next, we will discuss automating the generation of AI images based on these prompts.

ImageGenerator

How can we implement AI image generation? Here are a few options:

Paid:

• OpenAI API (DALL·E 3 model) or other APIs

Free:

• gpt4free (client.images.generate)
• Own generator

Speaking of free options, for better reliability, speed, and quality, we can build our own generator. Such a generator is demonstrated in the bot's demo.

It’s built using browser automation with Playwright and one of the free AI generators based on the DALL·E 3 model.

Next, I’ll guide you on how to write such a generator in the ImageGenerator class.

Playwright + Bing Image Creator

1. Create a Microsoft Bing account.

2. Go to https://www.bing.com/images/create.

3. Copy cookies using the EditThisCookie extension.

4. Save the cookies to a cookies.json file in the data folder of our bot.

5. In the constructor of the ImageGenerator class, create an attribute that holds the path to the cookies file.

6. Write a method that contains the driver object. Example of driver setup:

playwright = sync_playwright().start()
browser = playwright.chromium.launch()
context = browser.new_context()

Options like headless mode can be set in the browser object, and you can disable the AutomationControlled flag.

You can also set the User Agent and change the viewport in the context object.

Return the context from the method.

7. Create an attribute containing the driver object, and assign it the result of the method.

8. Create an attribute for the browser page: self.page = None. This is necessary for accessing the page object in other methods.

...

Writing the login method:

1. Open a new page:

self.page = self.driver.new_page()

2. Check if the cookies file exists. If it does, read its contents (for this, write a separate method) and load them into the browser:

self.driver.add_cookies(cookies)

Writing the execute method:

1. Navigate to the page https://www.bing.com/images/create.

The page URL can be set as a class attribute self.URL:

self.page.goto(self.URL)

2. Find the selector for the text input form.
3. Enter the text (received as an argument) into the form.
4. Find the selector for the "Create" button.
5. Click the button (or simulate pressing the Enter key).
6. Find the selector for the block containing the generated images.
7. Wait for this block to appear:

self.page.wait_for_selector(selector)

8. Find the selector for the images inside the block.
9. Extract the image URLs and download them into the folder for the specific scene.

Data for passing to the execute method can be prepared like this:

1. Loop through the CSV files with prompts from the prompts folder and read their contents.
2. Return a list of lists. Each list contains prompts for a separate script, and each prompt is an element of the list (a string or a dictionary value).
3. Loop through each list (representing a script).
4. Loop through each element (prompt) and pass it to the execute method.