Native Python Programing

데이터 카드를 패키지 형태로 압축 및 해제하는 기능을 제공하는 코드를 작성할 수 있습니다. 여기서는 zipfile 모듈을 사용하여 데이터를 .zip 파일로 압축하고, 필요 시 이를 해제하는 방식으로 구현합니다.

데이터카드 패키지 압축 및 해제 코드

import os
import json
import zipfile
from datetime import datetime


class DataCard:
    """데이터 카드 클래스"""
    def __init__(self, name, data, metadata=None):
        self.name = name
        self.data = data
        self.metadata = metadata or {
            "created_at": datetime.now().isoformat(),
            "description": "Default data card metadata."
        }

    def to_dict(self):
        """데이터카드를 딕셔너리로 변환"""
        return {
            "name": self.name,
            "data": self.data,
            "metadata": self.metadata,
        }

    @staticmethod
    def from_dict(data_dict):
        """딕셔너리로부터 데이터카드 생성"""
        return DataCard(
            name=data_dict["name"],
            data=data_dict["data"],
            metadata=data_dict["metadata"]
        )


class DataCardPackage:
    """데이터 카드 패키지 압축 및 해제 클래스"""
    @staticmethod
    def compress(data_cards, output_path):
        """데이터 카드를 ZIP 패키지로 압축"""
        with zipfile.ZipFile(output_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
            for index, card in enumerate(data_cards):
                card_name = f"card_{index + 1}.json"
                card_content = json.dumps(card.to_dict(), indent=4)
                zipf.writestr(card_name, card_content)
        print(f"Data cards compressed into: {output_path}")

    @staticmethod
    def decompress(zip_path, extract_path):
        """ZIP 패키지를 해제하여 데이터카드 목록 반환"""
        data_cards = []
        with zipfile.ZipFile(zip_path, 'r') as zipf:
            zipf.extractall(extract_path)
            for file_name in zipf.namelist():
                file_path = os.path.join(extract_path, file_name)
                with open(file_path, 'r') as file:
                    card_dict = json.load(file)
                    data_cards.append(DataCard.from_dict(card_dict))
        print(f"Data cards extracted to: {extract_path}")
        return data_cards


# 사용 예제
if __name__ == "__main__":
    # 데이터 카드 생성
    card1 = DataCard(name="Card1", data={"key1": "value1", "key2": "value2"})
    card2 = DataCard(name="Card2", data={"keyA": "valueA", "keyB": "valueB"})

    # 데이터 카드 압축
    cards = [card1, card2]
    output_zip = "data_cards.zip"
    DataCardPackage.compress(cards, output_zip)

    # 압축 해제
    extract_dir = "extracted_cards"
    os.makedirs(extract_dir, exist_ok=True)
    extracted_cards = DataCardPackage.decompress(output_zip, extract_dir)

    # 해제된 데이터카드 출력
    for card in extracted_cards:
        print(f"Name: {card.name}, Data: {card.data}, Metadata: {card.metadata}")

코드 설명

1. DataCard 클래스:
   • 데이터를 표현하는 기본 데이터카드 객체.
   • 데이터카드를 딕셔너리로 변환하는 to_dict 메서드와, 딕셔너리로부터 데이터카드를 생성하는 from_dict 메서드 제공.
2. DataCardPackage 클래스:
   • 데이터카드 압축(compress) 및 해제(decompress) 기능을 포함.
   • 압축 시 데이터카드를 JSON 파일 형태로 변환하여 .zip 파일로 저장.
   • 해제 시 .zip 파일에서 JSON 파일을 읽고, 이를 DataCard 객체로 변환.
3. 사용 예제:
   • 두 개의 데이터카드를 생성하고 이를 data_cards.zip 파일로 압축.
   • 압축된 파일을 해제하여 원래의 데이터카드를 복원.

실행 결과 (예시):

압축 완료 메시지:

Data cards compressed into: data_cards.zip

해제 완료 메시지:

Data cards extracted to: extracted_cards

복원된 데이터카드 출력:

Name: Card1, Data: {'key1': 'value1', 'key2': 'value2'}, Metadata: {'created_at': '2025-01-07T12:00:00.123456', 'description': 'Default data card metadata.'}
Name: Card2, Data: {'keyA': 'valueA', 'keyB': 'valueB'}, Metadata: {'created_at': '2025-01-07T12:00:00.123456', 'description': 'Default data card metadata.'}

주요 기능

• 데이터카드 압축:
  • 여러 데이터카드를 .zip 파일로 묶어 관리.
  • JSON 형식으로 저장하여 직관적인 데이터 구조 유지.
• 데이터카드 해제:
  • .zip 파일에서 데이터를 복원하고, 데이터카드 객체로 재생성.
• 유연한 메타데이터 관리:
  • 각 데이터카드는 생성 시간 등 메타데이터를 포함.

이 코드는 데이터카드를 저장하고 전송하거나, 대규모 데이터 관리에 활용할 수 있는 실용적인 방법을 제공합니다.

메타클래스를 사용하여 사용자 정의 예외 클래스를 생성하면, 공통적인 동작이나 속성을 예외 클래스에 자동으로 추가할 수 있습니다. 이를 통해 예외 메시지 형식을 통일하거나, 추가적인 메타데이터를 포함하는 예외 클래스를 손쉽게 관리할 수 있습니다.

사용자 정의 예외 메타클래스 코드

class ExceptionMeta(type):
    """메타클래스를 사용하여 공통 동작을 추가하는 사용자 정의 예외 클래스"""
    def __new__(cls, name, bases, dct):
        # 공통 속성 추가
        dct.setdefault("default_message", "An error occurred.")
        dct.setdefault("error_code", 1000)
        return super().__new__(cls, name, bases, dct)

    def __call__(cls, *args, **kwargs):
        """인스턴스 생성 시 메시지 형식을 통일"""
        instance = super().__call__(*args, **kwargs)
        if not hasattr(instance, "formatted_message"):
            instance.formatted_message = f"[{cls.error_code}] {instance.args[0] if instance.args else cls.default_message}"
        return instance

class CustomException(Exception, metaclass=ExceptionMeta):
    """기본 사용자 정의 예외 클래스"""
    pass

class ValidationError(CustomException):
    """검증 오류"""
    default_message = "Validation failed."
    error_code = 2001

class DatabaseError(CustomException):
    """데이터베이스 오류"""
    default_message = "A database error occurred."
    error_code = 3001

# 사용 예제
if __name__ == "__main__":
    try:
        raise ValidationError("Invalid data provided.")
    except ValidationError as e:
        print(f"ValidationError caught: {e.formatted_message}")

    try:
        raise DatabaseError()
    except DatabaseError as e:
        print(f"DatabaseError caught: {e.formatted_message}")

    try:
        raise CustomException()
    except CustomException as e:
        print(f"CustomException caught: {e.formatted_message}")

코드 설명

1. ExceptionMeta 메타클래스:
   • **default_message**와 **error_code**를 기본적으로 예외 클래스에 추가.
   • __call__ 메서드를 재정의하여 예외 인스턴스를 생성할 때 메시지 형식을 통일.
   • 각 예외 클래스에서 별도로 정의하지 않으면 default_message와 error_code가 기본값으로 사용됨.
2. CustomException:
   • 모든 사용자 정의 예외 클래스의 기본 클래스.
   • ExceptionMeta 메타클래스를 사용하여 공통 속성과 동작을 상속받음.
3. 파생 클래스 (ValidationError, DatabaseError):
   • 각 예외 클래스는 default_message와 error_code를 재정의하여 고유한 정보를 제공.
4. 사용 예제:
   • ValidationError와 DatabaseError를 각각 생성하며 메시지를 출력.
   • 기본 CustomException도 동일한 방식으로 동작.

실행 결과 (예시):

ValidationError caught: [2001] Invalid data provided.
DatabaseError caught: [3001] A database error occurred.
CustomException caught: [1000] An error occurred.

주요 기능

• 공통 속성 관리: default_message와 error_code를 메타클래스를 통해 자동으로 추가.
• 통일된 메시지 형식: 예외 메시지가 자동으로 포맷팅되어 관리 용이.
• 확장성: 새로운 예외 클래스가 메타클래스의 공통 동작을 쉽게 상속받을 수 있음.

이 코드는 애플리케이션의 다양한 예외 상황을 통일된 방식으로 처리하고, 개발 및 디버깅을 쉽게 하는 데 유용합니다.

데이터 카드에 푸터 카드를 생성하기 위한 메타클래스를 작성하여 클래스가 정의될 때 자동으로 공통 푸터 정보를 설정하도록 할 수 있습니다. 푸터는 일반적으로 데이터에 대한 요약 정보나 최종 수정 기록을 포함하는 데 사용됩니다.

푸터 카드 메타클래스 코드

from datetime import datetime

class FooterMeta(type):
    """푸터 카드를 생성하는 메타클래스"""
    def __new__(cls, name, bases, dct):
        # 푸터 정보 기본값 추가
        dct.setdefault("__footer__", {
            "last_updated": datetime.now(),
            "summary": f"Default footer for {name}.",
        })
        return super().__new__(cls, name, bases, dct)

    def update_footer(cls, key, value):
        """푸터 정보 업데이트"""
        if "__footer__" in cls.__dict__:
            cls.__footer__[key] = value
            cls.__footer__["last_updated"] = datetime.now()  # 마지막 업데이트 시간 갱신
        else:
            raise AttributeError("Footer not defined in the class.")

    def get_footer(cls):
        """푸터 정보 가져오기"""
        return cls.__footer__

class DataCard(metaclass=FooterMeta):
    """푸터 카드를 포함하는 데이터 카드"""
    def __init__(self, name, data):
        self.name = name
        self.data = data

    def display(self):
        """데이터 카드 정보 출력"""
        print(f"Data Card: {self.name}")
        print(f"Data: {self.data}")

    @classmethod
    def display_footer(cls):
        """푸터 정보 출력"""
        print("Footer Information:")
        for key, value in cls.__footer__.items():
            print(f"  {key}: {value}")

# 사용 예제
if __name__ == "__main__":
    # 기본 푸터 확인
    print("Default Footer:")
    DataCard.display_footer()

    # 푸터 업데이트
    DataCard.update_footer("summary", "This is a summary of the data card.")
    DataCard.update_footer("notes", "Footer metadata added.")

    print("\nUpdated Footer:")
    DataCard.display_footer()

    # 데이터 카드 생성
    card = DataCard(name="Sample Data", data={"key": "value"})
    print("\nCard Details:")
    card.display()

코드 설명

1. FooterMeta 메타클래스:
   • 클래스 정의 시 __footer__라는 공통 푸터를 자동으로 생성.
   • 기본 푸터는 마지막 업데이트 시간(last_updated)과 간단한 요약(summary)을 포함.
   • update_footer 메서드: 푸터의 특정 항목을 수정하고, 마지막 업데이트 시간을 자동 갱신.
   • get_footer 메서드: 현재 클래스의 푸터 정보를 반환.
2. DataCard 클래스:
   • FooterMeta 메타클래스를 기반으로 작성된 데이터 카드 클래스.
   • 클래스 수준에서 푸터 정보를 관리하며, 인스턴스 데이터와는 분리.
3. 사용 예제:
   • 기본 푸터를 확인하고, update_footer 메서드를 사용하여 푸터 값을 수정.
   • 데이터 카드를 생성하여 데이터와 푸터를 각각 출력.

실행 결과 (예시):

Default Footer:
Footer Information:
  last_updated: 2025-01-07 12:00:00.123456
  summary: Default footer for DataCard.

Updated Footer:
Footer Information:
  last_updated: 2025-01-07 12:01:00.123456
  summary: This is a summary of the data card.
  notes: Footer metadata added.

Card Details:
Data Card: Sample Data
Data: {'key': 'value'}

주요 기능

• 푸터 자동 생성: 클래스 정의 시 기본 푸터가 자동으로 설정.
• 푸터 업데이트 가능: 클래스 수준에서 푸터 정보를 동적으로 수정 가능.
• 자동 갱신: 푸터가 업데이트될 때 마지막 수정 시간이 자동으로 갱신.
• 클래스와 인스턴스 데이터 분리: 푸터는 클래스 수준에서 관리하며, 인스턴스 데이터와 독립적.

이 메타클래스는 데이터 카드에 공통적인 요약 정보나 변경 기록을 추가하여 관리하는 데 적합하며, 클래스의 관리 효율성을 높여줍니다.

데이터 카드에 헤더 카드를 생성하기 위한 메타클래스를 작성하여, 클래스가 정의될 때 자동으로 공통 헤더 정보를 설정하도록 할 수 있습니다. 아래는 헤더 카드 목적의 메타클래스를 구현한 샘플 코드입니다.

헤더 카드 메타클래스 코드

from datetime import datetime

class HeaderMeta(type):
    """헤더 카드를 생성하는 메타클래스"""
    def __new__(cls, name, bases, dct):
        # 헤더 정보 기본값 추가
        dct.setdefault("__header__", {
            "author": "Unknown",
            "version": "1.0",
            "created_at": datetime.now(),
            "description": f"{name} description not provided.",
        })
        return super().__new__(cls, name, bases, dct)

    def set_header(cls, key, value):
        """헤더 정보 설정"""
        if "__header__" in cls.__dict__:
            cls.__header__[key] = value
        else:
            raise AttributeError("Header not defined in the class.")

    def get_header(cls):
        """헤더 정보 가져오기"""
        return cls.__header__

class DataCard(metaclass=HeaderMeta):
    """헤더 카드를 포함하는 데이터 카드"""
    def __init__(self, name, data):
        self.name = name
        self.data = data

    def display(self):
        """데이터 카드 정보 출력"""
        print(f"Data Card: {self.name}")
        print(f"Data: {self.data}")

    @classmethod
    def display_header(cls):
        """헤더 정보 출력"""
        print("Header Information:")
        for key, value in cls.__header__.items():
            print(f"  {key}: {value}")

# 사용 예제
if __name__ == "__main__":
    # 기본 헤더 자동 설정
    print("Default Header:")
    DataCard.display_header()

    # 헤더 수정
    DataCard.set_header("author", "John Doe")
    DataCard.set_header("description", "A general-purpose data card.")
    DataCard.set_header("version", "2.0")

    print("\nUpdated Header:")
    DataCard.display_header()

    # 데이터 카드 생성
    card = DataCard(name="Sample Data", data={"key": "value"})
    print("\nCard Details:")
    card.display()

코드 설명

1. HeaderMeta 메타클래스:
   • 클래스 정의 시 __header__라는 공통 헤더를 자동으로 생성.
   • __header__ 기본값에는 작성자, 버전, 생성 시간, 설명 등을 포함.
   • set_header 메서드: 헤더 값을 업데이트할 수 있음.
   • get_header 메서드: 현재 클래스의 헤더 정보를 반환.
2. DataCard 클래스:
   • HeaderMeta 메타클래스를 기반으로 작성된 데이터 카드 클래스.
   • 클래스 수준에서 헤더 정보를 관리하며, 인스턴스 수준의 데이터와는 분리.
3. 사용 예제:
   • 기본 헤더를 확인하고, set_header 메서드를 사용하여 헤더 값을 수정.
   • 데이터 카드를 생성하여 데이터와 헤더를 각각 출력.

실행 결과 (예시):

Default Header:
Header Information:
  author: Unknown
  version: 1.0
  created_at: 2025-01-07 12:00:00.123456
  description: DataCard description not provided.

Updated Header:
Header Information:
  author: John Doe
  version: 2.0
  created_at: 2025-01-07 12:00:00.123456
  description: A general-purpose data card.

Card Details:
Data Card: Sample Data
Data: {'key': 'value'}

주요 기능

• 헤더 자동 생성: 클래스 정의 시 기본 헤더가 자동으로 설정.
• 헤더 수정 가능: 클래스 수준에서 헤더 정보를 동적으로 수정 가능.
• 클래스와 인스턴스 데이터 분리: 헤더는 클래스 수준에서 관리하며, 인스턴스 데이터와 독립적.

이 메타클래스는 데이터 카드와 같은 객체의 공통 메타데이터(헤더 정보)를 관리하는 데 적합하며, 코드의 일관성을 유지하면서도 유연한 확장을 가능하게 합니다.

히스토리 메타클래스는 클래스의 모든 메서드 호출과 속성 변경을 추적하여 히스토리를 기록하는 데 사용할 수 있습니다. 아래는 히스토리 기록을 위해 메타클래스를 사용하는 샘플 코드입니다.

히스토리 메타클래스 코드

from datetime import datetime
from functools import wraps

class HistoryMeta(type):
    """히스토리를 기록하는 메타클래스"""
    def __new__(cls, name, bases, dct):
        # 히스토리 저장용 리스트 추가
        dct.setdefault('__history__', [])

        # 기존 메서드 래핑
        for attr_name, attr_value in dct.items():
            if callable(attr_value) and not attr_name.startswith("__"):
                dct[attr_name] = cls.wrap_method(attr_name, attr_value)

        # 속성 설정 감시
        dct['__setattr__'] = cls.wrap_setattr(dct.get('__setattr__', object.__setattr__))
        return super().__new__(cls, name, bases, dct)

    @staticmethod
    def wrap_method(method_name, method):
        """메서드를 래핑하여 호출 기록 추가"""
        @wraps(method)
        def wrapped_method(self, *args, **kwargs):
            # 히스토리 추가
            entry = {
                "timestamp": datetime.now(),
                "action": "method_call",
                "method": method_name,
                "args": args,
                "kwargs": kwargs,
            }
            self.__history__.append(entry)
            return method(self, *args, **kwargs)
        return wrapped_method

    @staticmethod
    def wrap_setattr(original_setattr):
        """속성 설정을 래핑하여 변경 기록 추가"""
        def wrapped_setattr(self, key, value):
            if not key.startswith("__history__") and hasattr(self, '__history__'):
                entry = {
                    "timestamp": datetime.now(),
                    "action": "attribute_change",
                    "attribute": key,
                    "new_value": value,
                }
                self.__history__.append(entry)
            original_setattr(self, key, value)
        return wrapped_setattr

    def get_history(cls):
        """클래스의 히스토리 반환"""
        return cls.__dict__.get('__history__', [])

class HistoryEnabledClass(metaclass=HistoryMeta):
    """히스토리 메타클래스를 사용하는 클래스"""
    def __init__(self, name):
        self.name = name

    def update_name(self, new_name):
        self.name = new_name

    def display_name(self):
        print(f"Name: {self.name}")

# 사용 예제
if __name__ == "__main__":
    obj = HistoryEnabledClass("Initial Name")
    obj.display_name()

    obj.update_name("Updated Name")
    obj.display_name()

    # 속성 직접 변경
    obj.name = "Directly Updated Name"

    # 히스토리 출력
    print("\nHistory:")
    for entry in obj.__history__:
        print(entry)

코드 설명

1. HistoryMeta 메타클래스:
   • __new__: 클래스의 모든 메서드와 속성 설정 메서드를 래핑하여 히스토리를 기록할 수 있도록 수정.
   • wrap_method: 메서드를 래핑하여 호출 시 호출 정보(메서드 이름, 인수 등)를 히스토리에 기록.
   • wrap_setattr: 속성 설정을 감지하여 속성 변경 정보를 히스토리에 기록.
2. HistoryEnabledClass:
   • HistoryMeta 메타클래스를 사용하는 클래스.
   • 메서드 호출 및 속성 변경이 자동으로 기록됨.
3. 사용 예제:
   • display_name 및 update_name 메서드를 호출하고 속성을 직접 수정한 뒤, 히스토리를 출력.

실행 결과 (예시):

Name: Initial Name
Name: Updated Name

History:
{'timestamp': datetime.datetime(2025, 1, 7, 12, 0, 0, 123456), 'action': 'method_call', 'method': 'display_name', 'args': (), 'kwargs': {}}
{'timestamp': datetime.datetime(2025, 1, 7, 12, 0, 1, 123456), 'action': 'method_call', 'method': 'update_name', 'args': ('Updated Name',), 'kwargs': {}}
{'timestamp': datetime.datetime(2025, 1, 7, 12, 0, 2, 123456), 'action': 'method_call', 'method': 'display_name', 'args': (), 'kwargs': {}}
{'timestamp': datetime.datetime(2025, 1, 7, 12, 0, 3, 123456), 'action': 'attribute_change', 'attribute': 'name', 'new_value': 'Directly Updated Name'}

주요 기능

• 메서드 호출 기록: 메서드 이름, 인수, 호출 시간 등을 기록.
• 속성 변경 기록: 변경된 속성 이름, 새 값, 변경 시간 등을 기록.
• 중앙화된 히스토리 관리: 클래스 수준에서 모든 변경 사항을 추적 가능.

이 코드는 디버깅, 로깅, 변경 추적 등을 자동화하는 데 유용하며, 클래스의 동작 이력을 투명하게 관리할 수 있습니다.

히스토리 보조 카드는 데이터 카드의 변경 이력을 기록하여 추적할 수 있는 구조입니다. 이를 구현하기 위해 각 데이터 카드의 변경 사항(예: 설명 변경, 태그 추가/삭제)을 기록하고 조회할 수 있는 기능을 포함한 클래스를 작성했습니다.

히스토리 보조 카드 샘플 코드

from datetime import datetime
from typing import List, Dict, Any

class HistoryEntry:
    """히스토리 항목 클래스"""
    def __init__(self, action: str, details: Dict[str, Any]):
        self.timestamp = datetime.now()
        self.action = action
        self.details = details

    def __str__(self):
        details_str = ", ".join(f"{key}={value}" for key, value in self.details.items())
        return f"[{self.timestamp}] Action: {self.action}, Details: {details_str}"

class DataCardWithHistory:
    """히스토리 기능을 가진 데이터 카드"""
    def __init__(self, name: str, description: str, tags: List[str] = None):
        self.name = name
        self.description = description
        self.tags = tags or []
        self.created_at = datetime.now()
        self.updated_at = datetime.now()
        self.history: List[HistoryEntry] = []  # 히스토리 리스트
        self._add_history("create", {"name": self.name, "description": self.description, "tags": self.tags})

    def _add_history(self, action: str, details: Dict[str, Any]):
        """히스토리 추가"""
        self.history.append(HistoryEntry(action, details))

    def update_description(self, new_description: str):
        """설명 업데이트"""
        old_description = self.description
        self.description = new_description
        self.updated_at = datetime.now()
        self._add_history("update_description", {"old": old_description, "new": new_description})

    def add_tag(self, tag: str):
        """태그 추가"""
        if tag not in self.tags:
            self.tags.append(tag)
            self.updated_at = datetime.now()
            self._add_history("add_tag", {"tag": tag})

    def remove_tag(self, tag: str):
        """태그 삭제"""
        if tag in self.tags:
            self.tags.remove(tag)
            self.updated_at = datetime.now()
            self._add_history("remove_tag", {"tag": tag})

    def display_history(self):
        """히스토리 출력"""
        print(f"History for Data Card '{self.name}':")
        for entry in self.history:
            print(entry)

    def display(self):
        """데이터 카드 정보 출력"""
        print(f"Data Card: {self.name}")
        print(f"Description: {self.description}")
        print(f"Created At: {self.created_at}")
        print(f"Updated At: {self.updated_at}")
        print(f"Tags: {', '.join(self.tags)}")

# 사용 예제
if __name__ == "__main__":
    # 데이터 카드 생성
    card = DataCardWithHistory(name="Customer Data", description="Contains customer demographics.", tags=["customer", "demographics"])
    
    # 데이터 카드 업데이트
    card.update_description("Updated customer demographic data.")
    card.add_tag("analytics")
    card.remove_tag("demographics")

    # 데이터 카드 정보 출력
    print("Current Data Card:")
    card.display()

    # 히스토리 출력
    print("\nChange History:")
    card.display_history()

코드 설명

1. HistoryEntry 클래스:
   • 각 변경 사항을 기록하는 클래스.
   • action: 변경 작업의 이름(예: update_description, add_tag).
   • details: 변경 작업에 대한 추가 정보(예: 이전 값과 새 값).
2. DataCardWithHistory 클래스:
   • 히스토리를 기록하고 관리하는 데이터 카드.
   • _add_history: 히스토리 항목을 추가하는 내부 메서드.
   • 주요 메서드(update_description, add_tag, remove_tag)에서 변경 사항을 히스토리에 자동으로 기록.
3. 사용 예제:
   • 데이터 카드 생성 후 설명 업데이트, 태그 추가/삭제.
   • 현재 데이터 카드 상태와 히스토리 출력.

실행 결과 (예시):

Current Data Card:
Data Card: Customer Data
Description: Updated customer demographic data.
Created At: 2025-01-07 12:00:00.123456
Updated At: 2025-01-07 12:01:00.123456
Tags: customer, analytics

Change History:
[2025-01-07 12:00:00.123456] Action: create, Details: name=Customer Data, description=Contains customer demographics., tags=['customer', 'demographics']
[2025-01-07 12:01:00.123456] Action: update_description, Details: old=Contains customer demographics., new=Updated customer demographic data.
[2025-01-07 12:01:10.123456] Action: add_tag, Details: tag=analytics
[2025-01-07 12:01:20.123456] Action: remove_tag, Details: tag=demographics

주요 기능

• 데이터 카드의 변경 내역을 자동으로 기록.
• 변경 내역을 손쉽게 출력 가능.
• 데이터 변경이 언제, 어떻게 이루어졌는지 추적 가능.

이 코드는 변경 이력을 저장하여 데이터 카드의 투명성을 높이고, 데이터 변경의 추적 가능성을 보장합니다.

아래는 데이터 카드를 관리하기 위한 데이터 카드 컨테이너를 구현한 사용자 정의 클래스의 샘플 코드입니다. 이 클래스는 여러 데이터 카드를 저장하고, 검색 및 필터링 등의 기능을 제공합니다.

from datetime import datetime
from typing import List, Optional, Dict

class DataCard:
    """데이터 카드 클래스"""
    def __init__(self, name: str, description: str, tags: Optional[List[str]] = None):
        self.name = name
        self.description = description
        self.created_at = datetime.now()
        self.updated_at = datetime.now()
        self.tags = tags or []

    def update_description(self, new_description: str):
        self.description = new_description
        self.updated_at = datetime.now()

    def add_tag(self, tag: str):
        if tag not in self.tags:
            self.tags.append(tag)
            self.updated_at = datetime.now()

    def remove_tag(self, tag: str):
        if tag in self.tags:
            self.tags.remove(tag)
            self.updated_at = datetime.now()

    def display(self):
        print(f"Data Card: {self.name}")
        print(f"Description: {self.description}")
        print(f"Created At: {self.created_at}")
        print(f"Updated At: {self.updated_at}")
        print(f"Tags: {', '.join(self.tags)}")

class DataCardContainer:
    """데이터 카드 컨테이너 클래스"""
    def __init__(self):
        self.cards: List[DataCard] = []

    def add_card(self, card: DataCard):
        """컨테이너에 데이터 카드 추가"""
        if any(existing_card.name == card.name for existing_card in self.cards):
            raise ValueError(f"A card with the name '{card.name}' already exists.")
        self.cards.append(card)

    def remove_card(self, card_name: str):
        """컨테이너에서 데이터 카드 삭제"""
        self.cards = [card for card in self.cards if card.name != card_name]

    def get_card(self, card_name: str) -> Optional[DataCard]:
        """이름으로 데이터 카드 검색"""
        for card in self.cards:
            if card.name == card_name:
                return card
        return None

    def filter_by_tag(self, tag: str) -> List[DataCard]:
        """특정 태그를 포함한 데이터 카드 필터링"""
        return [card for card in self.cards if tag in card.tags]

    def display_all(self):
        """모든 데이터 카드 출력"""
        if not self.cards:
            print("No data cards available.")
        for card in self.cards:
            card.display()
            print("-" * 40)

# 사용 예제
if __name__ == "__main__":
    # 데이터 카드 생성
    card1 = DataCard(name="Customer Data", description="Contains customer demographics.", tags=["customer", "demographics"])
    card2 = DataCard(name="Sales Data", description="Sales performance data.", tags=["sales", "performance"])
    card3 = DataCard(name="Survey Data", description="Customer feedback survey results.", tags=["survey", "feedback"])

    # 컨테이너 생성 및 카드 추가
    container = DataCardContainer()
    container.add_card(card1)
    container.add_card(card2)
    container.add_card(card3)

    # 모든 카드 출력
    print("All Data Cards:")
    container.display_all()

    # 특정 카드 검색
    print("\nSearching for 'Sales Data':")
    sales_card = container.get_card("Sales Data")
    if sales_card:
        sales_card.display()

    # 특정 태그로 필터링
    print("\nFiltering cards with tag 'customer':")
    customer_cards = container.filter_by_tag("customer")
    for card in customer_cards:
        card.display()

코드 설명

1. DataCard 클래스:
   • 각 데이터 카드를 표현하며 이름, 설명, 태그, 생성/수정 시간을 포함.
   • 태그 추가/삭제 및 설명 업데이트 기능 제공.
2. DataCardContainer 클래스:
   • 여러 데이터를 관리할 컨테이너로, 다음 주요 기능 포함:
     • 카드 추가: 이름이 중복되지 않도록 확인.
     • 카드 삭제: 이름으로 특정 카드를 삭제.
     • 카드 검색: 이름으로 특정 카드 반환.
     • 태그 필터링: 특정 태그를 포함한 카드 목록 반환.
     • 전체 출력: 저장된 모든 데이터 카드를 출력.
3. 사용 예제:
   • 세 개의 데이터 카드를 생성하고 컨테이너에 추가.
   • 모든 카드 출력, 특정 카드 검색, 특정 태그로 필터링.

실행 결과 (예시):

All Data Cards:
Data Card: Customer Data
Description: Contains customer demographics.
Created At: 2025-01-07 12:00:00.123456
Updated At: 2025-01-07 12:00:00.123456
Tags: customer, demographics
----------------------------------------
Data Card: Sales Data
Description: Sales performance data.
Created At: 2025-01-07 12:00:01.123456
Updated At: 2025-01-07 12:00:01.123456
Tags: sales, performance
----------------------------------------
Data Card: Survey Data
Description: Customer feedback survey results.
Created At: 2025-01-07 12:00:02.123456
Updated At: 2025-01-07 12:00:02.123456
Tags: survey, feedback
----------------------------------------

Searching for 'Sales Data':
Data Card: Sales Data
Description: Sales performance data.
Created At: 2025-01-07 12:00:01.123456
Updated At: 2025-01-07 12:00:01.123456
Tags: sales, performance

Filtering cards with tag 'customer':
Data Card: Customer Data
Description: Contains customer demographics.
Created At: 2025-01-07 12:00:00.123456
Updated At: 2025-01-07 12:00:00.123456
Tags: customer, demographics

이 클래스 구조는 여러 데이터 카드를 체계적으로 관리하고 쉽게 검색, 필터링, 업데이트할 수 있도록 설계되었습니다.

다음은 파이썬에서 데이터 카드(Data Card) 자료구조를 구현하고 메타정보를 표현하는 샘플 코드입니다. 이 코드는 데이터 카드의 주요 속성(예: 이름, 설명, 생성 날짜, 업데이트 날짜, 태그, 관련 데이터셋 정보 등)을 포함한 클래스를 정의하고 메타정보를 표현하는 방법을 보여줍니다.

from datetime import datetime
from typing import List, Dict, Optional

class DataCard:
    def __init__(
        self, 
        name: str, 
        description: str, 
        tags: Optional[List[str]] = None, 
        related_datasets: Optional[List[str]] = None, 
        metadata: Optional[Dict[str, str]] = None
    ):
        self.name = name
        self.description = description
        self.created_at = datetime.now()
        self.updated_at = datetime.now()
        self.tags = tags or []
        self.related_datasets = related_datasets or []
        self.metadata = metadata or {}

    def update_description(self, new_description: str):
        self.description = new_description
        self.updated_at = datetime.now()

    def add_tag(self, tag: str):
        if tag not in self.tags:
            self.tags.append(tag)
            self.updated_at = datetime.now()

    def remove_tag(self, tag: str):
        if tag in self.tags:
            self.tags.remove(tag)
            self.updated_at = datetime.now()

    def add_related_dataset(self, dataset_name: str):
        if dataset_name not in self.related_datasets:
            self.related_datasets.append(dataset_name)
            self.updated_at = datetime.now()

    def update_metadata(self, key: str, value: str):
        self.metadata[key] = value
        self.updated_at = datetime.now()

    def display(self):
        print(f"Data Card: {self.name}")
        print(f"Description: {self.description}")
        print(f"Created At: {self.created_at}")
        print(f"Updated At: {self.updated_at}")
        print(f"Tags: {', '.join(self.tags)}")
        print(f"Related Datasets: {', '.join(self.related_datasets)}")
        print(f"Metadata: {self.metadata}")

# Example Usage
if __name__ == "__main__":
    # Create a new data card
    card = DataCard(
        name="Customer Demographics",
        description="Contains customer demographic information for analysis.",
        tags=["demographics", "customer", "analytics"],
        related_datasets=["sales_data", "survey_results"],
        metadata={"owner": "Data Science Team", "source": "Internal Database"}
    )

    # Update description
    card.update_description("Updated demographic data for customer analysis.")

    # Add a new tag
    card.add_tag("updated")

    # Update metadata
    card.update_metadata("last_reviewed", "2025-01-07")

    # Display the data card
    card.display()

주요 기능

1. 메타정보 관리: metadata 딕셔너리를 통해 키-값 쌍으로 메타정보를 저장.
2. 업데이트 관리: created_at과 updated_at으로 생성 및 수정 시간을 기록.
3. 태그 관리: 태그 추가/삭제 기능 포함.
4. 관련 데이터셋: 관련 데이터셋 목록을 저장.

이 코드는 데이터 카드의 구조를 간단히 표현하며, 실제 구현에서는 사용자 정의 예외 처리, 데이터 검증 등이 추가될 수 있습니다.

게임에서 퀘스트와 관련된 데이터를 관리하기 위해 데이터 카드 자료구조를 사용할 수 있습니다. 퀘스트 맵 데이터 카드 자료구조는 각 퀘스트를 카드 형태로 저장하며, 이를 통해 퀘스트의 세부 정보를 체계적으로 관리할 수 있습니다. 카드에는 퀘스트의 ID, 이름, 설명, 보상, 상태 등을 포함하여 게임 플레이 중 퀘스트 정보를 쉽게 조회하고 업데이트할 수 있습니다.

퀘스트 맵 데이터 카드 자료구조 설명

퀘스트 데이터 카드는 다음과 같은 필드를 포함합니다.

1. 퀘스트 ID (quest_id): 퀘스트를 구분하는 고유 식별자
2. 퀘스트 이름 (name): 퀘스트의 이름
3. 퀘스트 설명 (description): 퀘스트의 목적과 수행 방법을 설명
4. 보상 (rewards): 퀘스트 완료 시 제공되는 보상 (경험치, 아이템 등)
5. 퀘스트 상태 (status): 현재 퀘스트의 상태 (예: Not Started, In Progress, Completed)
6. 메타데이터 (metadata): 퀘스트에 대한 추가 정보 (예: 퀘스트 난이도, 퀘스트 위치 등)

데이터 카드 관리 클래스

퀘스트 데이터를 카드 형태로 관리하는 클래스를 정의하고, 퀘스트를 추가, 업데이트, 필터링, 조회하는 기능을 추가합니다.

예제 코드: 퀘스트 맵 데이터 카드 자료구조

from typing import List, Dict

# 퀘스트 데이터 카드 모델 정의
class QuestMap(list):
    def add_quest(self, quest_id: str, name: str, description: str, rewards: Dict, status: str = "Not Started", metadata: Dict = None):
        # 퀘스트 카드 생성
        quest_card = {
            "quest_id": quest_id,
            "name": name,
            "description": description,
            "rewards": rewards,
            "status": status,
            "metadata": metadata or {}
        }
        self.append(quest_card)  # 리스트에 퀘스트 카드 추가

    def update_quest_status(self, quest_id: str, new_status: str):
        # 특정 퀘스트의 상태 업데이트
        for quest in self:
            if quest["quest_id"] == quest_id:
                quest["status"] = new_status
                return quest  # 업데이트된 퀘스트 카드 반환
        return None  # 해당 퀘스트가 없을 때 None 반환

    def filter_by_status(self, status: str) -> List[Dict]:
        # 특정 상태에 해당하는 퀘스트만 필터링하여 반환
        return [quest for quest in self if quest["status"] == status]

    def get_quest(self, quest_id: str) -> Dict:
        # 특정 ID의 퀘스트 카드 조회
        for quest in self:
            if quest["quest_id"] == quest_id:
                return quest
        return None  # 해당 ID의 퀘스트가 없을 때 None 반환

# 퀘스트 맵 인스턴스 생성
quest_map = QuestMap()

# 퀘스트 추가
quest_map.add_quest(
    quest_id="Q001",
    name="Find the Lost Sword",
    description="Retrieve the legendary sword lost in the Forbidden Forest.",
    rewards={"experience": 500, "items": ["Legendary Sword"]},
    metadata={"difficulty": "Hard", "location": "Forbidden Forest"}
)

quest_map.add_quest(
    quest_id="Q002",
    name="Defend the Village",
    description="Help the villagers defend their homes from the goblin invasion.",
    rewards={"experience": 300, "items": ["Healing Potion"]},
    metadata={"difficulty": "Medium", "location": "East Village"}
)

# 퀘스트 상태 업데이트
updated_quest = quest_map.update_quest_status("Q001", "In Progress")
print("Updated Quest:", updated_quest)

# 특정 상태의 퀘스트 필터링 (예: In Progress 상태)
in_progress_quests = quest_map.filter_by_status("In Progress")
print("In Progress Quests:", in_progress_quests)

# 특정 ID의 퀘스트 조회
quest_details = quest_map.get_quest("Q002")
print("Details of Quest Q002:", quest_details)

출력 예시

Updated Quest: {
    'quest_id': 'Q001', 'name': 'Find the Lost Sword', 'description': 'Retrieve the legendary sword lost in the Forbidden Forest.',
    'rewards': {'experience': 500, 'items': ['Legendary Sword']},
    'status': 'In Progress', 'metadata': {'difficulty': 'Hard', 'location': 'Forbidden Forest'}
}

In Progress Quests: [
    {'quest_id': 'Q001', 'name': 'Find the Lost Sword', 'description': 'Retrieve the legendary sword lost in the Forbidden Forest.',
     'rewards': {'experience': 500, 'items': ['Legendary Sword']}, 'status': 'In Progress', 'metadata': {'difficulty': 'Hard', 'location': 'Forbidden Forest'}}
]

Details of Quest Q002: {
    'quest_id': 'Q002', 'name': 'Defend the Village', 'description': 'Help the villagers defend their homes from the goblin invasion.',
    'rewards': {'experience': 300, 'items': ['Healing Potion']},
    'status': 'Not Started', 'metadata': {'difficulty': 'Medium', 'location': 'East Village'}
}

코드 설명

• add_quest 메서드: 새로운 퀘스트 카드를 생성하여 퀘스트 맵에 추가합니다.
• update_quest_status 메서드: quest_id를 통해 퀘스트를 찾고, new_status로 상태를 업데이트합니다.
• filter_by_status 메서드: 특정 상태에 해당하는 모든 퀘스트를 필터링하여 반환합니다.
• get_quest 메서드: 특정 quest_id에 해당하는 퀘스트 카드를 반환합니다.

이 구조의 장점

• 퀘스트 관리 효율성: 퀘스트 상태를 일괄 관리하고 필터링할 수 있어 관리가 용이합니다.
• 가독성: 퀘스트 데이터가 각각의 카드로 구성되어 있어 코드를 읽고 이해하기가 쉽습니다.
• 확장성: 새로운 필드를 추가하거나 필터링 조건을 다양하게 확장할 수 있어 게임 설계에 유연하게 대응할 수 있습니다.

이 구조는 게임 내 다양한 퀘스트를 효과적으로 관리하고, 플레이어가 진행 상황을 쉽게 파악할 수 있도록 돕습니다.

사용자 액션 히스토리를 저장하고 관리하기 위한 데이터 카드 자료구조를 만들어, 사용자 활동을 체계적으로 기록하고 조회할 수 있는 구조를 설계할 수 있습니다. 데이터 카드는 각 사용자 활동을 하나의 카드로 저장하며, 각각의 액션 카드에는 사용자 ID, 액션 유형, 타임스탬프, 메타데이터 등의 필수 정보를 포함합니다. 이를 통해 사용자 액션 데이터를 효율적으로 관리하고 분석할 수 있습니다.

사용자 액션 히스토리 데이터 카드 모델 설명

1. 데이터 카드 구조:

   • user_id: 사용자 식별 ID
   • action_type: 사용자가 수행한 동작의 유형 (예: 로그인, 로그아웃, 페이지 조회 등)
   • timestamp: 액션이 발생한 시간
   • metadata: 해당 액션에 대한 추가 정보 (예: 페이지 URL, 디바이스 정보, 위치 등)

2. 데이터 카드 관리 클래스:

   • 데이터를 카드 형식으로 관리하는 클래스입니다.
   • 각 카드에 필요한 필드를 포함하고, 액션 데이터를 필터링하거나 정렬하여 쉽게 조회할 수 있도록 합니다.

3. 조회 및 필터 기능:

   • 사용자의 특정 시간대나 액션 유형을 기준으로 히스토리를 필터링하는 메서드를 추가하여 유연한 조회를 지원합니다.

예제 코드: 사용자 액션 히스토리 저장을 위한 데이터 카드 구조

다음은 사용자 액션 히스토리를 카드로 관리하는 UserActionHistory 클래스를 정의하고, 액션 추가와 필터링 기능을 구현한 예제입니다.

from datetime import datetime
from typing import List, Dict

# 사용자 액션 히스토리 데이터 카드 모델 정의
class UserActionHistory(list):
    def add_action(self, user_id: str, action_type: str, timestamp: str, metadata: Dict = None):
        # 액션 카드 생성
        action_card = {
            "user_id": user_id,
            "action_type": action_type,
            "timestamp": datetime.strptime(timestamp, "%Y-%m-%d %H:%M:%S"),
            "metadata": metadata or {}
        }
        self.append(action_card)  # 리스트에 액션 카드 추가

    def filter_by_user(self, user_id: str) -> List[Dict]:
        # 특정 사용자의 액션만 필터링하여 반환
        return [action for action in self if action["user_id"] == user_id]

    def filter_by_action_type(self, action_type: str) -> List[Dict]:
        # 특정 액션 유형에 해당하는 카드만 필터링하여 반환
        return [action for action in self if action["action_type"] == action_type]

    def filter_by_time_range(self, start_time: str, end_time: str) -> List[Dict]:
        # 특정 시간 범위 내의 카드만 반환
        start = datetime.strptime(start_time, "%Y-%m-%d %H:%M:%S")
        end = datetime.strptime(end_time, "%Y-%m-%d %H:%M:%S")
        return [action for action in self if start <= action["timestamp"] <= end]

# 사용자 액션 히스토리 인스턴스 생성
user_actions = UserActionHistory()

# 액션 추가
user_actions.add_action("user001", "login", "2024-10-21 10:15:00", {"device": "mobile", "location": "Seoul"})
user_actions.add_action("user002", "view_page", "2024-10-21 11:00:00", {"page_url": "/home"})
user_actions.add_action("user001", "logout", "2024-10-21 11:30:00", {"device": "mobile"})
user_actions.add_action("user003", "login", "2024-10-22 09:00:00", {"device": "desktop", "location": "Busan"})

# 필터링 예제: 특정 사용자의 모든 액션
user1_actions = user_actions.filter_by_user("user001")
print("Actions for user001:", user1_actions)

# 필터링 예제: 특정 액션 유형 (페이지 조회)
view_page_actions = user_actions.filter_by_action_type("view_page")
print("View Page Actions:", view_page_actions)

# 필터링 예제: 특정 시간 범위 내 액션
time_filtered_actions = user_actions.filter_by_time_range("2024-10-21 09:00:00", "2024-10-21 12:00:00")
print("Actions between 2024-10-21 09:00:00 and 2024-10-21 12:00:00:", time_filtered_actions)

출력 예시

Actions for user001: [
    {'user_id': 'user001', 'action_type': 'login', 'timestamp': datetime.datetime(2024, 10, 21, 10, 15), 'metadata': {'device': 'mobile', 'location': 'Seoul'}},
    {'user_id': 'user001', 'action_type': 'logout', 'timestamp': datetime.datetime(2024, 10, 21, 11, 30), 'metadata': {'device': 'mobile'}}
]

View Page Actions: [
    {'user_id': 'user002', 'action_type': 'view_page', 'timestamp': datetime.datetime(2024, 10, 21, 11, 0), 'metadata': {'page_url': '/home'}}
]

Actions between 2024-10-21 09:00:00 and 2024-10-21 12:00:00: [
    {'user_id': 'user001', 'action_type': 'login', 'timestamp': datetime.datetime(2024, 10, 21, 10, 15), 'metadata': {'device': 'mobile', 'location': 'Seoul'}},
    {'user_id': 'user002', 'action_type': 'view_page', 'timestamp': datetime.datetime(2024, 10, 21, 11, 0), 'metadata': {'page_url': '/home'}},
    {'user_id': 'user001', 'action_type': 'logout', 'timestamp': datetime.datetime(2024, 10, 21, 11, 30), 'metadata': {'device': 'mobile'}}
]

코드 설명

• UserActionHistory 클래스: list를 상속하여 사용자 액션 히스토리 카드를 저장하고 관리하는 클래스를 생성합니다.
• add_action 메서드: 사용자 액션 정보를 포함하는 카드를 생성하고 리스트에 추가합니다.
• filter_by_user 메서드: 특정 user_id에 해당하는 모든 액션 카드를 필터링합니다.
• filter_by_action_type 메서드: 특정 action_type에 해당하는 모든 액션 카드를 필터링합니다.
• filter_by_time_range 메서드: 지정된 시간 범위 내에 발생한 모든 액션 카드를 필터링합니다.

이 구조의 장점

• 필터링 및 검색 기능 강화: 사용자별, 액션 유형별, 시간대별로 액션을 조회할 수 있어 사용자 행동을 유연하게 분석할 수 있습니다.
• 확장성: 새로운 필터 조건이 필요할 때 쉽게 추가할 수 있어 확장성이 뛰어납니다.
• 유연한 관리: metadata 필드를 통해 액션별 추가 정보를 쉽게 저장할 수 있습니다.

이 구조는 사용자 행동 분석, 웹사이트 방문 기록 분석, 사용자 활동 로그 관리 등 여러 상황에 적용할 수 있는 유연한 데이터 카드 모델을 제공합니다.