de:
  linter:
    # This file is used to translate PyLint results from the original English output to German
    # The following hierarchy has been implemented:
    #
    # 1. severity of the linter check result
    #    a. The `severity_name` translates the severity itself
    # 2. code of the linter check result
    # 3. A list of required values for the actual translation
    #    a. example: not used anywhere, just for reference when editing this yml file
    #    b. name: Title of the linter check
    #    c. regex: A regex used to translate dynamic parts with _named_ capture groups
    #    d. replacement: A fix replacement translation which is used instead of the
    #                    original English output. It may refer to one of the named capture
    #                    groups to include dynamic content from the English original
    #    e. log_missing: Specifies whether missing translations should be logged to Sentry
    # 4. Optionally a named capture group from the regex
    # 5. A list of fix translations for _values / matches_ of the named capture group
    #
    convention:
      severity_name: Konvention
      wrong-import-position:
        example: Import "from turtle import *" should be placed at the top of the module
        name: Falsche Import-Position
        regex: .*"(?<import>.*)".*
        replacement: Der Import von "%{import}" sollte am Anfang der Datei stehen
        log_missing: false
      bad-whitespace:
        example: No space allowed before bracket
        name: Inkorrektes Leerzeichen
        regex: (?<what>Exactly one space required|No space allowed) (?<where>after|before|around) (?<when>.*)
        replacement: "%{where} %{when} %{what}"
        log_missing: true
        what:
          No space allowed: sollte kein Leerzeichen stehen
          Exactly one space required: sollte genau ein Leerzeichen stehen
        where:
          before: Vor
          after: Hinter
          around: Vor und hinter
        when:
          ':': einem Doppelpunkt
          assignment: einer Zuweisung
          comma: einem Komma
          comparison: einem Vergleich
          bracket: einer Klammer
          keyword argument assignment: einer Zuweisung von Schlüsselargumenten
      multiple-statements:
        example: More than one statement on a single line
        name: Mehrere Anweisungen
        regex: .*
        replacement: Mehr als eine Anweisung in einer Zeile
        log_missing: false
      superfluous-parens:
        example: Unnecessary parens after 'if' keyword
        name: Überflüssige Klammer
        regex: .*'(?<keyword>.*)'.*
        replacement: Nach dem Schlüsselwort '%{keyword}' ist keine Klammer notwendig
        log_missing: false
    error:
      severity_name: Fehler
      function-redefined:
        example: function already defined line 15
        name: Funktionsdefinition überschrieben
        regex: .*line (?<line>\d*).*
        replacement: Eine Funktion mit demselben Namen wurde bereits in Zeile %{line} definiert
        log_missing: false
      import-error:
        example: Unable to import 'turtel'
        name: Import-Fehler
        regex: .*'(?<import>.*)'.*
        replacement: Der Import von '%{import}' ist fehlgeschlagen
        log_missing: false
      syntax-error:
        example: EOL while scanning string literal (<unknown>, line 1)
        name: Syntax-Fehler
        regex: |
          (?<what>invalid syntax|EOL while scanning string literal|EOF while scanning triple-quoted string literal|cannot assign to|expected an indented block|Missing parentheses in call to|closing parenthesis|expression cannot contain assignment, perhaps you meant|f-string expression part cannot include a backslash|f-string:|invalid character in identifier|invalid decimal literal|trailing comma not allowed without surrounding parentheses|unexpected EOF while parsing|unexpected character after line continuation character|unexpected indent|unexpected unindent|unindent does not match any outer indentation level|unmatched|inconsistent use of tabs and spaces in indentation|illegal target for annotation|positional argument follows keyword argument|leading zeros in decimal integer literals are not permitted; use an 0o prefix for octal integers|cannot assign to comparison) ?(?<what_exactly>function call|literal|operator|set display|empty expression not allowed|single|unmatched)? ?(?:'(?<actual>[^'"]*)'\.*)? ?(?:(?<explanation>Did you mean|does not match opening parenthesis|is not allowed)(?: ')?)?(?:(?<suggestion>.*)(?:\?|'|"))? ?\((?<context>.*), line (?<line>\d*)\).*
        replacement: "%{what}%{what_exactly}%{actual}%{explanation}%{suggestion}" # unused: context, line
        log_missing: true
        what:
          invalid syntax: Ungültige Syntax
          EOL while scanning string literal: Ein String wurde nicht geschlossen
          EOF while scanning triple-quoted string literal: Ein Kommentar mit drei Anführungszeichen wurde nicht geschlossen
          cannot assign to: Die Zuweisung ist ungültig für
          expected an indented block: Ein eingerückter Codeblock wurde erwartet
          Missing parentheses in call to: Die Klammern beim Aufruf von "
          closing parenthesis: 'Die schließende Klammer '
          expression cannot contain assignment, perhaps you meant: 'Die Anweisung kann keine Zuweisung enthalten, vielleicht meintest du folgendes: '
          f-string expression part cannot include a backslash: Ein Platzhalter in einem f-String kann keinen Backslash \ enthalten
          'f-string:': 'f-String:'
          invalid character in identifier: Ungültiges Zeichen im Bezeichner
          invalid decimal literal: Ungültige Zahl # e.g. 100_years
          trailing comma not allowed without surrounding parentheses: Ein Komma am Ende einer Aufzählung ist ohne umgebende Klammern nicht erlaubt
          unexpected EOF while parsing: Es wurden weitere Zeichen in dem Quellcode erwartet, diese fehlten jedoch
          unexpected character after line continuation character: Nach einem Backslash \ außerhalb eines Strings darf in der selben Zeile kein weiteres Zeichen folgen
          unexpected indent: Ungültige Einrückung
          unexpected unindent: Ungültige Einrückung nach einem weiter eingerückten Code-Block
          unindent does not match any outer indentation level: Die Einrückung passt nicht zu einem vorherigen Teil
          unmatched: 'Die folgende Klammer scheint zu viel zu sein: '
          inconsistent use of tabs and spaces in indentation: Gemischte Einrückung mit Leerzeichen und Tabs
          illegal target for annotation: Ungültige Schreibweise eines Bezeichners mit einem Großbuchstaben
          positional argument follows keyword argument: Nach einem benannten Argument darf kein Argument ohne Namen folgen
          leading zeros in decimal integer literals are not permitted; use an 0o prefix for octal integers: Eine Zahl darf nicht mit einer führenden Null beginnen
          cannot assign to comparison: Ein Vergleich kann nicht das Ziel einer Zuweisung sein und daher nicht links von einem einfachen Gleichheitszeichen = stehen
        what_exactly:
          # must start with a space character
          function call: ' eine Funktion'
          literal: ' eine Zahl'
          operator: ' einen Operator'
          set display: ' einer Menge'
          list display: ' eine Liste'
          dict display: ' ein Dictionary'
          f-string expression: ' einem F-String'
          # the following are in the context of an f-string
          empty expression not allowed: ' eine leere Anweisung ist nicht erlaubt'
          single: ' eine einzelne "'
          unmatched: ' unpassende Klammer '
        explanation:
          Did you mean: '" fehlen. Vielleicht meintest du folgendes:'
          does not match opening parenthesis: ' passt nicht zu der öffnenden Klammer '
          is not allowed: '" ist nicht erlaubt'
        # additional capture groups that are used without translation:
        # - actual
        # - suggestion
        # - context
        # - line
      undefined-variable:
        example: Undefined variable 'beginn_fill'
        name: Undefinierter Bezeichner
        regex: .*'(?<name>.*)'.*
        replacement: Der Name '%{name}' ist unbekannt
        log_missing: false
      used-before-assignment:
        example: Using variable 'kleidung' before assignment
        name: Verwendung vor Zuweisung
        regex: .*'(?<name>.*)'.*
        replacement: Die Variable '%{name}' wird vor ihrer erstmaligen Zuweisung verwendet
        log_missing: false
      return-outside-function:
        example: Return outside function
        name: Return außerhalb einer Funktion
        regex: .*
        replacement: Ein Return kann nur innerhalb einer Funktion verwendet werden
        log_missing: false
    refactor:
      severity_name: Überarbeitung empfohlen
      comparison-with-itself:
        example: Redundant comparison - hauptspeise == hauptspeise
        name: Vergleich mit sich selbst
        regex: .* - (?<comparison>.*)
        replacement: Der Vergleich ist überflüssig - %{comparison}
        log_missing: false
      inconsistent-return-statements:
        example: Either all return statements in a function should return an expression, or none of them should.
        name: Uneinheitliche Rückgabewerte
        regex: .*
        replacement: Entweder sollten alle return Anweisungen in einer Funktion ein Ergebnis zurückgeben oder keine Anweisung sollte einen Rückgabewert haben
        log_missing: false
      redefined-argument-from-local:
        example: Redefining argument with the local name 'Wort'
        name: Überschreiben eines Arguments
        regex: .*'(?<name>.*)'.*
        replacement: Das Argument '%{name}' wird überschrieben
        log_missing: false
    warning:
      severity_name: Warnung
      bad-indentation:
        example: Bad indentation. Found 3 spaces, expected 4
        name: Ungültige Einrückung
        regex: .*(?<actual>\d+).*(?<expected>\d+).*
        replacement: Statt %{actual} Leerzeichen wurden %{expected} Leerzeichen erwartet
        log_missing: false
      duplicate-key:
        example: Duplicate key 100 in dictionary
        name: Doppelter Schlüssel
        regex: Duplicate key (?<key>.*) in dictionary
        replacement: Der Schlüssel '%{key}' ist im Dictionary doppelt vorhanden
        log_missing: false
      duplicate-except:
        example: Catching previously caught exception type ValueError
        name: Doppeltes Except
        regex: Catching previously caught exception type (?<exception>.*)
        replacement: Die zuvor bereits aufgefangene Exception '%{exception}' wird erneut behandelt
        log_missing: false
      mixed-indentation:
        example: Found indentation with tabs instead of spaces
        name: Gemischte Einrückung
        regex: .*
        replacement: Es wurde eine Einrückung mit Tabs anstelle von Leerzeichen entdeckt
        log_missing: false
      pointless-statement:
        example: Statement seems to have no effect
        name: sinnlose Anweisung
        regex: .*
        replacement: Die Anweisung scheint keine Auswirkungen zu haben
        log_missing: false
      pointless-string-statement:
        example: String statement has no effect
        name: sinnloser String
        regex: .*
        replacement: Ein einzelner String ohne Zuweisung hat keine Auswirkung
        log_missing: false
      redefined-builtin:
        example: Redefining built-in 'print'
        name: Überschreiben
        regex: .*'(?<builtin>.*)'.*
        replacement: Der interne Bezeichner '%{builtin}' wird überschrieben
        log_missing: false
      redefined-outer-name:
        example: Redefining name 'name' from outer scope (line 1)
        name: Überschreiben
        regex: .*'(?<name>.*)'.*\(line (?<line>\d*)\).*
        replacement: Der Bezeichner '%{name}', der bereits in Zeile %{line} definiert wurde, wird überschrieben
        log_missing: false
      self-assigning-variable:
        example: Assigning the same variable 'kleidung' to itself
        name: Selbstzuweisung
        regex: .*'(?<name>.*)'.*
        replacement: Die Variable '%{name}' wird sich selbst zugewiesen
        log_missing: false
      unreachable:
        example: Unreachable code
        name: Unerreichbar
        regex: .*
        replacement: Die Anweisung wird nie ausgeführt
        log_missing: false
      undefined-loop-variable:
        example: Using possibly undefined loop variable 'i'
        name: Unbekannte Schleifenvariable
        regex: .*'(?<name>.*)'.*
        replacement: Die Schleifenvariable '%{name}' ist möglicherweise nicht definiert
        log_missing: false
      unnecessary-semicolon:
        example: Unnecessary semicolon
        name: Unnötiges Semikolon
        regex: .*
        replacement: Am Ende einer Zeile sollte kein Semikolon stehen
        log_missing: false
      unused-argument:
        example: Unused argument 'laenge'
        name: Unbenutztes Argument
        regex: .*'(?<name>.*)'.*
        replacement: Das Argument '%{name}' wird nicht verwendet
        log_missing: false
      unused-variable:
        example: Unused variable 'i'
        name: Unbenutzte Variable
        regex: .*'(?<name>.*)'.*
        replacement: Die Variable '%{name}' wird nicht verwendet
        log_missing: false