Upload main (1).py

main (1).py

@@ -0,0 +1,515 @@
+import streamlit as st
+import zipfile, shutil, time
+import os
+import hashlib
+from streamlit_pdf_viewer import pdf_viewer
+from streamlit import runtime
+from streamlit.runtime.scriptrunner import get_script_run_ctx
+from streamlit_js_eval import streamlit_js_eval
+import secrets
+
+import threading
+from streamlit.runtime.scriptrunner import add_script_run_ctx
+import streamlit.components.v1 as components
+from streamlit.runtime import get_instance
+
+from pypdf import PdfReader
+import glob
+import logging
+
+
+def get_remote_ip() -> str:
+    """Get remote ip."""
+
+    try:
+        ctx = get_script_run_ctx()
+        if ctx is None:
+            return None
+
+        session_info = runtime.get_instance().get_client(ctx.session_id)
+        if session_info is None:
+            return None
+    except Exception as e:
+        return None
+
+    return session_info.request.remote_ip
+
+
+# colab side make dir
+def my_makedirs(path):
+    if not os.path.isdir(path):
+        os.makedirs(path)
+
+def heart_beat():
+    """
+    Heartbeat function to track whether the session is alive
+    """
+    thread = threading.Timer(interval=2, function=heart_beat)
+
+    # insert context to the current thread, needed for
+    # getting session specific attributes like st.session_state
+
+    add_script_run_ctx(thread)
+
+    # context is required to get session_id of the calling
+    # thread (which would be the script thread)
+    ctx = get_script_run_ctx()
+
+    # this is the main runtime, contains all the sessions
+    runtime = get_instance()
+
+    if runtime.is_active_session(session_id=ctx.session_id):
+        logging.info(f"{ctx.session_id} is alive.")
+        thread.start()
+    else:
+        print(st.session_state.uniq)
+        if os.path.isdir(f"removefolder/{st.session_state.uniq}"):
+            shutil.rmtree(f"removefolder/{st.session_state.uniq}")
+        logging.info(f"{ctx.session_id} is gone.")
+        return
+
+# JavaScript to detect browser exit
+EXIT_JS = """
+<script>
+    window.addEventListener('beforeunload', function (event) {
+        fetch('/close_session', {method: 'POST'}).then(response => {
+            return response.text();
+        }).then(data => {
+            console.log(data);
+        });
+    });
+</script>
+"""
+
+# Embed the JavaScript in the Streamlit app
+components.html(EXIT_JS)
+
+def main():
+
+    if 'uniq' not in st.session_state:
+        st.session_state.uniq = secrets.token_urlsafe()
+
+    temp_dir = st.session_state.uniq
+    my_makedirs(f"removefolder/{temp_dir}")
+
+    flag = True
+    if 'count' not in st.session_state:
+        st.session_state.count = 0
+    #tempolary
+    if 'temp' not in st.session_state:
+        st.session_state.temp = 0
+
+    if 'lang' not in st.session_state:
+        st.session_state.lang = ""
+    if 'result' not in st.session_state:
+        st.session_state.result = ""
+
+    obj_0 = st.empty()
+    obj_1 = st.empty()
+
+    obj_0.header("`PDF file uploader`")
+    st.markdown(f"The remote ip is `{get_remote_ip()}`")
+
+    uploaded_file = obj_1.file_uploader("UPLOAD your .pdf file", type="pdf")
+    ####
+    if uploaded_file is not None:
+        flag = False
+        st.success("PDF file translator")
+        # hashed
+        raw_filename = uploaded_file.name
+        intext_0 = f'<span style="color:LavenderBlush;background:Orchid">{raw_filename}</span>'
+        st.write(intext_0, unsafe_allow_html=True)
+        hashed_filename = hashlib.sha1(raw_filename.encode())
+        uploadedfilename = hashed_filename.hexdigest()
+        if "uploadedfilename" not in st.session_state:
+            st.session_state.uploadedfilename = uploadedfilename
+
+        if "book" not in st.session_state:
+            #            pdf_viewer(input=uploaded_file.getvalue(), width=700, height=500)
+
+            my_makedirs(
+                f"removefolder/{temp_dir}/upload_folder_{st.session_state.count}"
+            )
+
+            with open(
+                    f'removefolder/{temp_dir}/upload_folder_{st.session_state.count}/{uploadedfilename}.pdf',
+                    'wb') as file:
+                file.write(uploaded_file.getvalue())
+#            pdf_viewer(input=f'{temp_dir}/upload_folder_{st.session_state.count}/{uploadedfilename}.pdf', width=700, height=500)
+
+# read from PDF file
+            PDF = glob.glob(
+                f"removefolder/{temp_dir}/upload_folder_{st.session_state.count}/{uploadedfilename}.pdf"
+            )
+
+            doc = PdfReader(PDF[0])
+            # meta = doc.metadata
+            page_count = len(doc.pages)
+
+            book = []  # PDF text data pool
+            progressbar1 = st.empty()
+            my_bar1 = progressbar1.progress(0)
+            for index, page in enumerate(doc.pages):
+                page_text = page.extract_text()
+                book.append((index, page_text))
+                done = int(((index + 1) / page_count) * 100)
+                my_bar1.progress(done,
+                                 text=f"Reading Page Number : {index + 1}")
+            st.session_state.book = book
+            my_bar1.empty()
+            if os.path.isfile(
+                    f"removefolder/{temp_dir}/upload_folder_{st.session_state.count}/{uploadedfilename}.pdf"
+            ):
+                shutil.rmtree(
+                    f"removefolder/{temp_dir}/upload_folder_{st.session_state.count}/"
+                )
+
+        ########
+        reload_bt = st.empty()
+        if reload_bt.button("Upload another PDF file"):
+            for key in st.session_state.keys():
+                if key == "count" or key == "temp" or key == "lang":
+                    continue
+                else:
+                    del st.session_state[key]
+            shutil.rmtree(f"removefolder/{temp_dir}")
+            # page reload
+            streamlit_js_eval(js_expressions="parent.window.location.reload()")
+        st.markdown("----")
+
+        plain_text1 = " 𓃠 select target language 𓃠 "
+        var_text1 = f'##### <span style="color:green">{plain_text1}</span>'
+
+        select = st.empty()
+        select.write(var_text1, unsafe_allow_html=True)
+
+        # select language
+        st.markdown("""
+        `ja`: **Japanese**,
+        `en`: **English**,
+        `fr`: **French**,
+        `zb-TW`: **Chinese (traditional)**,
+        `zh-CN`: **Chinese (simplified)**,
+        `ru`: **Russian**,
+        `ko`: **Korean**,
+        `vi`: **Vietnamese**,
+        `th`: **Thai**,
+        `ca`: **Catalan**,
+        `si`: **Sinhalese**
+        """)
+        lang_code = [
+            "select language",
+            "Japanese",
+            "English",
+            "French",
+            "Chinese traditional",
+            "Chinese simplified",
+            "Russian",
+            "Korean",
+            "Vietnamese",
+            "Thai",
+            "Catalan",
+            "Sinhalese",
+        ]
+        sel = st.empty()
+        #language = sel.radio(
+        #            label='translate to',
+        #            options=lang_code,
+        #            index=0,
+        #            key = f"select_lang{st.session_state.count}")
+        language = sel.selectbox(
+            'translate to',
+            lang_code,
+            index=0,
+            #placeholder = "select language",
+            key=f"select_lang{st.session_state.count}")
+
+        statename = f"select_lang{st.session_state.count}"
+        if "target_lang" not in st.session_state:
+            st.session_state.target_lang = "UNSELECTED"
+
+        def reset_selected_lang():
+            st.session_state[statename] = "select language"
+
+        st.button('Reset Language', on_click=reset_selected_lang)
+
+    area = st.empty()
+    if flag:
+        if "select_lang" in st.session_state:
+            if st.session_state.select_lang != "select language":
+                area2 = st.empty()
+                plain_text2 = "☟Reset Language☟"
+                empty_text = "☟              ☟"
+                var_text2 = f'<span style="color:#FF69B4">{plain_text2}</span>'
+                while flag:
+                    area2.write(var_text2, unsafe_allow_html=True)
+                    time.sleep(0.9)
+                    area2.write(empty_text)
+                    time.sleep(0.5)
+
+        while flag:
+            area.text("𓀤 upload PDF file 𓀤")
+            time.sleep(1)
+            area.text("𓀥                 𓀥")
+            time.sleep(0.8)
+    else:
+        if f"select_lang{st.session_state.count}" in st.session_state:
+            statename = f"select_lang{st.session_state.count}"
+            if st.session_state[statename] != "select language":
+                plain_text2 = "Reset Language"
+                var_text2 = f'<span style="color:gray">▲ `{plain_text2}`</span>'
+                area.write(var_text2, unsafe_allow_html=True)
+
+        obj_0.empty()
+        obj_1.empty()  # uploader hide
+
+        # pdf translator
+        #------------------------------------------
+        st.markdown("----")
+        st.success("translator")
+
+        if "book" in st.session_state:
+            book_data = st.session_state.book
+            page_count = len(book_data)
+        else:
+            page_count = 0
+
+        st.text(f"PDF total pages : {page_count}")
+
+        progressbar = st.empty()
+        my_bar = progressbar.progress(0)
+
+        #3
+        #        from google.colab import output
+        import re
+        #from googletrans import Translator
+        from deep_translator import GoogleTranslator
+
+        title_name = re.sub("\.| |%|@|\"|\'", "_", f"{uploaded_file.name}")
+
+        if st.session_state.temp != int(st.session_state.count):
+            st.session_state.lang = "init"
+            st.session_state.temp = int(st.session_state.count)
+
+        if language not in lang_code[1:]:
+            language = None
+
+        if st.session_state.lang != language and language is not None:
+            st.session_state.count += 1
+            st.session_state.result = ""
+            st.session_state.lang = language
+
+            my_makedirs(
+                f"removefolder/{temp_dir}/work_{st.session_state.count}")
+
+            to = ""
+            match language:
+                case "Japanese":
+                    to = "ja"
+                case "English":
+                    to = "en"
+                case "French":
+                    to = "fr"
+                case "Chinese traditional":
+                    to = "zh-TW"
+                case "Chinese simplified":
+                    to = "zh-CN"
+                case "Russian":
+                    to = "ru"
+                case "Korean":
+                    to = "ko"
+                case "Vietnamese":
+                    to = "vi"
+                case "Thai":
+                    to = "th"
+                case "Catalan":
+                    to = "ca"
+                case "Sinhalese":
+                    to = "si"
+                case _:
+                    to = "unknown"
+
+            st.info(f"translate to [ {language} ]")
+
+            st.session_state.target_lang = to
+
+            work_area1 = st.empty()
+            work_area2 = st.empty()
+            #--------------------------------------
+
+            for index, page in enumerate(book_data):
+                page_text = page[1]
+                #                print("\nPage Number:" + str(index))
+                done = int(((index + 1) / page_count) * 100)
+                my_bar.progress(done,
+                                text=f"Working Page Number : {index + 1}")
+                #  print(len(page_text))
+                #  text_list = [s for s in page_text.split('\n') if s]
+                page_text = re.sub('\.', '.𓂀', page_text)
+                text_list = [s for s in page_text.split('𓂀')]
+                if len(text_list) < 1:
+                    continue
+
+                limit = 0
+                temp_list = []
+                line_number = []
+
+                for n, line in enumerate(text_list):
+                    limit += 1
+                    if limit > 10:
+                        limit = 0
+
+
+#                        output.clear()
+
+                    line2 = re.sub(r"\s+", " ", line)
+                    if line2 == "":
+                        continue
+                    temp_list.append((n, line2))
+
+                    if len(temp_list) == 15 or n == len(text_list) - 1:
+                        text_ = ""
+                        all_text_orig = ""
+                        all_text_done = ""
+                        for i, t in enumerate(temp_list):
+                            if t[1] != " ":
+                                line_number.append(t[0])
+                                text_ += '𓂀' + t[1].strip()
+                        temp_list.clear()
+
+                        text_2 = text_
+                        text_ = re.sub('𓂀', "", text_)
+                        while (re.search('𓂀', text_2)):
+                            num = line_number.pop(0)
+                            rep_words = f"𓃐NO:{num}| "
+                            text_2 = text_2.replace('𓂀', rep_words, 1)
+                        line_number.clear()
+
+                        #                        print(re.sub("𓃐","\n", text_2))
+                        #ts = Translator()
+                        all_text_orig = f":::info\n𓃰{index + 1:05d}" + f"-{n}" + f";\n:::\n{text_}\n"
+
+                        for times in range(0, 5):
+
+                            try:
+                                tsd = GoogleTranslator(
+                                    source="auto",
+                                    target=to).translate(text=text_)
+                                if tsd == None:
+                                    tsd = text_
+                                #tsd = ts.translate(text_, src="en", dest="ja")
+                                #translated_text = ts.translate(line, src="en", dest="ja").text
+                                all_text_done = f":::info\n𓆏{index + 1:05d}" + f"-{n}" + f";\n:::\n{tsd}\n"
+                                #all_text_done = f"**{index:05d}" + f"-{n}" + "; " +  tsd.text + "\n"
+
+                                # all_text_orig += str(n) + "; " + tsd.pronunciation + "\n"
+                                # print(index,n, line)
+                                # print(index,n, tsd.text)
+
+                                #                                print(all_text_orig)
+                                #                                print(all_text_done + "\n")
+                                if type(all_text_orig) is str and type(
+                                        all_text_done) is str:
+
+                                    #                                    intext_1 = f'<span style="color:DimGray;background:GhostWhite">{all_text_orig}</span>'
+                                    #                                    work_area1.markdown(intext_1, unsafe_allow_html=True)
+                                    # intext_2 = f'<span style="color:LavenderBlush;background:LightGray">{all_text_done}</span>'
+                                    work_area2.write(f"{all_text_done}")
+                                    # work_area2.markdown(intext_2, unsafe_allow_html=True)
+
+                                    with open(
+                                            f"removefolder/{temp_dir}/work_{st.session_state.count}/reuseMarkdown.txt",
+                                            "a") as tempf:
+                                        tempf.write(all_text_orig + "\n\n" +
+                                                    all_text_done + "\n\n")
+
+                                    # st.session_state.result += all_text_orig + "\n\n"
+                                    # st.session_state.result += all_text_done + "\n\n"
+
+                                # print(n, tsd.pronunciation)
+                                with open(
+                                        f"removefolder/{temp_dir}/work_{st.session_state.count}/{title_name}_done.txt",
+                                        "a") as f:
+                                    f.write(all_text_orig + all_text_done +
+                                            "\n")
+                                with open(
+                                        f"removefolder/{temp_dir}/work_{st.session_state.count}/{title_name}_done_{language}.txt",
+                                        "a") as f:
+                                    f.write(all_text_done + "\n")
+
+                                break
+
+                            except Exception as e:
+                                print(e)
+                                time.sleep(3)
+                                continue
+
+                        with open(
+                                f"removefolder/{temp_dir}/work_{st.session_state.count}/{title_name}_orig.txt",
+                                "a") as f:
+                            f.write(all_text_orig + "\n")
+
+            st.balloons()
+            st.markdown("----")
+
+            my_makedirs(f"removefolder/{temp_dir}/download_section")
+            shutil.move(
+                f"removefolder/{temp_dir}/work_{st.session_state.count}/reuseMarkdown.txt",
+                f"removefolder/{temp_dir}/download_section/reuseMarkdown_{st.session_state.count}.txt"
+            )
+
+            shutil.make_archive(
+                f'removefolder/{temp_dir}/download_section/{st.session_state.uploadedfilename}_{st.session_state.count}',\
+                format='zip',\
+                root_dir=f'removefolder/{temp_dir}/work_{st.session_state.count}'\
+                )
+            shutil.rmtree(
+                f"removefolder/{temp_dir}/work_{st.session_state.count}")
+
+            #--------------------------------------
+
+            st.success("Download translated text files")
+            st.write(intext_0, unsafe_allow_html=True)
+            # plain_text3 = f"[ {st.session_state.target_lang} ] : translated text files"
+            plain_text3 = f"[ {language} ] : translated text files"
+            var_text3 = f'##### <span style="color:#FF69B4">{plain_text3}</span>'
+
+            translated = st.empty()
+            translated.write(var_text3, unsafe_allow_html=True)
+
+            if os.path.isfile(
+                    f'removefolder/{temp_dir}/download_section/{st.session_state.uploadedfilename}_{st.session_state.count}.zip'
+            ):
+                with open(
+                        f"removefolder/{temp_dir}/download_section/{st.session_state.uploadedfilename}_{st.session_state.count}.zip",
+                        "rb") as fpath:
+                    btn = st.download_button(
+                        label=f"DOWNLOAD .zip file",
+                        data=fpath,
+                        file_name=
+                        f"{st.session_state.uploadedfilename}_{st.session_state.count}.zip",
+                        mime="application/zip")
+
+            plain_text4 = "download zipfile"
+            var_text4 = f'<span style="color:gray">▲ `{plain_text4}` 𓁉 </span>'
+            st.write(var_text4, unsafe_allow_html=True)
+
+            st.markdown("----")
+
+            plain_text5 = " 𓀡 results 𓁙 "
+            var_text5 = f'##### <span style="color:#20B2AA">{plain_text5}</span>'
+            st.write(var_text5, unsafe_allow_html=True)
+
+            tempf = open(
+                f"removefolder/{temp_dir}/download_section/reuseMarkdown_{st.session_state.count}.txt"
+            )
+            all_result = tempf.read()
+            tempf.close()
+            st.write(intext_0, unsafe_allow_html=True)
+            st.write(all_result, unsafe_allow_html=True)
+            # st.write(st.session_state.result, unsafe_allow_html=True)
+
+if __name__ == "__main__":
+    heart_beat()
+    
+    main()