|
""" |
|
Cellar text and eurovoc extraction |
|
|
|
python update.py 10000 dataset.jsonl |
|
|
|
will extract for the last 10,000 days text in english and eurovoc labels in the JSON line file. |
|
|
|
|
|
requirements: |
|
beautifulsoup4==4.12.2 |
|
docx2txt==0.8 |
|
ipython==8.14.0 |
|
jinja2==3.1.2 |
|
joblib==1.3.1 |
|
pdfminer.six==20221105 |
|
pip-chill==1.0.3 |
|
pycryptodome==3.18.0 |
|
requests==2.31.0 |
|
tqdm==4.65.0 |
|
xmltodict==0.13.0 |
|
""" |
|
import datetime |
|
import json |
|
from concurrent.futures import ProcessPoolExecutor |
|
|
|
from bs4 import BeautifulSoup |
|
import logging |
|
import re |
|
import sys |
|
|
|
from tqdm import tqdm |
|
from io import BytesIO |
|
import jinja2 |
|
from joblib import Memory |
|
|
|
location = './cache' |
|
memory = Memory(location, verbose=0) |
|
|
|
log = logging.getLogger(__name__) |
|
log.addHandler(logging.FileHandler('collect.log')) |
|
log.setLevel(logging.DEBUG) |
|
|
|
import xmltodict |
|
|
|
import docx2txt as docx2txt |
|
import requests |
|
from joblib import expires_after |
|
from pdfminer.high_level import extract_text |
|
|
|
|
|
def clean_text(func): |
|
""" |
|
Decorator used to clean the text |
|
:param func: |
|
:return: |
|
""" |
|
|
|
def inner(*args, **kwargs): |
|
text = func(*args, **kwargs) |
|
text = text.replace("\n", " ") |
|
text = text.replace(" .", ".") |
|
text = re.sub(' +', ' ', text) |
|
text = re.sub(' *[.] *', '. ', text) |
|
text = re.sub('\.\s*\.\s*\.+', '. ', text) |
|
text = '. '.join([s.strip() for s in text.split(".") if len(s.strip())]) |
|
return text |
|
|
|
return inner |
|
|
|
|
|
@memory.cache(cache_validation_callback=expires_after(minutes=120)) |
|
def get_eurovoc_terms_and_id(): |
|
eurovoc_terms_and_id = {} |
|
response = requests.get('http://publications.europa.eu/resource/dataset/eurovoc', |
|
headers={'Accept': 'application/xml', |
|
'Accept-Language': 'en'} |
|
) |
|
data = xmltodict.parse(response.content) |
|
for term in data['xs:schema']['xs:simpleType']['xs:restriction']['xs:enumeration']: |
|
try: |
|
name = term['xs:annotation']['xs:documentation'].split('/')[0].strip() |
|
for r in term['xs:annotation']['xs:appinfo']['record']: |
|
if r['@thesaurus_id'] != '': |
|
eurovoc_terms_and_id[name.lower()] = r['@thesaurus_id'] |
|
except KeyError as e: |
|
log.warning("⚠️ Could not parse", term) |
|
return eurovoc_terms_and_id |
|
|
|
|
|
def get_sparql_query(d): |
|
start = d.strftime('%Y-%m-%d') |
|
end = d + datetime.timedelta(days=2) |
|
end = end.strftime('%Y-%m-%d') |
|
environment = jinja2.Environment() |
|
template = environment.from_string(open("query.j2", 'r').read()) |
|
return template.render(start=start, end=end) |
|
|
|
|
|
def get_json_response(d): |
|
url = "https://publications.europa.eu/webapi/rdf/sparql" |
|
params = {"default-graph-uri": "", |
|
"query": get_sparql_query(d), |
|
"format": "application/sparql-results+json", |
|
"timeout": "0", |
|
"debug": "on", |
|
"run": "Run Query"} |
|
|
|
response = requests.get(url, params) |
|
assert response.status_code == 200 |
|
return response.json() |
|
|
|
|
|
def get_concepts_id(list_of_eurovoc_terms): |
|
terms = get_eurovoc_terms_and_id() |
|
for e in list_of_eurovoc_terms: |
|
try: |
|
yield terms[e.strip().lower()] |
|
except KeyError: |
|
log.warning(f"⚠️ Could not find {e} in Eurovoc") |
|
|
|
|
|
def get_docs(d): |
|
results = get_json_response(d) |
|
for r in results['results']['bindings']: |
|
terms = r['subjects']['value'].replace(u'\xa0', u' ').split(',') |
|
r['eurovoc_concepts'] = terms |
|
r['url'] = r['cellarURIs']['value'] |
|
r['title'] = r['title']['value'] |
|
r['date'] = r['date']['value'] |
|
r['lang'] = r['langIdentifier']['value'].lower() |
|
r['formats'] = [t for t in r['mtypes']['value'].split(',')] |
|
for c in ['cellarURIs', 'mtypes', 'langIdentifier', 'subjects', 'authors', 'workTypes', 'workIds']: |
|
del r[c] |
|
yield r |
|
|
|
|
|
def get_docs_text(d): |
|
docs = list(get_docs(d)) |
|
print(f"Processing documents ... {len(docs)}") |
|
with ProcessPoolExecutor(max_workers=16) as executor: |
|
for v in tqdm(executor.map(get_body, docs), total=len(docs), colour='green'): |
|
yield v |
|
|
|
|
|
def get_body(r): |
|
try: |
|
if 'pdf' in r['formats']: |
|
r['text'] = get_pdf_body(r) |
|
elif 'docx' in r['formats']: |
|
r['text'] = get_docx_body(r) |
|
elif 'doc' in r['formats']: |
|
r['text'] = get_doc_body(r) |
|
elif 'xhtml' in r['formats']: |
|
r['text'] = get_xhtml_body(r) |
|
else: |
|
log.warning(f"⚠️ Could not find a parser for {r['formats']}") |
|
return r |
|
except Exception as e: |
|
log.error(str(e) + str(r) ) |
|
|
|
|
|
|
|
@clean_text |
|
@memory.cache() |
|
def get_pdf_body(r): |
|
url = r['url'] |
|
language = r['lang'] |
|
accept = 'application/pdf' |
|
response = requests.get(url, headers={'Accept': accept, 'Accept-Language': language}) |
|
if response.status_code == 300: |
|
return " ".join(_multiple_choice(get_pdf_body, response, accept, language)) |
|
elif response.status_code == 200: |
|
mem = BytesIO(response.content) |
|
return extract_text(mem) |
|
|
|
@clean_text |
|
@memory.cache() |
|
def get_xhtml_body(r): |
|
url = r['url'] |
|
language = r['lang'] |
|
accept = 'application/xhtml+xml' |
|
response = requests.get(url, headers={'Accept': accept, 'Accept-Language': language}) |
|
if response.status_code == 300: |
|
return " ".join(_multiple_choice(get_xhtml_body, response, accept, language)) |
|
elif response.status_code == 200: |
|
soup = BeautifulSoup(response.content, 'html.parser') |
|
return soup.get_text() |
|
|
|
def get_docx_body(r): |
|
accept = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml' |
|
url = r['url'] |
|
lang = r['lang'] |
|
try: |
|
return _get_doc_body(url, accept, lang) |
|
except AssertionError as e: |
|
log.warning(f"⚠️ Could not download {url} {e}") |
|
print(f"⚠️ Could not download {r} --- {accept} {e}") |
|
return "" |
|
|
|
|
|
def get_doc_body(r): |
|
accept = 'application/msword' |
|
url = r['url'] |
|
lang = r['lang'] |
|
try: |
|
return _get_doc_body(url, accept, lang) |
|
except AssertionError as e: |
|
log.warning(f"⚠️ Could not download {url} {e}") |
|
print(f"⚠️ Could not download {r} --- {accept} {e}") |
|
return "" |
|
|
|
def _multiple_choice(func, response, accept, language): |
|
soup = BeautifulSoup(response.text, 'html.parser') |
|
for link in soup.find_all('a'): |
|
if 'href' in link.attrs: |
|
url = link.attrs['href'] |
|
yield func(url, accept, language) |
|
|
|
@clean_text |
|
@memory.cache() |
|
def _get_doc_body(url, accept, language='en'): |
|
response = requests.get(url, headers={'Accept': accept, 'Accept-Language': language}) |
|
if response.status_code == 300: |
|
return " ".join(_multiple_choice(_get_doc_body, response, accept, language)) |
|
elif response.status_code == 200: |
|
mem = BytesIO(response.content) |
|
log.info(f"📄 MS Word doc download and parsed {url}") |
|
return docx2txt.process(mem) |
|
else: |
|
raise AssertionError(f"📄 MS Word doc download failed {url} {response.status_code} {response.content}") |
|
|
|
|
|
if __name__ == '__main__': |
|
output = sys.argv[1] |
|
max = int(sys.argv[2]) |
|
ofiles = {} |
|
for i in range(max): |
|
d = datetime.date.today() - datetime.timedelta(days=i) |
|
print(d) |
|
ym = d.strftime('%Y-%m') |
|
if ym not in ofiles: |
|
ofiles[ym] = open(output + ym + '.jsonl', 'w') |
|
try: |
|
for d in get_docs_text(d): |
|
ofiles[ym].write(json.dumps(d) + '\n') |
|
ofiles[ym].flush() |
|
except Exception as e: |
|
log.error('Day ' + str(d) + ' ' + str(e)) |
|
print ('Day ' + str(d) + ' ' + str(e)) |
|
for f in ofiles.values(): |
|
f.close() |
|
|
