class LegacyLogger:
    def write_log(self, message):
        print(f"[LEGACY] {message}")

class NewLogger:
    def log(self, level, message):
        print(f"[{level.upper()}] {message}")

class LegacyLogger:
    """"""
    def write_log(self, message):
        print(f"[LEGACY] {message}")

class NewLoggerInterface:
    """"""
    def log(self, level, message):
        pass

class LoggerAdapter(NewLoggerInterface, LegacyLogger):
    """ - """
    def log(self, level, message):
        #
        formatted_message = f"{level}: {message}"
        self.write_log(formatted_message)

#
logger = LoggerAdapter()
logger.log("INFO", "")
logger.log("ERROR", "")

class LegacyPayment:
    """"""
    def process_payment(self, amount_in_dollars):
        print(f": ${amount_in_dollars}")
        return True

class NewPaymentInterface:
    """"""
    def pay(self, amount, currency="CNY"):
        pass

class PaymentAdapter(NewPaymentInterface):
    """ - """
   
    def __init__(self, legacy_payment):
        self.legacy_payment = legacy_payment
   
    def pay(self, amount, currency="CNY"):
        #
        if currency == "CNY":
            amount_in_dollars = amount / 7.0  #
        else:
            amount_in_dollars = amount
       
        #
        return self.legacy_payment.process_payment(amount_in_dollars)

#
legacy_payment = LegacyPayment()
payment = PaymentAdapter(legacy_payment)

#
payment.pay(700, "CNY")  # 700
payment.pay(100, "USD")  # 100

import json

class XMLData:
    """XML"""
    def get_xml_data(self):
        return """
        <users>
            <user>
                <name></name>
                <age>25</age>
            </user>
            <user>
                <name></name>
                <age>30</age>
            </user>
        </users>
        """

class JSONProcessor:
    """JSONJSON"""
    def process_json(self, json_data):
        data = json.loads(json_data)
        for user in data['users']:
            print(f": {user['name']}, : {user['age']}")

class XMLToJSONAdapter:
    """XMLJSON"""
   
    def __init__(self, xml_data):
        self.xml_data = xml_data
   
    def convert_to_json(self):
        # XMLJSON
        xml_content = self.xml_data.get_xml_data()
        # xml.etree.ElementTree
        json_data = {
            "users": [
                {"name": "", "age": 25},
                {"name": "", "age": 30}
            ]
        }
        return json.dumps(json_data, ensure_ascii=False)

#
xml_source = XMLData()
adapter = XMLToJSONAdapter(xml_source)
json_processor = JSONProcessor()

json_data = adapter.convert_to_json()
json_processor.process_json(json_data)

class WeChatPay:
    """SDK"""
    def wechat_pay(self, amount, user_id):
        print(f": {user_id}{amount}")
        return {"status": "success", "transaction_id": "wx_123456"}

class AliPay:
    """SDK"""
    def alipay(self, money, user_account):
        print(f": {user_account}{money}")
        return {"code": 200, "trade_no": "ali_789012"}

class UnifiedPaymentAdapter:
    """"""
   
    def __init__(self, payment_service):
        self.payment_service = payment_service
   
    def pay(self, amount, user_info):
        #
        if isinstance(self.payment_service, WeChatPay):
            return self.payment_service.wechat_pay(amount, user_info)
        elif isinstance(self.payment_service, AliPay):
            return self.payment_service.alipay(amount, user_info)
        else:
            raise ValueError("")

#
def process_order(payment_adapter, amount, user_info):
    """"""
    result = payment_adapter.pay(amount, user_info)
    print(f": {result}")
    return result

#
wechat_pay = WeChatPay()
ali_pay = AliPay()

wechat_adapter = UnifiedPaymentAdapter(wechat_pay)
ali_adapter = UnifiedPaymentAdapter(ali_pay)

#
process_order(wechat_adapter, 100, "user_001")
process_order(ali_adapter, 200, "user_002")

#
class DataFormatAdapter:
    """"""
    def convert_format(self, data):
        pass

#
class BadAdapter:
    """"""
    def convert_format(self, data):
        pass
   
    def validate_data(self, data):
        pass
   
    def cache_data(self, data):
        pass

from abc import ABC, abstractmethod

class PaymentInterface(ABC):
    """"""
    @abstractmethod
    def pay(self, amount, user_info):
        pass

class LoggerInterface(ABC):
    """"""
    @abstractmethod
    def log(self, level, message):
        pass

class AdapterFactory:
    """"""
   
    @staticmethod
    def create_payment_adapter(service_type):
        if service_type == "wechat":
            return UnifiedPaymentAdapter(WeChatPay())
        elif service_type == "alipay":
            return UnifiedPaymentAdapter(AliPay())
        else:
            raise ValueError(f": {service_type}")

#
wechat_adapter = AdapterFactory.create_payment_adapter("wechat")
ali_adapter = AdapterFactory.create_payment_adapter("alipay")

class CachingAdapter:
    """"""
   
    def __init__(self, adaptee):
        self.adaptee = adaptee
        self._cache = {}
   
    def process_data(self, key):
        if key not in self._cache:
            #
            result = self.adaptee.expensive_operation(key)
            self._cache[key] = result
        return self._cache[key]

class CSVReader:
    """CSV"""
    def read_csv(self, filepath):
        # CSV
        return [
            ["name", "age", "city"],
            ["Alice", "25", "Beijing"],
            ["Bob", "30", "Shanghai"]
        ]

class JSONExporter:
    """JSON"""
    def export_json(self, data):
        import json
        print("JSON:")
        print(json.dumps(data, indent=2, ensure_ascii=False))

# CSVToJSONAdapter
# ...

#
csv_reader = CSVReader()
json_exporter = JSONExporter()

#
adapter = CSVToJSONAdapter(csv_reader)
json_data = adapter.convert_to_json()
json_exporter.export_json(json_data)