[PYTHON] 100 Sprachverarbeitungsklopfen (2020): 25

"""
25.Extraktion der Vorlage
Extrahieren Sie die Feldnamen und Werte der im Artikel enthaltenen Vorlage "Basisinformationen" und speichern Sie sie als Wörterbuchobjekt.
"""

import json
import re

import utils


def get_uk_text(path):
    with open(path) as f:
        for line in f:
            line_data = json.loads(line)
            if line_data["title"] == "England":
                data = line_data
                break
    return data["text"]


uk_text = get_uk_text("jawiki-country.json")
# See uk_text.txt


# ans24
def get_basic_info(string: str) -> str:
    """Get basic information section
    """
    pattern = re.compile(
        r"""
            ^\{\{Grundinformation.*?$   # '{{Grundinformation'Zeilen beginnend mit
            (.*?)       #Ziel erfassen, 0 oder mehr Zeichen, nicht gierig
            ^\}\}$      # '}}'Zeilen, die mit enden
        """,
        re.MULTILINE | re.DOTALL | re.VERBOSE,
    )

    return re.findall(pattern, string)[0]


def get_content(string: str) -> list:
    r"""
    https://docs.python.org/3/library/re.html#regular-expression-syntax

    RE:
        - re.X (re.VERBOSE)     Allow us add command to explain the regular expression
        - re.M (re.MULTILINE)   Apply match to each line. If not specified, only match the first line.
        - re.S (re.DOTALL)      Allow to recognize '\n'
        - ^\|       String begin with |
        - ?         Causes the resulting RE to match 0 or 1 repetitions

        - *?        The '*' qualifier is greedy.
                    Adding ? after the qualifier makes it perform the match in non-greedy or minimal fashion; as few characters as possible will be matched.
                    e.g. <.*> is matched against '<a> b <c>'
                    e.g. <.*?> will match only '<a>'

        - (...)     Matches whatever regular expression is inside the parentheses,
        - (?=...)   Matches if ... matches next, but doesn’t consume any of the string. This is called a lookahead assertion.
                    For example, Isaac (?=Asimov) will match 'Isaac ' only if it’s followed by 'Asimov'.
        - (?:...)   A non-capturing version of regular parentheses.

    Input:
        - '|Nationaler Emblem-Link=（[[Britisches nationales Emblem|Staatswappen]]）'
    Return:
        - {"Nationaler Emblem-Link": "（[[Britisches nationales Emblem|Staatswappen]]）"}
    """
    pattern = re.compile(
        r"""
            ^\|         # '|'Zeilen beginnend mit
            (.+?)       #Erfassen Sie das Ziel (Feldname), ein oder mehrere Zeichen, nicht gierig
            \s*         #0 oder mehr Leerzeichen
            =
            \s*         #0 oder mehr Leerzeichen
            (.+?)       #Erfassen Sie ein Ziel (Wert), ein oder mehrere Zeichen, die nicht gierig sind
            (?:         #Starten Sie eine Gruppe, die nicht erfasst wird
                (?=\n\|)    #Neue Zeile+'|'Vorher (positive Vorausschau)
                |           #Oder
                (?=\n$)     #Neue Zeile+Vor dem Ende (bejahender Ausblick)
            )               #Gruppenende
            """,
        re.MULTILINE | re.DOTALL | re.VERBOSE,
    )
    result = re.findall(pattern, string)
    return {k: v for k, v in result}  # dict is ordered due to python 3.7


basic_info = get_basic_info(uk_text)
# print(basic_info[-100:])
# |Internationale Telefonnummer= 44
# |Hinweis= <references/>

result = get_content(basic_info)
utils.save_json(result, "25_en_basic_info.json")

for r in result.items():
    print(r)
# ('Kurzbezeichnung', 'England')
# ('Japanischer Ländername', 'Vereinigtes Königreich Großbritannien und Nordirland')
# ...
# ('Internationale Telefonnummer', '44')
# ('Hinweis', '<references/>')