class User:
    def __init__(self, name):
        self.name = name
        self.other_users = []  #
   
    def send_message(self, message, to_user):
        print(f"{self.name} {to_user.name}: {message}")
        to_user.receive_message(message, self)
   
    def receive_message(self, message, from_user):
        print(f"{self.name} {from_user.name} : {message}")

#
user1 = User("")
user2 = User("")
user3 = User("")

#
user1.other_users = [user2, user3]
user2.other_users = [user1, user3]
user3.other_users = [user1, user2]

user1.send_message("", user2)

class ChatRoom:
    def __init__(self):
        self.users = {}
   
    def register_user(self, user):
        self.users[user.name] = user
        user.chat_room = self
   
    def send_message(self, message, from_user, to_user_name=None):
        if to_user_name:  #
            if to_user_name in self.users:
                self.users[to_user_name].receive_message(message, from_user)
        else:  #
            for user_name, user in self.users.items():
                if user_name != from_user.name:
                    user.receive_message(message, from_user)

class User:
    def __init__(self, name):
        self.name = name
        self.chat_room = None
   
    def send_message(self, message, to_user_name=None):
        if self.chat_room:
            self.chat_room.send_message(message, self, to_user_name)
   
    def receive_message(self, message, from_user):
        print(f"{self.name} {from_user.name} : {message}")

#
chat_room = ChatRoom()

user1 = User("")
user2 = User("")
user3 = User("")

chat_room.register_user(user1)
chat_room.register_user(user2)
chat_room.register_user(user3)

user1.send_message("")  #
user2.send_message("", "")  #

from abc import ABC, abstractmethod
from typing import List

#
class Mediator(ABC):
    @abstractmethod
    def notify(self, sender: object, event: str, data: dict = None):
        pass

# -
class ChatRoomMediator(Mediator):
    def __init__(self):
        self.users: List[User] = []
   
    def add_user(self, user):
        self.users.append(user)
        user.set_mediator(self)
   
    def notify(self, sender, event, data=None):
        if event == "send_message":
            message = data.get("message")
            target_user = data.get("target_user")
           
            if target_user:  #
                for user in self.users:
                    if user.name == target_user:
                        user.receive_message(message, sender.name)
            else:  #
                for user in self.users:
                    if user != sender:
                        user.receive_message(message, sender.name)
       
        elif event == "user_joined":
            message = f": {sender.name} "
            for user in self.users:
                if user != sender:
                    user.receive_message(message, "")

#
class BaseComponent:
    def __init__(self):
        self._mediator = None
   
    def set_mediator(self, mediator: Mediator):
        self._mediator = mediator

# -
class User(BaseComponent):
    def __init__(self, name):
        super().__init__()
        self.name = name
   
    def send_message(self, message, target_user=None):
        print(f"{self.name} : {message}")
        self._mediator.notify(self, "send_message", {
            "message": message,
            "target_user": target_user
        })
   
    def join_chat(self):
        self._mediator.notify(self, "user_joined")
   
    def receive_message(self, message, from_name):
        print(f"{self.name} {from_name} : {message}")

#
def main():
    #
    chat_room = ChatRoomMediator()
   
    #
    alice = User("Alice")
    bob = User("Bob")
    charlie = User("Charlie")
   
    #
    chat_room.add_user(alice)
    chat_room.add_user(bob)
    chat_room.add_user(charlie)
   
    print("=== ===")
   
    # Alice
    alice.join_chat()
   
    #
    alice.send_message(" Alice")
    bob.send_message(" Alice")
    charlie.send_message("Alice ", "Alice")  #
   
    # Bob
    bob.send_message("")

if __name__ == "__main__":
    main()

class DialogMediator:
    def __init__(self):
        self.login_button = None
        self.username_input = None
        self.password_input = None
        self.remember_checkbox = None
   
    def notify(self, sender, event):
        if event == "username_changed" or event == "password_changed":
            #
            username = self.username_input.get_text()
            password = self.password_input.get_text()
            self.login_button.set_enabled(bool(username and password))
       
        elif event == "login_clicked":
            #
            username = self.username_input.get_text()
            password = self.password_input.get_text()
            remember = self.remember_checkbox.is_checked()
            print(f": {username}, : {remember}")
       
        elif event == "remember_changed":
            print("")

class UIComponent:
    def __init__(self, mediator=None):
        self.mediator = mediator
   
    def set_mediator(self, mediator):
        self.mediator = mediator

class Button(UIComponent):
    def click(self):
        if self.mediator:
            self.mediator.notify(self, "login_clicked")
   
    def set_enabled(self, enabled):
        print(f" {'' if enabled else ''}")

class TextInput(UIComponent):
    def __init__(self, mediator=None):
        super().__init__(mediator)
        self._text = ""
   
    def set_text(self, text):
        self._text = text
        if self.mediator:
            self.mediator.notify(self, "username_changed")
   
    def get_text(self):
        return self._text

#
dialog = DialogMediator()

login_btn = Button()
username_input = TextInput()
password_input = TextInput()

dialog.login_button = login_btn
dialog.username_input = username_input
dialog.password_input = password_input

login_btn.set_mediator(dialog)
username_input.set_mediator(dialog)
password_input.set_mediator(dialog)

#
username_input.set_text("user123")
password_input.set_text("pass123")
login_btn.click()

class OrderMediator:
    def __init__(self):
        self.inventory_system = None
        self.payment_system = None
        self.shipping_system = None
        self.notification_system = None
   
    def place_order(self, order_data):
        print("=== ===")
       
        #
        if not self.inventory_system.check_stock(order_data):
            return ""
       
        #
        payment_result = self.payment_system.process_payment(order_data)
        if not payment_result:
            return ""
       
        #
        self.inventory_system.update_stock(order_data)
       
        #
        shipping_info = self.shipping_system.schedule_delivery(order_data)
       
        #
        self.notification_system.send_confirmation(order_data, shipping_info)
       
        return ""

class InventorySystem:
    def check_stock(self, order_data):
        print("...")
        return True
   
    def update_stock(self, order_data):
        print("...")

class PaymentSystem:
    def process_payment(self, order_data):
        print("...")
        return True

class ShippingSystem:
    def schedule_delivery(self, order_data):
        print("...")
        return ": SF123456789"

class NotificationSystem:
    def send_confirmation(self, order_data, shipping_info):
        print(f": {shipping_info}")

#
mediator = OrderMediator()

mediator.inventory_system = InventorySystem()
mediator.payment_system = PaymentSystem()
mediator.shipping_system = ShippingSystem()
mediator.notification_system = NotificationSystem()

order_data = {"product_id": "123", "quantity": 2, "user_id": "user001"}
result = mediator.place_order(order_data)
print(f": {result}")

class UserRegistrationMediator:
    def notify(self, sender, event, data):
        if event == "user_registered":
            #
            self.send_welcome_email(data)
            self.create_user_profile(data)
            self.add_to_mailing_list(data)

class OrderProcessingMediator:
    def notify(self, sender, event, data):
        if event == "order_created":
            #
            self.validate_order(data)
            self.process_payment(data)
            self.update_inventory(data)

# -
class ComplexMediator:
    def handle_event(self, event_type, data):
        if event_type == "user_action":
            # ...
            pass
        elif event_type == "system_event":
            # ...
            pass

# -
class EventHandler:
    def handle(self, data):
        pass

class UserActionHandler(EventHandler):
    def handle(self, data):
        #
        pass

class SimpleMediator:
    def __init__(self):
        self.handlers = {}
   
    def register_handler(self, event_type, handler):
        self.handlers[event_type] = handler
   
    def notify(self, event_type, data):
        if event_type in self.handlers:
            self.handlers[event_type].handle(data)

from abc import ABC, abstractmethod
from typing import List

class Observer(ABC):
    @abstractmethod
    def update(self, event, data):
        pass

class Observable:
    def __init__(self):
        self._observers: List[Observer] = []
   
    def add_observer(self, observer):
        self._observers.append(observer)
   
    def notify_observers(self, event, data=None):
        for observer in self._observers:
            observer.update(event, data)

class ChatMediator(Observable):
    def send_message(self, message, sender, receiver=None):
        #
        event_data = {
            "message": message,
            "sender": sender,
            "receiver": receiver
        }
        self.notify_observers("message_sent", event_data)

class LoggingObserver(Observer):
    def update(self, event, data):
        if event == "message_sent":
            print(f": {data['sender']} ")