Upload files

Dockerfile

@@ -0,0 +1,30 @@
+FROM python:3.10-slim
+WORKDIR /code
+COPY ./requirements.txt /code/requirements.txt
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+RUN apt update && apt install -y ffmpeg
+RUN apt -y install wget
+RUN apt -y install firefox-esr
+
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH \
+    GECKODRIVERURL=https://github.com/mozilla/geckodriver/releases/download/v0.34.0/geckodriver-v0.34.0-linux64.tar.gz \
+    GECKODRIVERFILENAME=geckodriver-v0.34.0-linux64.tar.gz
+    
+
+WORKDIR $HOME/app
+
+COPY --chown=user . $HOME/app
+
+RUN wget -P $HOME/app $GECKODRIVERURL
+RUN tar --warning=no-file-changed -xzf $HOME/app/$GECKODRIVERFILENAME
+RUN rm $HOME/app/$GECKODRIVERFILENAME
+
+RUN chmod -x geckodriver
+
+RUN ls -ltr
+
+EXPOSE 7860
+ENTRYPOINT ["uvicorn", "api:app", "--host", "0.0.0.0", "--port", "7860"]

api.py

@@ -0,0 +1,134 @@
+import re
+import os
+from transformers import (BartTokenizerFast, 
+                          TFAutoModelForSeq2SeqLM)
+import tensorflow as tf
+from scraper import scrape_text
+from fastapi import FastAPI, Response
+from typing import List
+from pydantic import BaseModel
+import uvicorn
+import json
+import logging
+import multiprocessing
+
+
+os.environ['TF_USE_LEGACY_KERAS'] = "1"
+
+SUMM_CHECKPOINT = "facebook/bart-base"
+SUMM_INPUT_N_TOKENS = 400
+SUMM_TARGET_N_TOKENS = 300
+
+
+def load_summarizer_models():
+    summ_tokenizer = BartTokenizerFast.from_pretrained(SUMM_CHECKPOINT)
+    summ_model = TFAutoModelForSeq2SeqLM.from_pretrained(SUMM_CHECKPOINT)
+    summ_model.load_weights(os.path.join("models", "bart_en_summarizer.h5"), by_name=True)
+    logging.warning('Loaded summarizer models')
+    return summ_tokenizer, summ_model
+
+
+def summ_preprocess(txt):
+    txt = re.sub(r'^By \. [\w\s]+ \. ', ' ', txt) # By . Ellie Zolfagharifard . 
+    txt = re.sub(r'\d{1,2}\:\d\d [a-zA-Z]{3}', ' ', txt) # 10:30 EST
+    txt = re.sub(r'\d{1,2} [a-zA-Z]+ \d{4}', ' ', txt) # 10 November 1990
+    txt = txt.replace('PUBLISHED:', ' ')
+    txt = txt.replace('UPDATED', ' ')
+    txt = re.sub(r' [\,\.\:\'\;\|] ', ' ', txt) # remove puncts with spaces before and after
+    txt = txt.replace(' : ', ' ')
+    txt = txt.replace('(CNN)', ' ')
+    txt = txt.replace('--', ' ')
+    txt = re.sub(r'^\s*[\,\.\:\'\;\|]', ' ', txt) # remove puncts at beginning of sent
+    txt = re.sub(r' [\,\.\:\'\;\|] ', ' ', txt) # remove puncts with spaces before and after
+    txt = re.sub(r'\n+',' ', txt)
+    txt = " ".join(txt.split())
+    return txt
+
+
+def summ_inference_tokenize(input_: list, n_tokens: int):
+    tokenized_data = summ_tokenizer(text=input_, max_length=SUMM_TARGET_N_TOKENS, truncation=True, padding="max_length", return_tensors="tf")
+    return summ_tokenizer, tokenized_data    
+
+
+def summ_inference(txts: str):
+    txts = [*map(summ_preprocess, txts)]
+    inference_tokenizer, tokenized_data = summ_inference_tokenize(input_=txts, n_tokens=SUMM_INPUT_N_TOKENS)
+    pred = summ_model.generate(**tokenized_data, max_new_tokens=SUMM_TARGET_N_TOKENS)
+    result = ["" if t=="" else inference_tokenizer.decode(p, skip_special_tokens=True).strip() for t, p in zip(txts, pred)]
+    return result
+
+# def scrape_multi_process(urls):
+#     logging.warning('Entering get_news_multi_process() to extract new news articles')
+#     '''
+#     Get the data shape by parallely calculating lenght of each chunk and 
+#     aggregating them to get lenght of complete training dataset
+#     '''
+#     pool = multiprocessing.Pool(processes=multiprocessing.cpu_count())
+    
+#     results = []
+#     for url in urls:
+#         f = pool.apply_async(scrape_text, [url]) # asynchronously applying function to chunk. Each worker parallely begins to work on the job
+#         results.append(f) # appending result to results
+        
+#     scraped_texts = []
+#     for f in results:
+#         scraped_texts.append(f.get(timeout=120))
+#     pool.close()
+#     pool.join()
+#     logging.warning('Exiting scrape_multi_process()')
+#     return scraped_texts
+
+def scrape_urls(urls):
+    scraped_texts = []
+    scrape_errors = []
+    for url in urls:
+        text, err = scrape_text(url)
+        scraped_texts.append(text)
+        scrape_errors.append(err)
+    return scraped_texts, scrape_errors
+
+##### API #####
+app = FastAPI()
+summ_tokenizer, summ_model = load_summarizer_models()
+
+class URLList(BaseModel):
+    urls: List[str]
+    key: str
+
+
+class NewsSummarizerAPIAuthenticationError(Exception):
+    pass 
+
+
+def authenticate_key(api_key: str):
+    if api_key != os.getenv('API_KEY'):
+        raise NewsSummarizerAPIAuthenticationError("Authentication error: Invalid API key.")
+
+@app.post("/generate_summary/")
+async def read_items(q: URLList):
+    try:
+        urls = ""
+        scraped_texts = ""
+        scrape_errors = ""
+        summaries = ""
+        request_json = q.json()
+        request_json = json.loads(request_json)
+        urls = request_json['urls']
+        api_key = request_json['key']
+        _ = authenticate_key(api_key)
+        scraped_texts, scrape_errors = scrape_urls(urls)
+        summaries = summ_inference(scraped_texts)
+        status_code = 200
+        response_json = {'urls': urls, 'scraped_texts': scraped_texts, 'scrape_errors': scrape_errors, 'summaries': summaries, 'summarizer_error': ''}
+    except Exception as e:
+        status_code = 500
+        if e.__class__.__name__ == "NewsSummarizerAPIAuthenticationError":
+            status_code = 401
+        response_json = {'urls': urls, 'scraped_texts': scraped_texts, 'scrape_errors': scrape_errors, 'summaries': "", 'summarizer_error': f'error: {e}'}
+
+    json_str = json.dumps(response_json, indent=5) # convert dict to JSON str
+    return Response(content=json_str, media_type='application/json', status_code=status_code)
+
+
+if __name__ == '__main__':
+    uvicorn.run(app=app, host='0.0.0.0', port=7860)

models/bart_en_summarizer.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7e6381d18af41ddc2b674cde800281c5eb65ece6f0c964ab5a0e5f20b362d801
+size 558172300

requirements.txt

@@ -0,0 +1,8 @@
+transformers==4.39.3
+tensorflow==2.15.0
+unidecode
+tf-keras==2.15.0
+selenium==4.19.0
+fastapi
+pydantic
+uvicorn

scraper.py

@@ -0,0 +1,58 @@
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver import FirefoxOptions
+import re
+import logging
+import os
+
+
+def get_text(url, n_words=15):
+    try:
+        # geckodriver_path ='/home/user/app/geckodriver'
+        # os.environ['PATH'] += ':' + geckodriver_path
+        # os.environ['SELENIUM_DRIVER_CAPABILITIES'] = '{"alwaysLoadVcDrivers": true}'
+        driver = None
+        logging.warning(f"Initiated Scraping {url}")
+        user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36"
+        opts = FirefoxOptions()
+        opts.add_argument("--headless")
+        opts.add_argument(f"user-agent={user_agent}")
+        # opts.binary = geckodriver_path
+        # webdriver.firefox.driver = geckodriver_path
+        driver = webdriver.Firefox(options=opts)
+        driver.set_page_load_timeout(50)
+        driver.get(url)
+        elem = driver.find_element(By.TAG_NAME, "body").text
+        sents = elem.split("\n")
+        sentence_list = []
+        for sent in sents:
+            sent = sent.strip()
+            if (len(sent.split()) >= n_words) and (len(re.findall(r"^\w.+[^\w\)\s]$", sent))>0):
+                sentence_list.append(sent)
+        driver.quit()
+        logging.warning("Closed Webdriver")
+        logging.warning("Successfully scraped text")
+        if len(sentence_list) < 3:
+            raise Exception("Found nothing to scrape.")
+        return "\n".join(sentence_list), ""
+    except Exception as e: 
+        logging.warning(str(e))
+        if driver:
+            driver.close()
+            logging.warning("Closed Webdriver")
+        err_msg = str(e).split('\n')[0]
+        return "", err_msg
+
+
+def scrape_text(url, n_words=15,max_retries=2):
+    scraped_text = ""
+    scrape_error = ""
+    try:
+        n_tries = 1
+        while (n_tries <= max_retries) and (scraped_text == ""):
+            scraped_text, scrape_error = get_text(url=url, n_words=n_words)
+            n_tries += 1
+        return scraped_text, scrape_error
+    except Exception as e:
+        err_msg = str(e).split('\n')[0]
+        return "", err_msg