import xml.etree.ElementTree as ET

# XML 문자열 파싱
xml_string = '''
<root>
    <person id="1">
        <name>홍길동</name>
        <age>30</age>
        <skills>
            <skill>Python</skill>
            <skill>Java</skill>
        </skills>
    </person>
    <person id="2">
        <name>김철수</name>
        <age>25</age>
        <skills>
            <skill>JavaScript</skill>
        </skills>
    </person>
</root>
'''

# 문자열에서 XML 파싱
root = ET.fromstring(xml_string)

# 특정 요소 접근
person = root.find('person')
print(f"이름: {person.find('name').text}")  # 이름: 홍길동
print(f"나이: {person.find('age').text}")   # 나이: 30

# 속성 접근
print(f"ID: {person.get('id')}")  # ID: 1

# 모든 person 요소 순회
for person in root.findall('person'):
    name = person.find('name').text
    age = person.find('age').text
    print(f"{name}({age}세)")

# 중첩된 요소 접근
for person in root.findall('person'):
    name = person.find('name').text
    skills = [skill.text for skill in person.findall('skills/skill')]
    print(f"{name}의 기술: {', '.join(skills)}")

import xml.etree.ElementTree as ET
import os

# XML 파일 읽기
def read_xml_file(file_path):
    if not os.path.exists(file_path):
        print(f"파일이 존재하지 않는다: {file_path}")
        return None
    
    try:
        tree = ET.parse(file_path)
        root = tree.getroot()
        return root
    except ET.ParseError as e:
        print(f"XML 파싱 오류: {e}")
        return None

# XML 파일 쓰기
def write_xml_file(root, file_path):
    tree = ET.ElementTree(root)
    
    # XML 선언과 인덴트 설정
    tree.write(file_path, 
               encoding='utf-8', 
               xml_declaration=True, 
               method='xml',
               short_empty_elements=False)
    
    # 참고: ElementTree는 들여쓰기를 지원하지 않음
    # 들여쓰기가 필요하면 추가 처리 필요

# 새 XML 문서 생성
def create_xml_document():
    # 루트 요소 생성
    root = ET.Element('library')
    
    # 첫 번째 책 추가
    book1 = ET.SubElement(root, 'book')
    book1.set('id', '1')
    book1.set('available', 'true')
    
    title1 = ET.SubElement(book1, 'title')
    title1.text = '파이썬 프로그래밍'
    
    author1 = ET.SubElement(book1, 'author')
    author1.text = '홍길동'
    
    year1 = ET.SubElement(book1, 'year')
    year1.text = '2023'
    
    # 두 번째 책 추가
    book2 = ET.SubElement(root, 'book')
    book2.set('id', '2')
    book2.set('available', 'false')
    
    title2 = ET.SubElement(book2, 'title')
    title2.text = 'XML 처리 기초'
    
    author2 = ET.SubElement(book2, 'author')
    author2.text = '김철수'
    
    year2 = ET.SubElement(book2, 'year')
    year2.text = '2022'
    
    return root

# 사용 예시
if __name__ == "__main__":
    # 새 XML 문서 생성
    library = create_xml_document()
    
    # 파일로 저장
    output_file = 'library.xml'
    write_xml_file(library, output_file)
    print(f"XML 파일이 생성되었다: {output_file}")
    
    # 저장된 파일 다시 읽기
    root = read_xml_file(output_file)
    if root is not None:
        print(f"루트 태그: {root.tag}")
        print(f"책 수: {len(root.findall('book'))}")

import xml.etree.ElementTree as ET

# 요소 생성과 속성 설정
def create_person(name, age, job=None, skills=None):
    """사람 정보를 담은 XML 요소 생성"""
    person = ET.Element('person')
    
    # 기본 속성 추가
    person.set('id', str(id(person))[-6:])  # 고유 ID 생성
    
    # 자식 요소 추가
    name_elem = ET.SubElement(person, 'name')
    name_elem.text = name
    
    age_elem = ET.SubElement(person, 'age')
    age_elem.text = str(age)
    
    # 선택적 요소 추가
    if job:
        job_elem = ET.SubElement(person, 'job')
        job_elem.text = job
    
    # 중첩 요소 구조 생성
    if skills and len(skills) > 0:
        skills_elem = ET.SubElement(person, 'skills')
        for skill in skills:
            skill_elem = ET.SubElement(skills_elem, 'skill')
            skill_elem.text = skill
    
    return person

# 요소 검색 및 수정
def modify_person(person_elem, new_age=None, new_job=None):
    """기존 person 요소 수정"""
    if new_age:
        age_elem = person_elem.find('age')
        if age_elem is not None:
            age_elem.text = str(new_age)
        else:
            age_elem = ET.SubElement(person_elem, 'age')
            age_elem.text = str(new_age)
    
    if new_job:
        job_elem = person_elem.find('job')
        if job_elem is not None:
            job_elem.text = new_job
        else:
            job_elem = ET.SubElement(person_elem, 'job')
            job_elem.text = new_job

# 요소 삭제
def remove_skill(person_elem, skill_name):
    """특정 스킬 요소 삭제"""
    skills_elem = person_elem.find('skills')
    if skills_elem is not None:
        for skill_elem in skills_elem.findall('skill'):
            if skill_elem.text == skill_name:
                skills_elem.remove(skill_elem)
                return True
    return False

# 요소 검색 및 필터링
def find_people_by_criteria(root, min_age=None, job=None, skill=None):
    """조건에 맞는 사람 요소 찾기"""
    results = []
    
    for person in root.findall('person'):
        # 나이 조건 확인
        if min_age is not None:
            age_elem = person.find('age')
            if age_elem is None or int(age_elem.text) < min_age:
                continue
        
        # 직업 조건 확인
        if job is not None:
            job_elem = person.find('job')
            if job_elem is None or job_elem.text != job:
                continue
        
        # 기술 조건 확인
        if skill is not None:
            skills_found = False
            for skill_elem in person.findall('.//skill'):
                if skill_elem.text == skill:
                    skills_found = True
                    break
            if not skills_found:
                continue
        
        # 모든 조건 만족
        results.append(person)
    
    return results

# 사용 예시
if __name__ == "__main__":
    # 루트 요소 생성
    root = ET.Element('people')
    
    # 사람 요소 추가
    p1 = create_person('홍길동', 30, 'developer', ['Python', 'JavaScript'])
    p2 = create_person('김철수', 25, 'designer', ['Photoshop'])
    p3 = create_person('이영희', 35, 'manager')
    
    root.append(p1)
    root.append(p2)
    root.append(p3)
    
    # 요소 수정
    modify_person(p1, new_age=31, new_job='senior developer')
    
    # 요소 삭제
    remove_skill(p1, 'JavaScript')
    
    # 조건 검색
    developers = find_people_by_criteria(root, job='senior developer')
    for dev in developers:
        print(f"개발자: {dev.find('name').text}, 나이: {dev.find('age').text}")

import xml.etree.ElementTree as ET
from lxml import etree  # 완전한 XPath 지원을 위해

# 샘플 XML 데이터
xml_data = '''
<company>
    <department name="개발팀">
        <employee id="1001" type="정규직">
            <name>홍길동</name>
            <position>선임 개발자</position>
            <salary currency="KRW">70000000</salary>
            <skills>
                <skill level="expert">Python</skill>
                <skill level="intermediate">Java</skill>
            </skills>
        </employee>
        <employee id="1002" type="계약직">
            <name>김철수</name>
            <position>주니어 개발자</position>
            <salary currency="KRW">50000000</salary>
            <skills>
                <skill level="intermediate">JavaScript</skill>
                <skill level="beginner">Python</skill>
            </skills>
        </employee>
    </department>
    <department name="디자인팀">
        <employee id="2001" type="정규직">
            <name>이영희</name>
            <position>UI 디자이너</position>
            <salary currency="KRW">65000000</salary>
        </employee>
    </department>
</company>
'''

# ElementTree와 lxml 모두로 파싱
root_et = ET.fromstring(xml_data)
root_lxml = etree.fromstring(xml_data.encode('utf-8'))

def xpath_examples_elementtree():
    """ElementTree의 제한된 XPath 기능 예시"""
    print("=== ElementTree XPath 예시 ===")
    
    # 1. 모든 employee 요소 찾기
    employees = root_et.findall('.//employee')
    print(f"직원 수: {len(employees)}")
    
    # 2. 특정 속성을 가진 요소 찾기
    regular_employees = root_et.findall(".//employee[@type='정규직']")
    print(f"정규직 직원 수: {len(regular_employees)}")
    
    # 3. 특정 부서의 직원 찾기
    dev_employees = root_et.findall("./department[@name='개발팀']/employee")
    print(f"개발팀 직원 수: {len(dev_employees)}")
    
    # 4. 모든 스킬 찾기
    skills = root_et.findall('.//skill')
    print(f"총 스킬 수: {len(skills)}")
    
    # 5. 이름으로 직원 찾기
    for emp in employees:
        if emp.find('name').text == '홍길동':
            print(f"홍길동의 직급: {emp.find('position').text}")

def xpath_examples_lxml():
    """lxml의 완전한 XPath 기능 예시"""
    print("\n=== lxml XPath 예시 ===")
    
    # 1. 급여가 6천만원 이상인 직원 찾기 (ElementTree에서는 불가능)
    high_salary = root_lxml.xpath(".//employee[number(salary) >= 60000000]")
    print(f"고액연봉 직원 수: {len(high_salary)}")
    for emp in high_salary:
        name = emp.xpath("./name/text()")[0]
        salary = emp.xpath("./salary/text()")[0]
        print(f"- {name}: {salary}원")
    
    # 2. Python 기술을 가진 직원 찾기
    python_devs = root_lxml.xpath(".//employee[.//skill='Python']")
    print(f"\nPython 개발자 수: {len(python_devs)}")
    for emp in python_devs:
        name = emp.xpath("./name/text()")[0]
        level = emp.xpath(".//skill[text()='Python']/@level")[0]
        print(f"- {name} (레벨: {level})")
    
    # 3. 직원 ID와 이름 함께 가져오기
    print("\n직원 목록:")
    for emp in root_lxml.xpath(".//employee"):
        emp_id = emp.get('id')
        name = emp.xpath("./name/text()")[0]
        position = emp.xpath("./position/text()")[0]
        print(f"- [{emp_id}] {name} ({position})")
    
    # 4. 직급에 '선임' 또는 '시니어'가 포함된 직원 찾기
    senior_staff = root_lxml.xpath(".//employee[contains(position, '선임') or contains(position, '시니어')]")
    print(f"\n선임급 직원 수: {len(senior_staff)}")
    for emp in senior_staff:
        print(f"- {emp.xpath('./name/text()')[0]}")
    
    # 5. 특정 부서의 평균 급여 계산
    dev_salaries = root_lxml.xpath(".//department[@name='개발팀']/employee/salary/text()")
    if dev_salaries:
        avg_salary = sum(float(salary) for salary in dev_salaries) / len(dev_salaries)
        print(f"\n개발팀 평균 급여: {avg_salary:,.0f}원")

# 실행
xpath_examples_elementtree()
xpath_examples_lxml()

import xmlschema
from lxml import etree
import os

# XSD 파일을 사용한 검증
def validate_with_xmlschema(xml_file, xsd_file):
    """xmlschema 라이브러리를 사용한 XML 검증"""
    try:
        schema = xmlschema.XMLSchema(xsd_file)
        is_valid = schema.is_valid(xml_file)
        
        if is_valid:
            print(f"XML 파일이 스키마에 유효하다: {xml_file}")
        else:
            print(f"XML 파일이 스키마에 유효하지 않다: {xml_file}")
            # 상세 오류 정보
            validator = schema.iter_errors(xml_file)
            for error in validator:
                print(f"- 오류: {error}")
                
        return is_valid
    except Exception as e:
        print(f"검증 과정에서 오류 발생: {e}")
        return False

# lxml을 사용한 검증
def validate_with_lxml(xml_file, xsd_file):
    """lxml 라이브러리를 사용한 XML 검증"""
    try:
        # 스키마 로드
        xmlschema_doc = etree.parse(xsd_file)
        xmlschema = etree.XMLSchema(xmlschema_doc)
        
        # XML 파일 로드
        xml_doc = etree.parse(xml_file)
        
        # 검증
        is_valid = xmlschema.validate(xml_doc)
        
        if is_valid:
            print(f"XML 파일이 스키마에 유효하다: {xml_file}")
        else:
            print(f"XML 파일이 스키마에 유효하지 않다: {xml_file}")
            # 상세 오류 정보
            log = xmlschema.error_log
            for error in log:
                print(f"- 줄 {error.line}, 열 {error.column}: {error.message}")
                
        return is_valid
    except Exception as e:
        print(f"검증 과정에서 오류 발생: {e}")
        return False

# XML 스키마(XSD) 예시
def create_sample_xsd():
    """샘플 XSD 파일 생성"""
    xsd_content = '''<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="employees">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="employee" maxOccurs="unbounded">
          <xs:complexType>
            <xs:sequence>
              <xs:element name="name" type="xs:string"/>
              <xs:element name="age" type="xs:positiveInteger"/>
              <xs:element name="department" type="xs:string"/>
              <xs:element name="position" type="xs:string" minOccurs="0"/>
            </xs:sequence>
            <xs:attribute name="id" type="xs:ID" use="required"/>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>
'''
    with open("employees.xsd", "w", encoding="utf-8") as f:
        f.write(xsd_content)
    return "employees.xsd"

# 유효한 XML 예시
def create_valid_xml():
    """XSD에 유효한 XML 파일 생성"""
    xml_content = '''<?xml version="1.0" encoding="UTF-8"?>
<employees>
  <employee id="e1">
    <name>홍길동</name>
    <age>30</age>
    <department>개발</department>
    <position>선임 개발자</position>
  </employee>
  <employee id="e2">
    <name>김철수</name>
    <age>25</age>
    <department>디자인</department>
  </employee>
</employees>
'''
    with open("valid_employees.xml", "w", encoding="utf-8") as f:
        f.write(xml_content)
    return "valid_employees.xml"

# 유효하지 않은 XML 예시
def create_invalid_xml():
    """XSD에 유효하지 않은 XML 파일 생성"""
    xml_content = '''<?xml version="1.0" encoding="UTF-8"?>
<employees>
  <employee id="e1">
    <name>홍길동</name>
    <age>-30</age>  <!-- 음수는 positiveInteger에 유효하지 않음 -->
    <department>개발</department>
  </employee>
  <employee>  <!-- id 속성 누락 -->
    <name>김철수</name>
    <age>25</age>
    <!-- department 요소 누락 -->
  </employee>
</employees>
'''
    with open("invalid_employees.xml", "w", encoding="utf-8") as f:
        f.write(xml_content)
    return "invalid_employees.xml"

# 실행 예시
if __name__ == "__main__":
    # 샘플 파일 생성
    xsd_file = create_sample_xsd()
    valid_xml = create_valid_xml()
    invalid_xml = create_invalid_xml()
    
    print("xmlschema 라이브러리를 사용한 검증:")
    validate_with_xmlschema(valid_xml, xsd_file)
    validate_with_xmlschema(invalid_xml, xsd_file)
    
    print("\nlxml 라이브러리를 사용한 검증:")
    validate_with_lxml(valid_xml, xsd_file)
    validate_with_lxml(invalid_xml, xsd_file)
    
    # 임시 파일 정리
    for file in [xsd_file, valid_xml, invalid_xml]:
        if os.path.exists(file):
            os.remove(file)

import xml.etree.ElementTree as ET
import json
import csv
from lxml import etree
import io

# XML을 JSON으로 변환
def xml_to_json(xml_data, root_name='root'):
    """XML 데이터를 JSON 형식으로 변환"""
    
    def _element_to_dict(element):
        result = {}
        
        # 속성 처리
        for key, value in element.attrib.items():
            result[f"@{key}"] = value
        
        # 자식 요소 처리
        children = list(element)
        if len(children) == 0:
            # 텍스트만 있는 경우
            if element.text and element.text.strip():
                if len(result) == 0:
                    return element.text.strip()
                result['#text'] = element.text.strip()
        else:
            # 자식 요소들 처리
            child_elements = {}
            for child in children:
                child_dict = _element_to_dict(child)
                tag = child.tag
                
                if tag in child_elements:
                    # 동일 태그가 이미 존재하면 리스트로 변환
                    if not isinstance(child_elements[tag], list):
                        child_elements[tag] = [child_elements[tag]]
                    child_elements[tag].append(child_dict)
                else:
                    child_elements[tag] = child_dict
            
            result.update(child_elements)
        
        return result
    
    # XML 파싱
    root = ET.fromstring(xml_data) if isinstance(xml_data, str) else xml_data
    return {root.tag: _element_to_dict(root)}

# XML을 CSV로 변환
def xml_to_csv(xml_data, mapping, output_file):
    """XML 데이터를 CSV로 변환"""
    
    root = ET.fromstring(xml_data) if isinstance(xml_data, str) else xml_data
    items = root.findall(mapping['row_xpath'])
    
    # CSV 파일 생성
    with open(output_file, 'w', newline='', encoding='utf-8') as csvfile:
        writer = csv.DictWriter(csvfile, fieldnames=mapping['headers'])
        writer.writeheader()
        
        for item in items:
            row = {}
            for csv_col, xpath in mapping['columns'].items():
                element = item.find(xpath)
                if element is not None and element.text:
                    row[csv_col] = element.text.strip()
                else:
                    row[csv_col] = ''
            writer.writerow(row)

# XSLT를 사용한 XML 변환
def transform_with_xslt(xml_data, xslt_data):
    """XSLT를 사용하여 XML 변환"""
    
    # XML 및 XSLT 파싱
    xml_doc = etree.parse(io.StringIO(xml_data)) if isinstance(xml_data, str) else xml_data
    xslt_doc = etree.parse(io.StringIO(xslt_data)) if isinstance(xslt_data, str) else xslt_data
    
    # XSLT 변환기 생성
    transform = etree.XSLT(xslt_doc)
    
    # 변환 실행
    result = transform(xml_doc)
    
    return etree.tostring(result, pretty_print=True, encoding='utf-8').decode('utf-8')

# 대용량 XML 파일 처리 (이터레이터 패턴)
def process_large_xml(xml_file, element_tag, callback):
    """대용량 XML 파일의 특정 요소를 순차적으로 처리"""
    
    # 이벤트 기반 파서 사용
    context = etree.iterparse(xml_file, events=('end',), tag=element_tag)
    
    count = 0
    try:
        for event, elem in context:
            # 콜백 함수로 요소 처리
            callback(elem)
            count += 1
            
            # 처리 후 메모리 해제
            elem.clear()
            # 부모 요소의 참조도 제거
            while elem.getprevious() is not None:
                del elem.getparent()[0]
    except Exception as e:
        print(f"처리 중 오류 발생: {e}")
    
    return count

# 샘플 XML 데이터
sample_xml = '''
<employees>
  <employee id="1001" department="개발">
    <name>홍길동</name>
    <position>선임 개발자</position>
    <skills>
      <skill>Python</skill>
      <skill>XML</skill>
    </skills>
    <projects>
      <project>
        <name>데이터 분석 시스템</name>
        <duration>6개월</duration>
      </project>
      <project>
        <name>웹 서비스 개발</name>
        <duration>3개월</duration>
      </project>
    </projects>
  </employee>
  <employee id="1002" department="마케팅">
    <name>김철수</name>
    <position>마케팅 매니저</position>
    <skills>
      <skill>데이터 분석</skill>
      <skill>소셜 미디어</skill>
    </skills>
  </employee>
</employees>
'''

# 샘플 XSLT 변환
sample_xslt = '''
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="html" indent="yes"/>
  
  <xsl:template match="/">
    <html>
      <head>
        <title>직원 목록</title>
      </head>
      <body>
        <h1>직원 명단</h1>
        <table border="1">
          <tr>
            <th>ID</th>
            <th>이름</th>
            <th>부서</th>
            <th>직책</th>
            <th>스킬</th>
          </tr>
          <xsl:for-each select="//employee">
            <tr>
              <td><xsl:value-of select="@id"/></td>
              <td><xsl:value-of select="name"/></td>
              <td><xsl:value-of select="@department"/></td>
              <td><xsl:value-of select="position"/></td>
              <td>
                <xsl:for-each select="skills/skill">
                  <xsl:value-of select="."/>
                  <xsl:if test="position() != last()">, </xsl:if>
                </xsl:for-each>
              </td>
            </tr>
          </xsl:for-each>
        </table>
      </body>
    </html>
  </xsl:template>
</xsl:stylesheet>
'''

# 실행 예시
if __name__ == "__main__":
    # XML을 JSON으로 변환
    json_data = xml_to_json(sample_xml)
    print("JSON 변환 결과:")
    print(json.dumps(json_data, indent=2, ensure_ascii=False))
    
    # XML을 CSV로 변환
    mapping = {
        'row_xpath': './/employee',
        'headers': ['ID', '이름', '부서', '직책', '스킬'],
        'columns': {
            'ID': '@id',
            '이름': 'name',
            '부서': '@department',
            '직책': 'position',
            '스킬': 'skills'  # 이 부분은 별도 처리 필요 (간단한 예시)
        }
    }
    
    # XML을 XSLT로 HTML로 변환
    html_output = transform_with_xslt(sample_xml, sample_xslt)
    print("\nXSLT 변환 결과:")
    print(html_output[:500] + "...")  # 결과의 일부만 출력