Help for script adaptation!

[dix83]

import requests
import json

# URL-ul serverului Teprolin
url = "http://127.0.0.1:5000/process"

# Textul pe care dorim să îl procesăm
text = "Ion și-a cumpărat o mașină de tuns iarba de_la Kaufland."

# Operațiile necesare
operations = [
    "tokenization",
    "pos-tagging",
    "dependency-parsing",
    "chunking",
    "named-entity-recognition",
    "sentence-splitting"  
    
]

# Construim payload-ul pentru cererea POST
payload = {
    "text": text,
    "exec": ",".join(operations)
}

# Facem cererea POST
response = requests.post(url, data=payload)

# Verificăm dacă cererea a fost procesată cu succes
if response.status_code == 200:
    # Parsăm rezultatul JSON
    data = response.json()
    tokens = data["teprolin-result"]["tokenized"][0]  # Preluăm lista de tokeni din prima propoziție

    # Creăm un dicționar pentru a mapa chunk-urile la cuvintele lor, în ordinea corectă
    chunk_to_words = {}

    # Populăm dicționarul chunk_to_words cu cuvinte pentru fiecare chunk, în ordinea corectă
    for token in tokens:
        chunk_code = token["_chunk"]
        word = token["_wordform"]

        # Dacă chunk_code nu este gol, adăugăm cuvântul în lista corespunzătoare în ordinea apariției
        if chunk_code:
            sub_chunks = chunk_code.split(',')
            for sub_chunk in sub_chunks:
                if sub_chunk not in chunk_to_words:
                    chunk_to_words[sub_chunk] = []
                if word not in chunk_to_words[sub_chunk]:  # Evităm duplicările
                    chunk_to_words[sub_chunk].append(word)

    # Construim structura de tokeni în format JSON, cu chunk-urile completate corect
    tokens_formatted = []
    for token in tokens:
        # Obținem codul chunk-ului
        chunk_code = token["_chunk"]
        # Construim `chunk_det` doar dacă există un chunk_code
        if chunk_code:
            # Folosim un set temporar pentru a evita duplicatele
            seen_words = set()
            words_associated = " ".join(
                word for sub_chunk in chunk_code.split(",") if sub_chunk in chunk_to_words
                for word in chunk_to_words[sub_chunk] if word not in seen_words and not seen_words.add(word)
            )
        else:
            words_associated = ""

        # Structura finală a tokenului
        token_formatted = {
            "_bner": token.get("_bner", ""),
            "_chunk": chunk_code,  # Păstrăm codurile originale ale chunk-urilor
            "chunk_det": words_associated,  # Afișăm lista de cuvinte asociate cu chunk-ul
            "_ctg": token.get("_ctg", ""),
            "_deprel": token.get("_deprel", ""),
            "_expand": token.get("_expand", ""),
            "_head": token.get("_head", ""),
            "_id": token.get("_id", ""),
            "_lemma": token.get("_lemma", ""),
            "_msd": token.get("_msd", ""),
            "_ner": token.get("_ner", ""),
            "_phon": token.get("_phon", ""),
            "_syll": token.get("_syll", ""),
            "_wordform": token.get("_wordform", ""),
            "_upos": token.get("_upos", "")
            
        }
        tokens_formatted.append(token_formatted)

    # Afișăm rezultatul final în format JSON
    print("Rezultatul procesării textului cu 'chunk' și 'chunk_det' detaliat:")
    print(json.dumps(tokens_formatted, indent=4, ensure_ascii=False))
else:
    print("Eroare la cerere:", response.status_code)
    print(response.text)

The result is:
{
"_bner": "",
"_chunk": "Np#1",
"chunk_det": "Ion",
"_ctg": "NP",
"_deprel": "nsubj",
"_expand": "",
"_head": 4,
"_id": 1,
"_lemma": "Ion",
"_msd": "Np",
"_ner": "PER",
"_ner_2": "",
"_phon": "",
"_syll": "",
"_wordform": "Ion",
"_upos": ""
},
{
"_bner": "",
"_chunk": "Vp#1",
"chunk_det": "și- a cumpărat",
"_ctg": "PXD",
"_deprel": "expl:poss",
"_expand": "",
"_head": 4,
"_id": 2,
"_lemma": "sine",
"_msd": "Px3--d--y-----w",
"_ner": "",
"_ner_2": "",
"_phon": "",
"_syll": "",
"_wordform": "și-",
"_upos": ""
},

The upos form is always empty, could you suggest the reason?

[radu-ion]

Hello, TEPROLIN does not output the "_upos" field. POS tagging fields are "_ctg" (you can use this one instead of _upos, although it does not contain the UPOS tags for Romanian) and "_msd" which is the detailed version of "_ctg" with many more morphological attributes.

To see how "_ctg" and "_msd" map to UPOS, you can check out the Romanian UD corpus here:
https://github.com/UniversalDependencies/UD_Romanian-RRT, file ro_rrt-ud-train.conllu.

If you use the UDPipe NLP app of TEPROLIN (TTL is the default one), I think the '_ctg' field contains the actual UPOS of the token. But you have to install UDPipe first, as instructed in the README.

[IV-R]

ING: Modul de a lucra și a rezolva problema din TEPROLIN Issue #1

1. Configurarea mediului TEPROLIN

   1. Instalare dependințe:
      Asigurați-vă că toate dependențele necesare sunt instalate:
      • Din directorul principal al proiectului, executați:

pip install -r requirements.txt

•	Dependențe suplimentare:
•	Pentru TTL (TeproTTL.pl), instalați module Perl:

cpan install Unicode::String Algorithm::Diff BerkeleyDB File::Which File::HomeDir

•	Asigurați-vă că Java Runtime Environment (minim versiunea 15) este instalat pentru MLPLA.
•	Testați instalarea Java:

java -version

2.	Pornirea serverului TEPROLIN:
•	Lansați serverul în modul development pentru debug rapid:

python3 TeproREST.py

•	Pentru producție, utilizați uwsgi:

uwsgi --socket 0.0.0.0:5000 --protocol=http -w TeproREST:app

3.	Verificarea conexiunii:
•	Testați endpoint-ul http://127.0.0.1:5000/process cu un tool precum Postman sau curl:

curl -X POST -H "Content-Type: application/json"
-d '{"text": "Test text", "exec": "tokenize"}'
http://127.0.0.1:5000/process

2. Structura payload-ului pentru cereri POST

   • Endpoint-ul /process acceptă un payload în format JSON:

{
"text": "Textul care trebuie procesat.",
"exec": "tokenize,pos,ner,parse"
}

•	Exec: O listă de operații separate prin virgulă. Exemple:
•	tokenize: Tokenizare.
•	pos: Part of Speech tagging.
•	ner: Named Entity Recognition.
•	parse: Dependency Parsing.
•	Exemplu de implementare în Python:

import requests

url = "http://127.0.0.1:5000/process"
payload = {
"text": "Ion și-a cumpărat o mașină de tuns iarba.",
"exec": "tokenize,pos,ner"
}
headers = {"Content-Type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

if response.status_code == 200:
print("Result:", response.json())
else:
print(f"Error: {response.status_code} - {response.text}")

3. Interpretarea răspunsului serverului

   • Răspunsul serverului este structurat astfel:

{
"teprolin-result": {
"tokenized": [["Ion", "și-a", "cumpărat", "o", "mașină"]],
"pos-tagged": [["Ion/NNP", "și-a/PRP", "cumpărat/VBD"]],
"ner": [["Ion", "PER"]],
"parsed": ["ROOT(cumpărat-3, Ion-1)"]
}
}

•	Chei principale:
•	tokenized: Text tokenizat.
•	pos-tagged: Cuvintele cu tag-uri gramaticale.
•	ner: Entități numite (PER, ORG, LOC).
•	parsed: Rezultatul parsării dependente.

4. Debugging comun

   1. Probleme frecvente și soluții:
      • Eroare 500 (Internal Server Error):
      • Verificați dacă toate dependențele sunt instalate corect.
      • Asigurați-vă că TeproTTL.pl și MLPLA funcționează:

perl -c TeproTTL.pl
java -jar MLPLA.jar

•	Eroare 400 (Bad Request):
•	Verificați structura payload-ului (trebuie să fie valid JSON).

2.	Monitorizare și loguri:
•	Activați logurile serverului pentru debugging suplimentar:

python3 TeproREST.py --debug

5. Testare completă

   1. Testare manuală:
      • Utilizați Postman sau curl pentru a verifica fiecare operație (ex. doar tokenize, doar ner).
   2. Testare automată:
      • Scrieți un script de testare pentru toate operațiile:

operations = ["tokenize", "pos", "ner", "parse"]
for op in operations:
payload = {"text": "Test text", "exec": op}
response = requests.post(url, json=payload, headers=headers)
print(f"Operation {op}: {response.json()}")

6. Propunere pentru îmbunătățire

   • Documentare suplimentară:
   Adăugați exemple concrete pentru toate operațiile în README.md.
   • Validare mai bună a payload-ului:
   Adăugați verificări în TeproREST.py pentru a evita răspunsuri 500.

[IV-R]

import requests
import json

Define the text and processing operations

text = "România este o țară frumoasă cu o istorie bogată."
operations = ["tok", "pos", "dep", "chk", "ner", "ssplit"]

Construct the payload for the POST request

payload = {
"text": text,
"exec": ",".join(operations)
}

Define the URL for the TEPROLIN REST API

url = "http://127.0.0.1:5000/process"

Send the POST request to the API

try:
response = requests.post(url, json=payload)

# Check the response status
if response.status_code == 200:
    # Parse and print the JSON response
    data = response.json()
    print(json.dumps(data, indent=2, ensure_ascii=False))
else:
    print(f"Error: Received status code {response.status_code}")
    print(response.text)  # Print the error message if available

except requests.exceptions.RequestException as e:
print(f"Request failed: {e}")

[IV-R]

Acest fragment de cod este pentru verificarea răspunsului unei solicitări HTTP. Totuși, nu include o solicitare HTTP completă, dar îți pot explica ce face și cum să-l utilizezi corect:
1. Verificarea codului de răspuns: if response.status_code == 200 verifică dacă cererea HTTP a avut succes (status 200 înseamnă “OK”).
2. Parsarea și afișarea JSON:
• data = response.json() preia conținutul răspunsului în format JSON și îl convertește într-un dicționar Python.
• json.dumps(data, indent=2, ensure_ascii=False) îl formatează într-un mod lizibil.
3. Gestionarea erorilor:
• Dacă statusul nu este 200, se afișează codul de eroare și conținutul răspunsului (response.text).

Probleme și soluții:
1. Lipsa unei solicitări HTTP: Ai nevoie de o solicitare completă, cum ar fi cu requests:

import requests
import json

url = "https://example.com/api/endpoint" # Înlocuiește cu URL-ul tău
headers = {"Authorization": "Bearer YOUR_TOKEN"} # Adaugă antetele necesare
response = requests.get(url, headers=headers) # Sau requests.post pentru POST

if response.status_code == 200:
data = response.json()
print(json.dumps(data, indent=2, ensure_ascii=False))
else:
print(f"Error: Received status code {response.status_code}")
print(response.text)

2.	Lipsa pachetului requests: Dacă nu este instalat, instalează-l:

pip install requests

3.	Debugging: Dacă încă întâmpini probleme, asigură-te că:
•	URL-ul este corect.
•	Autentificarea și antetele sunt setate corect.
•	Serverul răspunde așa cum te aștepți.