add pages and all

.gitignore

@@ -1,2 +1,3 @@
 .idea
 .venv
+.env

.streamlit/config.toml

@@ -0,0 +1,2 @@
+[theme]
+base="light"

pages/0_DB_Overview.py

@@ -0,0 +1,67 @@
+import pandas as pd
+from src.utils.markdown_processing.md_preprocessing import convert_html_to_md
+from src.persistence.db import *
+import streamlit_nested_layout
+
+
+@st.cache_resource
+def init_connection():
+    return init_db()
+
+def render_url_content(element):
+    with st.container(border=True, height=400):
+        md = convert_html_to_md(element["cleaned_html"])
+        st.markdown(md, unsafe_allow_html=True)
+
+db = init_connection()
+
+# Titel der App
+st.title("Übersicht über die Datenbank-Inhalte")
+st.subheader("Aktuelle Einträge in der DB")
+st.write("""
+    - **unsorted_urls**: Enthält Daten-Objekte bestehend aus Start-Urls, Url-Typ (z.b. "city", "theater") sowie vom Crawler gefundene Sub-Urls.
+    - **event_urls**: Enthält Daten-Objekte bestehend aus Url, Referenz zur Basis-Url (Start-Url), Klasse (EventDetail / EventOverview) sowie HTML der Seite""")
+df = pd.DataFrame({
+    "DB-Collection":[
+       CollectionNames.UNSORTED_URLS,
+       CollectionNames.EVENT_URLS],
+    "Anzahl an Einträgen":[
+        db.unsorted_urls.count_documents({}),
+        db.event_urls.count_documents({})],
+    "Bereits verarbeitet":[
+        db.unsorted_urls.count_documents({"crawled": True}),
+        db.event_urls.count_documents({"final":True})
+    ]})
+st.table(df)
+
+overview_pages = list(db.event_urls.find(filter={"class":"EventOverview", "final":True}, projection={"url":1,"base_url_id":1,"cleaned_html":1}))
+detail_pages = list(db.event_urls.find(filter={"class":"EventDetail", "final":True}, projection={"url":1,"base_url_id":1,"cleaned_html":1, "data":1}) )
+
+st.subheader("Fertige Einträge in Event Urls:")
+st.write("Die fertigen Daten sind mithilfe der gpt-api in markdown übersetzt und nur der Veranstaltungsbereich heraus geschnitten.")
+data = [el for el in detail_pages if "data" in el]
+st.write(f"Fertig verarbeitete Urls: {len(data)} von {len(detail_pages)}")
+
+st.subheader("Einträge in Event Urls")
+st.write("""
+    Die Übersicht zeigt die finalen Daten aus **event_urls**, sortiert nach ihrer Klasse.""")
+with st.expander(f"Event-Übersichtsseiten ({len(overview_pages)})"):
+        for el in overview_pages:
+            try:
+                with st.expander(f"{el['url']} - ({db.unsorted_urls.find_one(filter={'_id':el['base_url_id']}, projection={'url_type':1})['url_type']})"):
+                    render_url_content(el)
+            except Exception as e:
+                st.write(f"Fehler: {e}")
+
+
+with st.expander(f"Event-Detailseiten ({len(detail_pages)})"):
+        for el in detail_pages:
+            try:
+                with st.expander(f"{el['url']}"):
+                    render_url_content(el)
+            except Exception as e:
+                st.write(f"Fehler bei {el['url']}: {e} ")
+
+
+
+

pages/1_Get_Urls.py

@@ -0,0 +1,131 @@
+from src.crawler.CrawlerV2 import Crawler
+from src.crawler.crawler_service import *
+from src.crawler.utils.maps_types import MAPS_TYPES
+from src.crawler.maps_api import get_maps_results
+from src.persistence.db import *
+import random
+import streamlit_nested_layout
+
+
+@st.cache_resource
+def init_connection():
+    return init_db()
+
+def crawl(item):
+        results =[]
+        try:
+            st.info(f"Crawle {item['url']}")
+
+            if "overview_pages" not in item:
+                crawler = Crawler(item["url"], item["url_type"], depth=2)
+                results = crawler.crawl()
+        except Exception as e:
+            st.error(f"Fehler beim crawlen: {e}")
+            db.unsorted_urls.delete_one({"_id":item["_id"]})
+            return
+
+        # Übersicht-Seiten erkennen
+        overview_regex = re.compile(
+            r"^https?:\/\/([a-zA-Z0-9.-]*\/)*(?!(advent))(kalender|.*veranstaltungen|veranstaltungskalender|.*events?|.*event-?kalender|([a-zA-Z]*)?programm|gottesdienste|auff(ü|ue)hrungen|termine|spielplan)(\/?|(\/?[a-zA-Z]*)\.[a-zA-Z]*)?$",
+            re.IGNORECASE)
+        overview_pages = set()
+        # URLs sortieren
+
+        sub_urls=[]
+        for url in results:
+            if overview_regex.match(url):
+                overview_pages.add(url)
+            else:
+                sub_urls.append(url)
+        if not overview_pages:
+            overview_regex = re.compile(
+                r"^https?:\/\/([a-zA-Z0-9.-]*\/)*(?!(advent))(kalender|.*veranstaltungen|veranstaltungskalender|.*events?|.*event-?kalender|([a-zA-Z]*)?programm|gottesdienste|auff(ü|ue)hrungen|termine|spielplan)(\/?|(\/?[a-zA-Z]*)\.[a-zA-Z]*)?",
+                re.IGNORECASE)
+            for url in results:
+                match = overview_regex.search(url)
+                if match:
+                    overview_pages.add(match.group())
+        overview_pages = {url.casefold() for url in overview_pages}
+
+        with st.expander("Gefundene Suburls"):
+            for url in sub_urls:
+                st.write(url)
+        with st.expander("Gefundene Übersichtsseiten:"):
+            for url in overview_pages:
+                st.write(url)
+
+        # Update DB entry
+        new_values = {"$set": {"crawled": True}}
+        if overview_pages:
+            new_values["$set"]["overview_pages"] = list(overview_pages)
+        if sub_urls:
+            item["sub_urls"] = sub_urls
+            new_values["$set"]["sub_urls"] = sub_urls
+
+        db.unsorted_urls.update_one({"_id":item["_id"]}, new_values)
+        print(db.unsorted_urls.find_one({"_id":item["_id"]}))
+
+db = init_connection()
+
+# content
+st.title("Event-Urls-Suche mit Crawler und Google API")
+st.write("""
+    Wähle aus für wie viele Urls der **Crawler** gestartert werden soll. Diese werden zufällig aus den noch nicht gecrawlten Urls aus der DB ausgewählt.
+    Wenn **"Google Maps Ergebnisse finden"** aktiviert ist, werden bei den Stadtportalen zusätzlich noch neue Veranstaltungsorte gesucht.""")
+with st.form("Crawler Settings"):
+    count = st.number_input("Wie viele URLs sollen gecrawled werden?", step=1)
+    maps = st.checkbox("Google Maps Ergebnisse finden",disabled=True)
+    st.info("Aktuell können keine neuen Start-URLs generiert werden. Billing für GCP fehlt.")
+    # Every form must have a submit button.
+    submitted = st.form_submit_button("Starte Crawler")
+    if submitted:
+        for i in range(count):
+            item = db.unsorted_urls.find_one({"crawled": None })
+            with st.expander(f"Ergebnisse für {item['url']} in {item['meta']['location']}"):
+
+                if item["url_type"] == "city" and maps:
+                    for type_id in random.sample(MAPS_TYPES, 5):
+                        print(item)
+                        if "maps_searches" not in item or "maps_searches" in item and type_id not in item["maps_searches"]:
+                            st.info(f"Suche Maps Ergebnisse für {type_id} in {item['meta']['location']}")
+                            maps_results = get_maps_results(type_id, item["meta"]["location"])
+                            if maps_results:
+                                new_elements = []
+                                with st.expander("Maps Ergebnisse"):
+                                    for result in maps_results:
+                                        if result.website_uri \
+                                                and "facebook" not in result.website_uri \
+                                                and "instagram" not in result.website_uri \
+                                                and "tiktok" not in result.website_uri \
+                                                and result.website_uri not in [e["url"] for e in new_elements]:
+                                            element = {
+                                                "url_type": type_id,
+                                                "url": result.website_uri,
+                                                "meta":{
+                                                    "website_host": result.display_name.text,
+                                                    "location": result.formatted_address.split(", ")[1],
+                                                    "address": result.formatted_address,
+                                                    "maps_types": list(result.types)
+                                                }}
+                                            st.write(f"{element['meta']['website_host']} - {element['url']}")
+                                            new_elements.append(element)
+                                    if new_elements:
+                                        db.unsorted_urls.insert_many(new_elements)
+
+                            if "maps_searches" in item:
+                                maps_searches = item["maps_searches"]
+                                maps_searches.append(type_id)
+                                item["maps_searches"] = maps_searches
+                            else:
+                                item["maps_searches"] =  [type_id]
+                        else:
+                            st.success("Maps Ergebnisse bereits in DB")
+
+                crawl(item)
+
+
+
+
+
+
+

pages/2_Get_Event_Data.py

@@ -0,0 +1,121 @@
+import streamlit as st
+from src.crawler.CrawlerV2 import *
+from bs4 import BeautifulSoup
+from src.utils.apis.gpt_api import classify_text
+import random
+
+from src.utils.helpers import clean_html, strip_html_to_text
+from src.utils.markdown_processing.md_preprocessing import convert_html_to_md
+from src.persistence.db import init_db
+from lxml import etree
+import streamlit_nested_layout
+
+@st.cache_resource
+def init_connection():
+    return init_db()
+
+def get_html(url:str):
+    response = requests.get(url)
+    if response.status_code >= 400:
+        print(f"Skipping {overview_url} with status code {response.status_code}")
+        return None
+    else:
+        return response.content
+
+def process_url(url:str, el):
+    try:
+        page_content = get_html(url)
+        if page_content:
+            cleaned_html = clean_html(page_content)
+            cleaned_text = strip_html_to_text(cleaned_html)
+            md = convert_html_to_md(cleaned_html)
+            gpt_class = classify_text(md)
+            with st.expander(url):
+                st.write("Bereinigtes HTML:")
+                with st.container(border=True, height=400):
+                    st.markdown(md)
+                st.write(f"GPT Klasse: {gpt_class['class']}")
+
+            if gpt_class["class"] != "None":
+                new_element = {
+                    "base_url_id": el["_id"],
+                    "base_url": el["url"],
+                    "url": url,
+                    "html": page_content,
+                    "cleaned_html": cleaned_html,
+                    "cleaned_text": cleaned_text,
+                    "class": gpt_class["class"]
+                }
+                db.event_urls.update_one(
+                    {"url": new_element["url"]},
+                    {"$setOnInsert": new_element},
+                    upsert=True
+                )
+                return new_element
+    except Exception as e:
+        st.error(f"Es is ein Fehler aufgetreten, die url {url} wird übersprungen\n Fehlermeldung: {e}")
+
+
+db = init_connection()
+
+suburls_count = 10
+
+# content
+st.title("Generieren von Event Daten")
+st.write("""
+    Hier werden die potentiellen Übersichtsseiten aus unsorted_urls sowie alle Links auf dieser Seite mithilfe der GPT API überprüft und den beiden Klassen **"EventDetail"** und **"EventOverview"** zugeordnet. Die Event Daten werden dann als neues Objekt in event_urls gespeichert.""")
+st.info(
+    f"Es werden immer nur max. {suburls_count} Suburls der Übersichtsseiten angeschaut, damit die Daten ausgeglichen bleiben")
+counter = st.number_input("Wie viele der Urls sollen insgesamt überprüft werden?", step=1)
+get_event_data = st.button("Event Daten sammeln")
+
+if get_event_data:
+    for i in range(counter):
+        el = db.unsorted_urls.find_one({"overview_pages": { "$exists": True, "$ne": [] } , "checked": None})
+        print(el)
+        if el:
+            with st.container(border=True):
+                if counter <= 0:
+                    break
+                st.subheader(f"Daten sammeln für {el['url']} mit {len(el['overview_pages'])} Übersichtsseiten")
+                update_element = el
+
+                for overview_url in el["overview_pages"]:
+
+                    st.info(f"Überprüfe Übersichtsseite: {overview_url}")
+
+                    new_element=process_url(overview_url,el)
+                    if new_element:
+                            soup = BeautifulSoup(new_element["cleaned_html"],"lxml")
+                            links = soup.find_all(["a"])
+                            urls = set()
+                            with st.expander("Suburls"):
+                                try:
+                                    for link in links:
+                                        href = link["href"]
+                                        url = urljoin(overview_url, href)
+                                        url = urlparse(url)._replace(query="", fragment="").geturl()
+                                        if overview_url != url and check_regex(url, PATTERNS) and str(urlparse(overview_url).scheme)+str(urlparse(overview_url).netloc) != url:
+                                            urls.add(url)
+                                except:
+                                    print("Exception while processing links")
+                                if len(urls) > suburls_count:
+                                    urls= set(random.sample(list(urls), 10))
+                                for url in urls:
+                                    new_element = process_url(url, el)
+                                if not urls:
+                                    st.info("Es wurden keine Eventseiten unter der Übersichtsseite gefunden")
+                                    update_element["overview_pages"].remove(overview_url)
+
+                    else:
+                        update_element["overview_pages"].remove(overview_url)
+                    counter = counter - 1
+                    if counter <= 0:
+                            break
+                new_values = {"$set": {"overview_pages": update_element["overview_pages"], "checked": True }}
+                db.unsorted_urls.update_one({"_id": update_element["_id"]}, new_values )
+
+
+
+
+

pages/3_Sort_Event_Data.py

@@ -0,0 +1,67 @@
+from src.utils.helpers import clean_html
+from src.utils.markdown_processing.md_preprocessing import convert_html_to_md
+from src.persistence.db import *
+from src.utils.apis.gpt_api import remove_boilerplate
+
+
+@st.cache_resource
+def init_connection():
+    return init_db()
+
+
+def render_url_content(element):
+    cleaned_html = clean_html(element["html"])
+    md = convert_html_to_md(cleaned_html)
+    with st.container(border=True, height=400):
+        st.markdown(md)
+
+def save_event_url():
+    data = None
+    if current_element["class"] == "EventDetail":
+        md = convert_html_to_md(clean_html(current_element["html"]))
+        data = remove_boilerplate(md)
+    result = db.event_urls.update_one({"_id": current_element["_id"]}, { "$set": { "final": True, "data": data} })
+
+def remove_url():
+    result = db.event_urls.delete_one({"_id": current_element["_id"]}),
+
+# Variables
+db = init_connection()
+current_element = db.event_urls.find_one(filter={"final": None})
+
+if current_element:
+    current_url = current_element['url']
+
+    # Page Content
+    st.header("Event Daten Sortieren")
+    st.subheader(f"{db.event_urls.count_documents({'final':None})} URLs sind noch unsortiert")
+    st.write("""
+        Hier wird das Datenset endgültig bereinigt. Wenn die von der GPT API zugeordnete Klasse (EventDetail / EventOverview) 
+        falsch ist, muss die URL gelöscht werden. Wenn es korrekt zugeordnet ist können die Daten gespeichert werden. \n 
+        **ACHTUNG** Teilweise sind die Daten unvollständig. Das liegt daran, dass das HTML gekürzt wurde, 
+        für die Sortierung ist das irrelvant, also auch abgeschnittene Events gehören in die Event-DB.\n
+        **Übersichtsseiten müssen Listen von Events enthalten. Eine Seite mit Kategorien oder anderen Links ist keine Übersichtsseite.** 
+        """)
+    st.info("Es sollen nur deutsche Texte verarbeitet werden. Alle anderen Texte müssen gelöscht werden. (Teilweise englisch ist okay)")
+    st.write("")
+    try:
+        st.write(f"""### Aktuelle Seite: \n{current_url} ({db.unsorted_urls.find_one(filter={"_id": current_element["base_url_id"]}, projection={"url_type":1})["url_type"]})""")
+        st.write(f"""#### Predicted Class: {current_element["class"]}""")
+        render_url_content(current_element)
+    except Exception as e:
+        st.write(f"Fehler: {e}")
+        st.write(current_url)
+    # Buttons
+    col1, col2= st.columns([1, 1])
+
+
+    with col1:
+        st.button("Als Event-URL speichern", on_click=save_event_url)
+    with col2:
+        st.button("URL löschen", on_click=remove_url)
+
+else:
+    st.write("Es sind aktuell keine Daten in der DB zur Berarbeitung vorhanden.")
+
+
+

pages/4_Control.py

@@ -0,0 +1,128 @@
+import pandas as pd
+from src.utils.helpers import clean_html
+from src.utils.markdown_processing.md_preprocessing import convert_html_to_md
+from src.nlp.playground.pipelines.title_extractor import TitleExtractor
+from src.utils.helpers import normalize_data
+from src.persistence.db import *
+from src.utils.apis.gpt_api import remove_boilerplate
+import torch
+
+
+@st.cache_resource
+def init_connection():
+    return init_db()
+
+def remove_url():
+    result = db.event_urls.delete_one({"_id": current_element["_id"]})
+    st.session_state.elements = db.event_urls.find({"final":True, "class": "EventDetail"},{"_id":1, "url":1, "data":1, "html":1, "information":1})
+
+def next():
+    db.event_urls.update_one({"_id": current_element["_id"]}, { "$set": { "information":event_information } })
+    st.session_state.index+=1
+
+def prev():
+    st.session_state.index-=1
+
+# Variables
+db = init_connection()
+if "index" not in st.session_state:
+    st.session_state.index = 0
+if "elements" not in st.session_state:
+    elements = db.event_urls.find({"final":True, "class": "EventDetail"},{"_id":1, "url":1, "data":1, "html":1, "information":1})
+
+    # preprocessing of html content: get cleaned markdown
+    for el in elements:
+        if "data" not in el:
+            print(el["url"])
+            md = convert_html_to_md(clean_html(el["html"]))
+            try:
+                st.info("GPT-API Anfrage läuft")
+                gpt_md = remove_boilerplate(md)
+                st.info("Verarbeitung beendet")
+                el["data"] = gpt_md
+                db.event_urls.update_one({"_id": el["_id"]}, { "$set": { 'data': el["data"] } })
+            except Exception as e:
+                st.error(f"Es ist ein Fehler aufgetreten: {e} \n")
+                db.event_urls.delete_one({"_id": el["_id"]})
+    st.session_state.elements = db.event_urls.find({"final":True, "class": "EventDetail"},{"_id":1, "url":1, "data":1, "html":1, "information":1})
+if "predictions_on" not in st.session_state:
+    st.session_state.predictions_on = False
+
+
+current_element = st.session_state.elements[st.session_state.index]
+
+predictions_on = st.toggle("Predictions an (Zeigt Extrahierte Daten an, die Seite lädt dadurch langsamer).")
+if predictions_on != st.session_state.predictions_on:
+    st.session_state.predictions_on = predictions_on
+
+if current_element:
+    current_url = current_element['url']
+
+    try:
+        st.write(f"""### Aktuelle Seite: \n{current_url} """)
+        if "data" not in current_element:
+            md = convert_html_to_md(clean_html(current_element["html"]))
+            try:
+                gpt_md = remove_boilerplate(md)
+                current_element["data"] = gpt_md
+                db.event_urls.update_one({"_id": current_element["_id"]}, { "$set": { 'data': current_element["data"] } })
+            except Exception as e:
+                st.error(f"Es ist ein Fehler aufgetreten: {e} \nDer Datenbankeintrag wird gelöscht.")
+                db.event_urls.delete_one({"_id": current_element["_id"]})
+        data = current_element["data"]
+        normalized_text = normalize_data(data)
+        predicted_title = None
+        predicted_date = None
+        if st.session_state.predictions_on:
+            predicted_title = TitleExtractor().extract_title(normalized_text)
+            # predicted_date = extract_entities(normalized_text, ["date", "date_range"])
+            # predicted_date = [ {d["text"],d["label"]} for d in predicted_date ] if predicted_date else None
+        st.subheader("Normalisierte Daten:")
+        with st.container(border=True, height=400):
+            st.markdown(normalized_text)
+        with st.expander("Code ansehen"):
+            with st.container( height=400):
+                st.code(normalized_text)
+        actual_title = st.text_input("Tatsächlicher Titel eingeben:", key="title"+ str(current_element["_id"]),
+                                     value=current_element.get("information", {}).get("actual", {}).get("title", None))
+        actual_date = None
+
+        event_information = {"actual": {"title":actual_title}}
+        data = {
+            "Information": [
+                "Titel",
+                # "Datum"
+            ],
+            "Tatsächlicher Wert":
+                [
+                    actual_title,
+                    # actual_date
+                ],
+            "Predicted Wert": [
+                predicted_title,
+                # predicted_date
+            ],
+        }
+        df = pd.DataFrame(data)
+
+        st.subheader("Vergleich der Titel:")
+        st.table(df)
+
+    except Exception as e:
+        st.write(f"Fehler: {e}")
+        st.write(current_url)
+    col1, col2, col3, col4= st.columns([1, 1, 1, 1])
+
+
+    with col1:
+        st.button("Zurück", on_click=prev)
+    with col3:
+        st.button("URL löschen", on_click=remove_url)
+    with col4:
+        st.button("Speichern und Weiter",on_click=next)
+
+else:
+    st.write("Es sind aktuell keine Daten in der DB zur Bearbeitung vorhanden.")
+
+
+

pages/5_Playground.py

@@ -0,0 +1,217 @@
+
+import logging
+import os
+import sys
+import gc
+import psutil
+import streamlit as st
+import pandas as pd
+st.info(f"Speicherauslastung vor imports: {psutil.virtual_memory().percent}%. Keys in Cache: {[k for k in st.session_state]}")
+
+
+from src.configuration.config import SessionStateConfig
+from src.nlp.playground.textsummarization import SumySummarizer
+from src.nlp.playground.pipelines.title_extractor import TitleExtractor
+from src.utils.helpers import normalize_data
+from src.utils.markdown_processing.CustomMarkdownAnalyzer.MarkdownAnalyzer import MarkdownAnalyzer
+from src.nlp.playground.llm import QwenLlmHandler
+from src.nlp.playground.ner import GlinerHandler
+from src.persistence.db import init_db
+from src.nlp.playground.textclassification import ZeroShotClassifier, CategoryMode, CustomMode
+
+entities_schema = [
+    '"title": str | None"',
+    '"organizer": str | None"',
+    '"startDate": str | None"',
+    '"endDate": str | None"',
+    '"startTime": str | None"',
+    '"endTime": str | None"',
+    '"admittanceTime": str | None"',
+    '"locationName": str | None"',
+    '"street": str | None"',
+    '"houseNumber": str | None"',
+    '"postalCode": str | None"',
+    '"city": str | None"',
+    '"price": list[float] | None"',
+    '"currency": str | None"',
+    '"priceFree": bool | None"',
+    '"ticketsRequired": bool | None"',
+    '"categories": list[str] | None"',
+    '"eventDescription": str | None"',
+    '"accesibilityInformation": str | None"',
+    '"keywords": list[str] | None"'
+]
+
+
+@st.cache_resource
+def init_connection():
+    return init_db()
+
+@st.cache_resource
+def init_data():
+    return db.event_urls.find(filter={"class":"EventDetail", "final":True}, projection={"url":1,"base_url_id":1,"cleaned_html":1, "data":1})
+
+def render_md(md):
+    st.subheader("Original Text:")
+    with st.container(border=True, height=400):
+        st.markdown(md)
+
+def render_table(table_data):
+    st.subheader("Extrahierte Daten:")
+    df = pd.DataFrame(table_data)
+    st.table(df)
+    st.markdown("---")
+
+def init_session_state(key, value):
+    if key not in st.session_state:
+        clear_st_cache()
+        st.session_state[key] = value
+
+def clear_st_cache():
+    keys = list(st.session_state.keys())
+    for key in keys:
+        st.session_state.pop(key)
+
+
+db = init_connection()
+data = init_data()
+
+st.info(f"Speicherauslastung: {psutil.virtual_memory().percent}%. Keys in Cache: {[k for k in st.session_state]}")
+
+
+with st.expander("Large Language Models"):
+    with st.form("Settings LLM"):
+        count = st.number_input("Wie viele Veranstaltungen sollen gestest werden?", step=1)
+        st.write("Welche Informationen sollen extrahiert werden?")
+        options = []
+        for ent in entities_schema:
+            option = st.checkbox(ent ,key=ent)
+            options.append(option)
+        submit_llm = st.form_submit_button("Start")
+
+    if submit_llm:
+        selected_entities = [entity for entity, selected in zip(entities_schema, options) if selected]
+        init_session_state(SessionStateConfig.QWEN_LLM_HANDLER, QwenLlmHandler())
+        qwen_llm_handler = st.session_state[SessionStateConfig.QWEN_LLM_HANDLER]
+        try:
+            for event in data:
+                extracted_data = qwen_llm_handler.extract_data(text=event["data"], entities= ", ".join(selected_entities))
+                table_data = [{"Key": key, "Value": value} for key, value in extracted_data.items()]
+
+                render_md(event["data"])
+                render_table(table_data)
+
+                count -= 1
+                if count == 0:
+                    break
+        except Exception as e:
+            st.write(f"Es ist ein Fehler aufgetreten: {e}")
+
+with st.expander("Named Entity Recognition"):
+    with st.form("Settings NER"):
+        count = st.number_input("Wie viele Veranstaltungen sollen gestest werden?", step=1)
+        label_input = st.text_input("Gebe die Labels der Entitäten getrennt durch Komma an.")
+        submit_ner = st.form_submit_button("Start")
+
+    if submit_ner:
+        init_session_state(SessionStateConfig.GLINER_HANDLER, GlinerHandler())
+        gliner_handler = st.session_state[SessionStateConfig.GLINER_HANDLER]
+        if label_input:
+            labels = label_input.split(",")
+        for event in data:
+            text = normalize_data(event["data"])
+            render_md(text)
+
+            extracted_data = gliner_handler.extract_entities(text, labels)
+            table_data = [{"Key": element["label"], "Value": element["text"] } for element in extracted_data]
+            render_table(table_data)
+
+            count -= 1
+            if count == 0:
+                break
+
+with st.expander("Textclassification"):
+    with st.form("Settings TextClassification"):
+        mode = st.selectbox("Classification Mode", ["Categories", "Custom"])
+        custom_labels = st.text_input("(Nur bei Custom Mode) Gib die Klassen Labels ein, durch Komma getrennt.", placeholder="Theater,Oper,Film")
+        custom_hypothesis_template = st.text_input("(Nur bei Custom Mode) Gib das Template ein. {} ist dabei der Platzhalter für die Labels", placeholder="Die Art der Veranstaltung ist {}")
+        count = st.number_input("Wie viele Veranstaltungen sollen gestest werden?", step=1)
+        submit_textclass = st.form_submit_button("Start")
+
+    if submit_textclass:
+        init_session_state(SessionStateConfig.ZERO_SHOT_CLASSIFIER, ZeroShotClassifier())
+        classifier = st.session_state[SessionStateConfig.ZERO_SHOT_CLASSIFIER]
+        if mode == "Categories":
+            classifier_mode = CategoryMode()
+        elif custom_labels and custom_hypothesis_template:
+            classifier_mode = CustomMode(labels=custom_labels.split(","), hypothesis_template=custom_hypothesis_template)
+        for event in data:
+            text = normalize_data(event["data"])
+            predictions = classifier.classify(text, classifier_mode)
+            table_data = [{"Kategorie": p.label, "Score": p.score} for p in predictions]
+
+            render_md(text)
+            render_table(table_data)
+
+            count -= 1
+            if count == 0:
+                break
+
+with st.expander("Titel Extraktion"):
+    with st.form("Settings TitleExtraction"):
+        count = st.number_input("Wie viele Veranstaltungen sollen gestest werden?", step=1)
+        submit_title_extr = st.form_submit_button("Start")
+
+    if submit_title_extr:
+        init_session_state("title_extractor", TitleExtractor())
+        title_extractor = st.session_state.title_extractor
+        st.info(f"Speicherauslastung: {psutil.virtual_memory().percent}%. Keys in Cache: {[k for k in st.session_state]}")
+
+        for event in data:
+            text = normalize_data(event["data"])
+            prediction = title_extractor.extract_title(text)
+            try:
+                pred2 = title_extractor.extract_title_classy_classification(text)
+            except FileNotFoundError as e:
+                pred2 = "ERROR: Train Model before usage"
+            table_data = [{"Label": "Titel (ZeroShot)", "Value": prediction}, {"Label": "Titel (FewShot)", "Value": pred2}]
+
+            render_md(text)
+            render_table(table_data)
+
+            count -= 1
+            if count == 0:
+                break
+
+with st.expander("Textsummarization"):
+    with st.form("Settings Textsummarization"):
+        count = st.number_input("Wie viele Veranstaltungen sollen gestest werden?", step=1)
+        submit_textsummarization = st.form_submit_button("Start")
+
+    if submit_textsummarization:
+        init_session_state(SessionStateConfig.SUMY_SUMMARIZER, SumySummarizer())
+        sumy_summarizer = st.session_state[SessionStateConfig.SUMY_SUMMARIZER]
+        st.info(f"Speicherauslastung: {psutil.virtual_memory().percent}%. Keys in Cache: {[k for k in st.session_state]}")
+        for event in data:
+            try:
+                md = normalize_data(event["data"])
+                md_analyzer = MarkdownAnalyzer(md).identify_all()["block_elements"]
+                md_analyzer = sorted(md_analyzer, key=lambda el: el.line)
+                text = "\n\n".join([el.text for el in md_analyzer])
+                sumy_summary = sumy_summarizer.summarize(text)
+                summary = []
+                for element in md_analyzer:
+                    if any(sentence in element.markdown for sentence in sumy_summary):
+                        summary.append(element.markdown)
+
+                render_md(md)
+                st.subheader("Extrahierte Daten:")
+                with st.container(border=True, height=400):
+                    st.markdown("\n\n".join(summary))
+
+            except Exception as e:
+                st.error(f"Fehler:{e}")
+                logging.exception("message")
+            count -= 1
+            if count == 0:
+                break

pages/6_Pipeline.py

@@ -0,0 +1,136 @@
+import streamlit as st
+import streamlit.components.v1 as components
+
+from src.configuration.config import SessionStateConfig
+from src.nlp.playground.Event import Event
+from src.nlp.playground.ner import GlinerHandler
+from src.nlp.playground.pipelines.description_extractor import DescriptionExtractor
+from src.nlp.playground.textclassification import ZeroShotClassifier, CategoryMode, CustomMode
+from src.nlp.playground.pipelines.title_extractor import TitleExtractor
+from src.persistence.db import init_db
+from src.utils.apis.gpt_api import remove_boilerplate
+from src.utils.helpers import normalize_data
+from src.utils.markdown_processing.CustomMarkdownAnalyzer.MarkdownAnalyzer import MarkdownAnalyzer
+from src.utils.markdown_processing.md_preprocessing import convert_html_to_md
+
+@st.cache_resource
+def init_connection():
+    return init_db()
+
+@st.cache_resource
+def init_data():
+    return db.event_urls.find(filter={"class":"EventDetail", "final":True}, projection={"url":1,"base_url_id":1,"cleaned_html":1, "data":1})
+
+
+if "title_extractor" not in st.session_state:
+    st.session_state["title_extractor"] = TitleExtractor()
+if "description_extractor" not in st.session_state:
+    st.session_state["description_extractor"] = DescriptionExtractor()
+if SessionStateConfig.ZERO_SHOT_CLASSIFIER not in st.session_state:
+    st.session_state[SessionStateConfig.ZERO_SHOT_CLASSIFIER] = ZeroShotClassifier()
+if SessionStateConfig.GLINER_HANDLER not in st.session_state:
+    st.session_state[SessionStateConfig.GLINER_HANDLER] = GlinerHandler()
+
+db = init_connection()
+data = init_data()
+element = next(data,None)
+
+
+st.subheader("Bereinigtes HTML")
+st.write(element["url"])
+st.components.v1.html(element["cleaned_html"], height=500, scrolling=True)
+
+start_pipeline = st.button("Starte Pipeline")
+if element:
+    title_extractor = st.session_state.title_extractor
+    description_extractor = st.session_state.description_extractor
+    classifier = st.session_state[SessionStateConfig.ZERO_SHOT_CLASSIFIER]
+    gliner_handler = st.session_state.gliner_handler
+    if start_pipeline:
+        html = element["cleaned_html"]
+        md = convert_html_to_md(html)
+        with st.expander("Markdown"):
+            with st.container(border=True, height=400):
+                st.markdown(md)
+        with st.expander("Markdown Code"):
+            with st.container(height=400):
+                st.code(md)
+
+        cleaned_md = remove_boilerplate(md)
+        st.info("Remove boilerplate with GPT API")
+        with st.expander("Gekürztes Markdown"):
+            with st.container(border=True, height=400):
+                st.markdown(cleaned_md)
+
+        normalized_md = normalize_data(cleaned_md)
+        with st.expander("Normalisiertes Markdown"):
+            with st.container(border=True, height=400):
+                st.markdown(normalized_md)
+
+
+        text = normalized_md
+        analyzer = MarkdownAnalyzer(text)
+        results = analyzer.identify_all()["block_elements"]
+        table_data = [{"Class": r.__class__.__name__, "Markdown": r.markdown} for r in results]
+        with st.expander("Markdown Elemente"):
+            st.table(table_data)
+
+        with st.expander("Markdown Segmente"):
+            segments = analyzer.segmentation()
+            for s in segments:
+                with st.container(border=True):
+                    for e in s:
+                        st.markdown(e.markdown)
+
+        extracted_event = Event()
+
+        st.info("Extracting title...")
+        extracted_event.title = title_extractor.extract_title(cleaned_md)
+
+        # extracted_event.categories = ZeroShotClassifier().classify(text, CategoryMode())
+        extracted_event.categories = []
+        st.info("Extracting Categories...")
+        family_category = [cat.label for cat in classifier.classify(text,CustomMode(["Kinder_und_Familie","Adults_only"],"Die Veranstaltung ist für {}")) if cat.score >= 0.8]
+        topic_category = [classifier.classify(text,CustomMode(
+            ["Kunst","Kultur", "Musik", "Sport", "Bildung", "Tanz", "Wissenschaft", "Unterhaltung", "Gesundheit", "Wellness", "Business", "Politik","Religion"],
+            "In der Veranstaltung geht es um {}"))[0].label]
+        type_category = [classifier.classify(text,CustomMode(
+            ["Oper", "Theater", "Konzert", "Gottesdienst", "Ausstellung", "Museum", "Planetarium", "Führung", "Film", "Vortrag", "Show", "Turnier", "Wettkampf", "Markt", "Feier", "Party"],
+            "Die Art der Veranstaltung ist {}"))[0].label]
+
+        extracted_event.categories.extend(family_category)
+        extracted_event.categories.extend(topic_category)
+        extracted_event.categories.extend(type_category)
+
+        st.info("Extracting Organizer and Location...")
+        entities = gliner_handler.extract_entities(text, ["EVENT_ORGANIZER","EVENT_LOCATION_NAME","EVENT_ADDRESS"])
+        extracted_event.organizers = list(set([item["text"] for item in entities if item["label"] == "EVENT_ORGANIZER"]))
+        extracted_event.locations = list(set([item["text"] for item in entities if item["label"] == "EVENT_LOCATION_NAME"]))
+        extracted_event.address = list(set([item["text"] for item in entities if item["label"] == "EVENT_ADDRESS"]))
+        st.info("Extracting Dates and Times...")
+        date_entities = gliner_handler.extract_entities(text, ["SINGLE_DATE", "DATE_RANGE", "START_TIME","END_TIME", "ADMITTANCE_TIME"])
+        st.write(date_entities)
+        st.info("Extracting Price Information...")
+        price_entities = gliner_handler.extract_entities(text, ["KOSTEN"])
+        extracted_event.prices = list(set([item["text"] for item in price_entities if any(char.isdigit() for char in item["text"])]))
+
+        st.info("Extracting Description...")
+        extracted_event.description = description_extractor.extract_description(text, extracted_event.title)
+
+        event_data = []
+        event_data.append({'Field': 'Title', 'Value': extracted_event.title})
+        event_data.append({'Field': 'Categories', 'Value': ", ".join(extracted_event.categories)})
+        event_data.append({'Field': 'Organizers', 'Value': ", ".join(extracted_event.organizers)})
+        event_data.append({'Field': 'Locations', 'Value': ", ".join(extracted_event.locations)})
+        event_data.append({'Field': 'Address', 'Value': ", ".join(extracted_event.address)})
+        event_data.append({'Field': 'Prices', 'Value': ", ".join(extracted_event.prices)})
+
+
+        st.subheader("Extrahierte Daten")
+        st.table(event_data)
+        st.write("Event Description:")
+        with st.container(border=True, height=400):
+            st.markdown(extracted_event.description)
+
+
+

pages/TEST.py

@@ -1,2 +0,0 @@
-import streamlit as st
-st.write("Hello world")

requirements.txt

@@ -1 +1,23 @@
-streamlit
+streamlit
+streamlit-nested-layout
+html2text
+httpx
+bs4
+sumy
+gliner
+markdownify
+google-maps-places
+openai
+dateparser
+lxml_html_clean
+pandas
+pymongo
+absl-py
+dotenv
+transformers
+
+
+
+
+
+

src/configuration/config.py

@@ -0,0 +1,7 @@
+# streamlit session state model keys
+
+class SessionStateConfig:
+    ZERO_SHOT_CLASSIFIER = "zero_shot_classifier"
+    SUMY_SUMMARIZER = "sumy_summarizer"
+    GLINER_HANDLER = "gliner_handler"
+    QWEN_LLM_HANDLER = "qwen_llm_handler"

src/crawler/CrawlerV2.py

@@ -0,0 +1,215 @@
+import gzip
+import sys
+
+import httpx
+from urllib.parse import urljoin
+
+from src.crawler.utils.regEx import PATTERNS
+from src.crawler.utils.keywords import KEYWORDS
+from src.crawler.crawler_service import *
+from urllib.robotparser import RobotFileParser
+
+URL_KEYWORDS = [
+    "veranstaltung", "event", "kalender", "kunst", "kultur",
+    "freizeit", "termine",
+    "happenings", "ausgehen", "aktivitäten", "aktivitaeten", "programm",
+    "wochenendtipps", "party", "festivals", "konzerte", "musik",
+    "shows", "theater", "veranstaltungskalender", "ausstellungen", "feste", "spielplan", "veranstaltungsplan"
+]
+
+
+class Crawler:
+    sys.path.append("..")
+    # filter variables
+    keywords = KEYWORDS
+    url_patterns = PATTERNS
+
+    def __init__(self, url: str, url_type: str, depth: int):
+
+        self.visited_urls = set()
+        self.excluded_urls = set()
+        self.excluded_urls.update(set(get_disallowed_urls(url)))
+        self.url_type = url_type
+        # set tupel of url and max depth to crawl
+        self.queue = [(url, depth)]
+        self.domain = urlparse(url).netloc
+        self.sitemaps_urls = get_sitemaps(url)
+        print(self.url_type)
+        print(f"Crawler startet for {url}")
+
+
+    def crawl(self):
+        # Loop through the URLs in the queue until it is empty
+        if self.sitemaps_urls:
+            print("Sitemaps Crawler startet...")
+            for url in self.sitemaps_urls:
+                if self.include_url(url):
+                    print("include URL: ", url)
+                    self.visited_urls.add(url)
+        else:
+            print("Crawler startet...")
+            while self.queue:
+                try:
+                    # get the next URL to crawl
+                    url_tupels = self.queue.pop(0)
+                    current_url = url_tupels[0]
+                    depth = url_tupels[1]
+                    # access = ask_robots(current_url, "*")
+                    access = True
+                    # make request
+                    if access and depth > 0:
+                        response = requests.get(current_url)
+                        if response.status_code >= 400:
+                            print(f"Skipping {current_url} with status code {response.status_code}")
+                            continue
+                        page_content = response.content
+
+                        # Parse the HTML content and extract links to other pages
+                        soup = BeautifulSoup(page_content, "lxml")
+                        urls_to_crawl = self.find_urls(soup, current_url)
+                        urls_to_crawl_tupels = []
+                        for url in urls_to_crawl:
+                            if self.include_url(url):
+                                urls_to_crawl_tupels.append((url, depth - 1))
+
+                        # Add the new URLs to the queue and mark the current URL as visited
+                        self.queue.extend(urls_to_crawl_tupels)
+
+
+                        print(f"Crawled {current_url} and found {len(urls_to_crawl)} new URLs to crawl")
+                    else:
+                        print("access denied for ",current_url )
+                except Exception as e:
+                    print("Exception:", e)
+
+                self.visited_urls.add(current_url)
+                if current_url in self.queue:
+                    self.queue.remove(current_url)
+        print("Done. Found ", len(self.visited_urls), " Urls")
+        return self.visited_urls
+
+    def find_urls(self, soup: BeautifulSoup, current_url: str):
+        # get all links from page content
+        links = soup.find_all("a", href=True)
+        urls_to_crawl = set()
+        for link in links:
+            href = link["href"]
+            url = urljoin(current_url, href)
+            url = urlparse(url)._replace(query="", fragment="").geturl()
+            urls_to_crawl.add(url)
+        return urls_to_crawl
+
+
+    def include_url(self,url) -> bool:
+
+        if urlparse(url).netloc.lower() != self.domain.lower() \
+                or url in self.visited_urls \
+                or not check_regex(url, self.url_patterns)\
+                or url in self.queue\
+                or url in self.excluded_urls:
+            return False
+        else:
+            print("Checking ", url)
+            # if self.url_type == "city":
+            if any(keyword in url for keyword in URL_KEYWORDS):
+                print("Found Event URL:", url)
+                return True
+            else:
+                self.excluded_urls.add(url)
+                return False
+            # else:
+            #     # if ask_robots(url,"*"):
+            #     if True:
+            #         response = requests.get(url)
+            #         if response.status_code >= 400:
+            #             self.excluded_urls.add(url)
+            #             print(f"Skipping {url} with status code {response.status_code}")
+            #             return False
+            #         else:
+            #             page_content = response.content
+            #             # Parse the HTML content and extract links to other pages
+            #             soup = BeautifulSoup(page_content, "html.parser")
+            #             # remove navigation elements
+            #             for nav in soup.find_all('nav'):
+            #                 nav.decompose()
+            #
+            #             # Step 2: Remove elements with "navigation" or "menu" in the id or class attributes
+            #
+            #             nav_elements= []
+            #             nav_elements.extend(soup.find_all(id=re.compile(r'.*navigation.*')))
+            #             nav_elements.extend(soup.find_all(id=re.compile(r'.*menu.*')))
+            #             nav_elements.extend(soup.find_all(class_=re.compile(r'.*navigation.*')))
+            #             nav_elements.extend(soup.find_all(class_=re.compile(r'.*menu.*')))
+            #
+            #             print(len(nav_elements))
+            #             for elem in nav_elements:
+            #                 if elem:
+            #                     elem.decompose()
+            #
+            #             content = get_page_content(soup)
+            #             print("searching content for keywords...")
+            #             if check_keywords(content, self.keywords):
+            #                 print("Found Keyword in ", url)
+            #                 return True
+            #             else:
+            #                 self.excluded_urls.add(url)
+            #                 return False
+
+
+
+def get_sitemaps(url):
+    url_parsed = urlparse(url)
+    url_robots_txt = url_parsed.scheme + '://' + url_parsed.netloc + '/robots.txt'
+    sitemaps = set()
+    all_urls = set()
+
+    robotParse = urllib.robotparser.RobotFileParser()
+    robotParse.set_url(url_robots_txt)
+    try:
+        robotParse.read()
+        robot_sitemaps = robotParse.site_maps()
+        if robot_sitemaps:
+            sitemaps.update(robot_sitemaps)
+        else:
+            sitemaps.add(url_parsed.scheme + "://" + url_parsed.netloc + "/sitemap.xml")
+            sitemaps.add(url_parsed.scheme + "://" + url_parsed.netloc + "/sitemaps.xml")
+
+
+        for sitemap in sitemaps:
+            print("Parsing sitemap:", sitemap)
+            sitemap_urls = get_urls_from_sitemap(sitemap, set())
+            all_urls.update(sitemap_urls)
+
+        print("Total urls collected from sitemaps: ", len(all_urls))
+    except Exception as e:
+        print("Exception while parsing sitemap from ", url, ":", e)
+    return all_urls
+
+def get_urls_from_sitemap(sitemap, urls):
+    print("Getting URLs from sitemap:", sitemap)
+    try:
+        response = httpx.get(sitemap)
+        if response.status_code == httpx.codes.OK:
+            # Prüfen, ob die Sitemap eine gezippte Datei ist
+            content_type = response.headers.get('Content-Type', '')
+            if 'gzip' in content_type or sitemap.endswith('.gz'):
+                # Falls gezippt, entpacken und lesen
+                decompressed_content = gzip.decompress(response.content)
+                soup = BeautifulSoup(decompressed_content, 'lxml')
+            else:
+                # Falls nicht gezippt, direkt parsen
+                soup = BeautifulSoup(response.content, 'lxml')
+
+            # URLs aus der Sitemap extrahieren
+            locs = soup.find_all("loc")
+            for loc in locs:
+                url = loc.get_text()
+                if "sitemap" in url:
+                    # Rekursiv aufrufen, falls es eine Unter-Sitemap ist
+                    urls.update(get_urls_from_sitemap(url, urls))
+                else:
+                    urls.add(url)
+
+    except Exception as e:
+        print("Exception while resolving sitemap:", sitemap, "-", e)
+    return urls

src/crawler/crawler_service.py

@@ -0,0 +1,106 @@
+import urllib
+import re
+import copy
+from bs4 import BeautifulSoup
+from urllib.parse import urlparse
+from urllib.robotparser import RobotFileParser
+from pathlib import Path
+import requests
+
+
+root_path = Path.cwd()
+html_filter = ['header', 'footer', 'svg', 'img', 'nav', 'script']
+
+# check if crawler is allowed to crawl url
+def ask_robots(url: str, useragent="*") -> bool:
+    try:
+        url_parsed = urlparse(url)
+        url_robots_txt = url_parsed.scheme + '://' + url_parsed.netloc + '/robots.txt'
+        print("robots.txt: ", url_robots_txt)
+        robotParse = urllib.robotparser.RobotFileParser()
+        robotParse.set_url(url_robots_txt)
+        robotParse.read()
+
+        print("Ask access to ", url)
+        return robotParse.can_fetch('*', url)
+    except Exception as e:
+        print("Ask Robots :", e)
+
+
+def get_disallowed_urls(url, user_agent="*"):
+    """
+    Gibt alle disallowed URLs für den angegebenen User-Agent aus der robots.txt zurück.
+
+    :param robots_url: Die URL zur robots.txt-Datei (z. B. "https://example.com/robots.txt").
+    :param user_agent: Der User-Agent, für den die Regeln geprüft werden (Standard: "*").
+    :return: Eine Liste der disallowed URLs.
+    """
+    # robots.txt Parser initialisieren
+    url_parsed = urlparse(url)
+    url_robots_txt = url_parsed.scheme + '://' + url_parsed.netloc + '/robots.txt'
+    rp = urllib.robotparser.RobotFileParser()
+    rp.set_url(url_robots_txt)
+    rp.read()
+
+    # Liste der disallowed Pfade initialisieren
+    disallowed_paths = []
+
+    # robots.txt-Datei als Text herunterladen
+    response = requests.get(url_robots_txt)
+    if response.status_code == 200:
+        # Parsen der robots.txt
+        lines = response.text.splitlines()
+        current_user_agent = None
+        for line in lines:
+            # Leerzeichen und Kommentare ignorieren
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+
+            # User-Agent-Zeilen erkennen
+            if line.lower().startswith("user-agent"):
+                current_user_agent = line.split(":")[1].strip()
+
+            # Disallow-Regeln erkennen
+            elif line.lower().startswith("disallow") and current_user_agent == user_agent:
+                disallow_path = line.split(":")[1].strip()
+                if disallow_path:
+                    disallowed_paths.append(disallow_path)
+
+    # Basis-URL extrahieren
+    base_url = url_robots_txt.rsplit("/", 1)[0]
+
+    # Vollständige URLs zurückgeben
+    disallowed_urls = [base_url + path for path in disallowed_paths]
+    return disallowed_urls
+
+
+# check if the url matches the regEx pattern, exclude it from crawler if it does
+def check_regex(url: str, url_patterns: dict) -> bool:
+    for pattern in url_patterns:
+        if pattern.match(url):
+            return False
+    return True
+
+
+# exclude url if website contains no keyword
+def check_keywords(content: str, keywords: dict) -> bool:
+    for word in keywords:
+        if re.search(word, content, flags=re.IGNORECASE):
+            return True
+    return False
+
+# get only the content of the page without html tags
+def get_page_content(soup: BeautifulSoup):
+    soup_temp = copy.copy(soup)
+    body = soup_temp.find('body')
+    if body is None:
+        return
+    for tag in html_filter:
+        for el in body.find_all(tag):
+            el.decompose()
+    return prettify_content(body.text)
+
+
+def prettify_content(content: str):
+    return re.sub(r'\n\s*\n', '\n', content)

src/crawler/maps_api.py

@@ -0,0 +1,23 @@
+from dataclasses import fields
+import streamlit as st
+from google.maps import places_v1
+import os
+from dotenv import load_dotenv
+
+
+def get_maps_results(query, location):
+    # Create a client
+    load_dotenv()
+    client = places_v1.PlacesClient(client_options={"api_key": os.getenv("GOOGLE_MAPS_API_KEY")})
+
+    # Initialize request argument(s)
+    request = places_v1.SearchTextRequest(
+        text_query=f"{query} in {location}",
+        included_type=query
+    )
+
+    fieldMask = "places.displayName,places.websiteUri,places.formattedAddress,places.types"
+    # Make the request
+    response = client.search_text(request=request, metadata=[("x-goog-fieldmask",fieldMask)])
+    return response.places
+

src/crawler/serp_maps.py

@@ -0,0 +1,62 @@
+from src.configuration.config import SERP_API_KEY
+from serpapi import GoogleSearch
+
+# maps type ids
+relevant_locations = [
+    "art_gallery",
+    "auditorium",
+    "museum",
+    "performing_arts_theater",
+    "amphitheatre",
+    "amphitheatre",
+    "amusement_center",
+    "amusement_park",
+    "banquet_hall",
+    "childrens_camp",
+    "comedy_club",
+    "community_center",
+    "concert_hall",
+    "convention_center",
+    "cultural_center",
+    "dance_hall",
+    "event_venue",
+    "karaoke",
+    "night_club",
+    "opera_house",
+    "philharmonic_hall",
+    "planetarium",
+    "library",
+    "church",
+    "hindu_temple",
+    "mosque",
+    "synagogue"
+]
+
+
+params = {
+    "engine": "google_maps",
+    "q": "",
+    "type": "search",
+    "api_key": SERP_API_KEY ,
+    # "ll": "@49.4540304,11.101698,14z"  # coordinates for Nuremberg with 15 zoom in
+}
+
+
+def get_maps_results(search_query ):
+    results = []
+
+    params["q"] = search_query
+    search = GoogleSearch(params)
+    search_dict = search.get_dict()
+    if "local_results" not in search_dict:
+        return results
+    local_results = search_dict["local_results"]
+
+    for location in local_results:
+        if "website" in location and location["website"] not in results:
+
+            results.append(location["website"])
+    return results
+
+
+# print(get_maps_results("Konzerte Nuernberg"))

src/crawler/serp_search.py

@@ -0,0 +1,29 @@
+from serpapi import GoogleSearch
+from urllib.parse import urlparse
+from src.configuration.config import SERP_API_KEY
+
+params = {
+    "q": "",
+    "location": "Nuremberg, Bavaria, Germany",
+    "hl": "en",
+    "gl": "us",
+    "google_domain": "google.com",
+    "api_key": SERP_API_KEY
+}
+
+def get_search_results(keywords):
+    results = []
+    for keyword in keywords:
+        params["q"] = keyword + " Veranstaltungen"
+        search = GoogleSearch(params)
+        organic_results = search.get_dict().get("organic_results")
+        if organic_results is not None:
+            for result in organic_results:
+                append_url = True
+                base_url = urlparse(result["link"]).netloc
+                for r in results:
+                    if  base_url in r.url:
+                        append_url = False
+                if append_url:
+                    results.append( result["link"])
+    return results

src/crawler/utils/keywords.py

@@ -0,0 +1,45 @@
+KEYWORDS = [
+    "Art Show",
+    "Aufführung",
+    "Ausstellung",
+    "Award Ceremony",
+    "Beginn",
+    "Charity",
+    "Club"
+    "Clubnight",
+    "Concert",
+    "Conference",
+    "Convention",
+    "Einlass",
+    "Eintritt",
+    "Exhibition",
+    "Festival",
+    "Fundraiser",
+    "Gala",
+    "Konferenz",
+    "Konzert",
+    "Kunstausstellung",
+    "Launch",
+    "Lecture",
+    "Meeting",
+    "Messe",
+    "Networking",
+    "Netzwerken",
+    "Party",
+    "Performance",
+    "Präsentation",
+    "Preisverleihung",
+    "Presentation",
+    "Seminar",
+    "Spendenaktion",
+    "Symposium",
+    "Tagung",
+    "Trade Show",
+    "Treffen",
+    "Veranstaltung",
+    "Vortrag",
+    "Webinar",
+    "Wohltätigkeitsveranstaltung",
+    "Workshop",
+    "Event",
+]

src/crawler/utils/maps_types.py

@@ -0,0 +1,25 @@
+MAPS_TYPES = [
+    "art_gallery",
+    "auditorium",
+    "museum",
+    "performing_arts_theater",
+    "amphitheatre",
+    "amphitheatre",
+    "childrens_camp",
+    "comedy_club",
+    "community_center",
+    "concert_hall",
+    "convention_center",
+    "cultural_center",
+    "dance_hall",
+    "karaoke",
+    "night_club",
+    "opera_house",
+    "philharmonic_hall",
+    "planetarium",
+    "library",
+    "church",
+    "hindu_temple",
+    "mosque",
+    "synagogue"
+]

src/crawler/utils/regEx.py

@@ -0,0 +1,97 @@
+import re
+
+# define patterns to filter urls that should not be crawled
+
+PATTERNS = [
+    re.compile(r'.*about us*.*', re.IGNORECASE),
+    re.compile(r'.*about*.*us.*', re.IGNORECASE),
+    re.compile(r'.*a(b|n)meld(en|ung)*.*', re.IGNORECASE),
+    re.compile(r'.*about.*', re.IGNORECASE),
+    re.compile(r'.*agb*.*', re.IGNORECASE),
+    re.compile(r'.*archiv*.*', re.IGNORECASE),
+    re.compile(r'.*aussteller*.*', re.IGNORECASE),
+    re.compile(r'.*auszeichnung*.*', re.IGNORECASE),
+    re.compile(r'.*barrierefrei*.*', re.IGNORECASE),
+    re.compile(r'.*bestellverfolgung*.*', re.IGNORECASE),
+    re.compile(r'.*bezahlung*.*',re.IGNORECASE),
+    re.compile(r'.*bilder*.*', re.IGNORECASE),
+    re.compile(r'.*cart*.*', re.IGNORECASE),
+    re.compile(r'.*checkout*.*', re.IGNORECASE),
+    re.compile(r'.*contact*.*', re.IGNORECASE),
+    re.compile(r'.*credit card*.*', re.IGNORECASE),
+    re.compile(r'^https?://(?:www\.)?.*\.(jpg|png|pdf)$'),
+    re.compile(r'.*datenschutz*.*', re.IGNORECASE),
+    re.compile(r'.*debit*.*', re.IGNORECASE),
+    re.compile(r'.*download*.*', re.IGNORECASE),
+    re.compile(r'.*dsgvo.*', re.IGNORECASE),
+    re.compile(r'.*faq*.*', re.IGNORECASE),
+    re.compile(r'.*firmen(feiern|veranstaltungen).*', re.IGNORECASE),
+    re.compile(r'.*f(oe|ö)rder.*', re.IGNORECASE),
+    re.compile(r'.*for-rent*.*', re.IGNORECASE),
+    re.compile(r'.*fotos*.*', re.IGNORECASE),
+    re.compile(r'.*g(ae|ä)steliste*.*', re.IGNORECASE),
+    re.compile(r'.*galerie*.*', re.IGNORECASE),
+    re.compile(r'.*gallery*.*', re.IGNORECASE),
+    re.compile(r'.*geschaeftsbedingungen*.*', re.IGNORECASE),
+    re.compile(r'.*geschäftsbedingungen*.*', re.IGNORECASE),
+    re.compile(r'.*giropay*.*', re.IGNORECASE),
+    re.compile(r'.*guestlist*.*', re.IGNORECASE),
+    re.compile(r'.*hinweise*.*', re.IGNORECASE),
+    re.compile(r'.*impressum*.*', re.IGNORECASE),
+    re.compile(r'.*info.*', re.IGNORECASE),
+    re.compile(r'.*jobs*.*', re.IGNORECASE),
+    re.compile(r'.*karriere*.*', re.IGNORECASE),
+    re.compile(r'.*kasse*.*', re.IGNORECASE),
+    re.compile(r'.*klarna*.*', re.IGNORECASE),
+    re.compile(r'.*kontakt*.*', re.IGNORECASE),
+    re.compile(r'.*konto*.*', re.IGNORECASE),
+    re.compile(r'.*kreditkarte*.*', re.IGNORECASE),
+    re.compile(r'.*lastschrift*.*', re.IGNORECASE),
+    re.compile(r'.*landschaftsprogramm*.*', re.IGNORECASE),
+    re.compile(r'.*lieferung*.*', re.IGNORECASE),
+    re.compile(r'.*location.*', re.IGNORECASE),
+    re.compile(r'.*login*.*', re.IGNORECASE),
+    re.compile(r'.*mein-konto*.*', re.IGNORECASE),
+    re.compile(r'.*meine-bestellungen*.*', re.IGNORECASE),
+    re.compile(r'.*merch*.*', re.IGNORECASE),
+    re.compile(r'.*merkzettel*.*', re.IGNORECASE),
+    re.compile(r'.*mieten*.*', re.IGNORECASE),
+    re.compile(r'.*account*.*', re.IGNORECASE),
+    re.compile(r'.*orders*.*', re.IGNORECASE),
+    re.compile(r'.*news*.*', re.IGNORECASE),
+    re.compile(r'.*newsletter*.*', re.IGNORECASE),
+    re.compile(r'.*pay*.*', re.IGNORECASE),
+    re.compile(r'.*payment*.*', re.IGNORECASE),
+    re.compile(r'.*paypal*.*', re.IGNORECASE),
+    re.compile(r'.*personal*.*', re.IGNORECASE),
+    re.compile(r'.*photos*.*', re.IGNORECASE),
+    re.compile(r'.*pics*.*', re.IGNORECASE),
+    re.compile(r'.*pictures*.*', re.IGNORECASE),
+    re.compile(r'.*policy*.*', re.IGNORECASE),
+    re.compile(r'.*portfolio*.*', re.IGNORECASE),
+    re.compile(r'.*press*.*', re.IGNORECASE),
+    re.compile(r'.*pressemeldung*.*', re.IGNORECASE),
+    re.compile(r'.*pressemitteilungen*.*', re.IGNORECASE),
+    re.compile(r'.*privacy-policy*.*', re.IGNORECASE),
+    re.compile(r'.*produkt*.*', re.IGNORECASE),
+    re.compile(r'.*rathaus*.*', re.IGNORECASE),
+    re.compile(r'.*rechnung*.*', re.IGNORECASE),
+    re.compile(r'.*sepa*.*', re.IGNORECASE),
+    re.compile(r'.*shop*.*', re.IGNORECASE),
+    re.compile(r'.*signup*.*', re.IGNORECASE),
+    re.compile(r'.*sofort*.*', re.IGNORECASE),
+    re.compile(r'.*support*.*', re.IGNORECASE),
+    re.compile(r'.*terms-of-use*.*', re.IGNORECASE),
+    re.compile(r'.*twitter|facebook|instagram|tiktok*.*', re.IGNORECASE),
+    re.compile(r'.*(ue|ü)ber.?uns*.*', re.IGNORECASE),
+    re.compile(r'.*unterricht*.*', re.IGNORECASE),
+    re.compile(r'.*versand*.*', re.IGNORECASE),
+    re.compile(r'.*verbraucherschutz*.*', re.IGNORECASE),
+    re.compile(r'.*warenkorb*.*', re.IGNORECASE),
+    re.compile(r'.*wegbeschreibung*.*', re.IGNORECASE),
+    re.compile(r'.*widerrufsbelehrung*.*', re.IGNORECASE),
+    re.compile(r'.*wishlist*.*', re.IGNORECASE),
+    re.compile(r'.*zahlung*.*', re.IGNORECASE),
+    re.compile(r'.*.jpeg', re.IGNORECASE),
+]
+

src/nlp/config.cfg

@@ -0,0 +1,17 @@
+[nlp]
+lang = "en"
+pipeline = ["llm"]
+
+[components]
+
+[components.llm]
+factory = "llm"
+
+[components.llm.task]
+@llm_tasks = "spacy.NER.v3"
+labels = ["PERSON", "ORGANISATION", "LOCATION"]
+
+[components.llm.model]
+@llm_models = "spacy.Dolly.v1"
+# For better performance, use dolly-v2-12b instead
+name = "dolly-v2-12b"

src/nlp/data/ner.json

@@ -0,0 +1 @@
+{"classes":["TITLE","STARTTIME","STARTDATE","ENDDATE","ENDTIME","LOCATION"],"annotations":[["Technik-Salon an der TIB: „FLY ROCKET FLY“\r\n==========================================\r\n\r\nÜber den Aufstieg und Fall des Raketenpioniers Lutz Kayser – ein Film- und Gesprächsabend mit dem Dokumentarfilmer Oliver Schwehm\r\n\r\nEin Start-Up aus dem Schwäbischen, 170 Millionen D-Mark Wagniskapital, ein privates Testgelände im afrikanischen Dschungel – so trat Lutz Kayser in den 1970 er-Jahren an, die Raumfahrt zu revolutionieren.\r\n\r\nWarum das gut hätten klappen können und schließlich doch scheiterte, schildert Oliver Schwehm in seiner bildreichen Dokumentation. Im Rahmen der Jubiläumstour zu Ehren von Lutz Kayser („50 Jahre OTRAG – Oribital Transport und Raketen AG“) machen Film und Regisseur am 05.12.2024 im Technik-Salon Station in der TIB in Hannover. Der Eintritt für die Veranstaltung [„FLY ROCKET FLY“](http://www.technik-salon.de/05.12.2024/fly-rocket-fly.html) ist frei (Spendenbox).\r\n\r\nMehr Informationen zum [Technik-Salon](http://www.technik-salon.de)\r\n\r\n**Wann?** 05.12.2024, 19:00-21:00\r\n\r\n**Wo?** Lesesaal im Marstallgebäude, TIB",{"entities":[[0,42,"TITLE"],[980,990,"STARTDATE"],[992,997,"STARTTIME"],[998,1003,"ENDTIME"],[1014,1047,"LOCATION"]]}]]}

src/nlp/data/test.txt

@@ -0,0 +1,14 @@
+Technik-Salon an der TIB: „FLY ROCKET FLY“
+==========================================
+
+Über den Aufstieg und Fall des Raketenpioniers Lutz Kayser – ein Film- und Gesprächsabend mit dem Dokumentarfilmer Oliver Schwehm
+
+Ein Start-Up aus dem Schwäbischen, 170 Millionen D-Mark Wagniskapital, ein privates Testgelände im afrikanischen Dschungel – so trat Lutz Kayser in den 1970 er-Jahren an, die Raumfahrt zu revolutionieren.
+
+Warum das gut hätten klappen können und schließlich doch scheiterte, schildert Oliver Schwehm in seiner bildreichen Dokumentation. Im Rahmen der Jubiläumstour zu Ehren von Lutz Kayser („50 Jahre OTRAG – Oribital Transport und Raketen AG“) machen Film und Regisseur am 05.12.2024 im Technik-Salon Station in der TIB in Hannover. Der Eintritt für die Veranstaltung [„FLY ROCKET FLY“](http://www.technik-salon.de/05.12.2024/fly-rocket-fly.html) ist frei (Spendenbox).
+
+Mehr Informationen zum [Technik-Salon](http://www.technik-salon.de)
+
+**Wann?** 05.12.2024, 19:00-21:00
+
+**Wo?** Lesesaal im Marstallgebäude, TIB

src/nlp/dates_txt

@@ -0,0 +1,4 @@
+Die Reservierungen für das diesjährige Mainzer Weihnachtsdorf werden voraussichtlich am 10.01.2024 EVENT_DATE um 08:00 freigeschaltet.
+Das Interkulturelle Fest wird am 08.09.2025 EVENT_DATE auf dem Domplatz gefeiert.**
+Vom 17.10.2025 - 03.11.2025 findet das Mainzer Oktoberfest zum 18. Mal statt.
+Nächster Termin: 13.09.2025 und 14.09.2025

src/nlp/experimental/annotations.json

@@ -0,0 +1,241 @@
+[
+    [
+        "Im Rahmen der Jubiläumstour zu Ehren von Lutz Kayser (\"50 Jahre OTRAG – Oribital Transport und Raketen AG\") machen Film und Regisseur am 05.12.2024 im Technik-Salon Station in der TIB in Hannover.",
+        {
+            "entities": [
+                [
+                    137,
+                    147,
+                    "EVENT_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Wann? 05.12.2024, 19:00-21:00",
+        {
+            "entities": [
+                [
+                    6,
+                    16,
+                    "EVENT_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Der siebte Workshop Retrodigitalisierung findet am 20.03.2025 und 21.03.2025 bei ZB MED – Informationszentrum Lebenswissenschaften in Köln statt.",
+        {
+            "entities": [
+                [
+                    51,
+                    61,
+                    "EVENT_DATE"
+                ],
+                [
+                    66,
+                    76,
+                    "EVENT_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Wann? 20.03.2025 - 21.03.2025",
+        {
+            "entities": [
+                [
+                    6,
+                    29,
+                    "EVENT_DATE_RANGE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Die 18. ACM International Conference on Web Search and Data Mining (WSDM 2025) wird vom 10.03.2025 - 14.03.2025 in Hannover stattfinden.",
+        {
+            "entities": [
+                [
+                    88,
+                    111,
+                    "EVENT_DATE_RANGE"
+                ]
+            ]
+        }
+    ],
+    [
+        "So. 08.12.2024 12:15 - 13:15 CET",
+        {
+            "entities": [
+                [
+                    4,
+                    14,
+                    "EVENT_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "24.12.2025 um 16:00",
+        {
+            "entities": [
+                [
+                    0,
+                    10,
+                    "EVENT_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "07.01.2025",
+        {
+            "entities": [
+                [
+                    0,
+                    10,
+                    "EVENT_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Am 01.07.2025",
+        {
+            "entities": [
+                [
+                    3,
+                    13,
+                    "EVENT_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Wann? 07.11.2024 - 09.03.2025",
+        {
+            "entities": [
+                [
+                    6,
+                    29,
+                    "EVENT_DATE_RANGE"
+                ]
+            ]
+        }
+    ],
+    [
+        "01.11.2024 - 09.03.2025",
+        {
+            "entities": [
+                [
+                    0,
+                    23,
+                    "EVENT_DATE_RANGE"
+                ]
+            ]
+        }
+    ],
+    [
+        "01.09.2025 - 26.12.2024",
+        {
+            "entities": [
+                [
+                    0,
+                    23,
+                    "EVENT_DATE_RANGE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Premiere am 01.12.2024",
+        {
+            "entities": [
+                [
+                    12,
+                    22,
+                    "EVENT_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "01.11.2025 ab 16:00",
+        {
+            "entities": [
+                [
+                    0,
+                    10,
+                    "EVENT_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "15.01.2025 ab 18:00",
+        {
+            "entities": [
+                [
+                    0,
+                    10,
+                    "EVENT_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "01.12.2025 ab 14:00-15:00",
+        {
+            "entities": [
+                [
+                    0,
+                    10,
+                    "EVENT_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "18.01.2025 ab 11:00-18:00",
+        {
+            "entities": [
+                [
+                    0,
+                    10,
+                    "EVENT_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "01.12.2024 – 08.12.2024",
+        {
+            "entities": [
+                [
+                    0,
+                    23,
+                    "EVENT_DATE_RANGE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Freitag 16:00-20:00 / Samstag 11:00-20:00 / Sonntag 11:00-18:00",
+        {
+            "entities": []
+        }
+    ],
+    [
+        "So, 15.12.2024 Beginn: 15:00 Einlass: 14:30",
+        {
+            "entities": [
+                [
+                    4,
+                    14,
+                    "EVENT_DATE"
+                ]
+            ]
+        }
+    ]
+]

src/nlp/experimental/annotations_v1.json

@@ -0,0 +1,430 @@
+[
+    [
+        "Im Rahmen der Jubiläumstour zu Ehren von Lutz Kayser („50 Jahre OTRAG – Oribital Transport und Raketen AG“) machen Film und Regisseur am 05.12.2024 im Technik-Salon Station in der TIB in Hannover.",
+        {
+            "entities": [
+                [
+                    137,
+                    147,
+                    "DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Der siebte Workshop Retrodigitalisierung findet am 20.03.2025 und 21.03.2025 bei ZB MED – Informationszentrum Lebenswissenschaften in Köln statt.",
+        {
+            "entities": [
+                [
+                    51,
+                    61,
+                    "START_DATE"
+                ],
+                [
+                    66,
+                    76,
+                    "END_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Die 18. ACM International Conference on Web Search and Data Mining (WSDM 2025) wird vom 10.03.2025 - 14.03.2025 in Hannover stattfinden.",
+        {
+            "entities": [
+                [
+                    88,
+                    98,
+                    "START_DATE"
+                ],
+                [
+                    101,
+                    111,
+                    "END_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Die Infoveranstaltung für geistliche Mütter und Väter findet am 08.12.2024 im Christlichen Zentrum Darmstadt statt.",
+        {
+            "entities": [
+                [
+                    64,
+                    74,
+                    "DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Erlebe einen besonderen Film-Gottesdienst am 24.12.2025 um 16:00.",
+        {
+            "entities": [
+                [
+                    45,
+                    55,
+                    "DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Termin für öffentliche Besichtigung am 07.01.2025.",
+        {
+            "entities": [
+                [
+                    39,
+                    49,
+                    "DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Cornelia Poletto Palazzo: Die Dinner-Show im Spiegelpalast findet vom 07.11.2024 bis 09.03.2025 statt.",
+        {
+            "entities": [
+                [
+                    70,
+                    80,
+                    "START_DATE"
+                ],
+                [
+                    85,
+                    95,
+                    "END_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Die Ausstellung \"Leonardo da Vinci – uomo universale\" läuft vom 01.09.2025 bis zum 26.12.2024 in Hamburg.",
+        {
+            "entities": [
+                [
+                    64,
+                    74,
+                    "START_DATE"
+                ],
+                [
+                    83,
+                    93,
+                    "END_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Liedernachmittag – Lieder von R. Schubert, R. Franz, A. Webern, H. Wolf. Vortrag im Museum August Kestner. Monika Abel, Sopran / Kathrin Isabelle Klein, Klavier. Termine 01.11.2025 ab 16:00.",
+        {
+            "entities": [
+                [
+                    170,
+                    180,
+                    "START_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Die goldene Stadt – Vortrag im Museum August Kestner mit Dr. Martin Hersch (München). Termine 15.01.2025 ab 18:00.",
+        {
+            "entities": [
+                [
+                    94,
+                    104,
+                    "START_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Stadtansichten – Erleben Sie bei einem Besuch der Sonderausstellung Städtetrip. Termine 01.12.2025 ab 14:00-15:00.",
+        {
+            "entities": [
+                [
+                    88,
+                    98,
+                    "START_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Finissage der Sonderausstellung Bartmann, Bier und Tafelzier. Steinzeug in der niederländischen Malerei. Mit Kuratorinnenführung. Termine 18.01.2025 ab 11:00-18:00.",
+        {
+            "entities": [
+                [
+                    138,
+                    148,
+                    "START_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Veranstaltungsinformationen 01.12.2024 – 08.12.2024. Nikolausmarkt im Kulturhof, Kulturzentrum Bottrop.",
+        {
+            "entities": [
+                [
+                    28,
+                    38,
+                    "START_DATE"
+                ],
+                [
+                    41,
+                    51,
+                    "END_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Verleihung Erlanger Theaterpreis. So. 8.12. Keine Anmeldung nötig. Theater in der Garage 19:00. Eintritt frei.",
+        {
+            "entities": []
+        }
+    ],
+    [
+        "SILVESTER 2024 IM FOODKLUB – Feiern Sie mit uns ins neue Jahr mit einem exquisiten levantinischen Festbuffet! 48€ pro Person. Datum: 2024.",
+        {
+            "entities": []
+        }
+    ],
+    [
+        "PIANOKLÄNGE & Herzgeschichten – Stiftung Gemeinsam für Halle. Termine 15.12.2024. Beginn 15:00, Einlass 14:30.",
+        {
+            "entities": [
+                [
+                    70,
+                    80,
+                    "START_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Zwischendrin – Beginn 17:00, Ende 19:00. Veranstaltungsort: Religionspädagogisches Institut im Heinrich-Fries-Haus. Termine 2024-25.",
+        {
+            "entities": []
+        }
+    ],
+    [
+        "vom 02.12. – 19.12.2024, Dauer ca. 30 Minuten",
+        {
+            "entities": [
+                [
+                    13,
+                    23,
+                    "END_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "01.01.2025*Donnerstag*  15.00 - 17.00 *Uhr*",
+        {
+            "entities": [
+                [
+                    0,
+                    10,
+                    "DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Vom 30.11.2024 - 06.07.2025 präsentieren wir in unserer Sonderausstellung das Werk des Berliner Künstlers Alexej Tchernyi.",
+        {
+            "entities": [
+                [
+                    4,
+                    14,
+                    "START_DATE"
+                ],
+                [
+                    17,
+                    27,
+                    "END_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "01.04.2025 *Montag* 15.00 - 16.00 *Uhr*",
+        {
+            "entities": [
+                [
+                    0,
+                    10,
+                    "DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "16.12.2024 **Beginn** 20:00-22:30",
+        {
+            "entities": [
+                [
+                    0,
+                    10,
+                    "DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "29.12.2024 **Beginn** 15:00-17:00",
+        {
+            "entities": [
+                [
+                    0,
+                    10,
+                    "DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Die Höhner Weihnacht findet am Freitag, 20.12.2024, im Eurogress Aachen statt.",
+        {
+            "entities": [
+                [
+                    40,
+                    50,
+                    "DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Feiere Weihnachten mit uns am 24.12.2024 um 16:00 in der Festhalle Durlach.",
+        {
+            "entities": [
+                [
+                    30,
+                    40,
+                    "DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Der Alpha Kurs startet am 13.01.2025 und geht 12 Wochen lang.",
+        {
+            "entities": [
+                [
+                    26,
+                    36,
+                    "DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Die Echo Night findet am 05.04.2025 statt.",
+        {
+            "entities": [
+                [
+                    25,
+                    35,
+                    "DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Das Nachbarschaftsfest findet am 06.07.2025 und 07.07.2025 statt.",
+        {
+            "entities": [
+                [
+                    33,
+                    43,
+                    "START_DATE"
+                ],
+                [
+                    48,
+                    58,
+                    "END_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Die Einführung des neuen Leiters der Jugendkirche findet am 01.12.2024 um 18:00 statt.",
+        {
+            "entities": [
+                [
+                    60,
+                    70,
+                    "DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Die Christuskapelle in Grötzingen ist vom 18.12.2023 bis 02.12.2024 täglich von 17:00-19:00 geöffnet.",
+        {
+            "entities": [
+                [
+                    42,
+                    52,
+                    "START_DATE"
+                ],
+                [
+                    57,
+                    67,
+                    "END_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Der Adventsmarkt in der Kapelle findet am 30.11.2024 von 14:00-19:00 statt.",
+        {
+            "entities": [
+                [
+                    42,
+                    52,
+                    "DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Die 18. Koblenzer Literaturtage finden vom 22.03.2025 bis 04.05.2025 statt.",
+        {
+            "entities": [
+                [
+                    43,
+                    53,
+                    "START_DATE"
+                ],
+                [
+                    58,
+                    68,
+                    "END_DATE"
+                ]
+            ]
+        }
+    ],
+    [
+        "Die Kunstausstellung \"Der erweiterte Raum\" ist vom 15.11.2024 bis 01.05.2025 zu sehen.",
+        {
+            "entities": [
+                [
+                    51,
+                    61,
+                    "START_DATE"
+                ],
+                [
+                    66,
+                    76,
+                    "END_DATE"
+                ]
+            ]
+        }
+    ]
+]

src/nlp/experimental/data/test.md

@@ -0,0 +1,34 @@
+Infoveranstaltung für geistliche Mütter und Väter
+=================================================
+
+**Als Kirche wollen wir uns in die junge Generation investieren und sie fördern. Dazu gebraucht Gott reife geistliche Mütter und Väter.**
+
+Datum und Uhrzeit
+-----------------
+
+So. 08.12.2024 12:15 - 13:15 CET
+
+Veranstaltungsort
+-----------------
+
+Christliches Zentrum Darmstadt
+
+Röntgenstraße 18 64291 Darmstadt
+
+Karte anzeigen
+
+Zu diesem Event
+---------------
+
+**Infoveranstaltung für geistliche Mütter und Väter**
+
+Als Kirche wollen wir uns in die junge Generation investieren und sie fördern. Dazu gebraucht Gott reife geistliche Mütter und Väter. Wenn du im altern von über 55 Jahren bist und einen Unterschied im Leben einer jungen Person machen möchtest, bist du herzlich zu dieser Infoveranstaltung eingeladen.
+
+Wir wollen uns gemeinsam austauschen was unsere ältere Generation auf ihrer Reise mit Gott benötigt und welches Erbe Gott ihnen gegeben hat. Zudem sprechen wir über das kommende Jahr und welche Schritte wir gehen dürfen, damit die junge Generation fest in Jesus verwurzelt ist.
+
+Wir starten mit einem kleinen Mittagessen und laden dich herzlich ein.
+
+Veranstaltet von
+----------------
+
+Christliches Zentrum Darmstadt

src/nlp/experimental/gliner/ner_fine_tuning.py

@@ -0,0 +1,42 @@
+from label_studio_sdk import Client
+
+LABEL_STUDIO_URL = 'http://localhost:8080'
+API_KEY = 'aad38f54021d443b17395123304a7c01001b55af'
+ls = Client(url=LABEL_STUDIO_URL, api_key=API_KEY)
+print(ls.check_connection())
+
+# Load and preprocess sample data
+from datasets import load_dataset
+from tqdm import tqdm
+
+# We don't need a ton of data, so we'll only look at the training set for now
+dataset = load_dataset("MultiCoNER/multiconer_v2", "English (EN)")["train"]
+medical_labels = ["Medication/Vaccine", "MedicalProcedure", "AnatomicalStructure", "Symptom", "Disease"]
+
+# Filter so we only look at samples with medical tags
+medical_dataset = []
+for item in tqdm(dataset):
+    has_medical = any(any(label in tag for label in medical_labels) for tag in item["ner_tags"])
+    if has_medical:
+        # We want the text as a full text and not a list of tokens, so we create that as another key value pair in the item dictionary
+        item["text"] = " ".join(item["tokens"])
+        medical_dataset.append(item)
+
+project = ls.start_project(
+    title='Medical NER with GLiNER',
+    label_config='''
+<View>
+  <Labels name="label" toName="text">
+    <Label value="Medication/Vaccine" background="red"/>
+    <Label value="MedicalProcedure" background="blue"/>
+    <Label value="AnatomicalStructure" background="orange"/>
+    <Label value="Symptom" background="green"/>
+    <Label value="Disease" background="purple"/>
+  </Labels>
+
+  <Text name="text" value="$text"/>
+</View>
+'''
+)
+
+project.import_tasks(medical_dataset)

src/nlp/experimental/gliner/open_information_extraction.py

@@ -0,0 +1,22 @@
+from gliner import GLiNER
+from gliner.multitask import GLiNEROpenExtractor
+
+model_id = 'urchade/gliner_multi-v2.1'
+model = GLiNER.from_pretrained(model_id)
+extractor = GLiNEROpenExtractor(model=model, prompt="Extrahiere den Veranstaltungstitel")
+
+text = """Technik-Salon an der TIB: „FLY ROCKET FLY“
+Über den Aufstieg und Fall des Raketenpioniers Lutz Kayser – ein Film- und Gesprächsabend mit dem Dokumentarfilmer Oliver Schwehm
+
+Ein Start-Up aus dem Schwäbischen, 170 Millionen D-Mark Wagniskapital, ein privates Testgelände im afrikanischen Dschungel – so trat Lutz Kayser in den 1970er-Jahren an, die Raumfahrt zu revolutionieren.
+
+Warum das gut hätten klappen können und schließlich doch scheiterte, schildert Oliver Schwehm in seiner bildreichen Dokumentation. Im Rahmen der Jubiläumstour zu Ehren von Lutz Kayser („50 Jahre OTRAG – Oribital Transport und Raketen AG“) machen Film und Regisseur am 5. Dezember 2024 im Technik-Salon Station in der TIB in Hannover. Der Eintritt für die Veranstaltung „FLY ROCKET FLY“ ist frei (Spendenbox).
+
+Mehr Informationen zum Technik-Salon
+
+Wann? 5. Dezember 2024, 19.00-21.00 Uhr
+
+Wo? Lesesaal im Marstallgebäude, TIB"""
+labels = ['title']
+predictions = extractor(text, labels=labels)
+print(predictions)

src/nlp/experimental/gliner/summarization.py

@@ -0,0 +1,194 @@
+import json
+
+from gliner import GLiNER
+from gliner.multitask import GLiNERSummarizer
+
+texts = [
+    """Cornelia Poletto Palazzo: Die Dinner-Show im Spiegelpalast
+Wann? 7. November 2024 bis 9. März 2025
+Wo? Spiegelpalast in Hamburg-Altona, Waidmannstraße 26
+
+Tickets sind hier erhältlich: Tickets buchen*
+
+Termine
+November 2024 bis 9. März 2025
+Erreichbarkeit
+Anreise mit den öffentlichen Verkehrsmitteln:
+Über die Bushaltestellen Langenfelderstraße und Diebsteich Ostseite erreichen Sie den Spiegelpalast in wenigen Gehminuten. Bitte nutzen Sie bevorzugt den ÖPNV zur Anreise.
+
+Anreise mit dem PKW:
+Eine begrenzte Anzahl an Parkplätzen steht Ihnen in unmittelbarer Nähe zum Spiegelpalast zur Verfügung. Folgen Sie der Beschilderung! Die Anreise mit dem ÖPNV wird empfohlen.""",
+
+    """Technik-Salon an der TIB: „FLY ROCKET FLY“
+Über den Aufstieg und Fall des Raketenpioniers Lutz Kayser – ein Film- und Gesprächsabend mit dem Dokumentarfilmer Oliver Schwehm
+
+Ein Start-Up aus dem Schwäbischen, 170 Millionen D-Mark Wagniskapital, ein privates Testgelände im afrikanischen Dschungel – so trat Lutz Kayser in den 1970er-Jahren an, die Raumfahrt zu revolutionieren.
+
+Warum das gut hätten klappen können und schließlich doch scheiterte, schildert Oliver Schwehm in seiner bildreichen Dokumentation. Im Rahmen der Jubiläumstour zu Ehren von Lutz Kayser („50 Jahre OTRAG – Oribital Transport und Raketen AG“) machen Film und Regisseur am 5. Dezember 2024 im Technik-Salon Station in der TIB in Hannover. Der Eintritt für die Veranstaltung „FLY ROCKET FLY“ ist frei (Spendenbox).
+
+Mehr Informationen zum Technik-Salon""",
+
+    """Workshop Retrodigitalisierung ================================
+Thema: Digitalisierte Sammlungen präsentieren – Konzeptionierung, Darstellung und Vermittlung
+
+Der siebte Workshop Retrodigitalisierung findet am 20. und 21. März 2025 bei ZB MED – Informationszentrum Lebenswissenschaften in Köln statt. Er richtet sich an Praktiker:innen, die sich in Bibliotheken mit der Retrodigitalisierung befassen. Wie in den Vorjahren bietet der Workshop ein breites Spektrum an interessanten Vorträgen zur Praxis der Retrodigitalisierung. Dafür brauchen wir Sie und Ihre Einreichungen!
+
+Im Fokus des nächsten Workshops steht die zeitgemäße Präsentation digitalisierter Sammlungen. Das Programm widmet sich insbesondere den Themen Konzeptionierung, Darstellung und Vermittlung von digitalisierten Sammlungen und Beständen über die Präsentationsplattformen der Einrichtungen rund um die Nutzung von Digitalisaten.
+
+Der Call for Presentations läuft noch bis zum 18. Oktober 2024. Wir freuen uns auf Ihren Beitrag!
+
+Der Workshop Retrodigitalisierung wird gemeinsam von den drei deutschen Zentralen Fachbibliotheken TIB – Leibniz-Informationszentrum Technik und Naturwissenschaften, ZB MED – Informationszentrum Lebenswissenschaften und ZBW – Leibniz-Informationszentrum Wirtschaft sowie der Staatsbibliothek zu Berlin – Preußischer Kulturbesitz durchgeführt.
+
+Wann? 20. März bis 21. März 2025
+
+Wo? ZB MED in Köln""",
+
+    """„ACM WSDM 2025“: renommierte Konferenz zu Websuche und Data Mining in Hannover
+Wissenschaftlicher Austausch und technologische Innovation im Fokus der 18. ACM International Conference on Web Search and Data Mining
+
+Die 18. ACM International Conference on Web Search and Data Mining (WSDM 2025) wird vom 10.03.2025 - 14.03.2025 in Hannover stattfinden. Die WSDM zählt zu den führenden Konferenzen in den Bereichen Websuche, Data Mining, Maschinelles Lernen und Künstliche Intelligenz. Sie bietet eine Plattform, auf der weltweit führende Wissenschaftler:innen, Fachleute und Praktiker:innen ihre neuesten Forschungsergebnisse präsentieren und zukunftsweisende Ideen austauschen können.
+
+Die Konferenz wird sich auf ein breites Spektrum aktueller Themen konzentrieren, darunter:
+
+Web of Things, ortsunabhängige und mobile Datenverarbeitung (Ubiquitous and Mobile Computing)
+Datenschutz, Fairness, Interpretierbarkeit
+Soziale Netzwerke
+Intelligente Assistenten
+Crowdsourcing und menschliche Datenverarbeitung
+Zur Konferenz-Website""",
+
+    """Infoveranstaltung für geistliche Mütter und Väter
+Als Kirche wollen wir uns in die junge Generation investieren und sie fördern. Dazu gebraucht Gott reife geistliche Mütter und Väter.
+
+Von Christliches Zentrum DarmstadtFolgenFolgen
+
+Datum und Uhrzeit
+So. 8. Dez. 2024 12:15 - 13:15 CET
+
+Veranstaltungsort
+Christliches Zentrum Darmstadt
+
+Röntgenstraße 18 64291 DarmstadtKarte anzeigen
+
+Zu diesem Event
+** Infoveranstaltung für geistliche Mütter und Väter **
+
+Als Kirche wollen wir uns in die junge Generation investieren und sie fördern. Dazu gebraucht Gott reife geistliche Mütter und Väter. Wenn du im altern von über 55 Jahren bist und einen Unterschied im Leben einer jungen Person machen möchtest, bist du herzlich zu dieser Infoveranstaltung eingeladen.
+
+Wir wollen uns gemeinsam austauschen was unsere ältere Generation auf ihrer Reise mit Gott ben��tigt und welches Erbe Gott ihnen gegeben hat. Zudem sprechen wir über das kommende Jahr und welche Schritte wir gehen dürfen, damit die junge Generation fest in Jesus verwurzelt ist.
+
+Wir starten mit einem kleinen Mittagessen und laden dich herzlich ein.
+
+Veranstaltet von
+Christliches Zentrum Darmstadt""",
+
+    """MJ – Das Michael Jackson Musical
+Das Erfolgsmusical über den Ausnahmekünstler Michael Jackson ist seit Dezember 2024 in Hamburg zu sehen! Tickets und Hotel können Sie hier bequem online buchen.
+
+Tickets buchen
+Erleben Sie das mehrfach ausgezeichnete Musical MJ – Das Michael Jackson Musical.
+
+Tickets buchen ab 63,99€*
+
+Tickets und Hotel buchen
+Sie möchten Ihren Musical-Besuch mit einer Reise nach Hamburg verbinden? Hier können Sie Ihre Tickets und Hotelübernachtung im Paket buchen:
+
+Reisepaket: MJ – Das Michael Jackson Musical ab 134,60€*
+
+Alle Vorteile auf einen Blick:
+
+Übernachtung im ausgewählten Hotel inkl. Frühstück, Zusatznächte buchbar
+Musical-Ticket in der gewählten Preiskategorie
+Hamburg Card (3 Tage) – Ihr Entdeckerticket für freie Fahrt mit Bus und Bahn im Wert von 31,90€
+Termine für MJ – Das Michael Jackson Musical
+Anfahrt
+MJ – Das Michael Jackson Musical | Stage Theater an der Elbe
+
+Norderelbstraße 8, 20457 Hamburg
+
+Kontakt speichern
+
+Adresse auf Karte anzeigen
+
+[Anfahrt](https://geofox.hvv.de/jsf/home.seam?clear=true&language=de&destination=Norderelbstra%C3%9Fe 8, 20457 Hamburg)
+
+Termine
+Premiere am 1. Dezember 2024""",
+
+    """Liedernachmittag
+Lieder von R. Schubert, R. Franz, A. Webern, H. Wolf
+
+Stuhlreihen im Museum August Kestner
+© MAK/LHH
+
+Vortrag im Museum August Kestner
+
+Monika Abel, Sopran / Kathrin Isabelle Klein, Klavier
+
+Termine
+
+11.01.2025 ab 16:00 Uhr
+
+Ort
+
+Museum August Kestner
+Platz der Menschenrechte 3
+30159 Hannover
+
+Konzertkarten: [email protected] und Tageskasse ab 15.00 Uhr im Museum
+
+Unter der Schirmherrschaft von Kammersängerin Helen Donath.
+
+Bis zu viermal im Jahr laden wir zu einem Liedernachmittag im Museum ein.
+
+In Zusammenarbeit mit: Lohmann-Stiftung für Liedgesang e.V., Hannover; Freundes- und Förderkreis des Museum August Kestner „Antike & Gegenwart e.V.“""",
+
+    """Die goldene Stadt
+Vortrag im Museum August Kestner
+
+Mit Dr. Martin Hersch (München)
+
+In Kooperation mit dem Freundeskreis Antike und Gegenwart
+
+Termine
+15.01.2025 ab 18:00 Uhr
+
+Ort
+Museum August Kestner
+Platz der Menschenrechte 3
+30159 Hannover
+
+Eintritt
+5,00 €
+
+ermäßigter Eintritt
+
+4,00 €""",
+
+    """Stadtansichten
+Erleben Sie bei einem Besuch der Sonderausstellung Städtetrip vielfältige und spannende Lyrik und Prosa verschiedener Autor*innen, nicht nur zum Thema Reisen. Ausgewählt und vorgetragen von der Literarischen Komponistin und Rezitatorin Marie Dettmer.
+
+Termine
+
+12.01.2025 ab 14:00 bis 15:00 Uhr
+
+Ort
+
+Landeshauptstadt Hannover
+
+Trammplatz 2
+
+30159 Hannover"""
+]
+
+model_id = 'urchade/gliner_multi-v2.1'
+model = GLiNER.from_pretrained(model_id)
+summarizer = GLiNERSummarizer(model=model)
+
+
+for text in texts :
+    summary = summarizer(text, threshold=0.001)
+    print("ORIGINAL")
+    print(text)
+    print("SUMMARY")
+    print(summary)

src/nlp/experimental/keyword_extraction.py

@@ -0,0 +1,33 @@
+import spacy
+from collections import Counter
+from string import punctuation
+nlp = spacy.load("de_core_news_lg")
+def get_hotwords(text):
+    result = []
+    pos_tag = ['PROPN', 'ADJ', 'NOUN']
+    doc = nlp(text.lower())
+    for token in doc:
+        if(token.text in nlp.Defaults.stop_words or token.text in punctuation):
+            continue
+        if(token.pos_ in pos_tag):
+            result.append(token.text)
+    return result
+new_text = """
+Technik-Salon an der TIB: „FLY ROCKET FLY“
+Über den Aufstieg und Fall des Raketenpioniers Lutz Kayser – ein Film- und Gesprächsabend mit dem Dokumentarfilmer Oliver Schwehm
+
+Ein Start-Up aus dem Schwäbischen, 170 Millionen D-Mark Wagniskapital, ein privates Testgelände im afrikanischen Dschungel – so trat Lutz Kayser in den 1970 er-Jahren an, die Raumfahrt zu revolutionieren.
+
+Warum das gut hätten klappen können und schließlich doch scheiterte, schildert Oliver Schwehm in seiner bildreichen Dokumentation. Im Rahmen der Jubiläumstour zu Ehren von Lutz Kayser („50 Jahre OTRAG – Oribital Transport und Raketen AG“) machen Film und Regisseur am 05.12.2024 im Technik-Salon Station in der TIB in Hannover. Der Eintritt für die Veranstaltung „FLY ROCKET FLY“ ist frei (Spendenbox).
+
+Mehr Informationen zum Technik-Salon
+
+Wann? 05.12.2024, 19:00-21:00
+
+Wo? Lesesaal im Marstallgebäude, TIB
+"""
+output = set(get_hotwords(new_text))
+print(output)
+most_common_list = Counter(output).most_common(10)
+for item in most_common_list:
+  print(item[0])

src/nlp/experimental/layout_parser.py

@@ -0,0 +1,23 @@
+import layoutparser as lp
+import cv2
+
+
+image = cv2.imread("data/img.png")
+image = image[..., ::-1]
+    # Convert the image from BGR (cv2 default loading style)
+    # to RGB
+
+
+
+model = lp.Detectron2LayoutModel('lp://PubLayNet/faster_rcnn_R_50_FPN_3x/config',
+                                 extra_config=["MODEL.ROI_HEADS.SCORE_THRESH_TEST", 0.8],
+                                 label_map={0: "Text", 1: "Title", 2: "List", 3:"Table", 4:"Figure"})
+    # Load the deep layout model from the layoutparser API
+    # For all the supported model, please check the Model
+    # Zoo Page: https://layout-parser.readthedocs.io/en/latest/notes/modelzoo.html
+
+layout = model.detect(image)
+    # Detect the layout of the input image
+
+lp.draw_box(image, layout, box_width=3)
+    # Show the detected layout of the input image

src/nlp/experimental/llm/inference_api_test.py

@@ -0,0 +1,227 @@
+from huggingface_hub import InferenceClient
+import json
+from src.configuration.config import INFERENCE_API_KEY
+texts = [
+    """Cornelia Poletto Palazzo: Die Dinner-Show im Spiegelpalast
+Wann? 7. November 2024 bis 9. März 2025
+Wo? Spiegelpalast in Hamburg-Altona, Waidmannstraße 26
+
+Tickets sind hier erhältlich: Tickets buchen*
+
+Termine
+November 2024 bis 9. März 2025
+Erreichbarkeit
+Anreise mit den öffentlichen Verkehrsmitteln:
+Über die Bushaltestellen Langenfelderstraße und Diebsteich Ostseite erreichen Sie den Spiegelpalast in wenigen Gehminuten. Bitte nutzen Sie bevorzugt den ÖPNV zur Anreise.
+
+Anreise mit dem PKW:
+Eine begrenzte Anzahl an Parkplätzen steht Ihnen in unmittelbarer Nähe zum Spiegelpalast zur Verfügung. Folgen Sie der Beschilderung! Die Anreise mit dem ÖPNV wird empfohlen.""",
+
+    """Technik-Salon an der TIB: „FLY ROCKET FLY“
+Über den Aufstieg und Fall des Raketenpioniers Lutz Kayser – ein Film- und Gesprächsabend mit dem Dokumentarfilmer Oliver Schwehm
+
+Ein Start-Up aus dem Schwäbischen, 170 Millionen D-Mark Wagniskapital, ein privates Testgelände im afrikanischen Dschungel – so trat Lutz Kayser in den 1970er-Jahren an, die Raumfahrt zu revolutionieren.
+
+Warum das gut hätten klappen können und schließlich doch scheiterte, schildert Oliver Schwehm in seiner bildreichen Dokumentation. Im Rahmen der Jubiläumstour zu Ehren von Lutz Kayser („50 Jahre OTRAG – Oribital Transport und Raketen AG“) machen Film und Regisseur am 5. Dezember 2024 im Technik-Salon Station in der TIB in Hannover. Der Eintritt für die Veranstaltung „FLY ROCKET FLY“ ist frei (Spendenbox).
+
+Mehr Informationen zum Technik-Salon""",
+
+    """Workshop Retrodigitalisierung ================================
+Thema: Digitalisierte Sammlungen präsentieren – Konzeptionierung, Darstellung und Vermittlung
+
+Der siebte Workshop Retrodigitalisierung findet am 20. und 21. März 2025 bei ZB MED – Informationszentrum Lebenswissenschaften in Köln statt. Er richtet sich an Praktiker:innen, die sich in Bibliotheken mit der Retrodigitalisierung befassen. Wie in den Vorjahren bietet der Workshop ein breites Spektrum an interessanten Vorträgen zur Praxis der Retrodigitalisierung. Dafür brauchen wir Sie und Ihre Einreichungen!
+
+Im Fokus des nächsten Workshops steht die zeitgemäße Präsentation digitalisierter Sammlungen. Das Programm widmet sich insbesondere den Themen Konzeptionierung, Darstellung und Vermittlung von digitalisierten Sammlungen und Beständen über die Präsentationsplattformen der Einrichtungen rund um die Nutzung von Digitalisaten.
+
+Der Call for Presentations läuft noch bis zum 18. Oktober 2024. Wir freuen uns auf Ihren Beitrag!
+
+Der Workshop Retrodigitalisierung wird gemeinsam von den drei deutschen Zentralen Fachbibliotheken TIB – Leibniz-Informationszentrum Technik und Naturwissenschaften, ZB MED – Informationszentrum Lebenswissenschaften und ZBW – Leibniz-Informationszentrum Wirtschaft sowie der Staatsbibliothek zu Berlin – Preußischer Kulturbesitz durchgeführt.
+
+Wann? 20. März bis 21. März 2025
+
+Wo? ZB MED in Köln""",
+
+    """„ACM WSDM 2025“: renommierte Konferenz zu Websuche und Data Mining in Hannover
+Wissenschaftlicher Austausch und technologische Innovation im Fokus der 18. ACM International Conference on Web Search and Data Mining
+
+Die 18. ACM International Conference on Web Search and Data Mining (WSDM 2025) wird vom 10.03.2025 - 14.03.2025 in Hannover stattfinden. Die WSDM zählt zu den führenden Konferenzen in den Bereichen Websuche, Data Mining, Maschinelles Lernen und Künstliche Intelligenz. Sie bietet eine Plattform, auf der weltweit führende Wissenschaftler:innen, Fachleute und Praktiker:innen ihre neuesten Forschungsergebnisse präsentieren und zukunftsweisende Ideen austauschen können.
+
+Die Konferenz wird sich auf ein breites Spektrum aktueller Themen konzentrieren, darunter:
+
+Web of Things, ortsunabhängige und mobile Datenverarbeitung (Ubiquitous and Mobile Computing)
+Datenschutz, Fairness, Interpretierbarkeit
+Soziale Netzwerke
+Intelligente Assistenten
+Crowdsourcing und menschliche Datenverarbeitung
+Zur Konferenz-Website""",
+
+    """Infoveranstaltung für geistliche Mütter und Väter
+Als Kirche wollen wir uns in die junge Generation investieren und sie fördern. Dazu gebraucht Gott reife geistliche Mütter und Väter.
+
+Von Christliches Zentrum DarmstadtFolgenFolgen
+
+Datum und Uhrzeit
+So. 8. Dez. 2024 12:15 - 13:15 CET
+
+Veranstaltungsort
+Christliches Zentrum Darmstadt
+
+Röntgenstraße 18 64291 DarmstadtKarte anzeigen
+
+Zu diesem Event
+** Infoveranstaltung für geistliche Mütter und Väter **
+
+Als Kirche wollen wir uns in die junge Generation investieren und sie fördern. Dazu gebraucht Gott reife geistliche Mütter und Väter. Wenn du im altern von über 55 Jahren bist und einen Unterschied im Leben einer jungen Person machen möchtest, bist du herzlich zu dieser Infoveranstaltung eingeladen.
+
+Wir wollen uns gemeinsam austauschen was unsere ältere Generation auf ihrer Reise mit Gott benötigt und welches Erbe Gott ihnen gegeben hat. Zudem sprechen wir über das kommende Jahr und welche Schritte wir gehen dürfen, damit die junge Generation fest in Jesus verwurzelt ist.
+
+Wir starten mit einem kleinen Mittagessen und laden dich herzlich ein.
+
+Veranstaltet von
+Christliches Zentrum Darmstadt""",
+
+    """MJ – Das Michael Jackson Musical
+Das Erfolgsmusical über den Ausnahmekünstler Michael Jackson ist seit Dezember 2024 in Hamburg zu sehen! Tickets und Hotel können Sie hier bequem online buchen.
+
+Tickets buchen
+Erleben Sie das mehrfach ausgezeichnete Musical MJ – Das Michael Jackson Musical.
+
+Tickets buchen ab 63,99€*
+
+Tickets und Hotel buchen
+Sie möchten Ihren Musical-Besuch mit einer Reise nach Hamburg verbinden? Hier können Sie Ihre Tickets und Hotelübernachtung im Paket buchen:
+
+Reisepaket: MJ – Das Michael Jackson Musical ab 134,60€*
+
+Alle Vorteile auf einen Blick:
+
+Übernachtung im ausgewählten Hotel inkl. Frühstück, Zusatznächte buchbar
+Musical-Ticket in der gewählten Preiskategorie
+Hamburg Card (3 Tage) – Ihr Entdeckerticket für freie Fahrt mit Bus und Bahn im Wert von 31,90€
+Termine für MJ – Das Michael Jackson Musical
+Anfahrt
+MJ – Das Michael Jackson Musical | Stage Theater an der Elbe
+
+Norderelbstraße 8, 20457 Hamburg
+
+Kontakt speichern
+
+Adresse auf Karte anzeigen
+
+[Anfahrt](https://geofox.hvv.de/jsf/home.seam?clear=true&language=de&destination=Norderelbstra%C3%9Fe 8, 20457 Hamburg)
+
+Termine
+Premiere am 1. Dezember 2024""",
+
+    """Liedernachmittag
+Lieder von R. Schubert, R. Franz, A. Webern, H. Wolf
+
+Stuhlreihen im Museum August Kestner
+© MAK/LHH
+
+Vortrag im Museum August Kestner
+
+Monika Abel, Sopran / Kathrin Isabelle Klein, Klavier
+
+Termine
+
+11.01.2025 ab 16:00 Uhr
+
+Ort
+
+Museum August Kestner
+Platz der Menschenrechte 3
+30159 Hannover
+
+Konzertkarten: [email protected] und Tageskasse ab 15.00 Uhr im Museum
+
+Unter der Schirmherrschaft von Kammersängerin Helen Donath.
+
+Bis zu viermal im Jahr laden wir zu einem Liedernachmittag im Museum ein.
+
+In Zusammenarbeit mit: Lohmann-Stiftung für Liedgesang e.V., Hannover; Freundes- und Förderkreis des Museum August Kestner „Antike & Gegenwart e.V.“""",
+
+    """Die goldene Stadt
+Vortrag im Museum August Kestner
+
+Mit Dr. Martin Hersch (München)
+
+In Kooperation mit dem Freundeskreis Antike und Gegenwart
+
+Termine
+15.01.2025 ab 18:00 Uhr
+
+Ort
+Museum August Kestner
+Platz der Menschenrechte 3
+30159 Hannover
+
+Eintritt
+5,00 €
+
+ermäßigter Eintritt
+
+4,00 €""",
+
+    """Stadtansichten
+Erleben Sie bei einem Besuch der Sonderausstellung Städtetrip vielfältige und spannende Lyrik und Prosa verschiedener Autor*innen, nicht nur zum Thema Reisen. Ausgewählt und vorgetragen von der Literarischen Komponistin und Rezitatorin Marie Dettmer.
+
+Termine
+
+12.01.2025 ab 14:00 bis 15:00 Uhr
+
+Ort
+
+Landeshauptstadt Hannover
+
+Trammplatz 2
+
+30159 Hannover"""
+]
+
+client = InferenceClient(
+    "Qwen/Qwen2.5-Coder-32B-Instruct",
+    token=INFERENCE_API_KEY,
+)
+
+for text in texts:
+    messages = [{
+        "role": "user",
+        "content": """"Du bist ein NER-Model. Gebe die Veranstaltungsinformationen Titel, Startdatum, Enddatum, Startzeit, 
+        Endzeit, Einlasszeit, LocationName, Straße, Hausnummer, Postleitzahl, Stadt, Preis usw. aus dem text in JSON Format zurück.
+        Es sollen keine Markdown Elemente enthalten sein, nur das JSON Objekt als string. 
+        Gebe Nur das JSON als Antwort zurück. JSON_Schema:  
+        {
+          "title": string,
+          "organizer": string,
+          "startDate": string,
+          "endDate": string,
+          "startTime": string,
+          "endTime": string,
+          "admittanceTime": string,
+          "locationName": string,
+          "street": string,
+          "houseNumber": string,
+          "postalCode": string,
+          "city": string,
+          "price": Array<float> | null,
+          "currency": string,
+          "priceFree": bool,
+          "ticketsRequired": bool.
+          "categories": Array<string> | null,
+          "eventDescription": string,
+          "accesibilityInformation": string,
+          "keywords": Array<string> | null,
+        }
+        Text: """ + text}]
+
+    response = client.chat_completion(messages, max_tokens=1000)
+    print(text)
+    print()
+    event = json.loads(response.choices[0].message.content)
+    print(f"TITEL: {event["title"]} - HOST: {event['organizer']}")
+    print(f"KATEGORIEN: {event["categories"]}")
+    print(f"KEYWORDS: {event['keywords']}")
+    print(f"BESCHREIBUNG:\n {event["eventDescription"]}")
+    print("_________________________________________________________________________________________________________________________")
+

src/nlp/experimental/llm/llm_image_document_question_answering.py

@@ -0,0 +1,8 @@
+from huggingface_hub import InferenceClient
+from src.configuration.config import INFERENCE_API_KEY
+client = InferenceClient(
+    "vikhyatk/moondream2",
+    token=INFERENCE_API_KEY,)
+response = client.image_to_text(
+    image="event.jpg")
+print(response)

src/nlp/experimental/llm/llm_ner.py

@@ -0,0 +1,32 @@
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+model_name = "Qwen/Qwen2.5-Coder-32B-Instruct"
+
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    torch_dtype="auto",
+    device_map="auto"
+)
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+
+prompt = "write a quick sort algorithm."
+messages = [
+    {"role": "system", "content": "You are Qwen, created by Alibaba Cloud. You are a helpful assistant."},
+    {"role": "user", "content": prompt}
+]
+text = tokenizer.apply_chat_template(
+    messages,
+    tokenize=False,
+    add_generation_prompt=True
+)
+model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
+
+generated_ids = model.generate(
+    **model_inputs,
+    max_new_tokens=512
+)
+generated_ids = [
+    output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
+]
+
+response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]

src/nlp/experimental/ner/create_spacy_annotations.py

@@ -0,0 +1,158 @@
+import json
+
+import spacy
+
+
+def convert_to_spacy_annotations(data):
+    spacy_annotations = []
+
+    for item in data:
+        text = item["text"]
+        entities = []
+
+        for entity in item["entities"]:
+            start_idx = text.find(entity["data"])
+            if start_idx != -1:
+                end_idx = start_idx + len(entity["data"])
+                entities.append((start_idx, end_idx, entity["label"]))
+
+        spacy_annotations.append((text, {"entities": entities}))
+
+    return spacy_annotations
+
+
+# Beispiel JSON-Daten
+data = [
+  {
+    "text": "Im Rahmen der Jubiläumstour zu Ehren von Lutz Kayser (\"50 Jahre OTRAG – Oribital Transport und Raketen AG\") machen Film und Regisseur am 05.12.2024 im Technik-Salon Station in der TIB in Hannover.",
+    "entities": [{ "data": "05.12.2024", "label": "EVENT_DATE" }]
+  },
+  {
+    "text": "Wann? 05.12.2024, 19:00-21:00",
+    "entities": [{ "data": "05.12.2024", "label": "EVENT_DATE" }]
+  },
+  {
+    "text": "Der siebte Workshop Retrodigitalisierung findet am 20.03.2025 und 21.03.2025 bei ZB MED – Informationszentrum Lebenswissenschaften in Köln statt.",
+    "entities": [
+      { "data": "20.03.2025", "label": "EVENT_DATE" },
+      { "data": "21.03.2025", "label": "EVENT_DATE" }
+    ]
+  },
+  {
+    "text": "Wann? 20.03.2025 - 21.03.2025",
+    "entities": [{ "data": "20.03.2025 - 21.03.2025", "label": "EVENT_DATE_RANGE" }]
+  },
+  {
+    "text": "Die 18. ACM International Conference on Web Search and Data Mining (WSDM 2025) wird vom 10.03.2025 - 14.03.2025 in Hannover stattfinden.",
+    "entities": [{ "data": "10.03.2025 - 14.03.2025", "label": "EVENT_DATE_RANGE" }]
+  },
+  {
+    "text": "So. 08.12.2024 12:15 - 13:15 CET",
+    "entities": [{ "data": "08.12.2024", "label": "EVENT_DATE" }]
+  },
+  {
+    "text": "24.12.2025 um 16:00",
+    "entities": [{ "data": "24.12.2025", "label": "EVENT_DATE" }]
+  },
+  {
+    "text": "07.01.2025",
+    "entities": [{ "data": "07.01.2025", "label": "EVENT_DATE" }]
+  },
+  {
+    "text": "Am 01.07.2025",
+    "entities": [{ "data": "01.07.2025", "label": "EVENT_DATE" }]
+  },
+  {
+    "text": "Wann? 07.11.2024 - 09.03.2025",
+    "entities": [{ "data": "07.11.2024 - 09.03.2025", "label": "EVENT_DATE_RANGE" }]
+  },
+  {
+    "text": "01.11.2024 - 09.03.2025",
+    "entities": [{ "data": "01.11.2024 - 09.03.2025", "label": "EVENT_DATE_RANGE" }]
+  },
+  {
+    "text": "01.09.2025 - 26.12.2024",
+    "entities": [{ "data": "01.09.2025 - 26.12.2024", "label": "EVENT_DATE_RANGE" }]
+  },
+  {
+    "text": "Premiere am 01.12.2024",
+    "entities": [
+      {
+        "data": "01.12.2024",
+        "label": "EVENT_DATE"
+      }
+    ]
+  },
+  {
+    "text": "01.11.2025 ab 16:00",
+    "entities": [
+      {
+        "data": "01.11.2025",
+        "label": "EVENT_DATE"
+      }
+    ]
+  },
+  {
+    "text": "15.01.2025 ab 18:00",
+    "entities": [
+      {
+        "data": "15.01.2025",
+        "label": "EVENT_DATE"
+      }
+    ]
+  },
+  {
+    "text": "01.12.2025 ab 14:00-15:00",
+    "entities": [
+      {
+        "data": "01.12.2025",
+        "label": "EVENT_DATE"
+      }
+    ]
+  },
+  {
+    "text": "18.01.2025 ab 11:00-18:00",
+    "entities": [
+      {
+        "data": "18.01.2025",
+        "label": "EVENT_DATE"
+      }
+    ]
+  },
+  {
+    "text": "01.12.2024 – 08.12.2024",
+    "entities": [
+      {
+        "data": "01.12.2024 – 08.12.2024",
+        "label": "EVENT_DATE_RANGE"
+      }
+    ]
+  },
+  {
+    "text": "Freitag 16:00-20:00 / Samstag 11:00-20:00 / Sonntag 11:00-18:00",
+    "entities": []
+  },
+  {
+    "text": "So, 15.12.2024 Beginn: 15:00 Einlass: 14:30",
+    "entities": [
+      {
+        "data": "15.12.2024",
+        "label": "EVENT_DATE"
+      }
+    ]
+  }
+]
+
+
+
+
+
+
+# Umwandlung in spaCy-Format
+annotations = convert_to_spacy_annotations(data)
+# JSON speichern
+with open("../annotations.json", "w", encoding="utf-8") as f:
+    json.dump(annotations, f, ensure_ascii=False, indent=4)
+
+# Ausgabe prüfen
+print(json.dumps(annotations, ensure_ascii=False, indent=4))

src/nlp/experimental/ner/few_shot_ner.py

@@ -0,0 +1,52 @@
+import spacy
+from spacy import displacy
+from spacy.tokenizer import Tokenizer
+from spacy.util import compile_prefix_regex, compile_suffix_regex, compile_infix_regex
+
+# Beispieltext mit Datum und Veranstaltung
+text = """Das Event findet am 01.02.2022 statt. Es wird um 19:00 Uhr beginnen."""
+
+# Lade ein vortrainiertes deutsches Modell (enthält Dependency Parser!)
+nlp = spacy.load("de_core_news_md")
+
+# Punkt als Infix definieren (damit 01.02.2022 getrennt wird)
+infixes = list(nlp.Defaults.infixes) + [r"(?<=\d)\.(?=\d)"]  # Punkt zwischen Zahlen trennen
+infix_re = compile_infix_regex(infixes)
+
+# Tokenizer mit neuer Infix-Regel setzen
+nlp.tokenizer = Tokenizer(nlp.vocab, infix_finditer=infix_re.finditer)
+
+# Entity Ruler für Datumsangaben hinzufügen
+ruler = nlp.add_pipe("entity_ruler", before="ner")
+
+patterns = [
+    {
+        "label": "DATE",
+        "pattern": [
+            {"SHAPE": "dd"}, {"ORTH": "."}, {"SHAPE": "dd"}, {"ORTH": "."}, {"SHAPE": "dddd"}
+        ]
+    }
+]
+ruler.add_patterns(patterns)
+
+# Verarbeite den Text
+doc = nlp(text)
+
+# Tokenisierung prüfen
+print("Tokens:", [token.text for token in doc])
+
+# Extrahiere erkannte Entitäten
+for ent in doc.ents:
+    print(ent.text, ent.label_ , ent.start_char, ent.end_char)
+
+# # Überprüfung der Abhängigkeiten zwischen Datum und Veranstaltung
+# for token in doc:
+#     if token.ent_type_ == "DATE":
+#         # Überprüfe, ob das Datum mit einem Ereigniswort verbunden ist
+#         # Hier suchen wir nach Wörtern wie "findet", "statt", "Event" etc.
+#         for child in token.head.children:
+#             if child.dep_ in ["ROOT", "prep", "attr", "dobj"] and child.lemma_ in ["findet", "statt", "Veranstaltung", "Event"]:
+#                 print(f"Das Datum {token.text} bezieht sich auf eine Veranstaltung.")
+#                 break
+
+displacy.serve(doc, style="dep")

src/nlp/experimental/ner/nu_ner.py

@@ -0,0 +1,33 @@
+from gliner import GLiNER
+
+def merge_entities(entities):
+    if not entities:
+        return []
+    merged = []
+    current = entities[0]
+    for next_entity in entities[1:]:
+        if next_entity['label'] == current['label'] and (next_entity['start'] == current['end'] + 1 or next_entity['start'] == current['end']):
+            current['text'] = text[current['start']: next_entity['end']].strip()
+            current['end'] = next_entity['end']
+        else:
+            merged.append(current)
+            current = next_entity
+    # Append the last entity
+    merged.append(current)
+    return merged
+
+
+model = GLiNER.from_pretrained("numind/NuNerZero")
+
+# NuZero requires labels to be lower-cased!
+labels = ["organization", "initiative", "project"]
+labels = [l.lower() for l in labels]
+
+text = "At the annual technology summit, the keynote address was delivered by a senior member of the Association for Computing Machinery Special Interest Group on Algorithms and Computation Theory, which recently launched an expansive initiative titled 'Quantum Computing and Algorithmic Innovations: Shaping the Future of Technology'. This initiative explores the implications of quantum mechanics on next-generation computing and algorithm design and is part of a broader effort that includes the 'Global Computational Science Advancement Project'. The latter focuses on enhancing computational methodologies across scientific disciplines, aiming to set new benchmarks in computational efficiency and accuracy."
+
+entities = model.predict_entities(text, labels)
+
+entities = merge_entities(entities)
+
+for entity in entities:
+    print(entity["text"], "=>", entity["label"])

src/nlp/experimental/ner/spacy_ner.py

@@ -0,0 +1,47 @@
+import json
+import random
+
+import spacy
+from spacy.training.example import Example
+
+# Lade das deutsche Basismodell
+nlp = spacy.load("de_core_news_sm")
+
+with open('../annotations.json', encoding='utf-8') as f:
+    TRAINING_DATA = json.load(f)
+
+# Wenn das Modell keine benutzerdefinierten Entitäten hat, füge die Entitätenerkennung hinzu
+if "ner" not in nlp.pipe_names:
+    ner = nlp.create_pipe("ner")
+    nlp.add_pipe("ner", last=True)
+else:
+    ner = nlp.get_pipe("ner")
+
+# Füge die Entitäten hinzu
+ner.add_label("START_DATE")
+ner.add_label("END_DATE")
+ner.add_label("DATE")
+ner.add_label("OTHER")
+
+# Trainingsdaten in Beispiele umwandeln
+examples = []
+for text, annotations in TRAINING_DATA:
+    doc = nlp.make_doc(text)
+    example = Example.from_dict(doc, annotations)
+    examples.append(example)
+
+# Beginne mit dem Training
+optimizer = nlp.begin_training()
+for epoch in range(30):  # Anzahl der Epochen
+    print(f"Epoch {epoch + 1}")
+    losses = {}
+    # Shuffle und trainiere das Modell mit den Beispielen
+    random.shuffle(examples)
+    # Trainiere mit den Beispielen
+    for example in examples:
+        nlp.update([example], drop=0.5, losses=losses)
+    print(losses)
+
+# Speichere das trainierte Modell
+nlp.to_disk("models/date_model")
+

src/nlp/experimental/ner/spacy_ner_rule_based.py

@@ -0,0 +1,58 @@
+import spacy
+from spacy.tokenizer import Tokenizer
+from spacy.util import compile_prefix_regex, compile_suffix_regex, compile_infix_regex
+from nltk import Tree
+
+
+# Beispieltext mit Datum
+text = "Das Event findet am 01.02.2022 statt."
+
+# Lade ein leeres deutsches Modell
+nlp = spacy.blank("de")
+nlp.add_pipe('sentencizer')
+
+# 1️⃣ Punkt als Suffix & Infix definieren (damit er zwischen Zahlen trennt)
+suffixes = list(nlp.Defaults.suffixes) + [r"\."]  # Punkt als Suffix hinzufügen
+infixes = list(nlp.Defaults.infixes) + [r"(?<=\d)\.(?=\d)"]  # Punkt zwischen Zahlen trennen
+
+# Regex-Objekte kompilieren
+suffix_re = compile_suffix_regex(suffixes)
+infix_re = compile_infix_regex(infixes)
+
+# Angepasste Tokenizer-Funktion setzen
+nlp.tokenizer = Tokenizer(nlp.vocab, suffix_search=suffix_re.search, infix_finditer=infix_re.finditer)
+# 2️⃣ Entity Ruler für Datumsangaben hinzufügen
+ruler = nlp.add_pipe("entity_ruler")
+
+patterns = [
+    {
+        "label": "DATE",
+        "pattern": [
+            {"SHAPE": "dd"}, {"ORTH": "."}, {"SHAPE": "dd"}, {"ORTH": "."}, {"SHAPE": "dddd"}
+        ]
+    }
+]
+
+ruler.add_patterns(patterns)
+
+# 3️⃣ Verarbeite den Text
+doc = nlp(text)
+
+# Prüfe Tokenisierung
+print("Tokens:", [token.text for token in doc])  # Punkt soll nun getrennt sein
+
+# Extrahiere erkannte Entitäten
+for ent in doc.ents:
+    print(ent.text, ent.label_)
+
+def to_nltk_tree(node):
+    if node.n_lefts + node.n_rights > 0:
+        return Tree(node.orth_, [to_nltk_tree(child) for child in node.children])
+    else:
+        return node.orth_
+
+
+
+for sent in doc.sents:
+    print(sent.text)
+    print(to_nltk_tree(sent.root))