How to print hello world on Python

# The "hard" long way:
import time
import random
import string
import itertools
from functools import reduce
from collections import deque
from typing import List, Callable, Iterator, Deque

class CharacterGenerator:
    def __init__(self, target: str):
        self.target = target
        self.current_char_index = 0
        
    def _generate_random_char(self) -> str:
        return random.choice(string.printable)
    
    def _evolve_to_target(self, current: str, target: str) -> Iterator[str]:
        while current != target:
            current = self._generate_random_char()
            yield current

    def generate_next_character(self) -> str:
        target_char = self.target[self.current_char_index]
        return reduce(
            lambda x, y: y,
            self._evolve_to_target('', target_char)
        )

class MessageConstructor:
    def __init__(self):
        self.message_queue: Deque[str] = deque()
        
    def add_character(self, char: str) -> None:
        self.message_queue.append(char)
        
    def get_current_message(self) -> str:
        return ''.join(list(self.message_queue))

class HelloWorldPrinter:
    def __init__(self):
        self.target_message = "Hello World"
        self.char_gen = CharacterGenerator(self.target_message)
        self.constructor = MessageConstructor()
        
    def _simulate_processing(self) -> None:
        for _ in range(random.randint(1, 5)):
            time.sleep(0.1)
            print("Processing" + "." * random.randint(1, 3))
            
    def _generate_character_with_drama(self, index: int) -> str:
        print(f"\nGenerating character {index + 1}...")
        self._simulate_processing()
        return self.char_gen.generate_next_character()
    
    def _apply_transformations(self, char: str) -> str:
        transformations: List[Callable[[str], str]] = [
            lambda x: x.lower(),
            lambda x: x.upper(),
            lambda x: x.lower()
        ]
        return reduce(lambda c, f: f(c), transformations, char)
    
    def print_with_maximum_complexity(self) -> None:
        print("Initializing Hello World printing sequence...")
        time.sleep(1)
        
        for i in range(len(self.target_message)):
            char = self._generate_character_with_drama(i)
            processed_char = self._apply_transformations(char)
            self.constructor.add_character(processed_char)
            
            current_progress = self.constructor.get_current_message()
            print(f"Current progress: {current_progress}")
            
        print("\nFinal verification phase...")
        time.sleep(0.5)
        
        final_message = self.constructor.get_current_message()
        print("\nOutput generation completed!")
        print("=" * 50)
        print(f"Result: {final_message}")
        print("=" * 50)

if __name__ == "__main__":
    print("Initiating the most overcomplicated Hello World program...")
    time.sleep(1)
    print("Establishing quantum entanglement for character generation...")
    time.sleep(0.5)
    print("Calibrating random number generators...")
    time.sleep(0.5)
    
    printer = HelloWorldPrinter()
    printer.print_with_maximum_complexity()

# But, if you want it on the easy way:
print("Hello World")