Deklinator – declinações de adjetivos -bilhões de exercícios

Deklinator - app gratuito

O que é o Deklinator? Como baixar, instalar?

Baixe o app gratuitamente!

Quer virar mestre em declinar adjetivos em alemão? Pare agora mesmo de gastar uma fortuna com livros de exercícios! Nesta aula, vou te mostrar como gerar exercícios de qualquer nível gratuitamente usando Inteligência Artificial! Baixe o Deklinator!

Baixe aqui: https://www.dropbox.com/s/nau2d4kbxfy5ja1/Deklinator_setup.exe?dl=0

Escolhe qualquer texto em alemão
(docx, txt, pptx, pdf, xlsx,epub,txt)
Inicie o app e selecione o arquivo
O aplicativo vai usar spacy para fazer uma analise
sintática do texto inteiro!
Já que esse processo é feito com inteligência artificial,
precisa de alguns “cavalos” rsrs
Por isso, não use um livro de 300 páginas,
senão vai demorar para sempre!
Escreva o número ao lado do texto para corrigir!
Assim que você tiver corrigido o texto inteiro,
aperte o último número:  (← Gib diese Nummer an ein,
sobald du alle Wörter dekliniert hast
O app vai comparar a sua frase com o original … 
A coisa mais legal desse app é que vai te mostrar  os casos
(nominativo, acusativo, dativo e genitivo), tipo de artigo
(artigo definido ou indefinido) etc. 
Assim, você realmente vai aprender alemão!
Mais informações (em inglês no GITHUB)https://github.com/hansalemaos/Deklinator

Se souber Python e quiser melhorar o Deklinator, entre em contato comigo!

Código de fonte

adjektive_artikel.py

import bs4
import spacy
from add_color_print_reg import *
from menudownload import *
satzanalyse_werkzeug = spacy.load("de_dep_news_trf")
import regex
from satzmetzger.satzmetzger import Satzmetzger
from fuzzywuzzy import fuzz
from maximize_console import *
add_color_print_to_regedit()
cfg = {}
maximize_console(lines=30000)


colorfunctionslogo = [drucker.f.black.red.normal, drucker.f.black.brightyellow.normal]
drucker.p_ascii_front_on_flag_with_border(
    text="Deklinator",
    colorfunctions=colorfunctionslogo,
    bordercolorfunction=drucker.f.brightgreen.black.italic,
    font="slant",
    width=1000,
    offset_from_left_side=5,
    offset_from_text=15,
)
colorfunctionspage = [
    drucker.f.black.brightwhite.normal,
    drucker.f.black.brightgreen.normal,
]
drucker.p_ascii_front_on_flag_with_border(
    text="www . queroestudaralemao . com . br",
    colorfunctions=colorfunctionspage,
    bordercolorfunction=drucker.f.brightgreen.black.negative,
    font="slant",
    width=1000,
    offset_from_left_side=1,
    offset_from_text=1,
)

def txtdateien_lesen(text):
    try:
        dateiohnehtml = (
            b"""<!DOCTYPE html><html><body><p>""" + text + b"""</p></body></html>"""
        )
        soup = bs4.BeautifulSoup(dateiohnehtml, "html.parser")
        soup = soup.text
        return soup.strip()
    except Exception as Fehler:
        print(Fehler)


kurzbeschreibung_aufgabe = drucker.f.black.brightyellow.italic(
    "\nDekliniere alle Wörter!\n"
)
return_choice = drucker.f.black.brightcyan.italic(
    " <-- Gib diese Nummer ein, sobald du alle Wörter dekliniert hast!\n"
)
prompt = drucker.f.black.magenta.bold(
    """Einige Wörter sind nicht gebeugt!\nGib die Nummer, die vor dem Wort steht, ein, um das Wort zu deklinieren!\n"""
)

satzmetzgerle = Satzmetzger()
p = subprocess.run(r"Everything2TXT.exe", capture_output=True)
ganzertext = txtdateien_lesen(p.stdout)
einzelnesaetze = satzmetzgerle.zerhack_den_text(ganzertext)
allesaetzefertigfueraufgabe = []
allemoeglichenpunkte = 0
punktevomuser = 0
artikel = [
    "der",
    "die",
    "das",
    "den",
    "dem",
    "des",
    "ein",
    "eine",
    "einem",
    "einer",
    "eines",
]
for satzindex, einzelnersatz in enumerate(einzelnesaetze):
    analysierter_text = satzanalyse_werkzeug(einzelnersatz)
    dokument_als_json = analysierter_text.doc.to_json()
    alleverbenimsatz = []
    schongedruckt = False
    satzdruckeneditiert = ""
    loesungshilfeganz = ""
    for token in dokument_als_json["tokens"]:
        anfangwort = token["start"]
        endewort = token["end"]
        aktuelleswort = dokument_als_json["text"][anfangwort:endewort]
        leerzeichenplatz = len(dokument_als_json["text"][anfangwort:endewort]) * "_"
        platzhalter = (
            dokument_als_json["text"][:anfangwort]
            + leerzeichenplatz
            + dokument_als_json["text"][endewort:]
        )
        satzschongemacht = dokument_als_json["text"][:anfangwort]
        satzdrucken = ""

        if "Case=" in token["morph"] and (
            ("DET" in token["pos"] and aktuelleswort in artikel)
            or "ADJ" in token["pos"]
        ):
            loesungshilfe = (
                aktuelleswort
                + ": \n-----------------\n"
                + "\n".join(regex.split(r"\|", token["morph"]))
                + "\n\n\n\n\n"
            )
            loesungshilfeganz = loesungshilfeganz + loesungshilfe
            if "DET" in token["pos"]:
                satzdrucken = (
                    drucker.f.black.white.italic("Wir sind hier:   ")
                    + drucker.f.white.black.normal(satzschongemacht)
                    + drucker.f.brightyellow.black.italic(aktuelleswort[:1] + "___")
                )
                satzdruckeneditiert = (
                    satzdruckeneditiert + " " + aktuelleswort[:1] + "___"
                )
            if "ADJ" in token["pos"]:
                wortdrucken = regex.sub("[ersnm]{,2}$", "__", aktuelleswort)
                satzdrucken = (
                    drucker.f.black.white.italic("Wir sind hier:   ")
                    + drucker.f.white.black.normal(satzschongemacht)
                    + drucker.f.brightyellow.black.italic(wortdrucken)
                )
                satzdruckeneditiert = satzdruckeneditiert + " " + wortdrucken

            allemoeglichenpunkte = allemoeglichenpunkte + 1

            richtigeantwort = regex.findall("Case=([^\|]+)", token["morph"])[0]
            if richtigeantwort == "Nom":
                richtigeantwort = "Nominativ"
            if richtigeantwort == "Acc":
                richtigeantwort = "Akkusativ"
            if richtigeantwort == "Dat":
                richtigeantwort = "Dativ"
            if richtigeantwort == "Gen":
                richtigeantwort = "Genitiv"

            continue
        else:
            satzdruckeneditiert = satzdruckeneditiert + f" {aktuelleswort}"
    ganzersatz = dokument_als_json["text"]
    satz1ohneleer = regex.sub(r"\s+", "", ganzersatz)
    satz2ohneleer = regex.sub(r"\s+", "", satzdruckeneditiert)
    gleichsaetze = fuzz.ratio(satz1ohneleer, satz2ohneleer)
    if gleichsaetze < 99:
        ganzersatz_split = regex.split(r"\s+", satzdruckeneditiert)
        ganzersatz_split = [x for x in ganzersatz_split if any(x)]
        # print(ganzersatz_split)
        cfg = {str(key + 1): x for key, x in enumerate(ganzersatz_split)}
        erreichbarepunktzahl = 100 - gleichsaetze
        allemoeglichenpunkte = allemoeglichenpunkte + erreichbarepunktzahl
        cfg = m.config_menu(
            kurzbeschreibung_aufgabe,
            cfg.copy(),
            return_choice=return_choice,
            prompt=prompt + kurzbeschreibung_aufgabe,
        )
        falschersatz = regex.sub(r"\s+", "", "".join([x[1] for x in cfg.items()]))
        aktuelleuebereinstimmungneu = fuzz.ratio(satz1ohneleer, falschersatz)

        if aktuelleuebereinstimmungneu == 100:
            print(
                drucker.f.brightwhite.brightgreen.italic(
                    "     Jetzt ist der Satz 100% richtig! Gut gemacht!: "
                )
                + drucker.f.brightgreen.black.negative(
                    f" {aktuelleuebereinstimmungneu} Prozent     "
                )
            )
            punktedieserdurchgang = 100 - aktuelleuebereinstimmungneu
            punktedieserdurchgang = abs(punktedieserdurchgang - erreichbarepunktzahl)
            punktevomuser = punktevomuser + punktedieserdurchgang

        if (
            aktuelleuebereinstimmungneu >= gleichsaetze
            and aktuelleuebereinstimmungneu < 100
        ):
            print(
                drucker.f.brightwhite.brightgreen.italic(
                    "     Der Satz ist besser als vorher, aber es gibt noch Fehler!: Die jetzige Übereinstimmung liegt bei: "
                )
                + drucker.f.brightgreen.black.negative(
                    f" {aktuelleuebereinstimmungneu} Prozent     "
                )
            )
            punktedieserdurchgang = 100 - aktuelleuebereinstimmungneu
            punktedieserdurchgang = abs(punktedieserdurchgang - erreichbarepunktzahl)
            punktevomuser = punktevomuser + punktedieserdurchgang

        elif aktuelleuebereinstimmungneu < gleichsaetze:
            print(
                drucker.f.brightwhite.red.italic(
                    "     Das war leider nicht so gut! Der Satz ist schlechter als vor der Korrektur! Die jetzige Übereinstimmung liegt bei: "
                )
                + drucker.f.brightred.black.negative(
                    f" {aktuelleuebereinstimmungneu} Prozent     "
                )
            )
            punktedieserdurchgang = 100 - aktuelleuebereinstimmungneu
            punktedieserdurchgang = -1 * abs(
                punktedieserdurchgang - erreichbarepunktzahl
            )
            punktevomuser = punktevomuser + punktedieserdurchgang

    if gleichsaetze < 100:
        satzvomuser = " ".join([x[1] for x in cfg.items()])
        print(
            drucker.f.brightgreen.black.negative(f"Original: ")
            + drucker.f.brightgreen.black.italic(ganzersatz)
            + "\n"
            + drucker.f.brightgreen.black.negative(f"Deine Version: ")
            + drucker.f.brightgreen.black.italic(satzvomuser)
        )
        print(loesungshilfeganz)

    print(
        drucker.f.magenta.black.italic(
            f"Deine Punktzahl: {punktevomuser}\nMaximale Punktzahl: {allemoeglichenpunkte}\n"
        )
    )
    print("\n" * 10)


menudownload.py

import re
import menu3
from farbprinter.farbprinter import Farbprinter
drucker =Farbprinter()
m = menu3.Menu(True)
ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
colorcodeweg = lambda result : ansi_escape.sub('', result)

def dict_reverser(d):
    seen = set()
    return {v: k for k, v in d.items() if v not in seen or seen.add(v)}

def mit_leerzeichen_auffuellen(farbigesmenu, offsetlinks=3, offsetrechts=3):
    farbigesmenu = [(len(x), x) for x in farbigesmenu].copy()
    farbigesmenu.sort(reverse=True)
    farbigesmenu = {offsetlinks * ' ' + x[1] + (farbigesmenu[0][0] + 1 - x[0]) * ' ' +offsetrechts * ' ' :x[1]   for x in farbigesmenu}
    return farbigesmenu.copy()

def create_color_menu(farbigesmenu, menuinfo="Welche Antwort ist richtig?", aufforderung="Deine Antwort oder 'q', um das Programm zu beenden: ", gewaehlteantwort='Deine Wahl: '):
    farbigesmenufertig = []
    funktionsauswahl = [drucker.f.black.brightred.normal, drucker.f.black.brightwhite.normal, drucker.f.black.brightmagenta.normal, drucker.f.black.brightgreen.normal, drucker.f.black.magenta.normal, drucker.f.black.brightcyan.normal, drucker.f.black.brightyellow.normal, drucker.f.black.brightblue.normal]
    farbigesmenudict = mit_leerzeichen_auffuellen(farbigesmenu)
    farbigesmenu = [x for x in farbigesmenudict.keys()]
    if len(farbigesmenu) > len(funktionsauswahl):
        funktionsauswahl = funktionsauswahl * len(farbigesmenu)
    for menuitem, farbe in zip(farbigesmenu, funktionsauswahl):
        farbigesmenufertig.append(farbe(menuitem))
    c = m.menu(menuinfo, farbigesmenufertig, aufforderung)
    antwort = colorcodeweg(farbigesmenu[c - 1])
    antwort = farbigesmenudict[antwort]
    m.success(gewaehlteantwort + antwort)
    return antwort






add_color_print_reg.py

from json import loads as jsonloads
from os import name as osname
from sys import exit as sysexit
from textwrap import TextWrapper
from random import choice
from requests import get as requestsget
from farbprinter.farbprinter import Farbprinter

windowsrechner = osname == "nt"
from winregistry import WinRegistry
from winreg import HKEY_CURRENT_USER, KEY_READ, REG_DWORD

linebreakx = 50
wrapper = TextWrapper(width=linebreakx)
drucker = Farbprinter()
jsonqueroestudaralemao = "https://www.queroestudaralemao.com.br/wp-content/uploads/updateinformatioen/update.json"
logo_auswahl = auswahlliste = [
    drucker.f.brightred.black.bold,
    drucker.f.black.brightred.bold,
    drucker.f.yellow.black.bold,
    drucker.f.brightyellow.black.bold,
]
REGEDITPATH = r"HKEY_CURRENT_USER\Console"
regedit_success = "I think, it has worked out! Let's start"
virtualterminalregedit = "VirtualTerminalLevel"
able_to_see_col_text = "Everything is configured right! You should be able to see colored text! Please restart the app if you can't see colored text"
regedit_is_zero = "HKEY_CURRENT_USER\Console\VirtualTerminalLevel is set to 0! I will try to change it to 1 so that you can read colored text!"
regeditfail = """I was unable to change the Registry!\n Let\'s try it anyway!\n If you can\'t read the text in the terminal, add this to your Windows Registry:\n\n[HKEY_CURRENT_USER\Console]\n
"VirtualTerminalLevel"=dword:00000001"""
try_to_create_key = "HKEY_CURRENT_USER\Console\VirtualTerminalLevel not found! I will try to create it so that you can see colored text"


def add_color_print_to_regedit():
    if windowsrechner:
        try:
            with WinRegistry() as client:
                try:

                    regedit_entry = client.read_entry(
                        REGEDITPATH, virtualterminalregedit
                    )
                    if int(regedit_entry.value) == 1:
                        print(drucker.f.black.green.negative(able_to_see_col_text))
                        return True
                    if int(regedit_entry.value) == 0:
                        print(drucker.f.black.brightyellow.negative(regedit_is_zero))
                        try:
                            client.write_entry(
                                REGEDITPATH,
                                virtualterminalregedit,
                                value=1,
                                reg_type=REG_DWORD,
                            )
                            print(drucker.f.black.green.negative(regedit_success))
                        except:
                            print(drucker.f.black.brightred.negative(regeditfail))
                            return False
                except:
                    print(drucker.f.black.brightyellow.negative(try_to_create_key))
                    try:
                        client.write_entry(
                            REGEDITPATH,
                            "VirtualTerminalLevel",
                            value=1,
                            reg_type=REG_DWORD,
                        )
                        print(drucker.f.black.green.negative(regedit_success))

                        return True
                    except:
                        print(drucker.f.black.brightred.negative(regeditfail))
                        return False
        except:
            print(
                drucker.f.black.brightred.negative(
                    "Error checking if VirtualTerminalLevel is set to 1"
                )
            )


def updates_quero_estudar_alemao():
    choice(auswahlliste)("made by queroestudaralemao.com.br")
    print(
        drucker.f.black.brightblue.bold(
            "\n         Updates from https://www.queroestudaralemao.com.br :\n\n"
        )
    )

    jsoninhalt = requestsget(jsonqueroestudaralemao)
    j = jsonloads(jsoninhalt.text)

    for key, value in j.items():
        neuigkeitendatum = drucker.f.cyan.brightwhite.italic(
            f"""         {key} - News from    """.ljust(20).rjust(20)
        )
        print(neuigkeitendatum, end=" ")
        print(
            drucker.f.black.brightwhite.negative(f'       {value["autor"]}:        '),
            end=" ",
        )
        print(
            drucker.f.brightwhite.blue.negative(f'       {value["datum"]}:        '),
            end=" ",
        )
        neuigkeitenwrap = wrapper.wrap(text=value["neuigkeiten"])
        print("\n")
        for satz in neuigkeitenwrap:
            print(drucker.f.black.brightyellow.bold("     "), end="")
            ausfuellen = (70 - len(satz)) * " "
            print(
                drucker.f.black.brightyellow.bold(f"   {satz}   {ausfuellen}"), end="\n"
            )
        if value["online"] == "0":
            print(value["nachricht"])
            sysexit()
        print("\n")

maximize_console.py

import os
import ctypes
import msvcrt
import subprocess
from ctypes import wintypes

kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
user32 = ctypes.WinDLL("user32", use_last_error=True)
SW_MAXIMIZE = 3
kernel32.GetConsoleWindow.restype = wintypes.HWND
kernel32.GetLargestConsoleWindowSize.restype = wintypes._COORD
kernel32.GetLargestConsoleWindowSize.argtypes = (wintypes.HANDLE,)
user32.ShowWindow.argtypes = (wintypes.HWND, ctypes.c_int)


def maximize_console(lines=None):
    fd = os.open("CONOUT$", os.O_RDWR)
    try:
        hCon = msvcrt.get_osfhandle(fd)
        max_size = kernel32.GetLargestConsoleWindowSize(hCon)
        if max_size.X == 0 and max_size.Y == 0:
            raise ctypes.WinError(ctypes.get_last_error())
    finally:
        os.close(fd)
    cols = max_size.X
    hWnd = kernel32.GetConsoleWindow()
    if cols and hWnd:
        if lines is None:
            lines = max_size.Y
        else:
            lines = max(min(lines, 9999), max_size.Y)
        subprocess.check_call("mode.com con cols={} lines={}".format(cols, lines))
        user32.ShowWindow(hWnd, SW_MAXIMIZE)

Artigos relacionados

Respostas

O seu endereço de e-mail não será publicado.

Start a Conversation

Hi! Click one of our member below to chat on Whatsapp

Suporte técnico

Suporte técnico

Suporte técnico - mande uma mensagem!

online

Tempo limitado!

Todos os cursos com 25% de desconto!