Now let's move on to the child classes.

We'll create a skeleton for ScriptWriter. The structure for the other child classes will be created following the same principle.

In the script_writer.py file, declare the ScriptWriter class and inherit it from the base class BaseGenerator.

Create the class constructor. Since we need to pass the project_folder argument to the BaseGenerator parent class constructor, we must first accept it in the ScriptWriter child class constructor. Let's do that.

To pass project_folder to the parent class, we need to call the parent class constructor. This is done using the super() function.

Call the parent class constructor using super() and pass the project_folder parameter.

* I will provide the code a bit later

Note that instance attributes of the child class ScriptWriter should be created after calling the super() function, as this is related to the initialization order of the base and child classes.

When your child class inherits functionality from a base class, the base class attributes need to be initialized before adding attributes in the child class.

When creating an object (instance) of ScriptWriter, the initialization order will be as follows:

1. The constructor of the ScriptWriter child class is called first.
2. Then, the constructor of the BaseGenerator parent class is called via super(). At this point, all parent class attributes are initialized.
3. Then, the constructor of the child class continues, where the child class attributes are initialized.

Next, after the class constructor, we will declare a method that will trigger the execution of the main task of the class. Let's name it execute and leave it empty for now.

Each of the child classes will have a method with this name, but it will have its own unique implementation for each class.

The creation of the skeleton for our classes is now complete.

Following the same principle, create the structure for the remaining child classes, changing only the class name.

Next, we'll move on to developing the bot's launch logic.

In the main.py file, we will implement the management of different operation modes for the bot.

Here's what we'll do:

1. Import our classes.
2. Add functions to run individual steps, each of which will create an instance of the corresponding class and call its execute method.
3. Add a function to run the full pipeline, which will sequentially execute all the steps.
4. Create a menu to select the bot's operation mode.

Let’s implement this.

First, we'll import the classes. Then, for each class, we’ll create a function that accepts the project_folder argument.

In the function, we will create an instance of the class and pass the project_folder parameter to the class constructor. After that, we will call the execute method on this object.

* I will provide the code a bit later

Note that instead of importing all classes globally, we can move the imports inside their respective functions.

This will speed up the bot’s startup and reduce memory usage in situations where not all classes are needed.

For example, if we only need to run one mode, the bot won’t import all other classes.

After declaring functions for each mode, we'll define a function that runs the full pipeline.

This function will sequentially execute all steps by calling the previously defined functions one by one.

Next, we'll declare the main function.

In this function, we'll declare a variable project_folder and assign it the project folder name.

We'll also create a menu here to choose the bot's operation mode.

We can implement this in two ways:

1. By parsing command-line arguments (argparse), allowing the bot to be launched from the command line.
2. By using a simple numeric input in the console.

We'll go with the simpler second option for now. I'll demonstrate the first option separately later.

So, let's first print the selection menu, and then get the user's choice using input.

Then, we'll run the corresponding mode based on the user's choice.

All that's left is to create the entry point ifname at the bottom of the file, with a call to the main() function.

This line ensures that the main() function is executed only when this file is run as the main program, not when it's imported as a module.

Example of bot control implementation via command line argument parsing (argparse)

How it works:

1. argparse is used to get the mode argument from the command line. This allows the user to choose which mode to run.

2. Depending on the value of args.mode, the corresponding functions are called (e.g., run_script_writer, run_script_divider, etc.).

3. Run it through the console, providing the required mode (e.g., full): python main.py full

The development of the bot control logic is now complete.

You can now run the bot in any mode and check if the constructor of the base class works.

After running, the project folders should be created automatically. This means that everything is working correctly.

You can create folders for another project by assigning a new value to the project_folder variable in the main function of the main.py file, and then run the bot again.

* Run the main.py file.

As we finish working on the bot’s basis, let’s think about what we haven’t taken care of yet.

Storing API keys and other project settings.

To address this, we will follow the standard practice and create a config.py file to store such data.

In this file, we will later create a settings class, where we will store these data in its attributes.

We will read the API keys from environment variables. This approach protects the data from accidentally being exposed in the code and repository.

So, let's create two files in the root of the project:

1. config.py - this will contain the settings class
2. .env - this is where we'll store API keys

To easily work with environment variables, we'll use the python-dotenv library. Install it via the terminal:

pip install python-dotenv

In the .env file, we'll place the necessary API keys (e.g., for OpenAI, Elevenlabs, Pexels) in the following format:

API_KEY_1=your_api_key_1

Next, we'll load these variables from the file using dotenv.