def Replace_Texts_by_Dic(username, prname):  # 2차 Lemmatization하는 함수입니다.
    import os
    from .utils import Read_Arg_, Read_Sheet_, import_dataframe, export_dataframe
    from tqdm import tqdm
    tqdm.pandas()  # 진행상황과 예정 ETA를 알려주는 tqdm 라이브러리 중,
    # apply 메소드에 적용되는 .pandas() 명령문을 실행해줍니다. (apply는 밑에 나옵니다.)
    input_directory = "/".join([username, prname])  # Non-창민버전
    ref, input_, output_ = Read_Arg_(
        username, prname, "Replace_Texts_by_Dic"
    )  # Read_Arg 명령문을 통해 Jlab Library에 해당 명령문에 필요한 참조파일, 인풋, 아웃풋을 가져옵니다.

    Dls = Read_Sheet_(username, prname, ref)[5:]
    Dls = Dls[Dls["Replace_Texts"] !=
              ""]  # Replace_Texts에 뭐라도 써있는 것들만으로 범위를 줄여줍니다.
    Dls = Dls[["tag", "Replace_Texts"
               ]]  # Worksheet 중 tag와 Replace_Texts에만 해당하는 컬럼만으로 줄여줍니다.
    Dls = Dls[~Dls.duplicated()].reset_index(
        drop=True)  # 중복된 것들을 제거해준 뒤, index를 새로 만들어줍니다.

    # 이 아래부터의 방식은 apply 방식을 위한 작업입니다.
    # 밑의 .apply메소드는 판다스 데이터프레임의 행마다 접근해 차례대로 정의한 함수를 실행시키는 방법입니다.
    # 현재 나와있는 pandas 처리 방법 중에 가장 빠른 속도를 보이는 메소드 입니다.

    def lemmatize(item):  # lemmatize라는 함수를 사용자 정의 함수로 정의 합니다.
        # 이 함수는 item이라는 인자에 대해 적용되는데,
        # 이는 이 코드내에서 궁극적으로 각 행의 메세지를 가리키게 됩니다.

        Dls_for_item = Dls[Dls["tag"].isin(item.split(
        ))]  # item(메세지)을 split()을 통해 공백기준으로 전부 split 시킨 리스트로 리턴해줍니다.
        # 해당 메세지가 "서강대학교 경영학과 학부 건물은 바오로관과 마태오관이 있습니다"라고 하면,
        # item.split()의 리턴값은
        # ["서강대학교", "경영학과", "학부", "건물은", "바오로관과", "마태오관이", "있습니다"]입니다.
        # 리턴 값의 요소들이 나타난 부분만 찾아(.isin)    Dls_for_item이라는 변수에 저장합니다.

        for unit in list(
                Dls_for_item["tag"]
        ):  # Dls_for_item데이터프레임에서 "tag"컬럼의 데이터를 리스트 형식으로 바꾼 후,
            # 이 리스트의 원소(unit)를 차례로 처리합니다. (for 반복문)
            item = item.replace(
                unit,
                tuple(Dls_for_item.loc[Dls_for_item["tag"] == unit,
                                       "Replace_Texts"])[0])
            # item(각 행의 메세지)은 unit차례로,
            # Dls_for_item에서 "Replace_Texts"에 해당히는 chink로 바꾼 것으로 치환한다.
            # Dls_for_item은 item의 원소 중 Dls에 있는 데이터만을 뽑아왔기 때문에
            # item에는 있으나 Dls에 없는 것을 탐색하는 불필요한 연산을 제거했다.

        return item  # item을 리턴한다.

    input_name = os.path.join(input_directory, input_)
    input_Message = import_dataframe(input_name)
    input_Message["contents"] = input_Message["contents"].progress_apply(
        lemmatize)  # .apply메소드를 통해
    # input_Message의 "contents" 컬럼에 행별로 lemmatize함수를 적용시킨다.
    input_Message = input_Message[
        input_Message["contents"].notna()]  # input_Message에 결측치들을 제거하고
    output_name = os.path.join(input_directory, output_)
    export_dataframe(input_Message, output_name)
    return input_Message  # 이 함수릐 리턴값으로 lemmatize된 input_Message를 준다.
def Delete_Overlapped_Messages(username, prname):  # 중복메세지를 제거하는 함수입니다.
    import os
    from tqdm import tqdm
    from .utils import Read_Arg_, import_dataframe, export_dataframe
    tqdm.pandas()

    ref, input_, output_ = Read_Arg_(
        username, prname, "Delete_Overlapped_Messages"
    )  # Read_Arg를 통해 참조파일, input파일, output파일을 불러옵니다.
    # 이 때 ref는 Overlapped여부를 판가름하는 문자열의 길이,
    # input파일은 메세지 csv파일의 이름,
    # output은 처리 후 내보낼 메세지 csv파일의 이름입니다.
    input_directory = "/".join([username, prname])  #Non-창민버 전

    input_name = os.path.join(input_directory, input_)
    input_Message = import_dataframe(input_name)
    # input_Message의 contents 열에서 결측치를 제외한 데이터들만을 가져옵니다.
    input_Message = input_Message[input_Message["contents"].notna()]
    input_Message.sort_values(by="contents",
                              inplace=True)  # contents열을 기준으로 정렬해줍니다.
    input_Message.reset_index(drop=True,
                              inplace=True)  # 데이터프레임의 index를 새로 정리합니다.

    input_Message["contents_til_" +
                  str(ref)] = input_Message["contents"].progress_apply(
                      lambda x: x[:ref] if len(x) >= ref else x)
    # 메세지 데이터 한 행의 데이터의 길이가 ref보다 길면 ref만큼을 가져오고,
    # 짧으면 그 데이터를 그대로 가져오는 함수를 .apply메소드를 통해
    # input_Message의 contents열에 적용시키고,
    # 그 결과값을 input_Message의 contents_til_...이라는 새로운 컬럼을 만들고 표시합니다.
    input_Message = input_Message[~input_Message["contents_til_" +
                                                 str(ref)].duplicated()].drop(
                                                     [
                                                         "contents_til_" +
                                                         str(ref)
                                                     ],
                                                     axis='columns')
    # input_Message의 contents_til_...이라는 컬럼을 기준으로
    # 중복되지 않은(~)데이터들만을 뽑아 (중복메세지 제거)
    # date, contents 열만 살려 input_Message변수를 업데이트 시켜줍니다.

    input_Message.sort_values(by="date", inplace=True)  # date 기준으로 데이터를 정렬하고
    input_Message.reset_index(drop=True, inplace=True)  # index를 재설정해줍니다.

    output_name = os.path.join(input_directory, output_)
    export_dataframe(input_Message,
                     output_name)  # 설정한 input_directory에 output 파일을 저장하고

    return input_Message  # 이 함수의 리턴값으로 처리된 input_Message를 내보냅니다. (DataFrame형식)
def Delete_Characters_by_Dic(
        username, prname):  # Worksheet에 작업한 내역을 바탕으로 불용어를 처리하는 함수 입니다.

    # 기본적인 아이디어는 1차 Delete_Characters와 같습니다.
    # Read_Sheet를 통해 Worksheet에 접근해서 Clean_Character 컬럼에 1 표시가 된
    # 데이터들의 "tag"열 데이터들을 뽑아옵니다. (제거  대상)
    # 이들을 정규표현식으로 통해 찾아내고, .apply메소드를 통해 제거합니다.
    import os, re
    from tqdm import tqdm
    from .utils import Read_Arg_, Read_Sheet_, import_dataframe, export_dataframe
    tqdm.pandas()
    input_directory = "/".join([username, prname])  # Non-창민버전
    ref, input_, output_ = Read_Arg_(
        username, prname, "Delete_Characters_by_Dic"
    )  # Read_Arg를 통해 참조파일, input파일, output파일을 불러옵니다.
    # 이 때 ref는 "Text_PreProcessing_Wokrsheet_Korean"시트를,
    # input파일은 메세지 csv파일의 이름,
    # output은 처리 후 내보낼 메세지 csv파일의 이름입니다.

    JDic = Read_Sheet_(username, prname, ref)[5:]
    JDic = JDic[~JDic["tag"].duplicated()]
    JDic["unit_length"] = JDic["tag"].apply(lambda x: len(str(x)))
    JDic = JDic.sort_values(by="unit_length", ascending=False)
    JDic_Clean = list(JDic.loc[JDic["Delete_Characters"] == 1, "tag"])
    Clean_candidates = str(JDic_Clean).replace("[", "").replace(
        "]", "").replace(", ''", "").replace(", ", "|").replace("'", "")

    def Clean_stopwords(item):
        item_edited = re.sub(Clean_candidates, " ", item)
        item_edited = re.sub(" +", " ", item_edited)
        return item_edited

    input_name = os.path.join(input_directory, input_)
    input_Message = import_dataframe(input_name)
    input_Message = input_Message[input_Message["contents"].notna()]
    input_Message["contents"] = input_Message["contents"].progress_apply(
        Clean_stopwords)
    input_Message = input_Message[input_Message["contents"].notna()]
    output_name = os.path.join(input_directory, output_)
    export_dataframe(input_Message, output_name)
    return input_Message
def Delete_Messages(username, prname):
    # SPAM 메세지라고 판단할 수 있는 요소를 찾아 데이터 제거하는 함수
    # 기본적인 아이디어는 1차 Lemmatization함수와 같습니다.
    # Read_Sheet를 통해 SPAM사전에 접근한 뒤,
    # SPAM이라고 판단할 수 있는 표현이 있는 메세지들을
    # .apply메소드를 통해 제거합니다.
    import os, re
    from tqdm import tqdm
    from .utils import Read_Arg_, Read_Sheet_, import_dataframe, export_dataframe
    input_directory = "/".join([username, prname])  #Non-창민버전
    tqdm.pandas()

    ref, input_, output_ = Read_Arg_(username, prname, "Delete_Messages")

    input_name = os.path.join(input_directory, input_)
    input_Message = import_dataframe(input_name)
    input_Message = input_Message[input_Message["contents"].notna()]

    SPAM = list(Read_Sheet_(username, prname, ref).iloc[:, 0])
    SPAM = str(SPAM).replace("[", "").replace("]",
                                              "").replace(", ''", "").replace(
                                                  ", ", "|").replace("'", "")
    SPAM = re.compile(SPAM)

    input_Message["SPAM"] = input_Message["contents"].progress_apply(
        SPAM.search)
    input_Message = input_Message[input_Message["SPAM"].isna()].drop(
        ["SPAM"], axis='columns')

    #input_Message.sort_values(by="date", inplace=True)
    input_Message.reset_index(drop=True, inplace=True)

    output_name = os.path.join(input_directory, output_)
    export_dataframe(input_Message, output_name)

    return input_Message
def Delete_StandardStopwords(username,
                             prname):  # 1차 불용어 처리 (불용어 사전을 새로 수정하고 만들어야 합니다.)
    import re, os
    from tqdm import tqdm
    from flashtext import KeywordProcessor
    from utils import Read_Arg_, Read_Sheet_, import_dataframe, export_dataframe
    kp = KeywordProcessor()
    tqdm.pandas()

    if (username == "") & (prname == ""):
        input_directory = ""  # Non-창민버전
    else:
        input_directory = "/".join([username, prname])  # Non-창민버전
    ref, input_, output_ = Read_Arg_(
        username, prname, "Delete_StandardStopwords"
    )  # Read_Arg를 통해 참조파일, input파일, output파일을 불러옵니다.
    # 이 때 ref는 "JDic_BizStopwords(경영불용어사전)"시트를,
    # input파일은 메세지 csv파일의 이름,
    # output은 처리 후 내보낼 메세지 csv파일의 이름입니다.
    Sym2Remain = Read_Sheet_(username, prname, "SymbolsDictionary")
    Clean = Read_Sheet_(username, prname, ref)  # Clean이라는 변수에 Read_Sheet를 통해
    # "JDic_BizStopwords(경영불용어사전)"시트를 불러옵니다.
    Clean.columns = Clean.iloc[0]
    Clean = Clean[1:]
    Clean["unit_length"] = Clean["word"].apply(
        lambda x: len(x))  # 이 때 하나의 이슈는 표현의 길이에 따른 나열 순서입니다.
    # (https://greeksharifa.github.io/정규표현식(re)/2018/07/22/regex-usage-03-basic/)
    # 만약 "에게"와 "에게서"를 예시로 들 떄,
    # 정규식 인자로 "에게"가 "에게서"보다 먼저 나열될 경우,
    # 메세지에서 "에게"에 대한 데이터를 먼저 찾으므로
    # 실제로 메세지에서 "에게서" 라고 표현되었던 데이터가
    # "에게"로 인해 "서"만으로 남게됩니다.
    # 따라서 위 방법을 사용하게 될 경우,
    # 불용어 사전의 칼럼으로 unit_length를 두고
    # 내림차순으로 정렬하는 것이 바람직해 보입니다.

    Sym2Remain_np = Sym2Remain.fillna("").to_numpy(dtype=list)
    all_V = list(map(lambda x: [i for i in x if i != ""],
                     Sym2Remain_np))  # all_V라는 변수에 lemma에 있는 데이터들을 전부 가져옵니다.
    print(all_V)
    # 이 때 all_V의 형태는 다음과 같습니다.
    # [[기준단어 a, 변형단어 a-1, 변형단어 a-2,... ],
    #  [기준단어 b, 변형단어 b-1, 변형단어 b-2,... ],
    #  ... ]
    for case in all_V:
        standardised = case[1]
        for keyword in case[0]:
            kp.add_keyword(keyword, standardised)
    print(kp.get_all_keywords())

    Clean = Clean.sort_values(
        by="unit_length",
        ascending=False)  # unit_length열 기준으로 내림차순으로 정렬해주고 최신화합니다.
    Clean = Clean[~Clean["word"].duplicated()]  # 혹시모를 중복 word를 제거합니다.

    # symbol = set(Clean.loc[Clean["class"] == "s", "word"])  # 기호는 Clean 데이터 프레임에서
    # # "class" 컬럼이 s인 것들의 "word"컬럼을 리스트화한 것입니다.
    # symbol = str(symbol).replace("{", "").replace("}", "").replace(", ''", "").replace(", ", "|").replace("'", "")

    # print(symbol)

    characters = set(Clean.loc[Clean["class"] == "c",
                               "word"])  # 문자는 Clean 데이터 프레임에서
    # "class" 컬럼이 c인 것들의 "word"컬럼을 리스트화한 것입니다.
    characters = str(characters).replace("{", "").replace("}", "").replace(
        ", ''", "").replace(", ", "|").replace("'", "")

    # 정규표현식을 사용하기 위한 작업입니다.
    # 본디, JDic_Clean은 ["물론", "무엇", "무슨" …] 처럼 리스트의 형태를 취합니다.
    # 정규표현식을 조작하게끔 하는 라이브러리 re는 인자로 문자열을 받습니다.
    # 따라서 리스트를 문자열로 바꿔줍니다. ( str(JDic_Clean) )
    # 또한, 정규식에는 .sub 메소드가 있는데,
    # 이는 세번째 인자(데이터)에서 첫번째 인자(특정 표현)를 발견하면
    # 두번째 인자로 바꿔주는 메소드입니다.
    # 아래에서 item(메세지 데이터의  각 행에 해당하는 데이터) 데이터에서
    # 불용어사전에 등록된 표현을 찾아 공백으로 바꿔주고자 합니다.
    # 이 때, 불용어 사전에 등록된 단어를 하나하나 바꿔주기 보다,
    # or식( | )을 써서 한번에 lookup하고자 합니다.
    # 그러기 위해서는 정규식의 인자에 들어가야할 형태는 다음과 같습니다.
    # "표현 1"|"표현 2"|"표현3"|…"
    # 더욱이 "ㅜ" 같은경우 "ㅜㅜ"로 메세지에서 발견될 수 있습니다.
    # 이는 정규식 내 +를 넣어주면 해결됩니다.
    # +는 해당표현이 1번이상 반복되는 경우를 뜻합니다.
    # 해당표현 바로 뒤에 +를 써줘 정규식에 넣어줘야 합니다.
    # 따라서 위 Clean_Candidates에는 다음과 같이 형태가 이루어져 있습니다.
    # "표현 1 +"|"표현 2 +"|"표현 3 +"|...

    # def save_symbol(item):  # lemmatize라는 함수를 정의합니다.
    #     input = item
    #     while True:
    #         input_revised = kp.replace_keywords(input) #input문장을 replace시켜준 후 item_replaced 변수에 저장
    #         if input == input_revised: #이전 문장과 수정 후 문장이 같다면 더이상 고칠게 없다는 의미이므로 반복문 탈출
    #             break
    #         else: # 이전 문장과 다르다면 바꿔줘야할 것이 있었다는 소리이므로 계속 진행. item_revised를 다시 이전의 값을 뜻하는 input으로 변경
    #             input = input_revised
    #             pass
    #     return input_revised

    def save_symbol2(item):  # lemmatize라는 함수를 정의합니다. (무식 버전)
        item_revised = item
        for i in range(len(Sym2Remain["decode"])):
            item_revised = item_revised.replace(
                Sym2Remain.iloc[i]["decode"],
                " " + Sym2Remain.iloc[i]["Encode"] + " ")
        return item_revised

    # def Clean_symbol(item):  # Clean_stopwords라는 사용자정의함수를 정의합니다.
    #     item_edited = re.sub(symbol, " ", item)  # 이는 정규표현식을 통해 item(input_Message의 각행의 데이터)에 대해
    #     # Clean_candidates에 해당하는 패턴이 나올 시 " "(공백)으로 치환해주는 함수입니다.
    #     item_edited = " ".join(item_edited.split())  # 다중공백도 제거해줍니다.
    #     return item_edited  # 이 함수의 리턴값을 치환된 데이터로 최신화된 데이터로 내보내도록 합니다.

    # def add_space_for_symbol(item):
    #    not_words = list(filter(bool, list(set(re.compile("[^\s*\w*\s*]*").findall(item)))))
    #    for end in not_words:                                     # 메세지의 한 행에서 있는 not_words리스트 요소마다
    #        item = item.replace(end," "+end)                                    # replace메소드를 통해 스페이스를 첨가해줍니다.
    #    return item

    def Clean_char(item):  # Clean_stopwords라는 사용자정의함수를 정의합니다.

        item_edited = re.sub(
            characters, " ",
            item)  # 이는 정규표현식을 통해 item(input_Message의 각행의 데이터)에 대해
        # Clean_candidates에 해당하는 패턴이 나올 시 " "(공백)으로 치환해주는 함수입니다.
        item_edited = " ".join(item_edited.split())  # 다중공백도 제거해줍니다.
        return item_edited  # 이 함수의 리턴값을 치환된 데이터로 최신화된 데이터로 내보내도록 합니다.

    def Clean_leftover_symbols(item):
        item_edited = re.sub("[^\w\s]", "", item)
        item_edited = " ".join(item_edited.split())  # 다중공백도 제거해줍니다.
        return item_edited

    input_name = os.path.join(input_directory, input_)
    input_Message = import_dataframe(input_name)
    input_Message = input_Message[
        input_Message["contents"].notna()]  # input Message에 있을 결측치(빈칸)을 제거합니다.

    input_Message["contents"] = input_Message["contents"].progress_apply(
        save_symbol2)
    #input_Message["contents"] = input_Message["contents"].progress_apply(Clean_symbol)
    # Clean_stopwords를 .apply메소드를 통해 적용시킵니다.
    # input_Message["contents"] = input_Message["contents"].progress_apply(add_space_for_symbol) #살릴 기호들 앞에 스페이스를 첨가해줍니다.
    input_Message["contents"] = input_Message["contents"].progress_apply(
        Clean_char)
    # Clean_stopwords를 .apply메소드를 통해 적용시킵니다.
    input_Message["contents"] = input_Message["contents"].progress_apply(
        Clean_leftover_symbols)

    output_name = os.path.join(input_directory, output_)
    export_dataframe(input_Message, output_name)

    return input_Message  # Delete_Characters의 리턴값으로 최신화된 데이터프레임으로 내보내도록 합니다.
def Make_Cooccurrence_Table(username, prname):
    from .utils import Read_Arg_, import_dataframe, export_dataframe
    from tqdm import tqdm

    if prname is not None:
        ind = 1  # 독립적으로 쓰이는 경우, Backbone사용
        ref, input_, output_ = Read_Arg_("Make_Cooccurrence_Table")
        Message_Df = import_dataframe(input_)

    else:
        ind = 0  # 다른 함수 내에서 사용될 경우, username에 분석할 text데이터를 넣는다.
        Message_Df = import_dataframe(username)

    Freq_df = Frequency_Analysis(text_file=Message_Df)  # 검색어 포함 할 때
    Freq_100 = Freq_df[Freq_df["count"] >= Freq_df["count"].max() * ref]
    Freq_100_tag = list(Freq_100.tag)

    CoTable = make_cotable(Freq_100_tag, Message_Df)

    CoTable_stacked = CoTable.stack().reset_index()
    CoTable_stacked.rename(columns={
        'level_0': 'tag_1',
        'level_1': 'tag_2',
        0: 'cooccurrence_count'
    },
                           inplace=True)
    CoTable_stacked = CoTable_stacked[
        CoTable_stacked["cooccurrence_count"] > 0]

    # 강조표현, 지시대명사, 접속사 등의 크게 의미를 부여하지 못하는 불용어 설정
    # stopwords = ['좋다', '우리', '있다', '다른', '많다', "너무", "정말",
    #              "많이", "가장", "하지만", "아주", "그냥", "조금", "매우", "합니다",
    #              "그러나", "것이", "위해", "때문에", "그것은", "하고", "하다", "하는",
    #              "하지", "입니다", "에서", "것을", "동안", "이것은", "수있는", "같다",
    #              "곳은", "곳을", "여기에", "또는", "또한", "다시", "있으며", "모두",
    #              "특히", "것입니다", " 대한", "바로", "다음", "대해", "가지고", "있지만",
    #              "정말로", "따라", "여러", "그것을", "것은", "해서", "가다", "갔다", "싶다",
    #              "완전", "정말", "했는데", "역시", "근데", "했다", "진짜", "하세", "엄청",
    #              "아니", "는데", "아마", "왔어", "있습니다", "있는"]

    # def erase_stopwords(dataframe):
    #     for word in stopwords:
    #         DataFrame = dataframe[dataframe["tag_1"] != word]
    #         DataFrame = DataFrame[DataFrame["tag_2"] != word]
    #     return DataFrame
    #
    # CoTable_stacked = erase_stopwords(CoTable_stacked)
    CoTable_stacked["includes"] = CoTable_stacked.apply(
        lambda df: 1 if df["tag_1"] in df["tag_2"] else 1
        if df["tag_2"] in df["tag_1"] else 0,
        axis=1)
    CoTable_stacked = CoTable_stacked[CoTable_stacked["includes"] != 1]
    CoTable_stacked = CoTable_stacked[CoTable_stacked.columns[:-1]]
    CoTable_stacked = CoTable_stacked.loc[
        CoTable_stacked["cooccurrence_count"] >=
        CoTable_stacked["cooccurrence_count"].max() * 0.05]
    CoTable_stacked = CoTable_stacked.sort_values(
        by='cooccurrence_count', ascending=False).reset_index(drop=True)

    keyword_dict = dict()
    for kw in tqdm(
            set(CoTable_stacked["tag_1"]) | set(CoTable_stacked["tag_2"])):
        keyword_dict[kw] = {
            "appearance":
            len(Message_Df[Message_Df["contents"].str.contains(kw)])
        }

    CoTable_stacked["W_1^n"] = CoTable_stacked["tag_1"].apply(
        lambda row: Freq_100.loc[Freq_100["tag"] == row, "count"].values[0])
    CoTable_stacked["W_2^n"] = CoTable_stacked["tag_2"].apply(
        lambda row: Freq_100.loc[Freq_100["tag"] == row, "count"].values[0])
    CoTable_stacked["W_1^m"] = CoTable_stacked["tag_1"].apply(
        lambda row: keyword_dict[row]["appearance"])
    CoTable_stacked["W_2^m"] = CoTable_stacked["tag_2"].apply(
        lambda row: keyword_dict[row]["appearance"])
    CoTable_stacked["W_(1|2)^m"] = CoTable_stacked["cooccurrence_count"]
    CoTable_stacked["W_(2|1)^m"] = CoTable_stacked["cooccurrence_count"]
    CoTable_stacked["W_(1and2)^m"] = CoTable_stacked["cooccurrence_count"]
    CoTable_stacked["W_(1or2)^m"] = CoTable_stacked["W_1^m"] + CoTable_stacked[
        "W_2^m"] - CoTable_stacked["cooccurrence_count"]
    CoTable_stacked[
        "W_1^n%"] = CoTable_stacked["W_1^n"] / Freq_100["count"].max()
    CoTable_stacked[
        "W_2^n%"] = CoTable_stacked["W_2^n"] / Freq_100["count"].max()
    CoTable_stacked["W_1^m%"] = CoTable_stacked["W_1^m"] / len(Message_Df)
    CoTable_stacked["W_2^m%"] = CoTable_stacked["W_2^m"] / len(Message_Df)
    CoTable_stacked["W_(1|2)^m%"] = CoTable_stacked[
        "cooccurrence_count"] / CoTable_stacked["W_2^m"]
    CoTable_stacked["W_(2|1)^m%"] = CoTable_stacked[
        "cooccurrence_count"] / CoTable_stacked["W_1^m"]
    CoTable_stacked["W_(1and2)^m%"] = CoTable_stacked["W_(1and2)^m"] / len(
        Message_Df)
    CoTable_stacked["W_(1or2)^m%"] = CoTable_stacked["W_(1or2)^m"] / len(
        Message_Df)
    CoTable_stacked["Fit(1|2)"] = CoTable_stacked[
        "W_(1|2)^m%"] / CoTable_stacked["W_(2|1)^m%"]
    CoTable_stacked["pair"] = CoTable_stacked[["tag_1", "tag_2"]].apply(
        lambda row: "-".join(row), axis=1)

    if ind == 1:
        export_dataframe(CoTable_stacked, output_)
    else:
        pass
    #output_name = os.path.join(input_directory, output_)

    return CoTable_stacked
def Frequency_Analysis(username, prname):
    import pandas as pd
    from collections import Counter
    from tqdm import tqdm as bar
    from .utils import Read_Arg_, import_dataframe, export_dataframe
    input_directory = "/".join([username, prname])  # Non-창민버전

    if prname is not None:  # prname이 써있는 것 -> 타 함수 내에서 사용 : 딕셔너리 사용.
        for_cooc = 0  # 순수하게 Frequency_Analysis를 해야할 우 ->
        ref, input_, output_ = Read_Arg_("Frequency_Analysis")
        Frequency_Gap = int(ref) / 100
        text = import_dataframe(input_)
    else:  # 분석할 textfile을 username에 적는다.
        for_cooc = 1
        ref, _, _ = Read_Arg_("Frequency_Analysis", isind=1)
        Frequency_Gap = int(ref) / 100
        text = import_dataframe(username)

    def get_contents(item):
        if item != "":
            # not_language = re.compile('[^ ㄱ-ㅎㅣ가-힣|a-z|A-Z]+')
            # item = re.sub(not_language,"",str(item))
            contents.append(str(item).lower().strip())

    contents = []
    tag_contents = []
    text.contents.apply(get_contents)

    for token in contents:  # 요 파트를 스페이스 기준이 아닌걸로 수정해야 한다.
        for word in str(token).split(" "):
            if len(str(word)) > 1:
                tag_contents.append(word)
    counted_contents = Counter(tag_contents)

    tag_count = []

    for n, c in counted_contents.most_common():
        dics = {"tag": n, "count": c}
        tag_count.append(dics)

    df_tag_count = pd.DataFrame(tag_count)
    df_tag_count = df_tag_count[df_tag_count["count"] >= 50].sort_values(
        by="tag").reset_index(drop=True)
    iterations = len(df_tag_count)
    row_num = 0

    total = bar(range(iterations - 1), desc="comparing...")
    for t in total:
        step = t + 1
        std_row = df_tag_count.iloc[row_num]
        comparison_row = df_tag_count.shift(-1).iloc[row_num]
        std_tag = str(std_row["tag"])
        std_count = std_row["count"]
        comparison_tag = str(comparison_row["tag"])
        comparison_count = comparison_row["count"]

        if std_tag == comparison_tag[:len(std_tag)]:
            frequency_gap = abs(std_count - comparison_count)
            if frequency_gap / std_count < Frequency_Gap:
                df_tag_count.iloc[row_num + 1,
                                  1] = comparison_count + std_count
                df_tag_count = df_tag_count[
                    df_tag_count["tag"] != std_tag].reset_index(drop=True)
            else:
                row_num = row_num + 1
                continue
        else:
            row_num = row_num + 1
            continue
        if step == iterations - 1:
            break

    df_tag_count = df_tag_count.sort_values(
        by="count", ascending=False).reset_index(drop=True)

    if for_cooc == 0:
        export_dataframe(df_tag_count, output_)
    else:
        pass

    return df_tag_count
def Delete_Characters(username,
                      prname):  # 1차 불용어 처리 (불용어 사전을 새로 수정하고 만들어야 합니다.)
    import re, os
    from tqdm import tqdm
    from .utils import Read_Arg_, Read_Sheet_, import_dataframe, export_dataframe
    tqdm.pandas()
    input_directory = "/".join([username, prname])  # Non-창민버전
    ref, input_, output_ = Read_Arg_(
        username, prname,
        "Delete_Characters")  # Read_Arg를 통해 참조파일, input파일, output파일을 불러옵니다.
    # 이 때 ref는 "Project_Stopwords"시트를,
    # input파일은 메세지 csv파일의 이름,
    # output은 처리 후 내보낼 메세지 csv파일의 이름입니다.

    Clean = Read_Sheet_(username, prname, ref)  # Clean이라는 변수에 Read_Sheet를 통해
    # "JDic_BizStopwords(경영불용어사전)"시트를 불러옵니다.
    Clean.columns = Clean.iloc[0]
    Clean = Clean[1:]
    Clean["unit_length"] = Clean["word"].apply(
        lambda x: len(str(x)))  # 이 때 하나의 이슈는 표현의 길이에 따른 나열 순서입니다.
    # (https://greeksharifa.github.io/정규표현식(re)/2018/07/22/regex-usage-03-basic/)
    # 만약 "에게"와 "에게서"를 예시로 들 떄,
    # 정규식 인자로 "에게"가 "에게서"보다 먼저 나열될 경우,
    # 메세지에서 "에게"에 대한 데이터를 먼저 찾으므로
    # 실제로 메세지에서 "에게서" 라고 표현되었던 데이터가
    # "에게"로 인해 "서"만으로 남게됩니다.
    # 따라서 위 방법을 사용하게 될 경우,
    # 불용어 사전의 칼럼으로 unit_length를 두고
    # 내림차순으로 정렬하는 것이 바람직해 보입니다.
    Clean = Clean.sort_values(
        by="unit_length",
        ascending=False)  # unit_length열 기준으로 내림차순으로 정렬해주고 최신화합니다.
    Clean = Clean[~Clean["word"].duplicated()]  # 혹시모를 중복 word를 제거합니다.
    column_data = list(
        Clean["word"])  # columns_data에 word열에 있는 데이터를 리스트로 변환합니다.
    Clean_cadidates = str(column_data).replace("[", "").replace(
        "]", "").replace(", ''", "").replace(", ", "|").replace("'", "")

    # 정규표현식을 사용하기 위한 작업입니다.
    # 본디, JDic_Clean은 ["물론", "무엇", "무슨" …] 처럼 리스트의 형태를 취합니다.
    # 정규표현식을 조작하게끔 하는 라이브러리 re는 인자로 문자열을 받습니다.
    # 따라서 리스트를 문자열로 바꿔줍니다. ( str(JDic_Clean) )
    # 또한, 정규식에는 .sub 메소드가 있는데,
    # 이는 세번째 인자(데이터)에서 첫번째 인자(특정 표현)를 발견하면
    # 두번째 인자로 바꿔주는 메소드입니다.
    # 아래에서 item(메세지 데이터의  각 행에 해당하는 데이터) 데이터에서
    # 불용어사전에 등록된 표현을 찾아 공백으로 바꿔주고자 합니다.
    # 이 때, 불용어 사전에 등록된 단어를 하나하나 바꿔주기 보다,
    # or식( | )을 써서 한번에 lookup하고자 합니다.
    # 그러기 위해서는 정규식의 인자에 들어가야할 형태는 다음과 같습니다.
    # "표현 1"|"표현 2"|"표현3"|…"
    # 더욱이 "ㅜ" 같은경우 "ㅜㅜ"로 메세지에서 발견될 수 있습니다.
    # 이는 정규식 내 +를 넣어주면 해결됩니다.
    # +는 해당표현이 1번이상 반복되는 경우를 뜻합니다.
    # 해당표현 바로 뒤에 +를 써줘 정규식에 넣어줘야 합니다.
    # 따라서 위 Clean_Candidates에는 다음과 같이 형태가 이루어져 있습니다.
    # "표현 1 +"|"표현 2 +"|"표현 3 +"|...

    def Clean_stopwords(item):  # Clean_stopwords라는 사용자정의함수를 정의합니다.
        item_edited = re.sub(
            Clean_cadidates, " ",
            item)  # 이는 정규표현식을 통해 item(input_Message의 각행의 데이터)에 대해
        # Clean_candidates에 해당하는 패턴이 나올 시 " "(공백)으로 치환해주는 함수입니다.
        item_edited = re.sub(" +", " ", item_edited)  # 다중공백도 제거해줍니다.
        return item_edited  # 이 함수의 리턴값을 치환된 데이터로 최신화된 데이터로 내보내도록 합니다.

    input_name = os.path.join(input_directory, input_)
    input_Message = import_dataframe(input_name)
    input_Message = input_Message[
        input_Message["contents"].notna()]  # input Message에 있을 결측치(빈칸)을 제거합니다.
    input_Message["contents"] = input_Message["contents"].progress_apply(
        Clean_stopwords)  # Clean_stopwords를 .apply메소드를 통해 적용시킵니다.

    output_name = os.path.join(input_directory, output_)
    export_dataframe(input_Message, output_name)
    return input_Message  # Delete_Characters의 리턴값으로 최신화된 데이터프레임으로 내보내도록 합니다.
def Replace_Texts_in_Messages(username, prname):  # 1차 Lemmatization 함수
    # (지금은 "JDic_Lemmatization(일반lemma사전)"의 양이 적어 이렇게 가지만,
    # 양이 많아진다면 2차 Lemmatization 함수처럼 수정해야 합니다.)
    import os, re
    import pandas as pd
    from tqdm import tqdm
    from utils import Read_Arg_, Read_Sheet_, import_dataframe, export_dataframe
    from flashtext import KeywordProcessor
    tqdm.pandas()

    if (username is None) or (prname is None):
        input_directory = ""
    else:
        input_directory = "/".join([username, prname])  # Non-창민버전
    #kp = KeywordProcessor()
    ref, input_, output_ = Read_Arg_(
        username, prname, "Replace_Texts_in_Messages"
    )  # Read_Arg를 통해 참조파일, input파일, output파일을 불러옵니다.
    # 이 때 ref는 "JDic_Lemmatization(일반lemma사전)"시트를,
    # input파일은 메세지 csv파일의 이름,
    # output은 처리 후 내보낼 메세지 csv파일의 이름입니다.

    # lemma라는 변수에 reference 시트를 불러오기
    lemma = Read_Sheet_(username, prname, ref)  # lemma라는 변수에 Read_Sheet를 통해
    # "JDic_Lemmatization(일반lemma사전)"시트를 불러옵니다.
    lemma = lemma.fillna("").to_numpy(dtype=list)
    all_V = list(map(lambda x: [i for i in x if i != ""],
                     lemma))  # all_V라는 변수에 lemma에 있는 데이터들을 전부 가져옵니다.

    # 이 때 all_V의 형태는 다음과 같습니다.
    # [[기준단어 a, 변형단어 a-1, 변형단어 a-2,... ],
    #  [기준단어 b, 변형단어 b-1, 변형단어 b-2,... ],
    #  ... ]
    # for case in all_V:
    #     standardised = case[0]
    #     for keyword in case[1:]:
    #         kp.add_keyword(keyword, standardised)
    #
    # def lemmatize(item):  # lemmatize라는 함수를 정의합니다.
    #     return kp.replace_keywords(item)
    #     # item_edited = item
    #     # for case in all_V:  # all_V내에 있는 단어세트(case) (ex. [기준단어 a, 변형단어 a-1, 변형단어 a-2,... ])별로
    #     #     exp4re = str(sorted(case[1:], key=len, reverse=True)).replace("[", "").replace("]",
    #     #                 "").replace(", ''", "").replace(", ", "|").replace("'", "")
    #     #     # [변형단어 a-1, 변형단어 a-2,... ]로 있는 case[1:]라는 리스트를 문자열로 바꿔주고,
    #     #     # "변형단어 a-1 +|변형단어 a-2 +|..." 식으로 바꿔줍니다.
    #     #     # 이는 정규식을 사용하기 위한 전처리 작업입니다.
    #     #     # 정규표현식을 사용하면 원하는 패턴의 문자열을 한번에 찾고 한번에 바꿀 수 있습니다.
    #     #     item_edited = re.sub(exp4re, case[0], item_edited)  # 변형단어들을 기준단어로 치환해주고 이를 item_edited라는 변수에 넣어줍니다.
    #     #     item_edited = re.sub("[\s]+", " ", item_edited)  # item_edited의 다중공백(space 두 개 이상의 공백)을 하나의 space로 치환합니다.
    #     # return item_edited  # item_edited을 리턴값으로 내보냅니다.
    #
    #
    # input_name = os.path.join(input_directory, input_)
    # input_Message = import_dataframe(input_name)
    # input_Message["contents"] = input_Message["contents"].progress_apply(lemmatize)  # lemmatize함수를 .apply메소드를 통해
    # # input_Message의 "contents"열에 적용시키고 표시합니다.
    #
    # input_Message = input_Message[input_Message["contents"].notna()]  # Null 값이 아닌 데이터들만을 표시합니다.
    """
    version 2.0 token decomposition 방식(21-05-30)
    """
    # lemee에는 lemmatize될 token을, lemer에서는 기준 token을 추가해준다.
    # lemee와 lemerfmf 열로 갖는 DataFrame을 lemm이라는 변수에 담아둔다.
    lemee = []
    lemer = []
    for case in all_V:
        standardised = case[0]
        for keyword in case[1:]:
            lemee.append(keyword)
            lemer.append(standardised)
    lemm = pd.DataFrame({"raw": lemee, "lem": lemer})

    # 원문데이터를 불러와 DataFrame형식으로 input_Message리는 변수에 담는다.
    if (username is None) or (prname is None):
        input_name = os.path.join(input_)
    else:
        input_directory = "/".join([username, prname])  # Non-창민버전
        input_name = os.path.join(input_directory, input_)
    input_Message = import_dataframe(input_name)

    # 원문 데이터로부 line넘버, token넘버고, token을 추출해
    # line_no, token_no, token 을 열로 갖는 DataFrame을 text_decomposition이라는 의미의 text_decomp 변수에 저장한다.
    line_no = []
    token_no = []
    token = []
    for lines in enumerate(input_Message["contents"]):
        for tokens in enumerate(str(lines[1]).split()):
            line_no.append(lines[0])
            token_no.append(tokens[0])
            token.append(tokens[1])
    text_decomp = pd.DataFrame({
        "line_no": line_no,
        "token_no": token_no,
        "token": token
    })

    # text_decomp 테이블 기준테이블로 설정하고  text_decomp의 "token"열과  lemm테이블의 "raw" 열을 "left join" 하고,
    #  중복열인 "raw"열을 제거한 후, "lem"열에 빈 부분을 같은 행의 "token"열의 값들로 채워준다.
    res = pd.merge(text_decomp,
                   lemm,
                   left_on=["token"],
                   right_on=["raw"],
                   how="left").drop(["raw"], axis=1)
    res["lem"] = res["lem"].fillna(res["token"])
    # 중간에 res가 어떻게 나오는지, 바뀐 부분이 어떻게 바뀌었는지 확인하는 코드 두 줄
    # print(res.head(30))
    # print(res[res["token"]!=res["lem"]].head(30))

    # lemmatize된 문장으로 뭉쳐주는 코드
    # new_lines라는 빈 리스트를 생성한다.
    new_lines = []
    # res의 line_no열에 있는 값들을 unique하게 불러온 후, 이들을 기준으로 순서대로 다음과 같은 실행을 거친다.
    #     res의 "line_no"가  i번째인 부분을 가져온 후, "token_no"를 기준으로 오름차순으로 정렬한 후 그 순서대로 "lem"열에 있는 token들을 정렬한다.
    #     정렬된 token 사이를 띄어쓰기로 채워 넣어 한 문장으로 만들어 new_line이라는 변수에 저장한다.
    #     new_lines리스트에 new_line을 추가한다.
    res = res.sort_values(by=["line_no", "token_no"])
    renewed = res.groupby("line_no", as_index=False).agg({'token':
                                                          ' '.join})["token"]
    input_Message["contents"] = renewed

    # sen_no = res["line_no"].unique()
    #
    # for i in tqdm(sen_no):
    #     new_line = " ".join(res[res["line_no"] == i].sort_values(by="token_no", ascending=True)["lem"])
    #     new_lines.append(new_line)
    # # 최종적으로 누적된 new_lines를 input_Message의 "contents"열에 넣어 갱신해준다.
    # input_Message["contents"] = new_lines

    output_name = os.path.join(input_directory, output_)
    export_dataframe(input_Message, output_name)

    return input_Message  # 처리한 input_Message를 리턴값으로 내보냅니다.