From daa5d2cd0a41684d15b8c5fc3d76113c75ad5f3d Mon Sep 17 00:00:00 2001 From: Matt Hillsdon <44397098+microbit-matt-hillsdon@users.noreply.github.com> Date: Thu, 25 Jan 2024 13:03:22 +0000 Subject: [PATCH] Preview of German and misc updates (#96) --- crowdin/translated/api.ca.json | 2 +- crowdin/translated/api.de.json | 5258 +++++++++++++++++ crowdin/translated/api.es-es.json | 190 +- crowdin/translated/api.ja.json | 12 +- lang/ca/typeshed/stdlib/neopixel.pyi | 2 +- lang/de/typeshed/stdlib/VERSIONS | 50 + .../de/typeshed/stdlib/_typeshed/__init__.pyi | 168 + lang/de/typeshed/stdlib/abc.pyi | 28 + lang/de/typeshed/stdlib/antigravity.pyi | 0 lang/de/typeshed/stdlib/array.pyi | 42 + lang/de/typeshed/stdlib/audio.pyi | 11 + lang/de/typeshed/stdlib/builtins.pyi | 1334 +++++ .../typeshed/stdlib/collections/__init__.pyi | 60 + lang/de/typeshed/stdlib/errno.pyi | 26 + lang/de/typeshed/stdlib/gc.pyi | 68 + lang/de/typeshed/stdlib/log.pyi | 89 + lang/de/typeshed/stdlib/love.pyi | 1 + lang/de/typeshed/stdlib/machine.pyi | 84 + lang/de/typeshed/stdlib/math.pyi | 246 + lang/de/typeshed/stdlib/microbit/__init__.pyi | 706 +++ .../stdlib/microbit/accelerometer.pyi | 103 + lang/de/typeshed/stdlib/microbit/audio.pyi | 124 + lang/de/typeshed/stdlib/microbit/compass.pyi | 70 + lang/de/typeshed/stdlib/microbit/display.pyi | 92 + lang/de/typeshed/stdlib/microbit/i2c.pyi | 49 + .../typeshed/stdlib/microbit/microphone.pyi | 62 + lang/de/typeshed/stdlib/microbit/speaker.pyi | 15 + lang/de/typeshed/stdlib/microbit/spi.pyi | 46 + lang/de/typeshed/stdlib/microbit/uart.pyi | 79 + lang/de/typeshed/stdlib/micropython.pyi | 131 + lang/de/typeshed/stdlib/music.pyi | 128 + lang/de/typeshed/stdlib/neopixel.pyi | 81 + lang/de/typeshed/stdlib/os.pyi | 63 + lang/de/typeshed/stdlib/power.pyi | 53 + lang/de/typeshed/stdlib/radio.pyi | 126 + lang/de/typeshed/stdlib/random.pyi | 80 + lang/de/typeshed/stdlib/speech.pyi | 76 + lang/de/typeshed/stdlib/struct.pyi | 56 + lang/de/typeshed/stdlib/sys.pyi | 93 + lang/de/typeshed/stdlib/this.pyi | 1 + lang/de/typeshed/stdlib/time.pyi | 111 + lang/de/typeshed/stdlib/types.pyi | 413 ++ lang/de/typeshed/stdlib/typing.pyi | 716 +++ lang/de/typeshed/stdlib/typing_extensions.pyi | 115 + lang/de/typeshed/stdlib/uarray.pyi | 1 + lang/de/typeshed/stdlib/ucollections.pyi | 1 + lang/de/typeshed/stdlib/uerrno.pyi | 1 + lang/de/typeshed/stdlib/urandom.pyi | 1 + lang/de/typeshed/stdlib/ustruct.pyi | 1 + lang/de/typeshed/stdlib/usys.pyi | 1 + lang/de/typeshed/stdlib/utime.pyi | 1 + lang/es-es/typeshed/stdlib/log.pyi | 12 +- .../typeshed/stdlib/microbit/__init__.pyi | 32 +- .../stdlib/microbit/accelerometer.pyi | 6 +- lang/es-es/typeshed/stdlib/microbit/audio.pyi | 70 +- lang/ja/typeshed/stdlib/microbit/__init__.pyi | 8 +- lang/ja/typeshed/stdlib/microbit/audio.pyi | 4 +- scripts/build-translations.sh | 2 +- 58 files changed, 11231 insertions(+), 170 deletions(-) create mode 100644 crowdin/translated/api.de.json create mode 100644 lang/de/typeshed/stdlib/VERSIONS create mode 100644 lang/de/typeshed/stdlib/_typeshed/__init__.pyi create mode 100644 lang/de/typeshed/stdlib/abc.pyi create mode 100644 lang/de/typeshed/stdlib/antigravity.pyi create mode 100644 lang/de/typeshed/stdlib/array.pyi create mode 100644 lang/de/typeshed/stdlib/audio.pyi create mode 100644 lang/de/typeshed/stdlib/builtins.pyi create mode 100644 lang/de/typeshed/stdlib/collections/__init__.pyi create mode 100644 lang/de/typeshed/stdlib/errno.pyi create mode 100644 lang/de/typeshed/stdlib/gc.pyi create mode 100644 lang/de/typeshed/stdlib/log.pyi create mode 100644 lang/de/typeshed/stdlib/love.pyi create mode 100644 lang/de/typeshed/stdlib/machine.pyi create mode 100644 lang/de/typeshed/stdlib/math.pyi create mode 100644 lang/de/typeshed/stdlib/microbit/__init__.pyi create mode 100644 lang/de/typeshed/stdlib/microbit/accelerometer.pyi create mode 100644 lang/de/typeshed/stdlib/microbit/audio.pyi create mode 100644 lang/de/typeshed/stdlib/microbit/compass.pyi create mode 100644 lang/de/typeshed/stdlib/microbit/display.pyi create mode 100644 lang/de/typeshed/stdlib/microbit/i2c.pyi create mode 100644 lang/de/typeshed/stdlib/microbit/microphone.pyi create mode 100644 lang/de/typeshed/stdlib/microbit/speaker.pyi create mode 100644 lang/de/typeshed/stdlib/microbit/spi.pyi create mode 100644 lang/de/typeshed/stdlib/microbit/uart.pyi create mode 100644 lang/de/typeshed/stdlib/micropython.pyi create mode 100644 lang/de/typeshed/stdlib/music.pyi create mode 100644 lang/de/typeshed/stdlib/neopixel.pyi create mode 100644 lang/de/typeshed/stdlib/os.pyi create mode 100644 lang/de/typeshed/stdlib/power.pyi create mode 100644 lang/de/typeshed/stdlib/radio.pyi create mode 100644 lang/de/typeshed/stdlib/random.pyi create mode 100644 lang/de/typeshed/stdlib/speech.pyi create mode 100644 lang/de/typeshed/stdlib/struct.pyi create mode 100644 lang/de/typeshed/stdlib/sys.pyi create mode 100644 lang/de/typeshed/stdlib/this.pyi create mode 100644 lang/de/typeshed/stdlib/time.pyi create mode 100644 lang/de/typeshed/stdlib/types.pyi create mode 100644 lang/de/typeshed/stdlib/typing.pyi create mode 100644 lang/de/typeshed/stdlib/typing_extensions.pyi create mode 100644 lang/de/typeshed/stdlib/uarray.pyi create mode 100644 lang/de/typeshed/stdlib/ucollections.pyi create mode 100644 lang/de/typeshed/stdlib/uerrno.pyi create mode 100644 lang/de/typeshed/stdlib/urandom.pyi create mode 100644 lang/de/typeshed/stdlib/ustruct.pyi create mode 100644 lang/de/typeshed/stdlib/usys.pyi create mode 100644 lang/de/typeshed/stdlib/utime.pyi diff --git a/crowdin/translated/api.ca.json b/crowdin/translated/api.ca.json index 24e0652..e0dbd52 100644 --- a/crowdin/translated/api.ca.json +++ b/crowdin/translated/api.ca.json @@ -4116,7 +4116,7 @@ "description": "(parameter name) Bytes per pixel. For RGBW neopixel support, pass 4 rather than the default of 3 for RGB and GRB." }, "neopixel.NeoPixel.__init__.param-doc.bpp": { - "message": "Bytes per píxel. Per al suport de RGBW neopixel, passa 4 en lloc dels 3 per defecte per a RGB i GRB.", + "message": "Bytes per píxel. Per al suport del neopixel RGBW , passa 4 en lloc dels 3 per defecte per a RGB i GRB.", "description": "Parameter docs" }, "neopixel.NeoPixel.__init__.param-name.n": { diff --git a/crowdin/translated/api.de.json b/crowdin/translated/api.de.json new file mode 100644 index 0000000..ad2ff50 --- /dev/null +++ b/crowdin/translated/api.de.json @@ -0,0 +1,5258 @@ +{ + "gc": { + "message": "gc", + "description": "(module name) Control the garbage collector" + }, + "gc.summary": { + "message": "Steuerung des Garbage Collectors", + "description": "Control the garbage collector" + }, + "gc.enable": { + "message": "enable", + "description": "(function name) Enable automatic garbage collection." + }, + "gc.enable.summary": { + "message": "Automatische Garbage Collection aktivieren.", + "description": "Enable automatic garbage collection." + }, + "gc.disable": { + "message": "disable", + "description": "(function name) Disable automatic garbage collection." + }, + "gc.disable.summary": { + "message": "Automatische Garbage Collection deaktivieren.", + "description": "Disable automatic garbage collection." + }, + "gc.collect": { + "message": "collect", + "description": "(function name) Run a garbage collection." + }, + "gc.collect.summary": { + "message": "Garbage Collection ausführen.", + "description": "Run a garbage collection." + }, + "gc.mem_alloc": { + "message": "mem alloc", + "description": "(function name) Get the number of bytes of heap RAM that are allocated." + }, + "gc.mem_alloc.summary": { + "message": "Ermittelt die Anzahl der dem Heap-Speicher zugewiesen Bytes.", + "description": "Get the number of bytes of heap RAM that are allocated." + }, + "gc.mem_free": { + "message": "mem free", + "description": "(function name) Get the number of bytes of available heap RAM, or -1 if this amount is not known." + }, + "gc.mem_free.summary": { + "message": "Gibt die Anzahl der Bytes des verfügbaren dynamischen Speichers zurück. -1 wird zurückgegeben, wenn dieser Wert unbekannt ist.", + "description": "Get the number of bytes of available heap RAM, or -1 if this amount is not known." + }, + "gc.threshold-1": { + "message": "threshold", + "description": "(function name) Query the additional GC allocation threshold." + }, + "gc.threshold-1.summary": { + "message": "Den zusätzlichen GC-Zuteilungsschwellwert abfragen.", + "description": "Query the additional GC allocation threshold." + }, + "gc.threshold-2": { + "message": "threshold", + "description": "(function name) Set the additional GC allocation threshold." + }, + "gc.threshold-2.summary": { + "message": "Den zusätzlichen GC-Schwellenwert festlegen.", + "description": "Set the additional GC allocation threshold." + }, + "gc.threshold-2.param-name.amount": { + "message": "amount", + "description": "(parameter name) The number of bytes after which a garbage collection should be triggered." + }, + "gc.threshold-2.param-doc.amount": { + "message": "Die Anzahl der Bytes, nach denen eine Garbage Collection ausgelöst werden soll.", + "description": "Parameter docs" + }, + "log": { + "message": "log", + "description": "(module name) Log data to your micro:bit V2." + }, + "log.summary": { + "message": "Zeichne Daten auf deinem micro:bit V2 auf.", + "description": "Log data to your micro:bit V2." + }, + "log.MILLISECONDS": { + "message": "millisekunden", + "description": "(field name) Milliseconds timestamp format." + }, + "log.MILLISECONDS.summary": { + "message": "Millisekunden Zeitstempelformat.", + "description": "Milliseconds timestamp format." + }, + "log.SECONDS": { + "message": "sekunden", + "description": "(field name) Seconds timestamp format." + }, + "log.SECONDS.summary": { + "message": "Sekunden Zeitstempelformat.", + "description": "Seconds timestamp format." + }, + "log.MINUTES": { + "message": "minuten", + "description": "(field name) Minutes timestamp format." + }, + "log.MINUTES.summary": { + "message": "Minuten Zeitstempelformat.", + "description": "Minutes timestamp format." + }, + "log.HOURS": { + "message": "stunden", + "description": "(field name) Hours timestamp format." + }, + "log.HOURS.summary": { + "message": "Stunden Zeitstempelformat.", + "description": "Hours timestamp format." + }, + "log.DAYS": { + "message": "tage", + "description": "(field name) Days timestamp format." + }, + "log.DAYS.summary": { + "message": "Tage Zeitstempelformat.", + "description": "Days timestamp format." + }, + "log.set_labels": { + "message": "Beschriftungen festlegen", + "description": "(function name) Set up the log file header." + }, + "log.set_labels.summary": { + "message": "Den Logdatei-Header setzen ", + "description": "Set up the log file header." + }, + "log.set_labels.param-name.*labels": { + "message": "*labels", + "description": "(parameter name) Any number of positional arguments, each corresponding to an entry in the log header." + }, + "log.set_labels.param-doc.*labels": { + "message": "Eine beliebige Anzahl von Positionsargumenten, die jeweils einem Eintrag in der Kopfzeile des Logs entsprechen.", + "description": "Parameter docs" + }, + "log.set_labels.param-name.timestamp": { + "message": "Zeitstempel", + "description": "(parameter name) Select the timestamp unit that will be automatically added as the first column in every row. Timestamp values can be one of ``log.MILLISECONDS``, ``log.SECONDS``, ``log.MINUTES``, ``log.HOURS``, ``log.DAYS`` or ``None`` to disable the timestamp. The default value is ``log.SECONDS``." + }, + "log.set_labels.param-doc.timestamp": { + "message": "Wähle die Zeitstempel-Einheit, die automatisch als erste Spalte in jeder Zeile hinzugefügt wird. Der Zeitstempel kann einen der folgenden Werte annehmen: {{log.MILLISECONDS}}, {{log.SECONDS}}, {{log.MINUTES}}, {{log.HOURS}}, {{log.DAYS}} oder {{None}}, um den Zeitstempel zu deaktivieren. Der Standardwert ist {{log.SECONDS}}.", + "description": "Parameter docs" + }, + "log.add-1": { + "message": "hinzufügen", + "description": "(function name) Add a data row to the log by passing a dictionary of headers and values." + }, + "log.add-1.summary": { + "message": "Füge dem Protokoll eine Datenzeile hinzu, indem du ein Dictionary mit Kopfzeileneinträgen und Werten übergibst.", + "description": "Add a data row to the log by passing a dictionary of headers and values." + }, + "log.add-1.param-name.data_dictionary": { + "message": "daten wörterbuch", + "description": "(parameter name) The data to log as a dictionary with a key for each header." + }, + "log.add-1.param-doc.data_dictionary": { + "message": "Die zu protokollierenden Daten in Form eines Dictionarys mit einem Schlüssel für jeden Kopfzeileneintrag.", + "description": "Parameter docs" + }, + "log.add-2": { + "message": "hinzufügen", + "description": "(function name) Add a data row to the log using keyword arguments." + }, + "log.add-2.summary": { + "message": "Füge dem Protokoll eine Datenzeile mit Schlüsselwörtern als Argumenten hinzu.", + "description": "Add a data row to the log using keyword arguments." + }, + "log.delete": { + "message": "löschen", + "description": "(function name) Deletes the contents of the log, including headers." + }, + "log.delete.summary": { + "message": "Löscht den Inhalt des Protokolls, einschließlich der Kopfzeilen.", + "description": "Deletes the contents of the log, including headers." + }, + "log.delete.param-name.full": { + "message": "vollständig", + "description": "(parameter name) ``True`` selects a “full” erase and ``False`` selects the “fast” erase method." + }, + "log.delete.param-doc.full": { + "message": "Mit {{True}} wird ein \" vollständiges\" Löschen und mit {{False}} die \"schnelle\" Löschmethode gewählt.", + "description": "Parameter docs" + }, + "log.set_mirroring": { + "message": "spiegeln", + "description": "(function name) Configure mirroring of the data logging activity to the serial output." + }, + "log.set_mirroring.summary": { + "message": "Richte die Spiegelung der Datenprotokollierung auf dem seriellen Ausgang ein.", + "description": "Configure mirroring of the data logging activity to the serial output." + }, + "log.set_mirroring.param-name.serial": { + "message": "seriell", + "description": "(parameter name) ``True`` enables mirroring data to the serial output." + }, + "log.set_mirroring.param-doc.serial": { + "message": "{{True}} aktiviert die Spiegelung von Daten auf dem seriellen Ausgang.", + "description": "Parameter docs" + }, + "machine": { + "message": "maschine", + "description": "(module name) Low-level utilities." + }, + "machine.summary": { + "message": "Low-Level-Utilities.", + "description": "Low-level utilities." + }, + "machine.unique_id": { + "message": "Eindeutige ID", + "description": "(function name) Get a byte string with a unique identifier of a board." + }, + "machine.unique_id.summary": { + "message": "Liefert eine Byte-Zeichenkette mit einem eindeutigen Bezeichner für ein Board.", + "description": "Get a byte string with a unique identifier of a board." + }, + "machine.reset": { + "message": "zurücksetzen", + "description": "(function name) Reset the device in a manner similar to pushing the external RESET button." + }, + "machine.reset.summary": { + "message": "Setzt das Gerät zurück, als würde man die externe RESET-Taste drückt.", + "description": "Reset the device in a manner similar to pushing the external RESET button." + }, + "machine.freq": { + "message": "freq", + "description": "(function name) Get the CPU frequency in hertz." + }, + "machine.freq.summary": { + "message": "Ermittelt die Taktfrequenz der CPU in Hertz.", + "description": "Get the CPU frequency in hertz." + }, + "machine.disable_irq": { + "message": "IRQ deaktivieren", + "description": "(function name) Disable interrupt requests." + }, + "machine.disable_irq.summary": { + "message": "Deaktiviere Interrupt-Anforderungen.", + "description": "Disable interrupt requests." + }, + "machine.enable_irq": { + "message": "IRQ aktivieren", + "description": "(function name) Re-enable interrupt requests." + }, + "machine.enable_irq.summary": { + "message": "Interrupt-Anfragen wieder aktivieren.", + "description": "Re-enable interrupt requests." + }, + "machine.enable_irq.param-name.state": { + "message": "state", + "description": "(parameter name) The value that was returned from the most recent call to the ``disable_irq`` function." + }, + "machine.enable_irq.param-doc.state": { + "message": "Der Wert, der beim letzten Aufruf der Funktion {{disable_irq}} zurückgegeben wurde.", + "description": "Parameter docs" + }, + "machine.time_pulse_us": { + "message": "zeitimpuls us", + "description": "(function name) Time a pulse on a pin." + }, + "machine.time_pulse_us.summary": { + "message": "Gibt die Dauer eines Impulses an einem Pin zurück.", + "description": "Time a pulse on a pin." + }, + "machine.time_pulse_us.param-name.pin": { + "message": "pin", + "description": "(parameter name) The pin to use" + }, + "machine.time_pulse_us.param-doc.pin": { + "message": "Der zu verwendende Pin", + "description": "Parameter docs" + }, + "machine.time_pulse_us.param-name.pulse_level": { + "message": "pulsstufe", + "description": "(parameter name) 0 to time a low pulse or 1 to time a high pulse" + }, + "machine.time_pulse_us.param-doc.pulse_level": { + "message": "0, um einen Low-Impuls oder 1, um einen High-Impuls zu messen", + "description": "Parameter docs" + }, + "machine.time_pulse_us.param-name.timeout_us": { + "message": "timeout us", + "description": "(parameter name) A microsecond timeout" + }, + "machine.time_pulse_us.param-doc.timeout_us": { + "message": "Eine Verzögerung in Mikrosekunden", + "description": "Parameter docs" + }, + "machine.mem": { + "message": "mem", + "description": "(class name) The class for the ``mem8``, ``mem16`` and ``mem32`` memory views." + }, + "machine.mem.summary": { + "message": "Die Klasse für die {{mem8}}, {{mem16}} und {{mem32}} Speicheranzeigen.", + "description": "The class for the ``mem8``, ``mem16`` and ``mem32`` memory views." + }, + "machine.mem.__getitem__": { + "message": "getitem", + "description": "(function name) Access a value from memory." + }, + "machine.mem.__getitem__.summary": { + "message": "Greife auf einen Wert im Speicher zu.", + "description": "Access a value from memory." + }, + "machine.mem.__getitem__.param-name.address": { + "message": "adresse", + "description": "(parameter name) The memory address." + }, + "machine.mem.__getitem__.param-doc.address": { + "message": "Die Speicheradresse.", + "description": "Parameter docs" + }, + "machine.mem.__setitem__": { + "message": "setitem", + "description": "(function name) Set a value at the given address." + }, + "machine.mem.__setitem__.summary": { + "message": "Setzt einen Wert an der angegebenen Adresse.", + "description": "Set a value at the given address." + }, + "machine.mem.__setitem__.param-name.address": { + "message": "adresse", + "description": "(parameter name) The memory address." + }, + "machine.mem.__setitem__.param-doc.address": { + "message": "Die Speicheradresse.", + "description": "Parameter docs" + }, + "machine.mem.__setitem__.param-name.value": { + "message": "wert", + "description": "(parameter name) The integer value to set." + }, + "machine.mem.__setitem__.param-doc.value": { + "message": "Der zu setzende Integer-Wert.", + "description": "Parameter docs" + }, + "machine.mem8": { + "message": "mem8", + "description": "(field name) 8-bit (byte) view of memory." + }, + "machine.mem8.summary": { + "message": "8-Bit (Byte) Ansicht des Speichers.", + "description": "8-bit (byte) view of memory." + }, + "machine.mem16": { + "message": "mem16", + "description": "(field name) 16-bit view of memory." + }, + "machine.mem16.summary": { + "message": "16-Bit (Byte) Ansicht des Speichers.", + "description": "16-bit view of memory." + }, + "machine.mem32": { + "message": "mem32", + "description": "(field name) 32-bit view of memory." + }, + "machine.mem32.summary": { + "message": "32-Bit (Byte) Ansicht des Speichers.", + "description": "32-bit view of memory." + }, + "math": { + "message": "math", + "description": "(module name) Mathematical functions." + }, + "math.summary": { + "message": "Mathematische Funktionen.", + "description": "Mathematical functions." + }, + "math.acos": { + "message": "acos", + "description": "(function name) Calculate the inverse cosine." + }, + "math.acos.summary": { + "message": "Berechnet den Arkuskosinus.", + "description": "Calculate the inverse cosine." + }, + "math.acos.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.acos.param-doc.x": { + "message": "Eine Zahl", + "description": "Parameter docs" + }, + "math.asin": { + "message": "asin", + "description": "(function name) Calculate the inverse sine." + }, + "math.asin.summary": { + "message": "Berechnet den Arkussinus.", + "description": "Calculate the inverse sine." + }, + "math.asin.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.asin.param-doc.x": { + "message": "Eine Zahl", + "description": "Parameter docs" + }, + "math.atan": { + "message": "atan", + "description": "(function name) Calculate the inverse tangent." + }, + "math.atan.summary": { + "message": "Berechnet den Arkustangens.", + "description": "Calculate the inverse tangent." + }, + "math.atan.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.atan.param-doc.x": { + "message": "Eine Zahl", + "description": "Parameter docs" + }, + "math.atan2": { + "message": "atan2", + "description": "(function name) Calculate the principal value of the inverse tangent of ``y/x``." + }, + "math.atan2.summary": { + "message": "Berechnet den Hauptwert des Arkustangens von {{y/x}}.", + "description": "Calculate the principal value of the inverse tangent of ``y/x``." + }, + "math.atan2.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.atan2.param-doc.x": { + "message": "Eine Zahl", + "description": "Parameter docs" + }, + "math.atan2.param-name.y": { + "message": "y", + "description": "(parameter name) A number" + }, + "math.atan2.param-doc.y": { + "message": "Eine Zahl", + "description": "Parameter docs" + }, + "math.ceil": { + "message": "ceil", + "description": "(function name) Round a number towards positive infinity." + }, + "math.ceil.summary": { + "message": "Rundet eine Zahl in Richtung positiver Unendlichkeit.", + "description": "Round a number towards positive infinity." + }, + "math.ceil.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.ceil.param-doc.x": { + "message": "Eine Zahl", + "description": "Parameter docs" + }, + "math.copysign": { + "message": "copysign", + "description": "(function name) Calculate ``x`` with the sign of ``y``." + }, + "math.copysign.summary": { + "message": "Berechne {{x}} mit dem Vorzeichen von {{y}}.", + "description": "Calculate ``x`` with the sign of ``y``." + }, + "math.copysign.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.copysign.param-doc.x": { + "message": "Eine Zahl", + "description": "Parameter docs" + }, + "math.copysign.param-name.y": { + "message": "y", + "description": "(parameter name) The source of the sign for the return value" + }, + "math.copysign.param-doc.y": { + "message": "Die Herkunft des Vorzeichens für den Rückgabewert", + "description": "Parameter docs" + }, + "math.cos": { + "message": "cos", + "description": "(function name) Calculate the cosine of ``x``." + }, + "math.cos.summary": { + "message": "Berechnet den Kosinus von {{x}}.", + "description": "Calculate the cosine of ``x``." + }, + "math.cos.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.cos.param-doc.x": { + "message": "Eine Zahl", + "description": "Parameter docs" + }, + "math.degrees": { + "message": "degrees", + "description": "(function name) Convert radians to degrees." + }, + "math.degrees.summary": { + "message": "Wandelt Bogenmaß (Radiant) in Grad um.", + "description": "Convert radians to degrees." + }, + "math.degrees.param-name.x": { + "message": "x", + "description": "(parameter name) A value in radians" + }, + "math.degrees.param-doc.x": { + "message": "Ein Wert in Radiant", + "description": "Parameter docs" + }, + "math.exp": { + "message": "exp", + "description": "(function name) Calculate the exponential of ``x``." + }, + "math.exp.summary": { + "message": "Berechnet den Exponentialwert von {{x}}.", + "description": "Calculate the exponential of ``x``." + }, + "math.exp.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.exp.param-doc.x": { + "message": "Eine Zahl", + "description": "Parameter docs" + }, + "math.fabs": { + "message": "fabs", + "description": "(function name) Return the absolute value of ``x``." + }, + "math.fabs.summary": { + "message": "Gibt den absoluten Wert von {{x}} zurück.", + "description": "Return the absolute value of ``x``." + }, + "math.fabs.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.fabs.param-doc.x": { + "message": "Eine Zahl", + "description": "Parameter docs" + }, + "math.floor": { + "message": "floor", + "description": "(function name) Round a number towards negative infinity." + }, + "math.floor.summary": { + "message": "Rundet eine Zahl in Richtung negativer Unendlichkeit.", + "description": "Round a number towards negative infinity." + }, + "math.floor.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.floor.param-doc.x": { + "message": "Eine Zahl", + "description": "Parameter docs" + }, + "math.fmod": { + "message": "fmod", + "description": "(function name) Calculate the remainder of ``x/y``." + }, + "math.fmod.summary": { + "message": "Berechne den Rest von {{x/y}}.", + "description": "Calculate the remainder of ``x/y``." + }, + "math.fmod.param-name.x": { + "message": "x", + "description": "(parameter name) The numerator" + }, + "math.fmod.param-doc.x": { + "message": "Der Zähler", + "description": "Parameter docs" + }, + "math.fmod.param-name.y": { + "message": "y", + "description": "(parameter name) The denominator" + }, + "math.fmod.param-doc.y": { + "message": "Der Nenner", + "description": "Parameter docs" + }, + "math.frexp": { + "message": "frexp", + "description": "(function name) Decomposes a floating-point number into its mantissa and exponent." + }, + "math.frexp.summary": { + "message": "Zerlegt eine Gleitkommazahl in ihre Mantisse und ihren Exponenten.", + "description": "Decomposes a floating-point number into its mantissa and exponent." + }, + "math.frexp.param-name.x": { + "message": "x", + "description": "(parameter name) A floating-point number" + }, + "math.frexp.param-doc.x": { + "message": "Eine Fließkommazahl", + "description": "Parameter docs" + }, + "math.isfinite": { + "message": "isfinite", + "description": "(function name) Check if a value is finite." + }, + "math.isfinite.summary": { + "message": "Überprüft, ob ein Wert endlich ist.", + "description": "Check if a value is finite." + }, + "math.isfinite.param-name.x": { + "message": "x", + "description": "(parameter name) A number." + }, + "math.isfinite.param-doc.x": { + "message": "Eine Zahl.", + "description": "Parameter docs" + }, + "math.isinf": { + "message": "isinf", + "description": "(function name) Check if a value is infinite." + }, + "math.isinf.summary": { + "message": "Überprüft, ob ein Wert unendlich ist.", + "description": "Check if a value is infinite." + }, + "math.isinf.param-name.x": { + "message": "x", + "description": "(parameter name) A number." + }, + "math.isinf.param-doc.x": { + "message": "Eine Zahl.", + "description": "Parameter docs" + }, + "math.isnan": { + "message": "isnan", + "description": "(function name) Check if a value is not-a-number (NaN)." + }, + "math.isnan.summary": { + "message": "Prüft, ob ein Wert keine Zahl (NaN ... Not A Number) ist.", + "description": "Check if a value is not-a-number (NaN)." + }, + "math.isnan.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.isnan.param-doc.x": { + "message": "Eine Zahl", + "description": "Parameter docs" + }, + "math.ldexp": { + "message": "ldexp", + "description": "(function name) Calculate ``x * (2**exp)``." + }, + "math.ldexp.summary": { + "message": "Berechne {{x * (2**exp)}}.", + "description": "Calculate ``x * (2**exp)``." + }, + "math.ldexp.param-name.exp": { + "message": "exp", + "description": "(parameter name) Integer exponent" + }, + "math.ldexp.param-doc.exp": { + "message": "Ganzzahl-Exponent", + "description": "Parameter docs" + }, + "math.ldexp.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.ldexp.param-doc.x": { + "message": "Eine Zahl", + "description": "Parameter docs" + }, + "math.log": { + "message": "log", + "description": "(function name) Calculate the logarithm of ``x`` to the given base (defaults to natural logorithm)." + }, + "math.log.summary": { + "message": "Berechnet den Logarithmus von {{x}} zur angegebenen Basis (standardmäßig den natürlichen Logarithmus).", + "description": "Calculate the logarithm of ``x`` to the given base (defaults to natural logorithm)." + }, + "math.log.param-name.base": { + "message": "base", + "description": "(parameter name) The base to use" + }, + "math.log.param-doc.base": { + "message": "Die zu verwendende Basis", + "description": "Parameter docs" + }, + "math.log.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.log.param-doc.x": { + "message": "Eine Zahl", + "description": "Parameter docs" + }, + "math.modf": { + "message": "modf", + "description": "(function name) Calculate the fractional and integral parts of ``x``." + }, + "math.modf.summary": { + "message": "Berechne die gebrochenen und ganzzahligen Teile von {{x}}.", + "description": "Calculate the fractional and integral parts of ``x``." + }, + "math.modf.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.modf.param-doc.x": { + "message": "Eine Zahl", + "description": "Parameter docs" + }, + "math.pow": { + "message": "pow", + "description": "(function name) Returns ``x`` to the power of ``y``." + }, + "math.pow.summary": { + "message": "Gibt {{x}} hoch {{y}} zurück.", + "description": "Returns ``x`` to the power of ``y``." + }, + "math.pow.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.pow.param-doc.x": { + "message": "Eine Zahl", + "description": "Parameter docs" + }, + "math.pow.param-name.y": { + "message": "y", + "description": "(parameter name) The exponent" + }, + "math.pow.param-doc.y": { + "message": "Der Exponent", + "description": "Parameter docs" + }, + "math.radians": { + "message": "radians", + "description": "(function name) Convert a degrees to radians." + }, + "math.radians.summary": { + "message": "Wandelt Grad in Bogenmaß (Radiant) um.", + "description": "Convert a degrees to radians." + }, + "math.radians.param-name.x": { + "message": "x", + "description": "(parameter name) A value in degrees" + }, + "math.radians.param-doc.x": { + "message": "Ein Wert in Grad", + "description": "Parameter docs" + }, + "math.sin": { + "message": "sin", + "description": "(function name) Calculate the sine of ``x``." + }, + "math.sin.summary": { + "message": "Berechnet den Sinus von {{x}}.", + "description": "Calculate the sine of ``x``." + }, + "math.sin.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.sin.param-doc.x": { + "message": "Eine Zahl", + "description": "Parameter docs" + }, + "math.sqrt": { + "message": "sqrt", + "description": "(function name) Calculate the square root of ``x``." + }, + "math.sqrt.summary": { + "message": "Berechnet die Quadratwurzel von {{x}}.", + "description": "Calculate the square root of ``x``." + }, + "math.sqrt.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.sqrt.param-doc.x": { + "message": "Eine Zahl", + "description": "Parameter docs" + }, + "math.tan": { + "message": "tan", + "description": "(function name) Calculate the tangent of ``x``." + }, + "math.tan.summary": { + "message": "Berechnet den Tangens von {{x}}.", + "description": "Calculate the tangent of ``x``." + }, + "math.tan.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.tan.param-doc.x": { + "message": "Eine Zahl", + "description": "Parameter docs" + }, + "math.trunc": { + "message": "trunc", + "description": "(function name) Round a number towards 0." + }, + "math.trunc.summary": { + "message": "Rundet eine Zahl gegen 0 ab.", + "description": "Round a number towards 0." + }, + "math.trunc.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.trunc.param-doc.x": { + "message": "Eine Zahl", + "description": "Parameter docs" + }, + "math.e": { + "message": "e", + "description": "(field name) Base of the natural logarithm" + }, + "math.e.summary": { + "message": "Basis des natürlichen Logarithmus", + "description": "Base of the natural logarithm" + }, + "math.pi": { + "message": "pi", + "description": "(field name) The ratio of a circle's circumference to its diameter" + }, + "math.pi.summary": { + "message": "Das Verhältnis des Umfangs eines Kreises zu seinem Durchmesser", + "description": "The ratio of a circle's circumference to its diameter" + }, + "microbit": { + "message": "microbit", + "description": "(module name) Pins, images, sounds, temperature and volume." + }, + "microbit.summary": { + "message": "Pins, Bilder, Töne, Temperatur und Lautstärke.", + "description": "Pins, images, sounds, temperature and volume." + }, + "microbit.run_every": { + "message": "run every", + "description": "(function name) Schedule to run a function at the interval specified by the time arguments **V2 only**." + }, + "microbit.run_every.summary": { + "message": "Plant die Ausführung einer Funktion in dem durch die Zeitargumente festgelegten Intervall **nur V2**.", + "description": "Schedule to run a function at the interval specified by the time arguments **V2 only**." + }, + "microbit.run_every.param-name.callback": { + "message": "callback", + "description": "(parameter name) Function to call at the provided interval. Omit when using as a decorator." + }, + "microbit.run_every.param-doc.callback": { + "message": "Funktion, die in dem angegebenen Intervall aufgerufen wird. Bei Verwendung als Dekorator weglassen.", + "description": "Parameter docs" + }, + "microbit.run_every.param-name.days": { + "message": "tage", + "description": "(parameter name) Sets the day mark for the scheduling." + }, + "microbit.run_every.param-doc.days": { + "message": "Legt den Tag für die Planung fest.", + "description": "Parameter docs" + }, + "microbit.run_every.param-name.h": { + "message": "h", + "description": "(parameter name) Sets the hour mark for the scheduling." + }, + "microbit.run_every.param-doc.h": { + "message": "Legt die Uhrzeit für die Planung fest.", + "description": "Parameter docs" + }, + "microbit.run_every.param-name.min": { + "message": "min", + "description": "(parameter name) Sets the minute mark for the scheduling." + }, + "microbit.run_every.param-doc.min": { + "message": "Legt die Minute für die Planung fest.", + "description": "Parameter docs" + }, + "microbit.run_every.param-name.ms": { + "message": "ms", + "description": "(parameter name) Sets the millisecond mark for the scheduling." + }, + "microbit.run_every.param-doc.ms": { + "message": "Legt die Millisekunde für die Planung fest.", + "description": "Parameter docs" + }, + "microbit.run_every.param-name.s": { + "message": "s", + "description": "(parameter name) Sets the second mark for the scheduling." + }, + "microbit.run_every.param-doc.s": { + "message": "Legt die Sekunde für die Planung fest.", + "description": "Parameter docs" + }, + "microbit.panic": { + "message": "panic", + "description": "(function name) Enter a panic mode." + }, + "microbit.panic.summary": { + "message": "In einen Panik-Modus gehen.", + "description": "Enter a panic mode." + }, + "microbit.panic.param-name.n": { + "message": "n", + "description": "(parameter name) An arbitrary integer <= 255 to indicate a status." + }, + "microbit.panic.param-doc.n": { + "message": "Eine beliebige ganze Zahl <= 255, um einen Status anzugeben.", + "description": "Parameter docs" + }, + "microbit.reset": { + "message": "reset", + "description": "(function name) Restart the board." + }, + "microbit.reset.summary": { + "message": "Board neu starten.", + "description": "Restart the board." + }, + "microbit.scale-1": { + "message": "scale", + "description": "(function name) Converts a value from a range to an integer range." + }, + "microbit.scale-1.summary": { + "message": "Konvertiert einen Wert aus einem Bereich in einen Ganzzahlenbereich.", + "description": "Converts a value from a range to an integer range." + }, + "microbit.scale-1.param-name.from_": { + "message": "from", + "description": "(parameter name) A tuple to define the range to convert from." + }, + "microbit.scale-1.param-doc.from_": { + "message": "Ein Tupel, das den Bereich definiert, aus dem konvertiert werden soll.", + "description": "Parameter docs" + }, + "microbit.scale-1.param-name.to": { + "message": "to", + "description": "(parameter name) A tuple to define the range to convert to." + }, + "microbit.scale-1.param-doc.to": { + "message": "Ein Tupel, das den Bereich definiert, in den konvertiert werden soll.", + "description": "Parameter docs" + }, + "microbit.scale-1.param-name.value": { + "message": "wert", + "description": "(parameter name) A number to convert." + }, + "microbit.scale-1.param-doc.value": { + "message": "Eine umzurechnende Zahl.", + "description": "Parameter docs" + }, + "microbit.scale-2": { + "message": "scale", + "description": "(function name) Converts a value from a range to a floating point range." + }, + "microbit.scale-2.summary": { + "message": "Konvertiert einen Wert von einem Bereich in einen Gleitkommabereich.", + "description": "Converts a value from a range to a floating point range." + }, + "microbit.scale-2.param-name.from_": { + "message": "from", + "description": "(parameter name) A tuple to define the range to convert from." + }, + "microbit.scale-2.param-doc.from_": { + "message": "Ein Tupel, das den Bereich definiert, aus dem konvertiert werden soll.", + "description": "Parameter docs" + }, + "microbit.scale-2.param-name.to": { + "message": "to", + "description": "(parameter name) A tuple to define the range to convert to." + }, + "microbit.scale-2.param-doc.to": { + "message": "Ein Tupel, das den Bereich definiert, in den konvertiert werden soll.", + "description": "Parameter docs" + }, + "microbit.scale-2.param-name.value": { + "message": "wert", + "description": "(parameter name) A number to convert." + }, + "microbit.scale-2.param-doc.value": { + "message": "Eine umzurechnende Zahl.", + "description": "Parameter docs" + }, + "microbit.sleep": { + "message": "sleep", + "description": "(function name) Wait for ``n`` milliseconds." + }, + "microbit.sleep.summary": { + "message": "Warte auf {{n}} Millisekunden.", + "description": "Wait for ``n`` milliseconds." + }, + "microbit.sleep.param-name.n": { + "message": "n", + "description": "(parameter name) The number of milliseconds to wait" + }, + "microbit.sleep.param-doc.n": { + "message": "Die Anzahl der zu wartenden Millisekunden", + "description": "Parameter docs" + }, + "microbit.running_time": { + "message": "running time", + "description": "(function name) Get the running time of the board." + }, + "microbit.running_time.summary": { + "message": "Ermittelt die Laufzeit des Boards.", + "description": "Get the running time of the board." + }, + "microbit.temperature": { + "message": "temperature", + "description": "(function name) Get the temperature of the micro:bit in degrees Celsius." + }, + "microbit.temperature.summary": { + "message": "Ermittelt die Temperatur des micro:bit in Grad Celcius.", + "description": "Get the temperature of the micro:bit in degrees Celsius." + }, + "microbit.set_volume": { + "message": "set volume", + "description": "(function name) Sets the volume." + }, + "microbit.set_volume.summary": { + "message": "Legt die Lautstärke fest.", + "description": "Sets the volume." + }, + "microbit.set_volume.param-name.v": { + "message": "v", + "description": "(parameter name) a value between 0 (low) and 255 (high)." + }, + "microbit.set_volume.param-doc.v": { + "message": "ein Wert zwischen 0 (niedrig) und 255 (hoch).", + "description": "Parameter docs" + }, + "microbit.Button": { + "message": "button", + "description": "(class name) The class for the buttons ``button_a`` and ``button_b``." + }, + "microbit.Button.summary": { + "message": "Die Klasse für die Tasten {{button_a}} und {{button_b}}.", + "description": "The class for the buttons ``button_a`` and ``button_b``." + }, + "microbit.Button.is_pressed": { + "message": "is pressed", + "description": "(function name) Check if the button is pressed." + }, + "microbit.Button.is_pressed.summary": { + "message": "Überprüft, ob die Taste gedrückt ist.", + "description": "Check if the button is pressed." + }, + "microbit.Button.was_pressed": { + "message": "was pressed", + "description": "(function name) Check if the button was pressed since the device started or the last time this method was called." + }, + "microbit.Button.was_pressed.summary": { + "message": "Überprüft, ob die Taste seit dem Start des Geräts oder dem letzten Aufruf dieser Methode gedrückt wurde.", + "description": "Check if the button was pressed since the device started or the last time this method was called." + }, + "microbit.Button.get_presses": { + "message": "get presses", + "description": "(function name) Get the running total of button presses, and resets this total\nto zero before returning." + }, + "microbit.Button.get_presses.summary": { + "message": "Ermittelt die Gesamtzahl der Tastendrücke und setzt diese Summe auf Null zurück, bevor sie zurückgegeben wird.", + "description": "Get the running total of button presses, and resets this total\nto zero before returning." + }, + "microbit.button_a": { + "message": "button a", + "description": "(field name) The left button ``Button`` object." + }, + "microbit.button_a.summary": { + "message": "Das {{Button}}-Objekt der linken Taste.", + "description": "The left button ``Button`` object." + }, + "microbit.button_b": { + "message": "button b", + "description": "(field name) The right button ``Button`` object." + }, + "microbit.button_b.summary": { + "message": "Das {{Button}}-Objekt der rechten Taste.", + "description": "The right button ``Button`` object." + }, + "microbit.MicroBitDigitalPin": { + "message": "microbitdigitalpin", + "description": "(class name) A digital pin." + }, + "microbit.MicroBitDigitalPin.summary": { + "message": "Ein digitaler Pin.", + "description": "A digital pin." + }, + "microbit.MicroBitDigitalPin.read_digital": { + "message": "read digital", + "description": "(function name) Get the digital value of the pin." + }, + "microbit.MicroBitDigitalPin.read_digital.summary": { + "message": "Ermittelt den digitalen Wert des Pins.", + "description": "Get the digital value of the pin." + }, + "microbit.MicroBitDigitalPin.write_digital": { + "message": "digital schreiben", + "description": "(function name) Set the digital value of the pin." + }, + "microbit.MicroBitDigitalPin.write_digital.summary": { + "message": "Stellt den digitalen Wert des Pins ein.", + "description": "Set the digital value of the pin." + }, + "microbit.MicroBitDigitalPin.write_digital.param-name.value": { + "message": "wert", + "description": "(parameter name) 1 to set the pin high or 0 to set the pin low" + }, + "microbit.MicroBitDigitalPin.write_digital.param-doc.value": { + "message": "1, um den Pin zu aktivieren, oder 0, um den Pin zu deaktivieren", + "description": "Parameter docs" + }, + "microbit.MicroBitDigitalPin.set_pull": { + "message": "setze Pull-Widerstand", + "description": "(function name) Set the pull state to one of three possible values: ``PULL_UP``, ``PULL_DOWN`` or ``NO_PULL``." + }, + "microbit.MicroBitDigitalPin.set_pull.summary": { + "message": "Setze den Status des Pull-Widerstands auf einen von drei möglichen Werten: {{PULL_UP}}, {{PULL_DOWN}} oder {{NO_PULL}}.", + "description": "Set the pull state to one of three possible values: ``PULL_UP``, ``PULL_DOWN`` or ``NO_PULL``." + }, + "microbit.MicroBitDigitalPin.set_pull.param-name.value": { + "message": "wert", + "description": "(parameter name) The pull state from the relevant pin, e.g. ``pin0.PULL_UP``." + }, + "microbit.MicroBitDigitalPin.set_pull.param-doc.value": { + "message": "Der Status des Pull-Widerstands vom relevanten Pin, z.B. {{pin0.PULL_UP}}.", + "description": "Parameter docs" + }, + "microbit.MicroBitDigitalPin.get_pull": { + "message": "gib Pull-Widerstand", + "description": "(function name) Get the pull state on a pin." + }, + "microbit.MicroBitDigitalPin.get_pull.summary": { + "message": "Abrufen des Status des Pull-Widerstands eines Pins.", + "description": "Get the pull state on a pin." + }, + "microbit.MicroBitDigitalPin.get_mode": { + "message": "gib Pin-Modus", + "description": "(function name) Returns the pin mode." + }, + "microbit.MicroBitDigitalPin.get_mode.summary": { + "message": "Gibt den Pin-Modus zurück.", + "description": "Returns the pin mode." + }, + "microbit.MicroBitDigitalPin.write_analog": { + "message": "analog schreiben", + "description": "(function name) Output a PWM signal on the pin, with the duty cycle proportional to ``value``." + }, + "microbit.MicroBitDigitalPin.write_analog.summary": { + "message": "Erzeugt ein PWM-Signal am Pin mit der Einschaltdauer proportional zu {{value}}.", + "description": "Output a PWM signal on the pin, with the duty cycle proportional to ``value``." + }, + "microbit.MicroBitDigitalPin.write_analog.param-name.value": { + "message": "wert", + "description": "(parameter name) An integer or a floating point number between 0 (0% duty cycle) and 1023 (100% duty)." + }, + "microbit.MicroBitDigitalPin.write_analog.param-doc.value": { + "message": "Eine Ganzzahl oder eine Gleitpunktzahl zwischen 0 (0% Einschaltdauer) und 1023 (100% Einschaltdauer).", + "description": "Parameter docs" + }, + "microbit.MicroBitDigitalPin.set_analog_period": { + "message": "setze analoge Periodendauer", + "description": "(function name) Set the period of the PWM signal being output to ``period`` in milliseconds." + }, + "microbit.MicroBitDigitalPin.set_analog_period.summary": { + "message": "Setzt die Periodendauer des PWM-Signals, das ausgegeben wird, auf {{period}} in Millisekunden.", + "description": "Set the period of the PWM signal being output to ``period`` in milliseconds." + }, + "microbit.MicroBitDigitalPin.set_analog_period.param-name.period": { + "message": "Periodendauer", + "description": "(parameter name) The period in milliseconds with a minimum valid value of 1ms." + }, + "microbit.MicroBitDigitalPin.set_analog_period.param-doc.period": { + "message": "Der Periodendauer in Millisekunden mit einem Mindestwert von 1ms.", + "description": "Parameter docs" + }, + "microbit.MicroBitDigitalPin.set_analog_period_microseconds": { + "message": "setze analoge Periodendauer", + "description": "(function name) Set the period of the PWM signal being output to ``period`` in microseconds." + }, + "microbit.MicroBitDigitalPin.set_analog_period_microseconds.summary": { + "message": "Setze die Periodendauer für die Ausgabe des PWM-Signals auf {{period}} in Mikrosekunden.", + "description": "Set the period of the PWM signal being output to ``period`` in microseconds." + }, + "microbit.MicroBitDigitalPin.set_analog_period_microseconds.param-name.period": { + "message": "Periodendauer", + "description": "(parameter name) The period in microseconds with a minimum valid value of 256µs." + }, + "microbit.MicroBitDigitalPin.set_analog_period_microseconds.param-doc.period": { + "message": "Die Periodendauer in Mikrosekunden mit einem Mindestwert von 256μs.", + "description": "Parameter docs" + }, + "microbit.MicroBitAnalogDigitalPin": { + "message": "microbitanalogdigitalpin", + "description": "(class name) A pin with analog and digital features." + }, + "microbit.MicroBitAnalogDigitalPin.summary": { + "message": "Ein Pin, der analogen und digitalen Signale erlaubt.", + "description": "A pin with analog and digital features." + }, + "microbit.MicroBitAnalogDigitalPin.read_analog": { + "message": "analog lesen", + "description": "(function name) Read the voltage applied to the pin." + }, + "microbit.MicroBitAnalogDigitalPin.read_analog.summary": { + "message": "Einlesen der Spannung, die am Pin anliegt.", + "description": "Read the voltage applied to the pin." + }, + "microbit.MicroBitTouchPin": { + "message": "microbittouchpin", + "description": "(class name) A pin with analog, digital and touch features." + }, + "microbit.MicroBitTouchPin.summary": { + "message": "Ein Pin mit analogen, digitalen und Touchfunktionen.", + "description": "A pin with analog, digital and touch features." + }, + "microbit.MicroBitTouchPin.is_touched": { + "message": "wird berührt", + "description": "(function name) Check if the pin is being touched." + }, + "microbit.MicroBitTouchPin.is_touched.summary": { + "message": "Überprüft, ob der Pin berührt wird.", + "description": "Check if the pin is being touched." + }, + "microbit.MicroBitTouchPin.set_touch_mode": { + "message": "definiert Berührungsmodus", + "description": "(function name) Set the touch mode for the pin." + }, + "microbit.MicroBitTouchPin.set_touch_mode.summary": { + "message": "Legt den Touchmodus für den Pin fest.", + "description": "Set the touch mode for the pin." + }, + "microbit.MicroBitTouchPin.set_touch_mode.param-name.value": { + "message": "wert", + "description": "(parameter name) ``CAPACITIVE`` or ``RESISTIVE`` from the relevant pin." + }, + "microbit.MicroBitTouchPin.set_touch_mode.param-doc.value": { + "message": "{{CAPACITIVE}} oder {{RESISTIVE}} Touchmodus des entsprechenden Pins.", + "description": "Parameter docs" + }, + "microbit.pin0": { + "message": "pin0", + "description": "(field name) Pin with digital, analog and touch features." + }, + "microbit.pin0.summary": { + "message": "Pin mit digitalen, analogen und Touchfunktionen.", + "description": "Pin with digital, analog and touch features." + }, + "microbit.pin1": { + "message": "pin1", + "description": "(field name) Pin with digital, analog and touch features." + }, + "microbit.pin1.summary": { + "message": "Pin mit digitalen, analogen und Touchfunktionen.", + "description": "Pin with digital, analog and touch features." + }, + "microbit.pin2": { + "message": "pin2", + "description": "(field name) Pin with digital, analog and touch features." + }, + "microbit.pin2.summary": { + "message": "Pin mit digitalen, analogen und Touchfunktionen.", + "description": "Pin with digital, analog and touch features." + }, + "microbit.pin3": { + "message": "pin3", + "description": "(field name) Pin with digital and analog features." + }, + "microbit.pin3.summary": { + "message": "Pin mit digitalen und analogen Funktionen.", + "description": "Pin with digital and analog features." + }, + "microbit.pin4": { + "message": "pin4", + "description": "(field name) Pin with digital and analog features." + }, + "microbit.pin4.summary": { + "message": "Pin mit digitalen und analogen Funktionen.", + "description": "Pin with digital and analog features." + }, + "microbit.pin5": { + "message": "pin5", + "description": "(field name) Pin with digital features." + }, + "microbit.pin5.summary": { + "message": "Pin mit Unterstützung für digitale Signale.", + "description": "Pin with digital features." + }, + "microbit.pin6": { + "message": "pin6", + "description": "(field name) Pin with digital features." + }, + "microbit.pin6.summary": { + "message": "Pin mit Unterstützung für digitale Signale.", + "description": "Pin with digital features." + }, + "microbit.pin7": { + "message": "pin7", + "description": "(field name) Pin with digital features." + }, + "microbit.pin7.summary": { + "message": "Pin mit digitalen Funktionen.", + "description": "Pin with digital features." + }, + "microbit.pin8": { + "message": "pin8", + "description": "(field name) Pin with digital features." + }, + "microbit.pin8.summary": { + "message": "Pin mit digitalen Funktionen.", + "description": "Pin with digital features." + }, + "microbit.pin9": { + "message": "pin9", + "description": "(field name) Pin with digital features." + }, + "microbit.pin9.summary": { + "message": "Pin mit digitalen Funktionen.", + "description": "Pin with digital features." + }, + "microbit.pin10": { + "message": "pin10", + "description": "(field name) Pin with digital and analog features." + }, + "microbit.pin10.summary": { + "message": "Pin mit digitalen und analogen Funktionen.", + "description": "Pin with digital and analog features." + }, + "microbit.pin11": { + "message": "pin11", + "description": "(field name) Pin with digital features." + }, + "microbit.pin11.summary": { + "message": "Pin mit digitalen Funktionen.", + "description": "Pin with digital features." + }, + "microbit.pin12": { + "message": "pin12", + "description": "(field name) Pin with digital features." + }, + "microbit.pin12.summary": { + "message": "Pin mit digitalen Funktionen.", + "description": "Pin with digital features." + }, + "microbit.pin13": { + "message": "pin13", + "description": "(field name) Pin with digital features." + }, + "microbit.pin13.summary": { + "message": "Pin mit digitalen Funktionen.", + "description": "Pin with digital features." + }, + "microbit.pin14": { + "message": "pin14", + "description": "(field name) Pin with digital features." + }, + "microbit.pin14.summary": { + "message": "Pin mit digitalen Funktionen.", + "description": "Pin with digital features." + }, + "microbit.pin15": { + "message": "pin15", + "description": "(field name) Pin with digital features." + }, + "microbit.pin15.summary": { + "message": "Pin mit digitalen Funktionen.", + "description": "Pin with digital features." + }, + "microbit.pin16": { + "message": "pin16", + "description": "(field name) Pin with digital features." + }, + "microbit.pin16.summary": { + "message": "Pin mit digitalen Funktionen.", + "description": "Pin with digital features." + }, + "microbit.pin19": { + "message": "pin19", + "description": "(field name) Pin with digital features." + }, + "microbit.pin19.summary": { + "message": "Pin mit digitalen Funktionen.", + "description": "Pin with digital features." + }, + "microbit.pin20": { + "message": "pin20", + "description": "(field name) Pin with digital features." + }, + "microbit.pin20.summary": { + "message": "Pin mit digitalen Funktionen.", + "description": "Pin with digital features." + }, + "microbit.pin_logo": { + "message": "pin logo", + "description": "(field name) A touch sensitive logo pin on the front of the micro:bit, which by default is set to capacitive touch mode." + }, + "microbit.pin_logo.summary": { + "message": "Ein berührungsempfindlicher Logo-Pin auf der Vorderseite des micro:bit, der standardmäßig auf den kapazitiven Touch-Modus eingestellt ist.", + "description": "A touch sensitive logo pin on the front of the micro:bit, which by default is set to capacitive touch mode." + }, + "microbit.pin_speaker": { + "message": "pin speaker", + "description": "(field name) A pin to address the micro:bit speaker." + }, + "microbit.pin_speaker.summary": { + "message": "Ein Pin zur Ansteuerung des micro:bit Lautsprechers.", + "description": "A pin to address the micro:bit speaker." + }, + "microbit.Image": { + "message": "image", + "description": "(class name) An image to show on the micro:bit LED display." + }, + "microbit.Image.summary": { + "message": "Ein Bild, das auf dem micro:bit LED-Display angezeigt werden soll.", + "description": "An image to show on the micro:bit LED display." + }, + "microbit.Image.HEART": { + "message": "heart", + "description": "(field name) Heart image." + }, + "microbit.Image.HEART.summary": { + "message": "Herz-Bild.", + "description": "Heart image." + }, + "microbit.Image.HEART_SMALL": { + "message": "heart small", + "description": "(field name) Small heart image." + }, + "microbit.Image.HEART_SMALL.summary": { + "message": "Kleines Herz-Bild.", + "description": "Small heart image." + }, + "microbit.Image.HAPPY": { + "message": "happy", + "description": "(field name) Happy face image." + }, + "microbit.Image.HAPPY.summary": { + "message": "Glückliches Gesichtsbild.", + "description": "Happy face image." + }, + "microbit.Image.SMILE": { + "message": "smile", + "description": "(field name) Smiling face image." + }, + "microbit.Image.SMILE.summary": { + "message": "Lächelndes Gesichtsbild.", + "description": "Smiling face image." + }, + "microbit.Image.SAD": { + "message": "sad", + "description": "(field name) Sad face image." + }, + "microbit.Image.SAD.summary": { + "message": "Trauriges Gesichtsbild.", + "description": "Sad face image." + }, + "microbit.Image.CONFUSED": { + "message": "confused", + "description": "(field name) Confused face image." + }, + "microbit.Image.CONFUSED.summary": { + "message": "Verwirrtes Gesichtsbild.", + "description": "Confused face image." + }, + "microbit.Image.ANGRY": { + "message": "angry", + "description": "(field name) Angry face image." + }, + "microbit.Image.ANGRY.summary": { + "message": "Wütendes Gesichtsbild.", + "description": "Angry face image." + }, + "microbit.Image.ASLEEP": { + "message": "asleep", + "description": "(field name) Sleeping face image." + }, + "microbit.Image.ASLEEP.summary": { + "message": "Schlafendes Gesichtsbild.", + "description": "Sleeping face image." + }, + "microbit.Image.SURPRISED": { + "message": "surprised", + "description": "(field name) Surprised face image." + }, + "microbit.Image.SURPRISED.summary": { + "message": "Überraschtes Gesichtsbild.", + "description": "Surprised face image." + }, + "microbit.Image.SILLY": { + "message": "silly", + "description": "(field name) Silly face image." + }, + "microbit.Image.SILLY.summary": { + "message": "Albernes Gesichtsbild.", + "description": "Silly face image." + }, + "microbit.Image.FABULOUS": { + "message": "fabelhaft", + "description": "(field name) Sunglasses face image." + }, + "microbit.Image.FABULOUS.summary": { + "message": "Bild mit Sonnenbrillengesicht.", + "description": "Sunglasses face image." + }, + "microbit.Image.MEH": { + "message": "meh", + "description": "(field name) Unimpressed face image." + }, + "microbit.Image.MEH.summary": { + "message": "Gleichgültiges Gesicht Bild.", + "description": "Unimpressed face image." + }, + "microbit.Image.YES": { + "message": "yes", + "description": "(field name) Tick image." + }, + "microbit.Image.YES.summary": { + "message": "abgehakt-Bild", + "description": "Tick image." + }, + "microbit.Image.NO": { + "message": "no", + "description": "(field name) Cross image." + }, + "microbit.Image.NO.summary": { + "message": "angekreuzt-Bild", + "description": "Cross image." + }, + "microbit.Image.CLOCK12": { + "message": "clock12", + "description": "(field name) Image with line pointing to 12 o'clock." + }, + "microbit.Image.CLOCK12.summary": { + "message": "Bild mit Linie, die auf 12 Uhr zeigt.", + "description": "Image with line pointing to 12 o'clock." + }, + "microbit.Image.CLOCK11": { + "message": "clock11", + "description": "(field name) Image with line pointing to 11 o'clock." + }, + "microbit.Image.CLOCK11.summary": { + "message": "Bild mit Linie, die auf 11 Uhr zeigt.", + "description": "Image with line pointing to 11 o'clock." + }, + "microbit.Image.CLOCK10": { + "message": "clock10", + "description": "(field name) Image with line pointing to 10 o'clock." + }, + "microbit.Image.CLOCK10.summary": { + "message": "Bild mit Linie, die auf 10 Uhr zeigt.", + "description": "Image with line pointing to 10 o'clock." + }, + "microbit.Image.CLOCK9": { + "message": "clock9", + "description": "(field name) Image with line pointing to 9 o'clock." + }, + "microbit.Image.CLOCK9.summary": { + "message": "Bild mit Linie, die auf 9 Uhr zeigt.", + "description": "Image with line pointing to 9 o'clock." + }, + "microbit.Image.CLOCK8": { + "message": "clock8", + "description": "(field name) Image with line pointing to 8 o'clock." + }, + "microbit.Image.CLOCK8.summary": { + "message": "Bild mit Linie, die auf 8 Uhr zeigt.", + "description": "Image with line pointing to 8 o'clock." + }, + "microbit.Image.CLOCK7": { + "message": "clock7", + "description": "(field name) Image with line pointing to 7 o'clock." + }, + "microbit.Image.CLOCK7.summary": { + "message": "Bild mit Linie, die auf 7 Uhr zeigt.", + "description": "Image with line pointing to 7 o'clock." + }, + "microbit.Image.CLOCK6": { + "message": "clock6", + "description": "(field name) Image with line pointing to 6 o'clock." + }, + "microbit.Image.CLOCK6.summary": { + "message": "Bild mit Linie, die auf 6 Uhr zeigt.", + "description": "Image with line pointing to 6 o'clock." + }, + "microbit.Image.CLOCK5": { + "message": "clock5", + "description": "(field name) Image with line pointing to 5 o'clock." + }, + "microbit.Image.CLOCK5.summary": { + "message": "Bild mit Linie, die auf 5 Uhr zeigt.", + "description": "Image with line pointing to 5 o'clock." + }, + "microbit.Image.CLOCK4": { + "message": "clock4", + "description": "(field name) Image with line pointing to 4 o'clock." + }, + "microbit.Image.CLOCK4.summary": { + "message": "Bild mit Linie, die auf 4 Uhr zeigt.", + "description": "Image with line pointing to 4 o'clock." + }, + "microbit.Image.CLOCK3": { + "message": "clock3", + "description": "(field name) Image with line pointing to 3 o'clock." + }, + "microbit.Image.CLOCK3.summary": { + "message": "Bild mit Linie, die auf 3 Uhr zeigt.", + "description": "Image with line pointing to 3 o'clock." + }, + "microbit.Image.CLOCK2": { + "message": "clock2", + "description": "(field name) Image with line pointing to 2 o'clock." + }, + "microbit.Image.CLOCK2.summary": { + "message": "Bild mit Linie, die auf 2 Uhr zeigt.", + "description": "Image with line pointing to 2 o'clock." + }, + "microbit.Image.CLOCK1": { + "message": "clock1", + "description": "(field name) Image with line pointing to 1 o'clock." + }, + "microbit.Image.CLOCK1.summary": { + "message": "Bild mit Linie, die auf 1 Uhr zeigt.", + "description": "Image with line pointing to 1 o'clock." + }, + "microbit.Image.ARROW_N": { + "message": "arrow n", + "description": "(field name) Image of arrow pointing north." + }, + "microbit.Image.ARROW_N.summary": { + "message": "Bild eines Pfeils, der nach Norden zeigt.", + "description": "Image of arrow pointing north." + }, + "microbit.Image.ARROW_NE": { + "message": "arrow ne", + "description": "(field name) Image of arrow pointing north east." + }, + "microbit.Image.ARROW_NE.summary": { + "message": "Bild eines Pfeils, der nach Nordosten zeigt.", + "description": "Image of arrow pointing north east." + }, + "microbit.Image.ARROW_E": { + "message": "arrow e", + "description": "(field name) Image of arrow pointing east." + }, + "microbit.Image.ARROW_E.summary": { + "message": "Bild eines Pfeils, der nach Osten zeigt.", + "description": "Image of arrow pointing east." + }, + "microbit.Image.ARROW_SE": { + "message": "arrow se", + "description": "(field name) Image of arrow pointing south east." + }, + "microbit.Image.ARROW_SE.summary": { + "message": "Bild eines Pfeils, der nach Südosten zeigt.", + "description": "Image of arrow pointing south east." + }, + "microbit.Image.ARROW_S": { + "message": "arrow s", + "description": "(field name) Image of arrow pointing south." + }, + "microbit.Image.ARROW_S.summary": { + "message": "Bild eines Pfeils, der nach Süden zeigt.", + "description": "Image of arrow pointing south." + }, + "microbit.Image.ARROW_SW": { + "message": "arrow sw", + "description": "(field name) Image of arrow pointing south west." + }, + "microbit.Image.ARROW_SW.summary": { + "message": "Bild eines Pfeils, der nach Südwesten zeigt.", + "description": "Image of arrow pointing south west." + }, + "microbit.Image.ARROW_W": { + "message": "arrow w", + "description": "(field name) Image of arrow pointing west." + }, + "microbit.Image.ARROW_W.summary": { + "message": "Bild eines Pfeils, der nach Westen zeigt.", + "description": "Image of arrow pointing west." + }, + "microbit.Image.ARROW_NW": { + "message": "arrow nw", + "description": "(field name) Image of arrow pointing north west." + }, + "microbit.Image.ARROW_NW.summary": { + "message": "Bild eines Pfeils, der nach Nordwesten zeigt.", + "description": "Image of arrow pointing north west." + }, + "microbit.Image.TRIANGLE": { + "message": "triangle", + "description": "(field name) Image of a triangle pointing up." + }, + "microbit.Image.TRIANGLE.summary": { + "message": "Bild eines Dreiecks, das nach oben zeigt.", + "description": "Image of a triangle pointing up." + }, + "microbit.Image.TRIANGLE_LEFT": { + "message": "triangle left", + "description": "(field name) Image of a triangle in the left corner." + }, + "microbit.Image.TRIANGLE_LEFT.summary": { + "message": "Bild eines Dreiecks in der linken Ecke.", + "description": "Image of a triangle in the left corner." + }, + "microbit.Image.CHESSBOARD": { + "message": "chessboard", + "description": "(field name) Alternate LEDs lit in a chessboard pattern." + }, + "microbit.Image.CHESSBOARD.summary": { + "message": "Abwechselnd leuchtende LEDs in einem Schachbrettmuster.", + "description": "Alternate LEDs lit in a chessboard pattern." + }, + "microbit.Image.DIAMOND": { + "message": "diamond", + "description": "(field name) Diamond image." + }, + "microbit.Image.DIAMOND.summary": { + "message": "Diamant-Bild.", + "description": "Diamond image." + }, + "microbit.Image.DIAMOND_SMALL": { + "message": "diamond small", + "description": "(field name) Small diamond image." + }, + "microbit.Image.DIAMOND_SMALL.summary": { + "message": "Kleines Diamant-Bild.", + "description": "Small diamond image." + }, + "microbit.Image.SQUARE": { + "message": "square", + "description": "(field name) Square image." + }, + "microbit.Image.SQUARE.summary": { + "message": "Quadrat-Bild", + "description": "Square image." + }, + "microbit.Image.SQUARE_SMALL": { + "message": "square small", + "description": "(field name) Small square image." + }, + "microbit.Image.SQUARE_SMALL.summary": { + "message": "Kleines Quadrat-Bild.", + "description": "Small square image." + }, + "microbit.Image.RABBIT": { + "message": "rabbit", + "description": "(field name) Rabbit image." + }, + "microbit.Image.RABBIT.summary": { + "message": "Kaninchen-Bild.", + "description": "Rabbit image." + }, + "microbit.Image.COW": { + "message": "cow", + "description": "(field name) Cow image." + }, + "microbit.Image.COW.summary": { + "message": "Kuh-Bild.", + "description": "Cow image." + }, + "microbit.Image.MUSIC_CROTCHET": { + "message": "music crotchet", + "description": "(field name) Crotchet note image." + }, + "microbit.Image.MUSIC_CROTCHET.summary": { + "message": "Viertelnoten-Bild.", + "description": "Crotchet note image." + }, + "microbit.Image.MUSIC_QUAVER": { + "message": "music quaver", + "description": "(field name) Quaver note image." + }, + "microbit.Image.MUSIC_QUAVER.summary": { + "message": "Achtelnoten-Bild.", + "description": "Quaver note image." + }, + "microbit.Image.MUSIC_QUAVERS": { + "message": "music quavers", + "description": "(field name) Pair of quavers note image." + }, + "microbit.Image.MUSIC_QUAVERS.summary": { + "message": "Achtelnotenpaar-Bild.", + "description": "Pair of quavers note image." + }, + "microbit.Image.PITCHFORK": { + "message": "pitchfork", + "description": "(field name) Pitchfork image." + }, + "microbit.Image.PITCHFORK.summary": { + "message": "Heugabel-Bild", + "description": "Pitchfork image." + }, + "microbit.Image.XMAS": { + "message": "xmas", + "description": "(field name) Christmas tree image." + }, + "microbit.Image.XMAS.summary": { + "message": "Weihnachtsbaum-Bild.", + "description": "Christmas tree image." + }, + "microbit.Image.PACMAN": { + "message": "pacman", + "description": "(field name) Pac-Man arcade character image." + }, + "microbit.Image.PACMAN.summary": { + "message": "Pac-Man Spielfigurenbild.", + "description": "Pac-Man arcade character image." + }, + "microbit.Image.TARGET": { + "message": "target", + "description": "(field name) Target image." + }, + "microbit.Image.TARGET.summary": { + "message": "Ziel-Bild", + "description": "Target image." + }, + "microbit.Image.TSHIRT": { + "message": "tshirt", + "description": "(field name) T-shirt image." + }, + "microbit.Image.TSHIRT.summary": { + "message": "T-Shirt-Bild.", + "description": "T-shirt image." + }, + "microbit.Image.ROLLERSKATE": { + "message": "rollerskate", + "description": "(field name) Rollerskate image." + }, + "microbit.Image.ROLLERSKATE.summary": { + "message": "Rollerskate-Bild.", + "description": "Rollerskate image." + }, + "microbit.Image.DUCK": { + "message": "duck", + "description": "(field name) Duck image." + }, + "microbit.Image.DUCK.summary": { + "message": "Ente-Bild", + "description": "Duck image." + }, + "microbit.Image.HOUSE": { + "message": "house", + "description": "(field name) House image." + }, + "microbit.Image.HOUSE.summary": { + "message": "Haus-Bild", + "description": "House image." + }, + "microbit.Image.TORTOISE": { + "message": "tortoise", + "description": "(field name) Tortoise image." + }, + "microbit.Image.TORTOISE.summary": { + "message": "Schildkröte-Bild", + "description": "Tortoise image." + }, + "microbit.Image.BUTTERFLY": { + "message": "butterfly", + "description": "(field name) Butterfly image." + }, + "microbit.Image.BUTTERFLY.summary": { + "message": "Schmetterling-Bild.", + "description": "Butterfly image." + }, + "microbit.Image.STICKFIGURE": { + "message": "stickfigure", + "description": "(field name) Stick figure image." + }, + "microbit.Image.STICKFIGURE.summary": { + "message": "Strichmännchen-Bild.", + "description": "Stick figure image." + }, + "microbit.Image.GHOST": { + "message": "ghost", + "description": "(field name) Ghost image." + }, + "microbit.Image.GHOST.summary": { + "message": "Geist-Bild.", + "description": "Ghost image." + }, + "microbit.Image.SWORD": { + "message": "sword", + "description": "(field name) Sword image." + }, + "microbit.Image.SWORD.summary": { + "message": "Schwert-Bild", + "description": "Sword image." + }, + "microbit.Image.GIRAFFE": { + "message": "giraffe", + "description": "(field name) Giraffe image." + }, + "microbit.Image.GIRAFFE.summary": { + "message": "Giraffe-Bild.", + "description": "Giraffe image." + }, + "microbit.Image.SKULL": { + "message": "skull", + "description": "(field name) Skull image." + }, + "microbit.Image.SKULL.summary": { + "message": "Schädel-Bild.", + "description": "Skull image." + }, + "microbit.Image.UMBRELLA": { + "message": "umbrella", + "description": "(field name) Umbrella image." + }, + "microbit.Image.UMBRELLA.summary": { + "message": "Bild eines Schirms.", + "description": "Umbrella image." + }, + "microbit.Image.SNAKE": { + "message": "Schlange", + "description": "(field name) Snake image." + }, + "microbit.Image.SNAKE.summary": { + "message": "Bild einer Schlange.", + "description": "Snake image." + }, + "microbit.Image.SCISSORS": { + "message": "Schere", + "description": "(field name) Scissors image." + }, + "microbit.Image.SCISSORS.summary": { + "message": "BIld einer Schere.", + "description": "Scissors image." + }, + "microbit.Image.ALL_CLOCKS": { + "message": "alle Uhren", + "description": "(field name) A list containing all the CLOCK_ images in sequence." + }, + "microbit.Image.ALL_CLOCKS.summary": { + "message": "Eine Liste mit allen CLOCK_ Bildern.", + "description": "A list containing all the CLOCK_ images in sequence." + }, + "microbit.Image.ALL_ARROWS": { + "message": "alle Pfeile", + "description": "(field name) A list containing all the ARROW_ images in sequence." + }, + "microbit.Image.ALL_ARROWS.summary": { + "message": "Eine Liste mit allen ARROW_ Bildern.", + "description": "A list containing all the ARROW_ images in sequence." + }, + "microbit.Image.__init__-1": { + "message": "init", + "description": "(function name) Create an image from a string describing which LEDs are lit." + }, + "microbit.Image.__init__-1.summary": { + "message": "Erstellen Sie ein Bild aus einer Zeichenkette, die beschreibt, welche LEDs leuchten.", + "description": "Create an image from a string describing which LEDs are lit." + }, + "microbit.Image.__init__-1.param-name.string": { + "message": "Zeichenkette", + "description": "(parameter name) The string describing the image." + }, + "microbit.Image.__init__-1.param-doc.string": { + "message": "Eine Zeichenkette, die das Bild beschreibt.", + "description": "Parameter docs" + }, + "microbit.Image.__init__-2": { + "message": "init", + "description": "(function name) Create an empty image with ``width`` columns and ``height`` rows." + }, + "microbit.Image.__init__-2.summary": { + "message": "Erstelle ein leeres Bild mit {{width}} Spalten und {{height}} Zeilen.", + "description": "Create an empty image with ``width`` columns and ``height`` rows." + }, + "microbit.Image.__init__-2.param-name.buffer": { + "message": "Puffer", + "description": "(parameter name) Optional array or bytes of ``width``×``height`` integers in range 0-9 to initialize the image" + }, + "microbit.Image.__init__-2.param-doc.buffer": { + "message": "Optionales Array oder Bytes von {{width}}×{{height}} Ganzzahlen im Bereich 0-9 um das Bild zu initialisieren", + "description": "Parameter docs" + }, + "microbit.Image.__init__-2.param-name.height": { + "message": "Höhe", + "description": "(parameter name) Optional height of the image" + }, + "microbit.Image.__init__-2.param-doc.height": { + "message": "Optionale Höhe des Bildes", + "description": "Parameter docs" + }, + "microbit.Image.__init__-2.param-name.width": { + "message": "Breite", + "description": "(parameter name) Optional width of the image" + }, + "microbit.Image.__init__-2.param-doc.width": { + "message": "Optionale Breite des Bildes", + "description": "Parameter docs" + }, + "microbit.Image.width": { + "message": "Breite", + "description": "(function name) Get the number of columns." + }, + "microbit.Image.width.summary": { + "message": "Ermittelt die Anzahl der Spalten.", + "description": "Get the number of columns." + }, + "microbit.Image.height": { + "message": "Höhe", + "description": "(function name) Get the number of rows." + }, + "microbit.Image.height.summary": { + "message": "Ermittelt die Anzahl der Zeilen.", + "description": "Get the number of rows." + }, + "microbit.Image.set_pixel": { + "message": "Pixelwerte setzen", + "description": "(function name) Set the brightness of a pixel." + }, + "microbit.Image.set_pixel.summary": { + "message": "Legt die Helligkeit eines Pixels fest.", + "description": "Set the brightness of a pixel." + }, + "microbit.Image.set_pixel.param-name.value": { + "message": "wert", + "description": "(parameter name) The brightness as an integer between 0 (dark) and 9 (bright)" + }, + "microbit.Image.set_pixel.param-doc.value": { + "message": "Die Helligkeit als Ganzzahl zwischen 0 (dunkel) und 9 (hell)", + "description": "Parameter docs" + }, + "microbit.Image.set_pixel.param-name.x": { + "message": "x", + "description": "(parameter name) The column number" + }, + "microbit.Image.set_pixel.param-doc.x": { + "message": "Die Spaltennummer", + "description": "Parameter docs" + }, + "microbit.Image.set_pixel.param-name.y": { + "message": "y", + "description": "(parameter name) The row number" + }, + "microbit.Image.set_pixel.param-doc.y": { + "message": "Die Zeilennummer", + "description": "Parameter docs" + }, + "microbit.Image.get_pixel": { + "message": "Pixelwerte holen", + "description": "(function name) Get the brightness of a pixel." + }, + "microbit.Image.get_pixel.summary": { + "message": "Ermittle die Helligkeit eines Pixels.", + "description": "Get the brightness of a pixel." + }, + "microbit.Image.get_pixel.param-name.x": { + "message": "x", + "description": "(parameter name) The column number" + }, + "microbit.Image.get_pixel.param-doc.x": { + "message": "Die Spaltennummer", + "description": "Parameter docs" + }, + "microbit.Image.get_pixel.param-name.y": { + "message": "y", + "description": "(parameter name) The row number" + }, + "microbit.Image.get_pixel.param-doc.y": { + "message": "Die Zeilennummer", + "description": "Parameter docs" + }, + "microbit.Image.shift_left": { + "message": "links verschieben", + "description": "(function name) Create a new image by shifting the picture left." + }, + "microbit.Image.shift_left.summary": { + "message": "Erstellen Sie ein neues Bild, indem Sie das Bild nach links verschieben.", + "description": "Create a new image by shifting the picture left." + }, + "microbit.Image.shift_left.param-name.n": { + "message": "n", + "description": "(parameter name) The number of columns to shift by" + }, + "microbit.Image.shift_left.param-doc.n": { + "message": "Die Anzahl der Spalten um die verschoben wird", + "description": "Parameter docs" + }, + "microbit.Image.shift_right": { + "message": "rechts verschieben", + "description": "(function name) Create a new image by shifting the picture right." + }, + "microbit.Image.shift_right.summary": { + "message": "Erstellen Sie ein neues Bild, indem Sie das Bild nach rechts verschieben.", + "description": "Create a new image by shifting the picture right." + }, + "microbit.Image.shift_right.param-name.n": { + "message": "n", + "description": "(parameter name) The number of columns to shift by" + }, + "microbit.Image.shift_right.param-doc.n": { + "message": "Die Anzahl der Spalten um die verschoben wird", + "description": "Parameter docs" + }, + "microbit.Image.shift_up": { + "message": "nach oben verschieben", + "description": "(function name) Create a new image by shifting the picture up." + }, + "microbit.Image.shift_up.summary": { + "message": "Erstellen Sie ein neues Bild, indem Sie das Bild nach oben verschoben wird.", + "description": "Create a new image by shifting the picture up." + }, + "microbit.Image.shift_up.param-name.n": { + "message": "n", + "description": "(parameter name) The number of rows to shift by" + }, + "microbit.Image.shift_up.param-doc.n": { + "message": "Die Anzahl der Zeilen um die verschoben wird", + "description": "Parameter docs" + }, + "microbit.Image.shift_down": { + "message": "nach unten verschieben", + "description": "(function name) Create a new image by shifting the picture down." + }, + "microbit.Image.shift_down.summary": { + "message": "Erstellen Sie ein neues Bild, indem Sie das Bild nach unten verschoben wird.", + "description": "Create a new image by shifting the picture down." + }, + "microbit.Image.shift_down.param-name.n": { + "message": "n", + "description": "(parameter name) The number of rows to shift by" + }, + "microbit.Image.shift_down.param-doc.n": { + "message": "Die Anzahl der Zeilen um die verschoben wird", + "description": "Parameter docs" + }, + "microbit.Image.crop": { + "message": "crop", + "description": "(function name) Create a new image by cropping the picture." + }, + "microbit.Image.crop.summary": { + "message": "Erstellen Sie ein neues Bild, indem das Bild zugeschnitten wird.", + "description": "Create a new image by cropping the picture." + }, + "microbit.Image.crop.param-name.h": { + "message": "h", + "description": "(parameter name) The crop height" + }, + "microbit.Image.crop.param-doc.h": { + "message": "Die Zuschneide-Höhe", + "description": "Parameter docs" + }, + "microbit.Image.crop.param-name.w": { + "message": "w", + "description": "(parameter name) The crop width" + }, + "microbit.Image.crop.param-doc.w": { + "message": "Die Zuschneide-Breite", + "description": "Parameter docs" + }, + "microbit.Image.crop.param-name.x": { + "message": "x", + "description": "(parameter name) The crop offset column" + }, + "microbit.Image.crop.param-doc.x": { + "message": "Die Offset-Spalte des Zuschneidens", + "description": "Parameter docs" + }, + "microbit.Image.crop.param-name.y": { + "message": "y", + "description": "(parameter name) The crop offset row" + }, + "microbit.Image.crop.param-doc.y": { + "message": "Die Offset-Zeile des Zuschneidens", + "description": "Parameter docs" + }, + "microbit.Image.copy": { + "message": "kopieren", + "description": "(function name) Create an exact copy of the image." + }, + "microbit.Image.copy.summary": { + "message": "Erstellt eine exakte Kopie des Bildes.", + "description": "Create an exact copy of the image." + }, + "microbit.Image.invert": { + "message": "invert", + "description": "(function name) Create a new image by inverting the brightness of the pixels in the\nsource image." + }, + "microbit.Image.invert.summary": { + "message": "Erstellt ein neues Bild, indem es die Helligkeit der Pixel des Ausgangsbildes invertiert.", + "description": "Create a new image by inverting the brightness of the pixels in the\nsource image." + }, + "microbit.Image.fill": { + "message": "fill", + "description": "(function name) Set the brightness of all the pixels in the image." + }, + "microbit.Image.fill.summary": { + "message": "Legt die Helligkeit für alle Pixel des Bildes fest.", + "description": "Set the brightness of all the pixels in the image." + }, + "microbit.Image.fill.param-name.value": { + "message": "value", + "description": "(parameter name) The new brightness as a number between 0 (dark) and 9 (bright)." + }, + "microbit.Image.fill.param-doc.value": { + "message": "Die neue Helligkeit als Zahl zwischen 0 (dunkel) und 9 (hell).", + "description": "Parameter docs" + }, + "microbit.Image.blit": { + "message": "blit", + "description": "(function name) Copy an area from another image into this image." + }, + "microbit.Image.blit.summary": { + "message": "Kopiert einen Bereich aus einem anderen Bild in dieses Bild.", + "description": "Copy an area from another image into this image." + }, + "microbit.Image.blit.param-name.h": { + "message": "h", + "description": "(parameter name) The number of rows to copy" + }, + "microbit.Image.blit.param-doc.h": { + "message": "Die Anzahl der zu kopierenden Zeilen", + "description": "Parameter docs" + }, + "microbit.Image.blit.param-name.src": { + "message": "src", + "description": "(parameter name) The source image" + }, + "microbit.Image.blit.param-doc.src": { + "message": "Das Ausgangsbild", + "description": "Parameter docs" + }, + "microbit.Image.blit.param-name.w": { + "message": "w", + "description": "(parameter name) The number of columns to copy" + }, + "microbit.Image.blit.param-doc.w": { + "message": "Die Anzahl der zu kopierenden Spalten", + "description": "Parameter docs" + }, + "microbit.Image.blit.param-name.x": { + "message": "x", + "description": "(parameter name) The starting column offset in the source image" + }, + "microbit.Image.blit.param-doc.x": { + "message": "Der Anfangsspalten-Offset im Ausgangsbild", + "description": "Parameter docs" + }, + "microbit.Image.blit.param-name.xdest": { + "message": "xdest", + "description": "(parameter name) The column offset to modify in this image" + }, + "microbit.Image.blit.param-doc.xdest": { + "message": "Der Spalten-Offset, der in diesem Bild geändert werden soll", + "description": "Parameter docs" + }, + "microbit.Image.blit.param-name.y": { + "message": "y", + "description": "(parameter name) The starting row offset in the source image" + }, + "microbit.Image.blit.param-doc.y": { + "message": "Der Anfangszeilen-Offset im Ausgangsbild", + "description": "Parameter docs" + }, + "microbit.Image.blit.param-name.ydest": { + "message": "ydest", + "description": "(parameter name) The row offset to modify in this image" + }, + "microbit.Image.blit.param-doc.ydest": { + "message": "Der Zeilen-Offset, der in diesem Bild geändert werden soll", + "description": "Parameter docs" + }, + "microbit.Image.__repr__": { + "message": "repr", + "description": "(function name) Get a compact string representation of the image." + }, + "microbit.Image.__repr__.summary": { + "message": "Liefert eine kompakte Stringrepräsentation des Bildes.", + "description": "Get a compact string representation of the image." + }, + "microbit.Image.__str__": { + "message": "str", + "description": "(function name) Get a readable string representation of the image." + }, + "microbit.Image.__str__.summary": { + "message": "Liefert eine lesbare String-Repräsentation des Bildes.", + "description": "Get a readable string representation of the image." + }, + "microbit.Image.__add__": { + "message": "add", + "description": "(function name) Create a new image by adding the brightness values from the two\nimages for each pixel." + }, + "microbit.Image.__add__.summary": { + "message": "Erstellt ein neues Bild, indem für jedes Pixel die Helligkeitswerte der beiden Bilder addiert werden.", + "description": "Create a new image by adding the brightness values from the two\nimages for each pixel." + }, + "microbit.Image.__add__.param-name.other": { + "message": "other", + "description": "(parameter name) The image to add." + }, + "microbit.Image.__add__.param-doc.other": { + "message": "Das zu addierende Bild.", + "description": "Parameter docs" + }, + "microbit.Image.__sub__": { + "message": "sub", + "description": "(function name) Create a new image by subtracting the brightness values of the\nother image from this image." + }, + "microbit.Image.__sub__.summary": { + "message": "Erstellt ein neues Bild, indem für jedes Pixel die Helligkeitswerte der beiden Bilder subtrahiert werden.", + "description": "Create a new image by subtracting the brightness values of the\nother image from this image." + }, + "microbit.Image.__sub__.param-name.other": { + "message": "other", + "description": "(parameter name) The image to subtract." + }, + "microbit.Image.__sub__.param-doc.other": { + "message": "Das zu subtrahierende Bild.", + "description": "Parameter docs" + }, + "microbit.Image.__mul__": { + "message": "mul", + "description": "(function name) Create a new image by multiplying the brightness of each pixel by\n``n``." + }, + "microbit.Image.__mul__.summary": { + "message": "Erstellt ein neues Bild, indem der Helligkeitswert jedes Pixels mit {{n}} multipliziert wird.", + "description": "Create a new image by multiplying the brightness of each pixel by\n``n``." + }, + "microbit.Image.__mul__.param-name.n": { + "message": "n", + "description": "(parameter name) The value to multiply by." + }, + "microbit.Image.__mul__.param-doc.n": { + "message": "Der Wert, mit dem multipliziert werden soll.", + "description": "Parameter docs" + }, + "microbit.Image.__truediv__": { + "message": "truediv", + "description": "(function name) Create a new image by dividing the brightness of each pixel by\n``n``." + }, + "microbit.Image.__truediv__.summary": { + "message": "Erstellt ein neues Bild, indem der Helligkeitswert jedes Pixels durch {{n}} dividiert wird.", + "description": "Create a new image by dividing the brightness of each pixel by\n``n``." + }, + "microbit.Image.__truediv__.param-name.n": { + "message": "n", + "description": "(parameter name) The value to divide by." + }, + "microbit.Image.__truediv__.param-doc.n": { + "message": "Der Wert, durch den dividiert werden soll.", + "description": "Parameter docs" + }, + "microbit.SoundEvent.LOUD": { + "message": "loud", + "description": "(field name) Represents the transition of sound events, from ``quiet`` to ``loud`` like clapping or shouting." + }, + "microbit.SoundEvent.LOUD.summary": { + "message": "Stellt den Übergang von Klangereignissen von {{quiet}} auf {{loud}} dar; wie beim Klatschen oder Rufen.", + "description": "Represents the transition of sound events, from ``quiet`` to ``loud`` like clapping or shouting." + }, + "microbit.SoundEvent.QUIET": { + "message": "stumm", + "description": "(field name) Represents the transition of sound events, from ``loud`` to ``quiet`` like speaking or background music." + }, + "microbit.SoundEvent.QUIET.summary": { + "message": "Stellt den Übergang von akustischen Ereignissen, wie Sprechen oder Hintergrundmusik, von {{loud}} zu {{quiet}} dar.", + "description": "Represents the transition of sound events, from ``loud`` to ``quiet`` like speaking or background music." + }, + "microbit.Sound": { + "message": "sound", + "description": "(class name) The built-in sounds can be called using ``audio.play(Sound.NAME)``." + }, + "microbit.Sound.summary": { + "message": "Die eingebauten Klänge können mit {{audio.play(Sound.NAME)}} aufgerufen werden.", + "description": "The built-in sounds can be called using ``audio.play(Sound.NAME)``." + }, + "microbit.Sound.GIGGLE": { + "message": "giggle", + "description": "(field name) Giggling sound." + }, + "microbit.Sound.GIGGLE.summary": { + "message": "Kichern-Sound.", + "description": "Giggling sound." + }, + "microbit.Sound.HAPPY": { + "message": "happy", + "description": "(field name) Happy sound." + }, + "microbit.Sound.HAPPY.summary": { + "message": "Happy-Sound.", + "description": "Happy sound." + }, + "microbit.Sound.HELLO": { + "message": "hello", + "description": "(field name) Greeting sound." + }, + "microbit.Sound.HELLO.summary": { + "message": "Begrüßung-Sound", + "description": "Greeting sound." + }, + "microbit.Sound.MYSTERIOUS": { + "message": "mysterious", + "description": "(field name) Mysterious sound." + }, + "microbit.Sound.MYSTERIOUS.summary": { + "message": "Geheimnisvoll-Sound", + "description": "Mysterious sound." + }, + "microbit.Sound.SAD": { + "message": "sad", + "description": "(field name) Sad sound." + }, + "microbit.Sound.SAD.summary": { + "message": "Traurig-Sound.", + "description": "Sad sound." + }, + "microbit.Sound.SLIDE": { + "message": "slide", + "description": "(field name) Sliding sound." + }, + "microbit.Sound.SLIDE.summary": { + "message": "Gleitender Ton.", + "description": "Sliding sound." + }, + "microbit.Sound.SOARING": { + "message": "aufsteigend", + "description": "(field name) Soaring sound." + }, + "microbit.Sound.SOARING.summary": { + "message": "Aufsteigender Klang.", + "description": "Soaring sound." + }, + "microbit.Sound.SPRING": { + "message": "Sppringfeder", + "description": "(field name) Spring sound." + }, + "microbit.Sound.SPRING.summary": { + "message": "Springfeder Klang", + "description": "Spring sound." + }, + "microbit.Sound.TWINKLE": { + "message": "Funkeln", + "description": "(field name) Twinkling sound." + }, + "microbit.Sound.TWINKLE.summary": { + "message": "Funkeln Klang", + "description": "Twinkling sound." + }, + "microbit.Sound.YAWN": { + "message": "yawn", + "description": "(field name) Yawning sound." + }, + "microbit.Sound.YAWN.summary": { + "message": "Gähnen Klang", + "description": "Yawning sound." + }, + "microbit.accelerometer": { + "message": "Beschleunigungssensor", + "description": "(module name) Measure the acceleration of the micro:bit and recognise gestures." + }, + "microbit.accelerometer.summary": { + "message": "Messen Sie die Beschleunigung des micro:bit und erkennen Sie Gesten.", + "description": "Measure the acceleration of the micro:bit and recognise gestures." + }, + "microbit.accelerometer.get_x": { + "message": "erhalte x", + "description": "(function name) Get the acceleration measurement in the ``x`` axis in milli-g." + }, + "microbit.accelerometer.get_x.summary": { + "message": "Erhalte die Beschleunigungsmessung in der {{x}} -Achse in Milli-g.", + "description": "Get the acceleration measurement in the ``x`` axis in milli-g." + }, + "microbit.accelerometer.get_y": { + "message": "erhalte y", + "description": "(function name) Get the acceleration measurement in the ``y`` axis in milli-g." + }, + "microbit.accelerometer.get_y.summary": { + "message": "Erhalte die Beschleunigungsmessung in der {{y}} -Achse in Milli-g.", + "description": "Get the acceleration measurement in the ``y`` axis in milli-g." + }, + "microbit.accelerometer.get_z": { + "message": "erhalte z", + "description": "(function name) Get the acceleration measurement in the ``z`` axis in milli-g." + }, + "microbit.accelerometer.get_z.summary": { + "message": "Erhalte die Beschleunigungsmessung in der {{z}} -Achse in Milli-g.", + "description": "Get the acceleration measurement in the ``z`` axis in milli-g." + }, + "microbit.accelerometer.get_values": { + "message": "Werte erhalten", + "description": "(function name) Get the acceleration measurements in all axes at once as a tuple." + }, + "microbit.accelerometer.get_values.summary": { + "message": "Erhalten Sie die Beschleunigungsmessungen in allen Achsen auf einmal als Tupel.", + "description": "Get the acceleration measurements in all axes at once as a tuple." + }, + "microbit.accelerometer.get_strength": { + "message": "erhalte Stärke", + "description": "(function name) Get the acceleration measurement of all axes combined, as a positive integer. This is the Pythagorean sum of the X, Y and Z axes." + }, + "microbit.accelerometer.get_strength.summary": { + "message": "Erhalte die Beschleunigungsmessung aller Achsen als positive Ganzzahl. Dies ist die euklidische Summe der X-, Y- und Z-Achsen.", + "description": "Get the acceleration measurement of all axes combined, as a positive integer. This is the Pythagorean sum of the X, Y and Z axes." + }, + "microbit.accelerometer.current_gesture": { + "message": "derzeitige Geste", + "description": "(function name) Get the name of the current gesture." + }, + "microbit.accelerometer.current_gesture.summary": { + "message": "Erhalte den Namen der aktuellen Geste.", + "description": "Get the name of the current gesture." + }, + "microbit.accelerometer.is_gesture": { + "message": "ist Geste", + "description": "(function name) Check if the named gesture is currently active." + }, + "microbit.accelerometer.is_gesture.summary": { + "message": "Überprüft, ob die benannte Geste derzeit aktiv ist.", + "description": "Check if the named gesture is currently active." + }, + "microbit.accelerometer.is_gesture.param-name.name": { + "message": "name", + "description": "(parameter name) The gesture name." + }, + "microbit.accelerometer.is_gesture.param-doc.name": { + "message": "Der Name der Geste.", + "description": "Parameter docs" + }, + "microbit.accelerometer.was_gesture": { + "message": "war Geste", + "description": "(function name) Check if the named gesture was active since the last call." + }, + "microbit.accelerometer.was_gesture.summary": { + "message": "Überprüft, ob die benannte Geste seit dem letzten Aufruf aktiv war.", + "description": "Check if the named gesture was active since the last call." + }, + "microbit.accelerometer.was_gesture.param-name.name": { + "message": "name", + "description": "(parameter name) The gesture name." + }, + "microbit.accelerometer.was_gesture.param-doc.name": { + "message": "Der Name der Geste.", + "description": "Parameter docs" + }, + "microbit.accelerometer.get_gestures": { + "message": "erhalte Gesten", + "description": "(function name) Return a tuple of the gesture history." + }, + "microbit.accelerometer.get_gestures.summary": { + "message": "Gibt ein Tupel der vergangenen Gesten zurück.", + "description": "Return a tuple of the gesture history." + }, + "microbit.accelerometer.set_range": { + "message": "Bereich einstellen", + "description": "(function name) Set the accelerometer sensitivity range, in g (standard gravity), to the closest values supported by the hardware, so it rounds to either ``2``, ``4``, or ``8`` g." + }, + "microbit.accelerometer.set_range.summary": { + "message": "Legen Sie den Bereich des Beschleunigungsmessers in g (Fallbeschleunigung) auf den nächstgelegenen Wert fest, welcher von der Hardware unterstützt wird. Diese sind {{2}}, {{4}}oder {{8}} g.", + "description": "Set the accelerometer sensitivity range, in g (standard gravity), to the closest values supported by the hardware, so it rounds to either ``2``, ``4``, or ``8`` g." + }, + "microbit.accelerometer.set_range.param-name.value": { + "message": "wert", + "description": "(parameter name) New range for the accelerometer, an integer in ``g``." + }, + "microbit.accelerometer.set_range.param-doc.value": { + "message": "Neuer Bereich für den Beschleunigungssensor, eine Ganzzahl in {{g}}.", + "description": "Parameter docs" + }, + "microbit.audio": { + "message": "Audio", + "description": "(module name) Play sounds using the micro:bit (import ``audio`` for V1 compatibility)." + }, + "microbit.audio.summary": { + "message": "Töne mit dem micro:bit abspielen (Importiere {{audio}} für V1-Kompatibilität).", + "description": "Play sounds using the micro:bit (import ``audio`` for V1 compatibility)." + }, + "microbit.audio.play": { + "message": "play", + "description": "(function name) Play a built-in sound, sound effect or custom audio frames." + }, + "microbit.audio.play.summary": { + "message": "Wiedergeben eines eingebauten Sounds, Soundeffekts oder benutzerdefinierten Aufnahme .", + "description": "Play a built-in sound, sound effect or custom audio frames." + }, + "microbit.audio.play.param-name.pin": { + "message": "pin", + "description": "(parameter name) An optional argument to specify the output pin can be used to override the default of ``pin0``. If we do not want any sound to play we can use ``pin=None``." + }, + "microbit.audio.play.param-doc.pin": { + "message": "Ein optionales Argument für den Ausgabepin kann angegeben werden, um die Standardeinstellung von {{pin0}}zu überschreiben. Wenn kein Ton wiedergegeben werden soll, kann {{pin=None}} verwendet werden.", + "description": "Parameter docs" + }, + "microbit.audio.play.param-name.return_pin": { + "message": "erhalte Pin", + "description": "(parameter name) Specifies a differential edge connector pin to connect to an external speaker instead of ground. This is ignored for the **V2** revision." + }, + "microbit.audio.play.param-doc.return_pin": { + "message": "Bestimmt einen Pin, mit dem der externen Lautsprecher anstatt mit Ground verbunden wird. Dies wird bei der **V2** Revision ignoriert.", + "description": "Parameter docs" + }, + "microbit.audio.play.param-name.source": { + "message": "Quelle", + "description": "(parameter name) A built-in ``Sound`` such as ``Sound.GIGGLE``, a ``SoundEffect`` or sample data as an iterable of ``AudioFrame`` objects." + }, + "microbit.audio.play.param-doc.source": { + "message": "Ein eingebauter {{Sound}} wie {{Sound.GIGGLE}}, ein {{SoundEffect}} oder Beispieldaten als Teil eines {{AudioFrame}} Objekts.", + "description": "Parameter docs" + }, + "microbit.audio.play.param-name.wait": { + "message": "wait", + "description": "(parameter name) If ``wait`` is ``True``, this function will block until the sound is complete." + }, + "microbit.audio.play.param-doc.wait": { + "message": "Wenn {{wait}} {{True}} ist, wird diese Funktion blockiert, bis der Klang abgeschlossen ist.", + "description": "Parameter docs" + }, + "microbit.audio.is_playing": { + "message": "spielt gerade", + "description": "(function name) Check whether a sound is playing." + }, + "microbit.audio.is_playing.summary": { + "message": "Überprüfen Sie, ob ein Ton abgespielt wird.", + "description": "Check whether a sound is playing." + }, + "microbit.audio.stop": { + "message": "Stop", + "description": "(function name) Stop all audio playback." + }, + "microbit.audio.stop.summary": { + "message": "Stoppe jede Audio-Wiedergabe.", + "description": "Stop all audio playback." + }, + "microbit.audio.SoundEffect": { + "message": "soundeffect", + "description": "(class name) A sound effect, composed by a set of parameters configured via the constructor or attributes." + }, + "microbit.audio.SoundEffect.summary": { + "message": "Ein Soundeffekt, zusammengestellt aus einer Reihe von Parametern, die über den Konstruktor oder durch Attribute konfiguriert werden.", + "description": "A sound effect, composed by a set of parameters configured via the constructor or attributes." + }, + "microbit.audio.SoundEffect.WAVEFORM_SINE": { + "message": "Sinuswelle", + "description": "(field name) Sine wave option used for the ``waveform`` parameter." + }, + "microbit.audio.SoundEffect.WAVEFORM_SINE.summary": { + "message": "Sinuswelle als Parameter für {{waveform}}.", + "description": "Sine wave option used for the ``waveform`` parameter." + }, + "microbit.audio.SoundEffect.WAVEFORM_SAWTOOTH": { + "message": "Sägezahnkurve", + "description": "(field name) Sawtooth wave option used for the ``waveform`` parameter." + }, + "microbit.audio.SoundEffect.WAVEFORM_SAWTOOTH.summary": { + "message": "Sägezahnkurve als Parameter für {{waveform}}.", + "description": "Sawtooth wave option used for the ``waveform`` parameter." + }, + "microbit.audio.SoundEffect.WAVEFORM_TRIANGLE": { + "message": "Dreiecksignal", + "description": "(field name) Triangle wave option used for the ``waveform`` parameter." + }, + "microbit.audio.SoundEffect.WAVEFORM_TRIANGLE.summary": { + "message": "Dreiecksignal als Parameter für {{waveform}}.", + "description": "Triangle wave option used for the ``waveform`` parameter." + }, + "microbit.audio.SoundEffect.WAVEFORM_SQUARE": { + "message": "Rechtecksignal", + "description": "(field name) Square wave option used for the ``waveform`` parameter." + }, + "microbit.audio.SoundEffect.WAVEFORM_SQUARE.summary": { + "message": "Rechtecksignal als Parameter für {{waveform}}.", + "description": "Square wave option used for the ``waveform`` parameter." + }, + "microbit.audio.SoundEffect.WAVEFORM_NOISE": { + "message": "Rauschsignal", + "description": "(field name) Noise option used for the ``waveform`` parameter." + }, + "microbit.audio.SoundEffect.WAVEFORM_NOISE.summary": { + "message": "Rauschsignal als Parameter für {{waveform}}.", + "description": "Noise option used for the ``waveform`` parameter." + }, + "microbit.audio.SoundEffect.SHAPE_LINEAR": { + "message": "lineare Interpolation", + "description": "(field name) Linear interpolation option used for the ``shape`` parameter." + }, + "microbit.audio.SoundEffect.SHAPE_LINEAR.summary": { + "message": "Lineare Interpolation als Parameter für {{shape}}.", + "description": "Linear interpolation option used for the ``shape`` parameter." + }, + "microbit.audio.SoundEffect.SHAPE_CURVE": { + "message": "geschwungene Kurve", + "description": "(field name) Curve interpolation option used for the ``shape`` parameter." + }, + "microbit.audio.SoundEffect.SHAPE_CURVE.summary": { + "message": "Kurven-Interpolation als Parameter für {{shape}}.", + "description": "Curve interpolation option used for the ``shape`` parameter." + }, + "microbit.audio.SoundEffect.SHAPE_LOG": { + "message": "logarithmische Interpolation", + "description": "(field name) Logarithmic interpolation option used for the ``shape`` parameter." + }, + "microbit.audio.SoundEffect.SHAPE_LOG.summary": { + "message": "Logarithmische Interpolation als Parameter für {{shape}}.", + "description": "Logarithmic interpolation option used for the ``shape`` parameter." + }, + "microbit.audio.SoundEffect.FX_NONE": { + "message": "kein fx", + "description": "(field name) No effect option used for the ``fx`` parameter." + }, + "microbit.audio.SoundEffect.FX_NONE.summary": { + "message": "Kein Effekt für {{fx}} verwendet.", + "description": "No effect option used for the ``fx`` parameter." + }, + "microbit.audio.SoundEffect.FX_TREMOLO": { + "message": "fx Tremolo", + "description": "(field name) Tremolo effect option used for the ``fx`` parameter." + }, + "microbit.audio.SoundEffect.FX_TREMOLO.summary": { + "message": "Tremelo-Effekt als Parameter für {{fx}}.", + "description": "Tremolo effect option used for the ``fx`` parameter." + }, + "microbit.audio.SoundEffect.FX_VIBRATO": { + "message": "fx Vibrato", + "description": "(field name) Vibrato effect option used for the ``fx`` parameter." + }, + "microbit.audio.SoundEffect.FX_VIBRATO.summary": { + "message": "Vibrato-Effekt als Parameter für {{fx}}.", + "description": "Vibrato effect option used for the ``fx`` parameter." + }, + "microbit.audio.SoundEffect.FX_WARBLE": { + "message": "fx Trillereffekt", + "description": "(field name) Warble effect option used for the ``fx`` parameter." + }, + "microbit.audio.SoundEffect.FX_WARBLE.summary": { + "message": "Triller-Effekt als Parameter für {{fx}}.", + "description": "Warble effect option used for the ``fx`` parameter." + }, + "microbit.audio.SoundEffect.freq_start": { + "message": "Startfrequenz", + "description": "(field name) Start frequency in Hertz (Hz), a number between ``0`` and ``9999``" + }, + "microbit.audio.SoundEffect.freq_start.summary": { + "message": "Startfrequenz in Hertz (Hz), eine Zahl zwischen {{0}} und {{9999}}", + "description": "Start frequency in Hertz (Hz), a number between ``0`` and ``9999``" + }, + "microbit.audio.SoundEffect.freq_end": { + "message": "Endfrequenz", + "description": "(field name) End frequency in Hertz (Hz), a number between ``0`` and ``9999``" + }, + "microbit.audio.SoundEffect.freq_end.summary": { + "message": "Endfrequenz in Hertz (Hz), eine Zahl zwischen {{0}} und {{9999}}", + "description": "End frequency in Hertz (Hz), a number between ``0`` and ``9999``" + }, + "microbit.audio.SoundEffect.duration": { + "message": "Dauer", + "description": "(field name) Duration of the sound in milliseconds, a number between ``0`` and ``9999``" + }, + "microbit.audio.SoundEffect.duration.summary": { + "message": "Dauer des Klangs in Millisekunden, eine Zahl zwischen {{0}} und {{9999}}", + "description": "Duration of the sound in milliseconds, a number between ``0`` and ``9999``" + }, + "microbit.audio.SoundEffect.vol_start": { + "message": "vol Start", + "description": "(field name) Start volume value, a number between ``0`` and ``255``" + }, + "microbit.audio.SoundEffect.vol_start.summary": { + "message": "Startlautstärke, eine Zahl zwischen {{0}} und {{255}}", + "description": "Start volume value, a number between ``0`` and ``255``" + }, + "microbit.audio.SoundEffect.vol_end": { + "message": "vol Ende", + "description": "(field name) End volume value, a number between ``0`` and ``255``" + }, + "microbit.audio.SoundEffect.vol_end.summary": { + "message": "Endlautstärke, eine Nummer zwischen {{0}} und {{255}}", + "description": "End volume value, a number between ``0`` and ``255``" + }, + "microbit.audio.SoundEffect.waveform": { + "message": "waveform", + "description": "(field name) Type of waveform shape, one of these values: ``WAVEFORM_SINE``, ``WAVEFORM_SAWTOOTH``, ``WAVEFORM_TRIANGLE``, ``WAVEFORM_SQUARE``, ``WAVEFORM_NOISE`` (randomly generated noise)" + }, + "microbit.audio.SoundEffect.waveform.summary": { + "message": "Typ der Sinuswelle, einer dieser Werte: {{WAVEFORM_SINE}}, {{WAVEFORM_SAWTOOTH}}, {{WAVEFORM_TRIANGLE}}, {{WAVEFORM_SQUARE}}, {{WAVEFORM_NOISE}} (zufällig generiertes Geräusch)", + "description": "Type of waveform shape, one of these values: ``WAVEFORM_SINE``, ``WAVEFORM_SAWTOOTH``, ``WAVEFORM_TRIANGLE``, ``WAVEFORM_SQUARE``, ``WAVEFORM_NOISE`` (randomly generated noise)" + }, + "microbit.audio.SoundEffect.fx": { + "message": "fx", + "description": "(field name) Effect to add on the sound, one of the following values: ``FX_TREMOLO``, ``FX_VIBRATO``, ``FX_WARBLE``, or ``FX_NONE``" + }, + "microbit.audio.SoundEffect.fx.summary": { + "message": "Effekt, der dem Sound hinzugefügt werden soll, in Frage kommende Werte: {{FX_TREMOLO}}, {{FX_VIBRATO}}, {{FX_WARBLE}}, oder {{FX_NONE}}", + "description": "Effect to add on the sound, one of the following values: ``FX_TREMOLO``, ``FX_VIBRATO``, ``FX_WARBLE``, or ``FX_NONE``" + }, + "microbit.audio.SoundEffect.shape": { + "message": "shape", + "description": "(field name) The type of the interpolation curve between the start and end frequencies, different wave shapes have different rates of change in frequency. One of the following values: ``SHAPE_LINEAR``, ``SHAPE_CURVE``, ``SHAPE_LOG``" + }, + "microbit.audio.SoundEffect.shape.summary": { + "message": "Die Art der Interpolationskurve zwischen der Anfangs- und der Endfrequenz. Verschiedene Wellenformen haben unterschiedliche Frequenzänderungsraten. In Frage kommende Werte: {{SHAPE_LINEAR}}, {{SHAPE_CURVE}}, {{SHAPE_LOG}}", + "description": "The type of the interpolation curve between the start and end frequencies, different wave shapes have different rates of change in frequency. One of the following values: ``SHAPE_LINEAR``, ``SHAPE_CURVE``, ``SHAPE_LOG``" + }, + "microbit.audio.SoundEffect.__init__": { + "message": "init", + "description": "(function name) Create a new sound effect." + }, + "microbit.audio.SoundEffect.__init__.summary": { + "message": "Erstelle einen neuen Soundeffekt. ", + "description": "Create a new sound effect." + }, + "microbit.audio.SoundEffect.__init__.param-name.duration": { + "message": "Dauer", + "description": "(parameter name) Duration of the sound in milliseconds, a number between ``0`` and ``9999``." + }, + "microbit.audio.SoundEffect.__init__.param-doc.duration": { + "message": "Dauer des Tons in Millisekunden, eine Zahl zwischen {{0}} und {{9999}}.", + "description": "Parameter docs" + }, + "microbit.audio.SoundEffect.__init__.param-name.freq_end": { + "message": "Endfrequenz", + "description": "(parameter name) End frequency in Hertz (Hz), a number between ``0`` and ``9999``." + }, + "microbit.audio.SoundEffect.__init__.param-doc.freq_end": { + "message": "Endfrequenz in Hertz (Hz), eine Zahl zwischen {{0}} und {{9999}}.", + "description": "Parameter docs" + }, + "microbit.audio.SoundEffect.__init__.param-name.freq_start": { + "message": "Startfrequenz", + "description": "(parameter name) Start frequency in Hertz (Hz), a number between ``0`` and ``9999``." + }, + "microbit.audio.SoundEffect.__init__.param-doc.freq_start": { + "message": "Startfrequenz in Hertz (Hz), eine Zahl zwischen {{0}} und {{9999}}.", + "description": "Parameter docs" + }, + "microbit.audio.SoundEffect.__init__.param-name.fx": { + "message": "fx", + "description": "(parameter name) Effect to add on the sound, one of the following values: ``FX_TREMOLO``, ``FX_VIBRATO``, ``FX_WARBLE``, or ``FX_NONE``." + }, + "microbit.audio.SoundEffect.__init__.param-doc.fx": { + "message": "Effekt, der dem Sound hinzugefügt werden soll, in Frage kommende Werte: {{FX_TREMOLO}}, {{FX_VIBRATO}}, {{FX_WARBLE}}, oder {{FX_NONE}}.", + "description": "Parameter docs" + }, + "microbit.audio.SoundEffect.__init__.param-name.shape": { + "message": "shape", + "description": "(parameter name) The type of the interpolation curve between the start and end frequencies, different wave shapes have different rates of change in frequency. One of the following values: ``SHAPE_LINEAR``, ``SHAPE_CURVE``, ``SHAPE_LOG``." + }, + "microbit.audio.SoundEffect.__init__.param-doc.shape": { + "message": "Die Art der Interpolationskurve zwischen der Anfangs- und der Endfrequenz. Verschiedene Wellenformen haben unterschiedliche Frequenzänderungsraten. In Frage kommende Werte: {{SHAPE_LINEAR}}, {{SHAPE_CURVE}}, {{SHAPE_LOG}}.", + "description": "Parameter docs" + }, + "microbit.audio.SoundEffect.__init__.param-name.vol_end": { + "message": "vol Ende", + "description": "(parameter name) End volume value, a number between ``0`` and ``255``." + }, + "microbit.audio.SoundEffect.__init__.param-doc.vol_end": { + "message": "Endlautstärke, eine Nummer zwischen {{0}} und {{255}}.", + "description": "Parameter docs" + }, + "microbit.audio.SoundEffect.__init__.param-name.vol_start": { + "message": "vol Start", + "description": "(parameter name) Start volume value, a number between ``0`` and ``255``." + }, + "microbit.audio.SoundEffect.__init__.param-doc.vol_start": { + "message": "Startlautstärke, eine Zahl zwischen {{0}} und {{255}}.", + "description": "Parameter docs" + }, + "microbit.audio.SoundEffect.__init__.param-name.waveform": { + "message": "waveform", + "description": "(parameter name) Type of waveform shape, one of these values: ``WAVEFORM_SINE``, ``WAVEFORM_SAWTOOTH``, ``WAVEFORM_TRIANGLE``, ``WAVEFORM_SQUARE``, ``WAVEFORM_NOISE`` (randomly generated noise)." + }, + "microbit.audio.SoundEffect.__init__.param-doc.waveform": { + "message": "Typ der Sinuswelle, einer dieser Werte: {{WAVEFORM_SINE}}, {{WAVEFORM_SAWTOOTH}}, {{WAVEFORM_TRIANGLE}}, {{WAVEFORM_SQUARE}}, {{WAVEFORM_NOISE}} (zufällig generiertes Geräusch). ", + "description": "Parameter docs" + }, + "microbit.audio.SoundEffect.copy": { + "message": "kopieren", + "description": "(function name) Create a copy of this ``SoundEffect``." + }, + "microbit.audio.SoundEffect.copy.summary": { + "message": "Erstelle eine Kopie dieses {{SoundEffect}}. ", + "description": "Create a copy of this ``SoundEffect``." + }, + "microbit.audio.AudioFrame": { + "message": "audioframe", + "description": "(class name) An ``AudioFrame`` object is a list of 32 samples each of which is a unsigned byte\n(whole number between 0 and 255)." + }, + "microbit.audio.AudioFrame.summary": { + "message": "Ein {{AudioFrame}}-Objekt ist eine Liste von 32 Samples, von denen jedes ein vorzeichenloses Byte ist \n(ganze Zahl zwischen 0 und 255).", + "description": "An ``AudioFrame`` object is a list of 32 samples each of which is a unsigned byte\n(whole number between 0 and 255)." + }, + "microbit.audio.AudioFrame.copyfrom": { + "message": "copyfrom", + "description": "(function name) Overwrite the data in this ``AudioFrame`` with the data from another ``AudioFrame`` instance." + }, + "microbit.audio.AudioFrame.copyfrom.summary": { + "message": "Überschreibe die Daten in diesem {{AudioFrame}} mit den Daten einer anderen {{AudioFrame}} Instanz. ", + "description": "Overwrite the data in this ``AudioFrame`` with the data from another ``AudioFrame`` instance." + }, + "microbit.audio.AudioFrame.copyfrom.param-name.other": { + "message": "other", + "description": "(parameter name) ``AudioFrame`` instance from which to copy the data." + }, + "microbit.audio.AudioFrame.copyfrom.param-doc.other": { + "message": "{{AudioFrame}} Instanz von der die Daten kopiert werden sollen.", + "description": "Parameter docs" + }, + "microbit.compass": { + "message": "Kompass", + "description": "(module name) Use the built-in compass." + }, + "microbit.compass.summary": { + "message": "Benutze den eingebauten Kompass. ", + "description": "Use the built-in compass." + }, + "microbit.compass.calibrate": { + "message": "calibrate", + "description": "(function name) Starts the calibration process." + }, + "microbit.compass.calibrate.summary": { + "message": "Startet den Kalibrierungsprozess. ", + "description": "Starts the calibration process." + }, + "microbit.compass.is_calibrated": { + "message": "ist kalibriert", + "description": "(function name) Check is the compass is calibrated." + }, + "microbit.compass.is_calibrated.summary": { + "message": "Überprüfe, dass der Kompass kalibriert ist. ", + "description": "Check is the compass is calibrated." + }, + "microbit.compass.clear_calibration": { + "message": "clear calibration", + "description": "(function name) Undoes the calibration, making the compass uncalibrated again." + }, + "microbit.compass.clear_calibration.summary": { + "message": "Setzt die Kalibrierung zurück, sodass der Kompass nicht mehr kalibriert ist. ", + "description": "Undoes the calibration, making the compass uncalibrated again." + }, + "microbit.compass.get_x": { + "message": "erhalte x", + "description": "(function name) Get the magnetic field strength on the ``x`` axis." + }, + "microbit.compass.get_x.summary": { + "message": "Ermittle die Magnetfeldstärke der {{x}}-Achse. ", + "description": "Get the magnetic field strength on the ``x`` axis." + }, + "microbit.compass.get_y": { + "message": "erhalte y", + "description": "(function name) Get the magnetic field strength on the ``y`` axis." + }, + "microbit.compass.get_y.summary": { + "message": "Ermittle die Magnetfeldstärke der {{y}}-Achse. ", + "description": "Get the magnetic field strength on the ``y`` axis." + }, + "microbit.compass.get_z": { + "message": "erhalte z", + "description": "(function name) Get the magnetic field strength on the ``z`` axis." + }, + "microbit.compass.get_z.summary": { + "message": "Ermittle die Magnetfeldstärke der {{z}}-Achse. ", + "description": "Get the magnetic field strength on the ``z`` axis." + }, + "microbit.compass.heading": { + "message": "Ausrichtung", + "description": "(function name) Get the compass heading." + }, + "microbit.compass.heading.summary": { + "message": "Ermittle die Kompassrichtung. ", + "description": "Get the compass heading." + }, + "microbit.compass.get_field_strength": { + "message": "get field strength", + "description": "(function name) Get the magnitude of the magnetic field around the device." + }, + "microbit.compass.get_field_strength.summary": { + "message": "Ermittle die Größe des Magnetfelds um das Gerät herum.", + "description": "Get the magnitude of the magnetic field around the device." + }, + "microbit.display": { + "message": "Display", + "description": "(module name) Show text, images and animations on the 5×5 LED display." + }, + "microbit.display.summary": { + "message": "Texte, Bilder und Animationen auf dem 5x5 LED-Display anzeigen.", + "description": "Show text, images and animations on the 5×5 LED display." + }, + "microbit.display.get_pixel": { + "message": "Pixelwerte holen", + "description": "(function name) Get the brightness of the LED at column ``x`` and row ``y``." + }, + "microbit.display.get_pixel.summary": { + "message": "Ermittle die Helligkeit der LED auf Spalte {{x}} und Zeile {{y}}. ", + "description": "Get the brightness of the LED at column ``x`` and row ``y``." + }, + "microbit.display.get_pixel.param-name.x": { + "message": "x", + "description": "(parameter name) The display column (0..4)" + }, + "microbit.display.get_pixel.param-doc.x": { + "message": "Die Anzeige-Spalte (0..4)", + "description": "Parameter docs" + }, + "microbit.display.get_pixel.param-name.y": { + "message": "y", + "description": "(parameter name) The display row (0..4)" + }, + "microbit.display.get_pixel.param-doc.y": { + "message": "Die Anzeigezeile (0..4)", + "description": "Parameter docs" + }, + "microbit.display.set_pixel": { + "message": "Pixelwerte setzen", + "description": "(function name) Set the brightness of the LED at column ``x`` and row ``y``." + }, + "microbit.display.set_pixel.summary": { + "message": "Ändere die Helligkeit der LED auf Spalte {{x}} und Zeile {{y}}. ", + "description": "Set the brightness of the LED at column ``x`` and row ``y``." + }, + "microbit.display.set_pixel.param-name.value": { + "message": "wert", + "description": "(parameter name) The brightness between 0 (off) and 9 (bright)" + }, + "microbit.display.set_pixel.param-doc.value": { + "message": "Die Helligkeit zwischen 0 (aus) und 9 (am hellsten)", + "description": "Parameter docs" + }, + "microbit.display.set_pixel.param-name.x": { + "message": "x", + "description": "(parameter name) The display column (0..4)" + }, + "microbit.display.set_pixel.param-doc.x": { + "message": "Die Anzeige-Spalte (0..4)", + "description": "Parameter docs" + }, + "microbit.display.set_pixel.param-name.y": { + "message": "y", + "description": "(parameter name) The display row (0..4)" + }, + "microbit.display.set_pixel.param-doc.y": { + "message": "Die Anzeigezeile (0..4)", + "description": "Parameter docs" + }, + "microbit.display.clear": { + "message": "löschen", + "description": "(function name) Set the brightness of all LEDs to 0 (off)." + }, + "microbit.display.clear.summary": { + "message": "Setzt die Helligkeit aller LEDs auf 0 (aus).", + "description": "Set the brightness of all LEDs to 0 (off)." + }, + "microbit.display.show": { + "message": "show", + "description": "(function name) Shows images, letters or digits on the LED display." + }, + "microbit.display.show.summary": { + "message": "Zeigt Bilder, Buchstaben oder Ziffern auf der LED-Anzeige an.", + "description": "Shows images, letters or digits on the LED display." + }, + "microbit.display.show.param-name.clear": { + "message": "löschen", + "description": "(parameter name) If ``clear`` is ``True``, the display will be cleared after the sequence has finished." + }, + "microbit.display.show.param-doc.clear": { + "message": "Wenn {{clear}} {{True}}ist, wird die Anzeige ausgeschaltet, nachdem die Sequenz beendet ist.", + "description": "Parameter docs" + }, + "microbit.display.show.param-name.delay": { + "message": "Verzögerung", + "description": "(parameter name) Each letter, digit or image is shown with ``delay`` milliseconds between them." + }, + "microbit.display.show.param-doc.delay": { + "message": "Jeder Buchstabe, Ziffer oder Bild wird mit {{delay}} Millisekunden zwischen ihnen angezeigt.", + "description": "Parameter docs" + }, + "microbit.display.show.param-name.image": { + "message": "image", + "description": "(parameter name) A string, number, image or list of images to show." + }, + "microbit.display.show.param-doc.image": { + "message": "Eine Zeichenkette, Nummer, Bild oder Liste der anzuzeigenden Bilder.", + "description": "Parameter docs" + }, + "microbit.display.show.param-name.loop": { + "message": "loop", + "description": "(parameter name) If ``loop`` is ``True``, the animation will repeat forever." + }, + "microbit.display.show.param-doc.loop": { + "message": "Wenn {{loop}} {{True}}ist, wird sich die Animation für immer wiederholen.", + "description": "Parameter docs" + }, + "microbit.display.show.param-name.wait": { + "message": "wait", + "description": "(parameter name) If ``wait`` is ``True``, this function will block until the animation is finished, otherwise the animation will happen in the background." + }, + "microbit.display.show.param-doc.wait": { + "message": "Wenn {{wait}} {{True}}ist, wird diese Funktion blockiert, bis die Animation beendet ist, andernfalls wird die Animation im Hintergrund stattfinden.", + "description": "Parameter docs" + }, + "microbit.display.scroll": { + "message": "scrollen", + "description": "(function name) Scrolls a number or text on the LED display." + }, + "microbit.display.scroll.summary": { + "message": "Scrollt eine Zahl oder einen Text auf dem LED-Display.", + "description": "Scrolls a number or text on the LED display." + }, + "microbit.display.scroll.param-name.delay": { + "message": "Verzögerung", + "description": "(parameter name) The ``delay`` parameter controls how fast the text is scrolling." + }, + "microbit.display.scroll.param-doc.delay": { + "message": "Der {{delay}} -Parameter bestimmt, wie schnell der Text scrollt.", + "description": "Parameter docs" + }, + "microbit.display.scroll.param-name.loop": { + "message": "loop", + "description": "(parameter name) If ``loop`` is ``True``, the animation will repeat forever." + }, + "microbit.display.scroll.param-doc.loop": { + "message": "Wenn {{loop}} {{True}}ist, wird sich die Animation für immer wiederholen.", + "description": "Parameter docs" + }, + "microbit.display.scroll.param-name.monospace": { + "message": "Monospace", + "description": "(parameter name) If ``monospace`` is ``True``, the characters will all take up 5 pixel-columns in width, otherwise there will be exactly 1 blank pixel-column between each character as they scroll." + }, + "microbit.display.scroll.param-doc.monospace": { + "message": "Wenn {{monospace}} {{True}}ist, werden alle Zeichen 5 Pixel breit sein. Zwischen den Zeichen gibt es beim scrollen genau 1 leere Pixelspalte.", + "description": "Parameter docs" + }, + "microbit.display.scroll.param-name.text": { + "message": "text ", + "description": "(parameter name) The string to scroll. If ``text`` is an integer or float it is first converted to a string using ``str()``." + }, + "microbit.display.scroll.param-doc.text": { + "message": "Der zu wiederzugebende String. Wenn {{text}} eine Ganzzahl oder ein Float ist, wird er zuerst mit {{str()}} in einen String konvertiert.", + "description": "Parameter docs" + }, + "microbit.display.scroll.param-name.wait": { + "message": "wait", + "description": "(parameter name) If ``wait`` is ``True``, this function will block until the animation is finished, otherwise the animation will happen in the background." + }, + "microbit.display.scroll.param-doc.wait": { + "message": "Wenn {{wait}} {{True}}ist, wird diese Funktion blockiert, bis die Animation beendet ist, andernfalls wird die Animation im Hintergrund stattfinden.", + "description": "Parameter docs" + }, + "microbit.display.on": { + "message": "an", + "description": "(function name) Turn on the LED display." + }, + "microbit.display.on.summary": { + "message": "Schalten Sie das LED-Display ein.", + "description": "Turn on the LED display." + }, + "microbit.display.off": { + "message": "off", + "description": "(function name) Turn off the LED display (disabling the display allows you to re-use the GPIO pins for other purposes)." + }, + "microbit.display.off.summary": { + "message": "Schalten Sie die LED-Anzeige aus (das Deaktivieren des Displays erlaubt es Ihnen, die GPIO-Pins für andere Zwecke zu verwenden).", + "description": "Turn off the LED display (disabling the display allows you to re-use the GPIO pins for other purposes)." + }, + "microbit.display.is_on": { + "message": "ist an", + "description": "(function name) Check whether the LED display is enabled." + }, + "microbit.display.is_on.summary": { + "message": "Überprüfen Sie, ob die LED-Anzeige aktiviert ist.", + "description": "Check whether the LED display is enabled." + }, + "microbit.display.read_light_level": { + "message": "bestimme Licht Intensität", + "description": "(function name) Read the light level." + }, + "microbit.display.read_light_level.summary": { + "message": "Bestimmt die Lichtintensität.", + "description": "Read the light level." + }, + "microbit.i2c": { + "message": "i2c", + "description": "(module name) Communicate with devices using the I²C bus protocol." + }, + "microbit.i2c.summary": { + "message": "Kommunikation mit Geräten über das I2C-Busprotokoll.", + "description": "Communicate with devices using the I²C bus protocol." + }, + "microbit.i2c.init": { + "message": "init", + "description": "(function name) Re-initialize a peripheral." + }, + "microbit.i2c.init.summary": { + "message": "Eine Peripherie neu initialisieren.", + "description": "Re-initialize a peripheral." + }, + "microbit.i2c.init.param-name.freq": { + "message": "freq", + "description": "(parameter name) clock frequency" + }, + "microbit.i2c.init.param-doc.freq": { + "message": "Taktfrequenz", + "description": "Parameter docs" + }, + "microbit.i2c.init.param-name.scl": { + "message": "scl", + "description": "(parameter name) ``scl`` pin (default 19)" + }, + "microbit.i2c.init.param-doc.scl": { + "message": "{{scl}} Pin (standardmäßig 19)", + "description": "Parameter docs" + }, + "microbit.i2c.init.param-name.sda": { + "message": "sda", + "description": "(parameter name) ``sda`` pin (default 20)" + }, + "microbit.i2c.init.param-doc.sda": { + "message": "{{sda}} Pin (standardmäßig 20)", + "description": "Parameter docs" + }, + "microbit.i2c.scan": { + "message": "scan", + "description": "(function name) Scan the bus for devices." + }, + "microbit.i2c.scan.summary": { + "message": "Scannt den Bus nach Geräten.", + "description": "Scan the bus for devices." + }, + "microbit.i2c.read": { + "message": "read", + "description": "(function name) Read bytes from a device." + }, + "microbit.i2c.read.summary": { + "message": "Liest Bytes von einem Gerät..", + "description": "Read bytes from a device." + }, + "microbit.i2c.read.param-name.addr": { + "message": "addr", + "description": "(parameter name) The 7-bit address of the device" + }, + "microbit.i2c.read.param-doc.addr": { + "message": "Die 7-Bit-Adresse des Geräts", + "description": "Parameter docs" + }, + "microbit.i2c.read.param-name.n": { + "message": "n", + "description": "(parameter name) The number of bytes to read" + }, + "microbit.i2c.read.param-doc.n": { + "message": "Die Anzahl der zu lesenden Bytes", + "description": "Parameter docs" + }, + "microbit.i2c.read.param-name.repeat": { + "message": "wiederholen", + "description": "(parameter name) If ``True``, no stop bit will be sent" + }, + "microbit.i2c.read.param-doc.repeat": { + "message": "Wenn {{True}}wird kein Stop-Bit gesendet", + "description": "Parameter docs" + }, + "microbit.i2c.write": { + "message": "schreiben", + "description": "(function name) Write bytes to a device." + }, + "microbit.i2c.write.summary": { + "message": "Schreibe Bytes auf ein Gerät.", + "description": "Write bytes to a device." + }, + "microbit.i2c.write.param-name.addr": { + "message": "addr", + "description": "(parameter name) The 7-bit address of the device" + }, + "microbit.i2c.write.param-doc.addr": { + "message": "Die 7-Bit-Adresse des Geräts", + "description": "Parameter docs" + }, + "microbit.i2c.write.param-name.buf": { + "message": "buf", + "description": "(parameter name) A buffer containing the bytes to write" + }, + "microbit.i2c.write.param-doc.buf": { + "message": "Ein Puffer mit den zu schreibenden Bytes", + "description": "Parameter docs" + }, + "microbit.i2c.write.param-name.repeat": { + "message": "wiederholen", + "description": "(parameter name) If ``True``, no stop bit will be sent" + }, + "microbit.i2c.write.param-doc.repeat": { + "message": "Wenn {{True}}wird kein Stop-Bit gesendet", + "description": "Parameter docs" + }, + "microbit.microphone": { + "message": "Mikrofon", + "description": "(module name) Respond to sound using the built-in microphone (V2 only)." + }, + "microbit.microphone.summary": { + "message": "Reagiere auf Ton mithilfe des integrierten Mikrofons (nur V2). ", + "description": "Respond to sound using the built-in microphone (V2 only)." + }, + "microbit.microphone.current_event": { + "message": "current event", + "description": "(function name) Get the last recorded sound event" + }, + "microbit.microphone.current_event.summary": { + "message": "Abrufen des letzten aufgezeichneten Sound-Ereignisses", + "description": "Get the last recorded sound event" + }, + "microbit.microphone.was_event": { + "message": "was event", + "description": "(function name) Check if a sound was heard at least once since the last call." + }, + "microbit.microphone.was_event.summary": { + "message": "Überprüfung, ob seit dem letzten Anruf mindestens einmal ein Geräusch gehört wurde.", + "description": "Check if a sound was heard at least once since the last call." + }, + "microbit.microphone.was_event.param-name.event": { + "message": "event", + "description": "(parameter name) The event to check for, such as ``SoundEvent.LOUD`` or ``SoundEvent.QUIET``" + }, + "microbit.microphone.was_event.param-doc.event": { + "message": "Das Ereignis, auf das geprüft werden soll, z. B. {{SoundEvent.LOUD}} oder {{SoundEvent.QUIET}}", + "description": "Parameter docs" + }, + "microbit.microphone.is_event": { + "message": "is event", + "description": "(function name) Check the most recent sound event detected." + }, + "microbit.microphone.is_event.summary": { + "message": "Überprüfe das zuletzt erkannte Sound-Ereignis.", + "description": "Check the most recent sound event detected." + }, + "microbit.microphone.is_event.param-name.event": { + "message": "event", + "description": "(parameter name) The event to check for, such as ``SoundEvent.LOUD`` or ``SoundEvent.QUIET``" + }, + "microbit.microphone.is_event.param-doc.event": { + "message": "Das Ereignis, auf das geprüft werden soll, z. B. {{SoundEvent.LOUD}} oder {{SoundEvent.QUIET}}", + "description": "Parameter docs" + }, + "microbit.microphone.get_events": { + "message": "get events", + "description": "(function name) Get the sound event history as a tuple." + }, + "microbit.microphone.get_events.summary": { + "message": "Liefert den Verlauf der Sound-Ereignisse in Form eines Tupels.", + "description": "Get the sound event history as a tuple." + }, + "microbit.microphone.set_threshold": { + "message": "set threshold", + "description": "(function name) Set the threshold for a sound event." + }, + "microbit.microphone.set_threshold.summary": { + "message": "Legt den Schwellenwert für ein Sound-Ereignis fest.", + "description": "Set the threshold for a sound event." + }, + "microbit.microphone.set_threshold.param-name.event": { + "message": "event", + "description": "(parameter name) A sound event, such as ``SoundEvent.LOUD`` or ``SoundEvent.QUIET``." + }, + "microbit.microphone.set_threshold.param-doc.event": { + "message": "Ein Sound-Ereignis, wie {{SoundEvent.LOUD}} oder {{SoundEvent.QUIET}}.", + "description": "Parameter docs" + }, + "microbit.microphone.set_threshold.param-name.value": { + "message": "wert", + "description": "(parameter name) The threshold level in the range 0-255." + }, + "microbit.microphone.set_threshold.param-doc.value": { + "message": "Der Schwellenwert im Bereich 0-255.", + "description": "Parameter docs" + }, + "microbit.microphone.sound_level": { + "message": "Lautstärke", + "description": "(function name) Get the sound pressure level." + }, + "microbit.microphone.sound_level.summary": { + "message": "Ermittle den Schalldruckpegel. ", + "description": "Get the sound pressure level." + }, + "microbit.speaker": { + "message": "Lautsprecher", + "description": "(module name) Control the built-in speaker (V2 only)." + }, + "microbit.speaker.summary": { + "message": "Steuere den integrierten Lautsprecher (nur V2). ", + "description": "Control the built-in speaker (V2 only)." + }, + "microbit.speaker.off": { + "message": "off", + "description": "(function name) Turn the speaker off." + }, + "microbit.speaker.off.summary": { + "message": "Lautsprecher ausschalten. ", + "description": "Turn the speaker off." + }, + "microbit.speaker.on": { + "message": "an", + "description": "(function name) Turn the speaker on." + }, + "microbit.speaker.on.summary": { + "message": "Lautsprecher einschalten. ", + "description": "Turn the speaker on." + }, + "microbit.spi": { + "message": "spi", + "description": "(module name) Communicate with devices using the serial peripheral interface (SPI) bus." + }, + "microbit.spi.summary": { + "message": "Kommunikation mit Geräten über die serielle Schnittstelle (SPI). ", + "description": "Communicate with devices using the serial peripheral interface (SPI) bus." + }, + "microbit.spi.init": { + "message": "init", + "description": "(function name) Initialize SPI communication." + }, + "microbit.spi.init.summary": { + "message": "SPI-Kommunikation initialisieren. ", + "description": "Initialize SPI communication." + }, + "microbit.spi.init.param-name.baudrate": { + "message": "baudrate", + "description": "(parameter name) The speed of communication." + }, + "microbit.spi.init.param-doc.baudrate": { + "message": "Die Übertragungsgeschwindigkeit.", + "description": "Parameter docs" + }, + "microbit.spi.init.param-name.bits": { + "message": "bits", + "description": "(parameter name) The width in bits of each transfer. Currently only ``bits=8`` is supported. However, this may change in the future." + }, + "microbit.spi.init.param-doc.bits": { + "message": "Die Breite in Bits jeder Übertragung. Derzeit wird nur {{bits=8}} unterstützt. Dies kann sich jedoch in Zukunft ändern.", + "description": "Parameter docs" + }, + "microbit.spi.init.param-name.miso": { + "message": "miso", + "description": "(parameter name) miso pin (default 14)" + }, + "microbit.spi.init.param-doc.miso": { + "message": "miso pin (Voreinstellung 14)", + "description": "Parameter docs" + }, + "microbit.spi.init.param-name.mode": { + "message": "mode", + "description": "(parameter name) Determines the combination of clock polarity and phase - `see online table `_." + }, + "microbit.spi.init.param-doc.mode": { + "message": "Legt die Kombination aus Taktpolarität und Phase fest - `siehe Online-Tabelle `_.", + "description": "Parameter docs" + }, + "microbit.spi.init.param-name.mosi": { + "message": "mosi", + "description": "(parameter name) mosi pin (default 15)" + }, + "microbit.spi.init.param-doc.mosi": { + "message": "MOSI Pin (standardmäßig 15)", + "description": "Parameter docs" + }, + "microbit.spi.init.param-name.sclk": { + "message": "sclk", + "description": "(parameter name) sclk pin (default 13)" + }, + "microbit.spi.init.param-doc.sclk": { + "message": "SCLK Pin (standardmäßig 13)", + "description": "Parameter docs" + }, + "microbit.spi.read": { + "message": "read", + "description": "(function name) Read bytes." + }, + "microbit.spi.read.summary": { + "message": "Bytes lesen.", + "description": "Read bytes." + }, + "microbit.spi.read.param-name.nbytes": { + "message": "nbytes", + "description": "(parameter name) Maximum number of bytes to read." + }, + "microbit.spi.read.param-doc.nbytes": { + "message": "Maximum der zu lesenden Bytes. ", + "description": "Parameter docs" + }, + "microbit.spi.write": { + "message": "schreiben", + "description": "(function name) Write bytes to the bus." + }, + "microbit.spi.write.summary": { + "message": "Schreibe Bytes auf den Bus. ", + "description": "Write bytes to the bus." + }, + "microbit.spi.write.param-name.buffer": { + "message": "Puffer", + "description": "(parameter name) A buffer to read data from." + }, + "microbit.spi.write.param-doc.buffer": { + "message": "Ein Puffer, von dem Daten gelesen werden.", + "description": "Parameter docs" + }, + "microbit.spi.write_readinto": { + "message": "write readinto", + "description": "(function name) Write the ``out`` buffer to the bus and read any response into the ``in_`` buffer." + }, + "microbit.spi.write_readinto.summary": { + "message": "Schreibe den {{out}} Zwischenspeicher (Buffer) auf den Bus und lies jede Antwort in den {{in_}} Buffer.", + "description": "Write the ``out`` buffer to the bus and read any response into the ``in_`` buffer." + }, + "microbit.spi.write_readinto.param-name.in_": { + "message": "in", + "description": "(parameter name) The buffer to read data from." + }, + "microbit.spi.write_readinto.param-doc.in_": { + "message": "Der Puffer, von dem Daten gelesen werden.", + "description": "Parameter docs" + }, + "microbit.spi.write_readinto.param-name.out": { + "message": "out", + "description": "(parameter name) The buffer to write any response to." + }, + "microbit.spi.write_readinto.param-doc.out": { + "message": "Der Puffer, in den eine Antwort geschrieben werden soll.", + "description": "Parameter docs" + }, + "microbit.uart": { + "message": "uart", + "description": "(module name) Communicate with a device using a serial interface." + }, + "microbit.uart.summary": { + "message": "Verbindet mit einem Gerät über eine serielle Schnittstelle.", + "description": "Communicate with a device using a serial interface." + }, + "microbit.uart.ODD": { + "message": "odd", + "description": "(field name) Odd parity" + }, + "microbit.uart.ODD.summary": { + "message": "Ungerade Parität", + "description": "Odd parity" + }, + "microbit.uart.EVEN": { + "message": "gerade", + "description": "(field name) Even parity" + }, + "microbit.uart.EVEN.summary": { + "message": "Gerade Parität", + "description": "Even parity" + }, + "microbit.uart.init": { + "message": "init", + "description": "(function name) Initialize serial communication." + }, + "microbit.uart.init.summary": { + "message": "Initialisiere die serielle Kommunikation.", + "description": "Initialize serial communication." + }, + "microbit.uart.init.param-name.baudrate": { + "message": "Baudrate", + "description": "(parameter name) The speed of communication." + }, + "microbit.uart.init.param-doc.baudrate": { + "message": "Die Übertragungsgeschwindigkeit.", + "description": "Parameter docs" + }, + "microbit.uart.init.param-name.bits": { + "message": "Bits", + "description": "(parameter name) The size of bytes being transmitted. micro:bit only supports 8." + }, + "microbit.uart.init.param-doc.bits": { + "message": "Die Größe der Bytes die übertragen werden. micro:bit unterstützt nur 8.", + "description": "Parameter docs" + }, + "microbit.uart.init.param-name.parity": { + "message": "Parität", + "description": "(parameter name) How parity is checked, ``None``, ``uart.ODD`` or ``uart.EVEN``." + }, + "microbit.uart.init.param-doc.parity": { + "message": "Wie Parität geprüft wird, {{None}}, {{uart.ODD}} oder {{uart.EVEN}}.", + "description": "Parameter docs" + }, + "microbit.uart.init.param-name.rx": { + "message": "rx", + "description": "(parameter name) Receiving pin." + }, + "microbit.uart.init.param-doc.rx": { + "message": "Empfangspin.", + "description": "Parameter docs" + }, + "microbit.uart.init.param-name.stop": { + "message": "Stop", + "description": "(parameter name) The number of stop bits, has to be 1 for micro:bit." + }, + "microbit.uart.init.param-doc.stop": { + "message": "Die Anzahl der Stopbits, muss 1 für micro:bit sein.", + "description": "Parameter docs" + }, + "microbit.uart.init.param-name.tx": { + "message": "tx", + "description": "(parameter name) Transmitting pin." + }, + "microbit.uart.init.param-doc.tx": { + "message": "Sendepin.", + "description": "Parameter docs" + }, + "microbit.uart.any": { + "message": "any", + "description": "(function name) Check if any data is waiting." + }, + "microbit.uart.any.summary": { + "message": "Überprüfen Sie, ob irgendwelche Daten warten.", + "description": "Check if any data is waiting." + }, + "microbit.uart.read": { + "message": "read", + "description": "(function name) Read bytes." + }, + "microbit.uart.read.summary": { + "message": "Bytes lesen.", + "description": "Read bytes." + }, + "microbit.uart.read.param-name.nbytes": { + "message": "nbytes", + "description": "(parameter name) If ``nbytes`` is specified then read at most that many bytes, otherwise read as many bytes as possible" + }, + "microbit.uart.read.param-doc.nbytes": { + "message": "Wenn {{nbytes}} angegeben ist, werden höchstens so viele Bytes gelesen. Andernfalls werden so viele Bytes wie möglich gelesen.", + "description": "Parameter docs" + }, + "microbit.uart.readinto": { + "message": "readinto", + "description": "(function name) Read bytes into the ``buf``." + }, + "microbit.uart.readinto.summary": { + "message": "Lese Bytes in {{buf}}.", + "description": "Read bytes into the ``buf``." + }, + "microbit.uart.readinto.param-name.buf": { + "message": "buf", + "description": "(parameter name) The buffer to write to." + }, + "microbit.uart.readinto.param-doc.buf": { + "message": "Der Puffer, in den geschrieben werden soll.", + "description": "Parameter docs" + }, + "microbit.uart.readinto.param-name.nbytes": { + "message": "nbytes", + "description": "(parameter name) If ``nbytes`` is specified then read at most that many bytes, otherwise read ``len(buf)`` bytes." + }, + "microbit.uart.readinto.param-doc.nbytes": { + "message": "Wenn {{nbytes}} angegeben ist, werden höchstens so viele Bytes gelesen. Andernfalls werden {{len(buf)}} Bytes gelesen.", + "description": "Parameter docs" + }, + "microbit.uart.readline": { + "message": "readline", + "description": "(function name) Read a line, ending in a newline character." + }, + "microbit.uart.readline.summary": { + "message": "Liest eine Zeile bis zum Zeilenumbruch.", + "description": "Read a line, ending in a newline character." + }, + "microbit.uart.write": { + "message": "schreiben", + "description": "(function name) Write a buffer to the bus." + }, + "microbit.uart.write.summary": { + "message": "Schreibt einen Puffer auf den Bus.", + "description": "Write a buffer to the bus." + }, + "microbit.uart.write.param-name.buf": { + "message": "buf", + "description": "(parameter name) A bytes object or a string." + }, + "microbit.uart.write.param-doc.buf": { + "message": "Ein Byte-Objekt oder ein String. ", + "description": "Parameter docs" + }, + "micropython": { + "message": "micropython", + "description": "(module name) MicroPython internals." + }, + "micropython.summary": { + "message": "MicroPython Grundlagen.", + "description": "MicroPython internals." + }, + "micropython.const": { + "message": "const", + "description": "(function name) Used to declare that the expression is a constant so that the compiler can\noptimise it." + }, + "micropython.const.summary": { + "message": "Wird verwendet, um zu deklarieren, dass der Ausdruck eine Konstante ist, damit der Compiler ihn optimieren kann.", + "description": "Used to declare that the expression is a constant so that the compiler can\noptimise it." + }, + "micropython.const.param-name.expr": { + "message": "expr", + "description": "(parameter name) A constant expression." + }, + "micropython.const.param-doc.expr": { + "message": "Ein konstant bleibender Ausdruck.", + "description": "Parameter docs" + }, + "micropython.opt_level-1": { + "message": "opt level", + "description": "(function name) Get the current optimisation level for the compilation of scripts." + }, + "micropython.opt_level-1.summary": { + "message": "Ermittelt die aktuelle Optimierungsstufe für die Kompilierung von Skripten.", + "description": "Get the current optimisation level for the compilation of scripts." + }, + "micropython.opt_level-2": { + "message": "opt level", + "description": "(function name) Sets the optimisation level for subsequent compilation of scripts." + }, + "micropython.opt_level-2.summary": { + "message": "Legt die Optimierungsstufe für die nachfolgende Kompilierung von Skripten fest.", + "description": "Sets the optimisation level for subsequent compilation of scripts." + }, + "micropython.opt_level-2.param-name.level": { + "message": "level", + "description": "(parameter name) An integer optimisation level." + }, + "micropython.opt_level-2.param-doc.level": { + "message": "Eine ganzzahlige Optimierungsstufe.", + "description": "Parameter docs" + }, + "micropython.mem_info": { + "message": "mem info", + "description": "(function name) Print information about currently used memory." + }, + "micropython.mem_info.summary": { + "message": "Gibt Informationen über den aktuell verwendeten Speicher zurück.", + "description": "Print information about currently used memory." + }, + "micropython.mem_info.param-name.verbose": { + "message": "verbose", + "description": "(parameter name) If the ``verbose`` argument is given then extra information is printed." + }, + "micropython.mem_info.param-doc.verbose": { + "message": "Wenn das Argument {{verbose}} angegeben wird, werden zusätzliche Informationen ausgegeben.", + "description": "Parameter docs" + }, + "micropython.qstr_info": { + "message": "qstr info", + "description": "(function name) Print information about currently interned strings." + }, + "micropython.qstr_info.summary": { + "message": "Gibt Informationen zu aktuell eingebetteten Strings zurück.", + "description": "Print information about currently interned strings." + }, + "micropython.qstr_info.param-name.verbose": { + "message": "verbose", + "description": "(parameter name) If the ``verbose`` argument is given then extra information is printed." + }, + "micropython.qstr_info.param-doc.verbose": { + "message": "Wenn das Argument {{verbose}} angegeben wird, werden zusätzliche Informationen ausgegeben.", + "description": "Parameter docs" + }, + "micropython.stack_use": { + "message": "stack use", + "description": "(function name) Return an integer representing the current amount of stack that is being\nused." + }, + "micropython.stack_use.summary": { + "message": "Gibt einen Integerwert zurück, der dem aktuell verwendeten Stack-Speicher entspricht.", + "description": "Return an integer representing the current amount of stack that is being\nused." + }, + "micropython.heap_lock": { + "message": "heap lock", + "description": "(function name) Lock the heap." + }, + "micropython.heap_lock.summary": { + "message": "Heap-Speicher sperren.", + "description": "Lock the heap." + }, + "micropython.heap_unlock": { + "message": "heap unlock", + "description": "(function name) Unlock the heap." + }, + "micropython.heap_unlock.summary": { + "message": "Heap-Speicher entsperren.", + "description": "Unlock the heap." + }, + "micropython.kbd_intr": { + "message": "kbd intr", + "description": "(function name) Set the character that will raise a ``KeyboardInterrupt`` exception." + }, + "micropython.kbd_intr.summary": { + "message": "Zeichen festlegen, das eine {{KeyboardInterrupt}}-Exception auslöst.", + "description": "Set the character that will raise a ``KeyboardInterrupt`` exception." + }, + "micropython.kbd_intr.param-name.chr": { + "message": "chr", + "description": "(parameter name) Character code to raise the interrupt or -1 to disable capture of Ctrl-C." + }, + "micropython.kbd_intr.param-doc.chr": { + "message": "Zeichencode, um den Interrupt auszulösen, oder -1, um die Erfassung von Ctrl-C zu deaktivieren.", + "description": "Parameter docs" + }, + "music": { + "message": "Musik", + "description": "(module name) Create and play melodies." + }, + "music.summary": { + "message": "Erstelle und spiele Lieder.", + "description": "Create and play melodies." + }, + "music.DADADADUM": { + "message": "dadadadaam", + "description": "(field name) Melody: the opening to Beethoven’s 5th Symphony in C minor." + }, + "music.DADADADUM.summary": { + "message": "Melodie: der Anfang von Beethovens 5. Symphonie in c-Moll.", + "description": "Melody: the opening to Beethoven’s 5th Symphony in C minor." + }, + "music.ENTERTAINER": { + "message": "Entertainer", + "description": "(field name) Melody: the opening fragment of Scott Joplin’s Ragtime classic “The Entertainer”." + }, + "music.ENTERTAINER.summary": { + "message": "Melodie: die ersten Takte des Ragtime-Klassikers \"The Entertainer\" von Scott Joplin.", + "description": "Melody: the opening fragment of Scott Joplin’s Ragtime classic “The Entertainer”." + }, + "music.PRELUDE": { + "message": "prelude", + "description": "(field name) Melody: the opening of the first Prelude in C Major of J.S.Bach’s 48 Preludes and Fugues." + }, + "music.PRELUDE.summary": { + "message": "Melodie: Beginn des ersten Präludiums in C-Dur der 48 Präludien und Fugen von J.S. Bach.", + "description": "Melody: the opening of the first Prelude in C Major of J.S.Bach’s 48 Preludes and Fugues." + }, + "music.ODE": { + "message": "Ode", + "description": "(field name) Melody: the “Ode to Joy” theme from Beethoven’s 9th Symphony in D minor." + }, + "music.ODE.summary": { + "message": "Melodie: Die „Ode an die Freude“ von Beethovens neunter Symphonie in d-Moll.", + "description": "Melody: the “Ode to Joy” theme from Beethoven’s 9th Symphony in D minor." + }, + "music.NYAN": { + "message": "Nyan", + "description": "(field name) Melody: the Nyan Cat theme (http://www.nyan.cat/)." + }, + "music.NYAN.summary": { + "message": "Melodie: Die Nyan-Katze (http://www.nyan.cat/)", + "description": "Melody: the Nyan Cat theme (http://www.nyan.cat/)." + }, + "music.RINGTONE": { + "message": "Klingelton", + "description": "(field name) Melody: something that sounds like a mobile phone ringtone." + }, + "music.RINGTONE.summary": { + "message": "Melodie: Etwas das wie ein Handy-Klingelton klingt.", + "description": "Melody: something that sounds like a mobile phone ringtone." + }, + "music.FUNK": { + "message": "Funk", + "description": "(field name) Melody: a funky bass line for secret agents and criminal masterminds." + }, + "music.FUNK.summary": { + "message": "Melodie: eine funkige Basslinie für Geheimagenten und Superschurken.", + "description": "Melody: a funky bass line for secret agents and criminal masterminds." + }, + "music.BLUES": { + "message": "Blues", + "description": "(field name) Melody: a boogie-woogie 12-bar blues walking bass." + }, + "music.BLUES.summary": { + "message": "Melodie: ein 12-taktiger Boogie-Woogie-Blues mit Walking Bass.", + "description": "Melody: a boogie-woogie 12-bar blues walking bass." + }, + "music.BIRTHDAY": { + "message": "Geburtstag", + "description": "(field name) Melody: “Happy Birthday to You…”" + }, + "music.BIRTHDAY.summary": { + "message": "Melodie: „Alles Gute zum Geburtstag…“", + "description": "Melody: “Happy Birthday to You…”" + }, + "music.WEDDING": { + "message": "Hochzeit", + "description": "(field name) Melody: the bridal chorus from Wagner’s opera “Lohengrin”." + }, + "music.WEDDING.summary": { + "message": "Melodie: der Hochzeitschor aus Wagners Oper \"Lohengrin\".", + "description": "Melody: the bridal chorus from Wagner’s opera “Lohengrin”." + }, + "music.FUNERAL": { + "message": "Beerdigung", + "description": "(field name) Melody: the “funeral march” otherwise known as Frédéric Chopin’s Piano Sonata No. 2 in B♭ minor, Op. 35." + }, + "music.FUNERAL.summary": { + "message": "Melodie: der \"Trauermarsch\", auch bekannt als Frédéric Chopins Klaviersonate Nr. 2 in b-Moll, op. 35.", + "description": "Melody: the “funeral march” otherwise known as Frédéric Chopin’s Piano Sonata No. 2 in B♭ minor, Op. 35." + }, + "music.PUNCHLINE": { + "message": "punchline", + "description": "(field name) Melody: a fun fragment that signifies a joke has been made." + }, + "music.PUNCHLINE.summary": { + "message": "Melodie: ein lustiges Fragment, das anzeigt, dass ein Scherz gemacht worden ist.", + "description": "Melody: a fun fragment that signifies a joke has been made." + }, + "music.PYTHON": { + "message": "python", + "description": "(field name) Melody: John Philip Sousa’s march “Liberty Bell” aka, the theme for “Monty Python’s Flying Circus” (after which the Python programming language is named)." + }, + "music.PYTHON.summary": { + "message": "Melodie: John Philip Sousas Marsch \"Liberty Bell\", auch bekannt als das Thema von \"Monty Python's Flying Circus\" (nach dem die Programmiersprache Python benannt ist).", + "description": "Melody: John Philip Sousa’s march “Liberty Bell” aka, the theme for “Monty Python’s Flying Circus” (after which the Python programming language is named)." + }, + "music.BADDY": { + "message": "baddy", + "description": "(field name) Melody: silent movie era entrance of a baddy." + }, + "music.BADDY.summary": { + "message": "Melodie: Auftritt eines Stummfilm-Bösewichts.", + "description": "Melody: silent movie era entrance of a baddy." + }, + "music.CHASE": { + "message": "chase", + "description": "(field name) Melody: silent movie era chase scene." + }, + "music.CHASE.summary": { + "message": "Melodie: Stummfilm-Verfolgungsszene.", + "description": "Melody: silent movie era chase scene." + }, + "music.BA_DING": { + "message": "ba ding", + "description": "(field name) Melody: a short signal to indicate something has happened." + }, + "music.BA_DING.summary": { + "message": "Melodie: ein kurzes Signal, um anzuzeigen, dass etwas passiert ist.", + "description": "Melody: a short signal to indicate something has happened." + }, + "music.WAWAWAWAA": { + "message": "wawawawaa", + "description": "(field name) Melody: a very sad trombone." + }, + "music.WAWAWAWAA.summary": { + "message": "Melody: Eine sehr traurige Posaune.", + "description": "Melody: a very sad trombone." + }, + "music.JUMP_UP": { + "message": "jump up", + "description": "(field name) Melody: for use in a game, indicating upward movement." + }, + "music.JUMP_UP.summary": { + "message": "Melodie: zur Verwendung in einem Spiel, um eine Aufwärtsbewegung zu untermalen.", + "description": "Melody: for use in a game, indicating upward movement." + }, + "music.JUMP_DOWN": { + "message": "jump down", + "description": "(field name) Melody: for use in a game, indicating downward movement." + }, + "music.JUMP_DOWN.summary": { + "message": "Melodie: zur Verwendung in einem Spiel, um eine Abwärtsbewegung zu untermalen.", + "description": "Melody: for use in a game, indicating downward movement." + }, + "music.POWER_UP": { + "message": "power up", + "description": "(field name) Melody: a fanfare to indicate an achievement unlocked." + }, + "music.POWER_UP.summary": { + "message": "Melodie: eine Fanfare, die einen Erfolg anzeigt oder dass etwas freigeschalten wurde.", + "description": "Melody: a fanfare to indicate an achievement unlocked." + }, + "music.POWER_DOWN": { + "message": "power down", + "description": "(field name) Melody: a sad fanfare to indicate an achievement lost." + }, + "music.POWER_DOWN.summary": { + "message": "Melodie: eine traurige Fanfare, wenn etwas nicht geklappt hat.", + "description": "Melody: a sad fanfare to indicate an achievement lost." + }, + "music.set_tempo": { + "message": "set tempo", + "description": "(function name) Sets the approximate tempo for playback." + }, + "music.set_tempo.summary": { + "message": "Legt das ungefähre Tempo für die Wiedergabe fest.", + "description": "Sets the approximate tempo for playback." + }, + "music.set_tempo.param-name.bpm": { + "message": "bpm", + "description": "(parameter name) An integer determining how many beats per minute." + }, + "music.set_tempo.param-doc.bpm": { + "message": "Ein Integerwert, der die Beats pro Minute angibt.", + "description": "Parameter docs" + }, + "music.set_tempo.param-name.ticks": { + "message": "ticks", + "description": "(parameter name) The number of ticks constituting a beat." + }, + "music.set_tempo.param-doc.ticks": { + "message": "Die Anzahl der Ticks in einem Beat.", + "description": "Parameter docs" + }, + "music.get_tempo": { + "message": "get tempo", + "description": "(function name) Gets the current tempo as a tuple of integers: ``(ticks, bpm)``." + }, + "music.get_tempo.summary": { + "message": "Gibt das aktuelle Tempo als Tupel von Integerwerten zurück: {{(ticks, bpm)}}.", + "description": "Gets the current tempo as a tuple of integers: ``(ticks, bpm)``." + }, + "music.play": { + "message": "play", + "description": "(function name) Plays music." + }, + "music.play.summary": { + "message": "Spielt Musik.", + "description": "Plays music." + }, + "music.play.param-name.loop": { + "message": "loop", + "description": "(parameter name) If ``loop`` is set to ``True``, the tune repeats until ``stop`` is called or the blocking call is interrupted." + }, + "music.play.param-doc.loop": { + "message": "Wenn {{loop}} auf {{True}} gesetzt ist, wird die Melodie wiederholt, bis {{stop}} aufgerufen oder der blockierende Aufruf unterbrochen wird.", + "description": "Parameter docs" + }, + "music.play.param-name.music": { + "message": "Musik", + "description": "(parameter name) music specified in `a special notation `_" + }, + "music.play.param-doc.music": { + "message": "Musik, die in `einer speziellen Notation `_ angegeben ist", + "description": "Parameter docs" + }, + "music.play.param-name.pin": { + "message": "pin", + "description": "(parameter name) the output pin for use with an external speaker (default ``pin0``), ``None`` for no sound." + }, + "music.play.param-doc.pin": { + "message": "der Ausgangspin zur Verwendung mit einem externen Lautsprecher (Voreinstellung {{pin0}}), {{None}} für keinen Ton.", + "description": "Parameter docs" + }, + "music.play.param-name.wait": { + "message": "wait", + "description": "(parameter name) If ``wait`` is set to ``True``, this function is blocking." + }, + "music.play.param-doc.wait": { + "message": "Wenn {{wait}} auf {{True}} gesetzt ist, stoppt diese Funktion die weitere Codeausführung.", + "description": "Parameter docs" + }, + "music.pitch": { + "message": "Tonhöhe", + "description": "(function name) Play a note." + }, + "music.pitch.summary": { + "message": "Musiknoten spielen", + "description": "Play a note." + }, + "music.pitch.param-name.duration": { + "message": "Dauer", + "description": "(parameter name) A millisecond duration. If negative then sound is continuous until the next call or a call to ``stop``." + }, + "music.pitch.param-doc.duration": { + "message": "Eine Dauer in Millisekunden. Bei negativem Wert erhält man bis zum nächsten Aufruf oder einem Aufruf von {{stop}} einen Dauerton.", + "description": "Parameter docs" + }, + "music.pitch.param-name.frequency": { + "message": "Frequenz", + "description": "(parameter name) An integer frequency" + }, + "music.pitch.param-doc.frequency": { + "message": "Eine ganzzahlige Frequenz", + "description": "Parameter docs" + }, + "music.pitch.param-name.pin": { + "message": "pin", + "description": "(parameter name) Optional output pin (default ``pin0``)." + }, + "music.pitch.param-doc.pin": { + "message": "Optionaler Ausgabepin (Standard {{pin0}}).", + "description": "Parameter docs" + }, + "music.pitch.param-name.wait": { + "message": "wait", + "description": "(parameter name) If ``wait`` is set to ``True``, this function is blocking." + }, + "music.pitch.param-doc.wait": { + "message": "Wenn {{wait}} auf {{True}} gesetzt ist, stoppt diese Funktion die weitere Codeausführung.", + "description": "Parameter docs" + }, + "music.stop": { + "message": "stop", + "description": "(function name) Stops all music playback on the built-in speaker and any pin outputting sound." + }, + "music.stop.summary": { + "message": "Stoppt die Musikwiedergabe über den eingebauten Lautsprecher sowie jeden Pin, der Sound ausgibt.", + "description": "Stops all music playback on the built-in speaker and any pin outputting sound." + }, + "music.stop.param-name.pin": { + "message": "pin", + "description": "(parameter name) An optional argument can be provided to specify a pin, e.g. ``music.stop(pin1)``." + }, + "music.stop.param-doc.pin": { + "message": "Ein optionales Argument kann zur Angabe eines Pins angegeben werden, z. B. {{music.stop(pin1)}}.", + "description": "Parameter docs" + }, + "music.reset": { + "message": "zurücksetzen", + "description": "(function name) Resets ticks, bpm, duration and octave to their default values." + }, + "music.reset.summary": { + "message": "Setzt Ticks, bpm, Dauer und Oktave auf ihre Standardwerte zurück.", + "description": "Resets ticks, bpm, duration and octave to their default values." + }, + "neopixel": { + "message": "neopixel", + "description": "(module name) Individually addressable RGB and RGBW LED strips." + }, + "neopixel.summary": { + "message": "Individuell adressierbare RGB- und RGBW-LED-Streifen.", + "description": "Individually addressable RGB and RGBW LED strips." + }, + "neopixel.NeoPixel.__init__": { + "message": "init", + "description": "(function name) Initialise a new strip of neopixel LEDs controlled via a pin." + }, + "neopixel.NeoPixel.__init__.summary": { + "message": "Initialisierung eines neuen Streifens von Neopixel-LEDs, die über einen Pin gesteuert werden.", + "description": "Initialise a new strip of neopixel LEDs controlled via a pin." + }, + "neopixel.NeoPixel.__init__.param-name.bpp": { + "message": "bpp", + "description": "(parameter name) Bytes per pixel. For RGBW neopixel support, pass 4 rather than the default of 3 for RGB and GRB." + }, + "neopixel.NeoPixel.__init__.param-doc.bpp": { + "message": "Bytes pro Pixel. Für die RGBW Neopixel-Unterstützung, müssen 4 statt der standardmäßigen 3 Bytes pro Pixel für RGB und GRB übergeben werden.", + "description": "Parameter docs" + }, + "neopixel.NeoPixel.__init__.param-name.n": { + "message": "n", + "description": "(parameter name) The number of neopixels in the strip." + }, + "neopixel.NeoPixel.__init__.param-doc.n": { + "message": "Die Anzahl der Neopixel auf dem Streifen.", + "description": "Parameter docs" + }, + "neopixel.NeoPixel.__init__.param-name.pin": { + "message": "pin", + "description": "(parameter name) The pin controlling the neopixel strip." + }, + "neopixel.NeoPixel.__init__.param-doc.pin": { + "message": "Der Pin, der den Neopixelstreifen steuert.", + "description": "Parameter docs" + }, + "neopixel.NeoPixel.clear": { + "message": "löschen", + "description": "(function name) Clear all the pixels." + }, + "neopixel.NeoPixel.clear.summary": { + "message": "Lösche alle Pixel.", + "description": "Clear all the pixels." + }, + "neopixel.NeoPixel.show": { + "message": "show", + "description": "(function name) Show the pixels." + }, + "neopixel.NeoPixel.show.summary": { + "message": "Die Pixel anzeigen.", + "description": "Show the pixels." + }, + "neopixel.NeoPixel.write": { + "message": "schreiben", + "description": "(function name) Show the pixels (micro:bit V2 only)." + }, + "neopixel.NeoPixel.write.summary": { + "message": "Pixel anzeigen (nur micro:bit V2)", + "description": "Show the pixels (micro:bit V2 only)." + }, + "neopixel.NeoPixel.fill": { + "message": "fill", + "description": "(function name) Colour all pixels a given RGB/RGBW value (micro:bit V2 only)." + }, + "neopixel.NeoPixel.fill.summary": { + "message": "Alle Pixel mit einem bestimmten RGB/RGBW-Wert färben.", + "description": "Colour all pixels a given RGB/RGBW value (micro:bit V2 only)." + }, + "neopixel.NeoPixel.fill.param-name.colour": { + "message": "Farbe", + "description": "(parameter name) A tuple of the same length as the number of bytes per pixel (bpp)." + }, + "neopixel.NeoPixel.fill.param-doc.colour": { + "message": "Ein Tupel mit der gleichen Länge wie die Anzahl der Bytes pro Pixel (bpp).", + "description": "Parameter docs" + }, + "neopixel.NeoPixel.__setitem__": { + "message": "setitem", + "description": "(function name) Set a pixel colour." + }, + "neopixel.NeoPixel.__setitem__.summary": { + "message": "Eine Pixelfarbe festlegen.", + "description": "Set a pixel colour." + }, + "neopixel.NeoPixel.__setitem__.param-name.key": { + "message": "key", + "description": "(parameter name) The pixel number." + }, + "neopixel.NeoPixel.__setitem__.param-doc.key": { + "message": "Die Pixelnummer.", + "description": "Parameter docs" + }, + "neopixel.NeoPixel.__setitem__.param-name.value": { + "message": "wert", + "description": "(parameter name) The colour." + }, + "neopixel.NeoPixel.__setitem__.param-doc.value": { + "message": "Die Farbe.", + "description": "Parameter docs" + }, + "neopixel.NeoPixel.__getitem__": { + "message": "getitem", + "description": "(function name) Get a pixel colour." + }, + "neopixel.NeoPixel.__getitem__.summary": { + "message": "Eine Pixelfarbe erfassen.", + "description": "Get a pixel colour." + }, + "neopixel.NeoPixel.__getitem__.param-name.key": { + "message": "key", + "description": "(parameter name) The pixel number." + }, + "neopixel.NeoPixel.__getitem__.param-doc.key": { + "message": "Die Pixelnummer.", + "description": "Parameter docs" + }, + "neopixel.NeoPixel.__len__": { + "message": "len", + "description": "(function name) Get length of this pixel strip." + }, + "neopixel.NeoPixel.__len__.summary": { + "message": "Erhalte die Länge des Pixelstreifens.", + "description": "Get length of this pixel strip." + }, + "os": { + "message": "os", + "description": "(module name) Access the file system." + }, + "os.summary": { + "message": "Auf das Dateisystem zugreifen.", + "description": "Access the file system." + }, + "os.listdir": { + "message": "listdir", + "description": "(function name) List files." + }, + "os.listdir.summary": { + "message": "Dateien auflisten.", + "description": "List files." + }, + "os.remove": { + "message": "Entfernen", + "description": "(function name) Remove (delete) a file." + }, + "os.remove.summary": { + "message": "Entferne (lösche) eine Datei.", + "description": "Remove (delete) a file." + }, + "os.remove.param-name.filename": { + "message": "Dateiname", + "description": "(parameter name) The file to delete." + }, + "os.remove.param-doc.filename": { + "message": "Die zu löschende Datei.", + "description": "Parameter docs" + }, + "os.size": { + "message": "size", + "description": "(function name) Returns the size of a file." + }, + "os.size.summary": { + "message": "Gibt die Größe einer Datei zurück", + "description": "Returns the size of a file." + }, + "os.size.param-name.filename": { + "message": "Dateiname", + "description": "(parameter name) The file" + }, + "os.size.param-doc.filename": { + "message": "Die Datei", + "description": "Parameter docs" + }, + "os.uname_result": { + "message": "uname result", + "description": "(class name) Result of ``os.uname()``" + }, + "os.uname_result.summary": { + "message": "Ergebnis von {{os.uname()}}", + "description": "Result of ``os.uname()``" + }, + "os.uname_result.sysname": { + "message": "sysname", + "description": "(field name) Operating system name." + }, + "os.uname_result.sysname.summary": { + "message": "Name des Betriebssystems.", + "description": "Operating system name." + }, + "os.uname_result.nodename": { + "message": "Knotenname", + "description": "(field name) Name of machine on network (implementation-defined)." + }, + "os.uname_result.nodename.summary": { + "message": "Name des Rechners im Netz (durch die Implementierung definiert).", + "description": "Name of machine on network (implementation-defined)." + }, + "os.uname_result.release": { + "message": "Veröffentlichung", + "description": "(field name) Operating system release." + }, + "os.uname_result.release.summary": { + "message": "Betriebssystemveröffentlichung.", + "description": "Operating system release." + }, + "os.uname_result.version": { + "message": "Version", + "description": "(field name) Operating system version." + }, + "os.uname_result.version.summary": { + "message": "Betriebssystemversion.", + "description": "Operating system version." + }, + "os.uname_result.machine": { + "message": "maschine", + "description": "(field name) Hardware identifier." + }, + "os.uname_result.machine.summary": { + "message": "Hardware-Kennung.", + "description": "Hardware identifier." + }, + "os.uname": { + "message": "uname", + "description": "(function name) Returns information identifying the current operating system." + }, + "os.uname.summary": { + "message": "Gibt Informationen zum aktuellen Betriebssystem zurück.", + "description": "Returns information identifying the current operating system." + }, + "radio": { + "message": "radio", + "description": "(module name) Communicate between micro:bits with the built-in radio." + }, + "radio.summary": { + "message": "Kommunikation zwischen micro:bits mit dem integrierten Funk.", + "description": "Communicate between micro:bits with the built-in radio." + }, + "radio.RATE_1MBIT": { + "message": "rate 1mbit", + "description": "(field name) Constant used to indicate a throughput of 1 MBit a second." + }, + "radio.RATE_1MBIT.summary": { + "message": "Konstante zur Angabe eines Durchsatzes von 1 MBit pro Sekunde.", + "description": "Constant used to indicate a throughput of 1 MBit a second." + }, + "radio.RATE_2MBIT": { + "message": "rate 2mbit", + "description": "(field name) Constant used to indicate a throughput of 2 MBit a second." + }, + "radio.RATE_2MBIT.summary": { + "message": "Konstante zur Angabe eines Durchsatzes von 2 MBit pro Sekunde.", + "description": "Constant used to indicate a throughput of 2 MBit a second." + }, + "radio.on": { + "message": "an", + "description": "(function name) Turns the radio on." + }, + "radio.on.summary": { + "message": "Schaltet den Funk ein.", + "description": "Turns the radio on." + }, + "radio.off": { + "message": "off", + "description": "(function name) Turns off the radio, saving power and memory." + }, + "radio.off.summary": { + "message": "Schaltet den Funk aus, um Strom und Speicherplatz zu sparen.", + "description": "Turns off the radio, saving power and memory." + }, + "radio.config": { + "message": "config", + "description": "(function name) Configures the radio." + }, + "radio.config.summary": { + "message": "Konfiguriert den Funk.", + "description": "Configures the radio." + }, + "radio.config.param-name.address": { + "message": "adresse", + "description": "(parameter name) (default=0x75626974) an arbitrary name, expressed as a 32-bit address, that's used to filter incoming packets at the hardware level, keeping only those that match the address you set.\nThe default used by other micro:bit related platforms is the default setting used here." + }, + "radio.config.param-doc.address": { + "message": "(default=0x75626974) ein beliebiger Name, ausgedrückt als 32-Bit-Adresse, der verwendet wird, um eingehende Pakete auf der Hardware-Ebene zu filtern und nur diejenigen zu behalten, die mit der eingestellten Adresse übereinstimmen. \nDie Standardeinstellung, die von anderen micro:bit-verwandten Plattformen verwendet wird, wird auch hier verwendet.", + "description": "Parameter docs" + }, + "radio.config.param-name.channel": { + "message": "channel", + "description": "(parameter name) (default=7) an integer value from 0 to 83 (inclusive) that defines an arbitrary \"channel\" to which the radio is tuned.\nMessages will be sent via this channel and only messages received via this channel will be put onto the incoming message queue. Each step is 1MHz wide, based at 2400MHz." + }, + "radio.config.param-doc.channel": { + "message": "(default=7) ein Integer-Wert zwischen 0 und 83 (einschließlich), der einen beliebigen \"Kanal\" definiert, auf den der Funk eingestellt ist.\nNachrichten werden über diesen Kanal gesendet und nur Nachrichten, die über diesen Kanal empfangen werden, werden in die Warteschlange der eingehenden Nachricht aufgenommen. Jeder Schritt ist 1MHz breit, beginnend mit 2400MHz.", + "description": "Parameter docs" + }, + "radio.config.param-name.data_rate": { + "message": "data rate", + "description": "(parameter name) (default=``radio.RATE_1MBIT``) indicates the speed at which data throughput takes place.\nCan be one of the following constants defined in the ``radio`` module: ``RATE_250KBIT``, ``RATE_1MBIT`` or ``RATE_2MBIT``." + }, + "radio.config.param-doc.data_rate": { + "message": "(default={{radio.RATE_1MBIT}}) zeigt die Geschwindigkeit an, mit der der Datendurchsatz stattfindet.\nKann eine der folgenden Konstanten sein, die im Modul {{radio}} definiert sind: {{RATE_250KBIT}}, {{RATE_1MBIT}} oder {{RATE_2MBIT}}.", + "description": "Parameter docs" + }, + "radio.config.param-name.group": { + "message": "group", + "description": "(parameter name) (default=0) an 8-bit value (0-255) used with the ``address`` when filtering messages.\nConceptually, \"address\" is like a house/office address and \"group\" is like the person at that address to which you want to send your message." + }, + "radio.config.param-doc.group": { + "message": "(default=0) ein 8-Bit-Wert (0-255), der zusammen mit {{address}} beim Filtern von Nachrichten verwendet wird. \"address\" ist wie eine Haus-/Büroadresse und \"group\" ist wie die Person an dieser Adresse, an die die Nachricht gesendet werden soll.", + "description": "Parameter docs" + }, + "radio.config.param-name.length": { + "message": "length", + "description": "(parameter name) (default=32) defines the maximum length, in bytes, of a message sent via the radio.\nIt can be up to 251 bytes long (254 - 3 bytes for S0, LENGTH and S1 preamble)." + }, + "radio.config.param-doc.length": { + "message": "(default=32) legt die maximale Länge einer über Funk gesendeten Nachricht in Bytes fest. Sie kann bis zu 251 Bytes lang sein (254 - 3 Bytes für S0, LENGTH und S1-Präambel).", + "description": "Parameter docs" + }, + "radio.config.param-name.power": { + "message": "power", + "description": "(parameter name) (default=6) is an integer value from 0 to 7 (inclusive) to indicate the strength of signal used when broadcasting a message.\nThe higher the value the stronger the signal, but the more power is consumed by the device. The numbering translates to positions in the following list of dBm (decibel milliwatt) values: -30, -20, -16, -12, -8, -4, 0, 4." + }, + "radio.config.param-doc.power": { + "message": "(default=6) ist ein ganzzahliger Wert von 0 bis 7 (einschließlich), der die Stärke des Signals angibt, das beim Senden einer Nachricht verwendet wird. Je höher der Wert, desto stärker ist das Signal, aber desto mehr Strom wird vom Gerät verbraucht. Die Nummerierung entspricht den Positionen in der folgenden Liste von dBm-Werten (Dezibel Milliwatt): -30, -20, -16, -12, -8, -4, 0, 4.", + "description": "Parameter docs" + }, + "radio.config.param-name.queue": { + "message": "queue", + "description": "(parameter name) (default=3) specifies the number of messages that can be stored on the incoming message queue.\nIf there are no spaces left on the queue for incoming messages, then the incoming message is dropped." + }, + "radio.config.param-doc.queue": { + "message": "(default=3) gibt die Anzahl der Nachrichten an, die in der Warteschlange für eingehende Nachrichten gespeichert werden können. Wenn in der Warteschlange kein Platz mehr für eingehende Nachrichten ist, wird die eingehende Nachricht verworfen.", + "description": "Parameter docs" + }, + "radio.reset": { + "message": "zurücksetzen", + "description": "(function name) Reset the settings to their default values." + }, + "radio.reset.summary": { + "message": "Setzt die Einstellungen auf ihre Standardwerte zurück.", + "description": "Reset the settings to their default values." + }, + "radio.send_bytes": { + "message": "send bytes", + "description": "(function name) Sends a message containing bytes." + }, + "radio.send_bytes.summary": { + "message": "Sendet eine Nachricht bestehend aus Bytes.", + "description": "Sends a message containing bytes." + }, + "radio.send_bytes.param-name.message": { + "message": "message", + "description": "(parameter name) The bytes to send." + }, + "radio.send_bytes.param-doc.message": { + "message": "Die zu sendenden Bytes.", + "description": "Parameter docs" + }, + "radio.receive_bytes": { + "message": "receive bytes", + "description": "(function name) Receive the next incoming message on the message queue." + }, + "radio.receive_bytes.summary": { + "message": "Empfängt die nächste eingehende Nachricht in der Nachrichtenwarteschlange.", + "description": "Receive the next incoming message on the message queue." + }, + "radio.receive_bytes_into": { + "message": "receive bytes into", + "description": "(function name) Copy the next incoming message on the message queue into a buffer." + }, + "radio.receive_bytes_into.summary": { + "message": "Kopiert die nächste eingehende Nachricht in der Nachrichtenwarteschlange in einen Puffer.", + "description": "Copy the next incoming message on the message queue into a buffer." + }, + "radio.receive_bytes_into.param-name.buffer": { + "message": "Puffer", + "description": "(parameter name) The target buffer. The message is truncated if larger than the buffer." + }, + "radio.receive_bytes_into.param-doc.buffer": { + "message": "Der Zielpuffer. Die Nachricht wird abgeschnitten, wenn sie größer als der Puffer ist.", + "description": "Parameter docs" + }, + "radio.send": { + "message": "send", + "description": "(function name) Sends a message string." + }, + "radio.send.summary": { + "message": "Sendet eine Nachricht als String.", + "description": "Sends a message string." + }, + "radio.send.param-name.message": { + "message": "message", + "description": "(parameter name) The string to send." + }, + "radio.send.param-doc.message": { + "message": "Der zu sendende String.", + "description": "Parameter docs" + }, + "radio.receive": { + "message": "receive", + "description": "(function name) Works in exactly the same way as ``receive_bytes`` but returns whatever was sent." + }, + "radio.receive.summary": { + "message": "Funktioniert genauso wie {{receive_bytes}}, gibt aber zurück, was gesendet wurde.", + "description": "Works in exactly the same way as ``receive_bytes`` but returns whatever was sent." + }, + "radio.receive_full": { + "message": "receive full", + "description": "(function name) Returns a tuple containing three values representing the next incoming message on the message queue." + }, + "radio.receive_full.summary": { + "message": "Gibt ein Tupel mit drei Werten zurück, die die nächste eingehende Nachricht in der Nachrichtenwarteschlange darstellen.", + "description": "Returns a tuple containing three values representing the next incoming message on the message queue." + }, + "random": { + "message": "random", + "description": "(module name) Generate random numbers." + }, + "random.summary": { + "message": "Gibt eine Zufallszahl zurück.", + "description": "Generate random numbers." + }, + "random.getrandbits": { + "message": "getrandbits", + "description": "(function name) Generate an integer with ``n`` random bits." + }, + "random.getrandbits.summary": { + "message": "Erzeugt einen Integerwert mit {{n}} zufälligen Bits.", + "description": "Generate an integer with ``n`` random bits." + }, + "random.getrandbits.param-name.n": { + "message": "n", + "description": "(parameter name) A value between 1-30 (inclusive)." + }, + "random.getrandbits.param-doc.n": { + "message": "Ein Wert zwischen 1-30 (einschließlich).", + "description": "Parameter docs" + }, + "random.seed": { + "message": "seed", + "description": "(function name) Initialize the random number generator." + }, + "random.seed.summary": { + "message": "Initialisiert den Zufallszahlengenerator.", + "description": "Initialize the random number generator." + }, + "random.seed.param-name.n": { + "message": "n", + "description": "(parameter name) The integer seed" + }, + "random.seed.param-doc.n": { + "message": "Der Integer-Seed", + "description": "Parameter docs" + }, + "random.randint": { + "message": "randint", + "description": "(function name) Choose a random integer between ``a`` and ``b`` inclusive." + }, + "random.randint.summary": { + "message": "Wählt eine zufällige Ganzzahl zwischen {{a}} und {{b}} (einschließlich) aus.", + "description": "Choose a random integer between ``a`` and ``b`` inclusive." + }, + "random.randint.param-name.a": { + "message": "a", + "description": "(parameter name) Start value for the range (inclusive)" + }, + "random.randint.param-doc.a": { + "message": "Anfangswert für den Bereich (inklusiv)", + "description": "Parameter docs" + }, + "random.randint.param-name.b": { + "message": "b", + "description": "(parameter name) End value for the range (inclusive)" + }, + "random.randint.param-doc.b": { + "message": "Endwert für den Bereich (inklusiv)", + "description": "Parameter docs" + }, + "random.randrange-1": { + "message": "randrange", + "description": "(function name) Choose a randomly selected integer between zero and up to (but not\nincluding) ``stop``." + }, + "random.randrange-1.summary": { + "message": "Wählt eine zufällige Ganzzahl zwischen Null und {{stop}} (exklusiv) aus.", + "description": "Choose a randomly selected integer between zero and up to (but not\nincluding) ``stop``." + }, + "random.randrange-1.param-name.stop": { + "message": "stop", + "description": "(parameter name) End value for the range (exclusive)" + }, + "random.randrange-1.param-doc.stop": { + "message": "Endwert für den Bereich (exklusiv)", + "description": "Parameter docs" + }, + "random.randrange-2": { + "message": "randrange", + "description": "(function name) Choose a randomly selected element from ``range(start, stop, step)``." + }, + "random.randrange-2.summary": { + "message": "Wählt ein zufälliges Element aus {{range(start, stop, step)}}.", + "description": "Choose a randomly selected element from ``range(start, stop, step)``." + }, + "random.randrange-2.param-name.start": { + "message": "start", + "description": "(parameter name) The start of the range (inclusive)" + }, + "random.randrange-2.param-doc.start": { + "message": "Anfang des Bereichs (inklusiv)", + "description": "Parameter docs" + }, + "random.randrange-2.param-name.step": { + "message": "step", + "description": "(parameter name) The step." + }, + "random.randrange-2.param-doc.step": { + "message": "Schrittweite", + "description": "Parameter docs" + }, + "random.randrange-2.param-name.stop": { + "message": "stop", + "description": "(parameter name) The end of the range (exclusive)" + }, + "random.randrange-2.param-doc.stop": { + "message": "Das Ende des Bereichs (exklusiv)", + "description": "Parameter docs" + }, + "random.choice": { + "message": "choice", + "description": "(function name) Choose a random element from the non-empty sequence ``seq``." + }, + "random.choice.summary": { + "message": "Wählt ein zufälliges Element aus der nicht leeren Sequenz {{seq}}.", + "description": "Choose a random element from the non-empty sequence ``seq``." + }, + "random.choice.param-name.seq": { + "message": "seq", + "description": "(parameter name) A sequence." + }, + "random.choice.param-doc.seq": { + "message": "Eine Sequenz.", + "description": "Parameter docs" + }, + "random.random": { + "message": "random", + "description": "(function name) Generate a random floating point number in the range [0.0, 1.0)." + }, + "random.random.summary": { + "message": "Erzeugt eine zufällige Fließkommazahl im Bereich [0.0, 1.0).", + "description": "Generate a random floating point number in the range [0.0, 1.0)." + }, + "random.uniform": { + "message": "uniform", + "description": "(function name) Return a random floating point number between ``a`` and ``b`` inclusive." + }, + "random.uniform.summary": { + "message": "Gibt eine zufällige Fließkommazahl zwischen {{a}} und {{b}} inklusiv aus.", + "description": "Return a random floating point number between ``a`` and ``b`` inclusive." + }, + "random.uniform.param-name.a": { + "message": "a", + "description": "(parameter name) Start value for the range (inclusive)" + }, + "random.uniform.param-doc.a": { + "message": "Anfangswert für den Bereich (inklusiv)", + "description": "Parameter docs" + }, + "random.uniform.param-name.b": { + "message": "b", + "description": "(parameter name) End value for the range (inclusive)" + }, + "random.uniform.param-doc.b": { + "message": "Endwert für den Bereich (inklusiv)", + "description": "Parameter docs" + }, + "speech": { + "message": "speech", + "description": "(module name) Make the micro:bit talk, sing and make other speech like sounds." + }, + "speech.summary": { + "message": "Bringe den micro:bit dazu zu Sprechen, zu Singen und andere sprachähnliche Geräusche zu machen.", + "description": "Make the micro:bit talk, sing and make other speech like sounds." + }, + "speech.translate": { + "message": "translate", + "description": "(function name) Translate English words to phonemes." + }, + "speech.translate.summary": { + "message": "Übersetze englische Wörter in Sprache.", + "description": "Translate English words to phonemes." + }, + "speech.translate.param-name.words": { + "message": "Wörter", + "description": "(parameter name) A string of English words." + }, + "speech.translate.param-doc.words": { + "message": "Ein String englischer Wörter.", + "description": "Parameter docs" + }, + "speech.pronounce": { + "message": "pronounce", + "description": "(function name) Pronounce phonemes." + }, + "speech.pronounce.summary": { + "message": "Laute aussprechen.", + "description": "Pronounce phonemes." + }, + "speech.pronounce.param-name.mouth": { + "message": "Mund", + "description": "(parameter name) A number representing the mouth of the voice" + }, + "speech.pronounce.param-doc.mouth": { + "message": "Eine Zahl, die den Mund der Stimme repräsentiert", + "description": "Parameter docs" + }, + "speech.pronounce.param-name.phonemes": { + "message": "Phoneme", + "description": "(parameter name) The string of phonemes to pronounce" + }, + "speech.pronounce.param-doc.phonemes": { + "message": "Die auszusprechenden Phoneme als Zeichenkette", + "description": "Parameter docs" + }, + "speech.pronounce.param-name.pin": { + "message": "pin", + "description": "(parameter name) Optional argument to specify the output pin can be used to override the default of ``pin0``.\nIf we do not want any sound to play out of the pins can use ``pin=None``. micro:bit V2 only." + }, + "speech.pronounce.param-doc.pin": { + "message": "Optionales Argument, um den Ausgangspin anzugeben, kann verwendet werden, um den Standardwert von {{pin0}} zu überschreiben. Wenn wir keinen Ton über die Pins abspielen wollen, können wir {{pin=None}} verwenden. nur micro:bit V2.", + "description": "Parameter docs" + }, + "speech.pronounce.param-name.pitch": { + "message": "Tonhöhe", + "description": "(parameter name) A number representing the pitch of the voice" + }, + "speech.pronounce.param-doc.pitch": { + "message": "Eine Zahl, die die Tonhöhe der Stimme angibt", + "description": "Parameter docs" + }, + "speech.pronounce.param-name.speed": { + "message": "tempo", + "description": "(parameter name) A number representing the speed of the voice" + }, + "speech.pronounce.param-doc.speed": { + "message": "Eine Zahl, die die Geschwindigkeit der Stimme angibt", + "description": "Parameter docs" + }, + "speech.pronounce.param-name.throat": { + "message": "klang ", + "description": "(parameter name) A number representing the throat of the voice" + }, + "speech.pronounce.param-doc.throat": { + "message": "Eine Zahl, die den Klang der Stimme angibt", + "description": "Parameter docs" + }, + "speech.say": { + "message": "sage", + "description": "(function name) Say English words." + }, + "speech.say.summary": { + "message": "Sage englische Wörter", + "description": "Say English words." + }, + "speech.say.param-name.mouth": { + "message": "Mund", + "description": "(parameter name) A number representing the mouth of the voice" + }, + "speech.say.param-doc.mouth": { + "message": "Eine Zahl, die den Mund der Stimme repräsentiert", + "description": "Parameter docs" + }, + "speech.say.param-name.pin": { + "message": "pin", + "description": "(parameter name) Optional argument to specify the output pin can be used to override the default of ``pin0``.\nIf we do not want any sound to play out of the pins can use ``pin=None``. micro:bit V2 only." + }, + "speech.say.param-doc.pin": { + "message": "Optionales Argument, um den Ausgangspin anzugeben, kann verwendet werden, um den Standardwert von {{pin0}} zu überschreiben. Wenn wir keinen Ton über die Pins abspielen wollen, können wir {{pin=None}} verwenden. nur micro:bit V2.", + "description": "Parameter docs" + }, + "speech.say.param-name.pitch": { + "message": "Tonhöhe", + "description": "(parameter name) A number representing the pitch of the voice" + }, + "speech.say.param-doc.pitch": { + "message": "Eine Zahl, die die Tonhöhe der Stimme angibt", + "description": "Parameter docs" + }, + "speech.say.param-name.speed": { + "message": "tempo", + "description": "(parameter name) A number representing the speed of the voice" + }, + "speech.say.param-doc.speed": { + "message": "Eine Zahl, die die Geschwindigkeit der Stimme angibt", + "description": "Parameter docs" + }, + "speech.say.param-name.throat": { + "message": "klang ", + "description": "(parameter name) A number representing the throat of the voice" + }, + "speech.say.param-doc.throat": { + "message": "Eine Zahl, die den Klang der Stimme angibt", + "description": "Parameter docs" + }, + "speech.say.param-name.words": { + "message": "Wörter", + "description": "(parameter name) The string of words to say." + }, + "speech.say.param-doc.words": { + "message": "Der zu sagene String", + "description": "Parameter docs" + }, + "speech.sing": { + "message": "sing", + "description": "(function name) Sing phonemes." + }, + "speech.sing.summary": { + "message": "Singe Phoneme", + "description": "Sing phonemes." + }, + "speech.sing.param-name.mouth": { + "message": "Mund", + "description": "(parameter name) A number representing the mouth of the voice" + }, + "speech.sing.param-doc.mouth": { + "message": "Eine Zahl, die den Mund der Stimme repräsentiert", + "description": "Parameter docs" + }, + "speech.sing.param-name.phonemes": { + "message": "Phoneme", + "description": "(parameter name) The string of words to sing." + }, + "speech.sing.param-doc.phonemes": { + "message": "Der zu singende String", + "description": "Parameter docs" + }, + "speech.sing.param-name.pin": { + "message": "pin", + "description": "(parameter name) Optional argument to specify the output pin can be used to override the default of ``pin0``.\nIf we do not want any sound to play out of the pins can use ``pin=None``. micro:bit V2 only." + }, + "speech.sing.param-doc.pin": { + "message": "Optionales Argument, um den Ausgangspin anzugeben, kann verwendet werden, um den Standardwert von {{pin0}} zu überschreiben. Wenn wir keinen Ton über die Pins abspielen wollen, können wir {{pin=None}} verwenden. nur micro:bit V2.", + "description": "Parameter docs" + }, + "speech.sing.param-name.pitch": { + "message": "Tonhöhe", + "description": "(parameter name) A number representing the pitch of the voice" + }, + "speech.sing.param-doc.pitch": { + "message": "Eine Zahl, die die Tonhöhe der Stimme angibt", + "description": "Parameter docs" + }, + "speech.sing.param-name.speed": { + "message": "tempo", + "description": "(parameter name) A number representing the speed of the voice" + }, + "speech.sing.param-doc.speed": { + "message": "Eine Zahl, die die Geschwindigkeit der Stimme angibt", + "description": "Parameter docs" + }, + "speech.sing.param-name.throat": { + "message": "klang ", + "description": "(parameter name) A number representing the throat of the voice" + }, + "speech.sing.param-doc.throat": { + "message": "Eine Zahl, die den Klang der Stimme angibt", + "description": "Parameter docs" + }, + "struct": { + "message": "struktur", + "description": "(module name) Pack and unpack primitive data types." + }, + "struct.summary": { + "message": "Packe und entpacke primitive Datentypen.", + "description": "Pack and unpack primitive data types." + }, + "struct.calcsize": { + "message": "calcsize", + "description": "(function name) Get the number of bytes needed to store the given ``fmt``." + }, + "struct.calcsize.summary": { + "message": "Rufe die Anzahl der benötigten Bytes ab, um den angegebenen {{fmt}} zu speichern.", + "description": "Get the number of bytes needed to store the given ``fmt``." + }, + "struct.calcsize.param-name.fmt": { + "message": "fmt", + "description": "(parameter name) A format string." + }, + "struct.calcsize.param-doc.fmt": { + "message": "Ein Format-String.", + "description": "Parameter docs" + }, + "struct.pack": { + "message": "packen", + "description": "(function name) Pack values according to a format string." + }, + "struct.pack.summary": { + "message": "Werte nach einem Format-String packen.", + "description": "Pack values according to a format string." + }, + "struct.pack.param-name.*vn": { + "message": "*vn", + "description": "(parameter name) The remaining values." + }, + "struct.pack.param-doc.*vn": { + "message": "Die verbleibenden Werte.", + "description": "Parameter docs" + }, + "struct.pack.param-name.fmt": { + "message": "fmt", + "description": "(parameter name) The format string." + }, + "struct.pack.param-doc.fmt": { + "message": "Der Formatstring", + "description": "Parameter docs" + }, + "struct.pack.param-name.v1": { + "message": "v1", + "description": "(parameter name) The first value." + }, + "struct.pack.param-doc.v1": { + "message": "Der erste Wert.", + "description": "Parameter docs" + }, + "struct.pack_into": { + "message": "packen in", + "description": "(function name) Pack values according to a format string." + }, + "struct.pack_into.summary": { + "message": "Werte nach einem Format-String packen.", + "description": "Pack values according to a format string." + }, + "struct.pack_into.param-name.*vn": { + "message": "*vn", + "description": "(parameter name) The remaining values." + }, + "struct.pack_into.param-doc.*vn": { + "message": "Die verbleibenden Werte.", + "description": "Parameter docs" + }, + "struct.pack_into.param-name.buffer": { + "message": "Puffer", + "description": "(parameter name) The target buffer to write into." + }, + "struct.pack_into.param-doc.buffer": { + "message": "Der Buffer, in den geschrieben werden soll.", + "description": "Parameter docs" + }, + "struct.pack_into.param-name.fmt": { + "message": "fmt", + "description": "(parameter name) The format string." + }, + "struct.pack_into.param-doc.fmt": { + "message": "Der Formatstring", + "description": "Parameter docs" + }, + "struct.pack_into.param-name.offset": { + "message": "offset", + "description": "(parameter name) The offset into the buffer. May be negative to count from the end of the buffer." + }, + "struct.pack_into.param-doc.offset": { + "message": "Der Offset in den Puffer. Kann negativ sein, um vom Ende des Puffers aus zu zählen.", + "description": "Parameter docs" + }, + "struct.pack_into.param-name.v1": { + "message": "v1", + "description": "(parameter name) The first value." + }, + "struct.pack_into.param-doc.v1": { + "message": "Der erste Wert.", + "description": "Parameter docs" + }, + "struct.unpack": { + "message": "unpack", + "description": "(function name) Unpack data according to a format string." + }, + "struct.unpack.summary": { + "message": "Daten nach einem Format-String entpacken.", + "description": "Unpack data according to a format string." + }, + "struct.unpack.param-name.data": { + "message": "Daten", + "description": "(parameter name) The data." + }, + "struct.unpack.param-doc.data": { + "message": "Die Daten.", + "description": "Parameter docs" + }, + "struct.unpack.param-name.fmt": { + "message": "fmt", + "description": "(parameter name) The format string." + }, + "struct.unpack.param-doc.fmt": { + "message": "Der Formatstring", + "description": "Parameter docs" + }, + "struct.unpack_from": { + "message": "entpacken von", + "description": "(function name) Unpack data from a buffer according to a format string." + }, + "struct.unpack_from.summary": { + "message": "Daten aus einem Puffer nach einem Format-String entpacken.", + "description": "Unpack data from a buffer according to a format string." + }, + "struct.unpack_from.param-name.buffer": { + "message": "Puffer", + "description": "(parameter name) The source buffer to read from." + }, + "struct.unpack_from.param-doc.buffer": { + "message": "Der Quellpuffer, von dem gelesen werden soll.", + "description": "Parameter docs" + }, + "struct.unpack_from.param-name.fmt": { + "message": "fmt", + "description": "(parameter name) The format string." + }, + "struct.unpack_from.param-doc.fmt": { + "message": "Der Formatstring", + "description": "Parameter docs" + }, + "struct.unpack_from.param-name.offset": { + "message": "offset", + "description": "(parameter name) The offset into the buffer. May be negative to count from the end of the buffer." + }, + "struct.unpack_from.param-doc.offset": { + "message": "Der Offset in den Puffer. Kann negativ sein, um vom Ende des Puffers aus zu zählen.", + "description": "Parameter docs" + }, + "sys": { + "message": "sys", + "description": "(module name) System specific functions" + }, + "sys.summary": { + "message": "Systemspezifische Funktionen", + "description": "System specific functions" + }, + "sys.exit": { + "message": "exit", + "description": "(function name) Terminate current program with a given exit code." + }, + "sys.exit.summary": { + "message": "Ein Programm mit dem gegebenen Exit-Code beenden.", + "description": "Terminate current program with a given exit code." + }, + "sys.exit.param-name.retval": { + "message": "retval", + "description": "(parameter name) The exit code or message." + }, + "sys.exit.param-doc.retval": { + "message": "Der Exit-Code oder die Nachricht.", + "description": "Parameter docs" + }, + "sys.print_exception": { + "message": "Ausnahme ausgeben", + "description": "(function name) Print an exception with a traceback." + }, + "sys.print_exception.summary": { + "message": "Eine Ausnahme mit einem Traceback ausgeben.", + "description": "Print an exception with a traceback." + }, + "sys.print_exception.param-name.exc": { + "message": "exc", + "description": "(parameter name) The exception to print" + }, + "sys.print_exception.param-doc.exc": { + "message": "Die auszugebende Ausnahme", + "description": "Parameter docs" + }, + "sys.argv": { + "message": "argv", + "description": "(field name) A mutable list of arguments the current program was started with." + }, + "sys.argv.summary": { + "message": "Eine veränderbare Liste von Argumenten, mit denen das aktuelle Programm gestartet wurde.", + "description": "A mutable list of arguments the current program was started with." + }, + "sys.byteorder": { + "message": "byteorder", + "description": "(field name) The byte order of the system (``\"little\"`` or ``\"big\"``)." + }, + "sys.byteorder.summary": { + "message": "Die Byte-Reihenfolge des Systems ({{\"little\"}} oder {{\"big\"}}).", + "description": "The byte order of the system (``\"little\"`` or ``\"big\"``)." + }, + "sys.implementation": { + "message": "Implementierung", + "description": "(field name) Object with information about the current Python implementation." + }, + "sys.implementation.summary": { + "message": "Objekt mit Informationen über die aktuelle Python-Implementierung.", + "description": "Object with information about the current Python implementation." + }, + "sys.maxsize": { + "message": "maxsize", + "description": "(field name) \nMaximum value which a native integer type can hold on the current platform,\nor maximum value representable by MicroPython integer type, if it's smaller\nthan platform max value (that is the case for MicroPython ports without\nlong int support)." + }, + "sys.maxsize.summary": { + "message": "Maximaler Wert, den ein nativer Integer-Typ auf der aktuellen Plattform halten kann, oder maximaler Wert, der durch den MicroPython-Integer-Typ darstellbar ist, wenn er kleiner ist als der maximale Plattformwert (das ist der Fall bei MicroPython-Ports ohne \"long int\"-Unterstützung).", + "description": "\nMaximum value which a native integer type can hold on the current platform,\nor maximum value representable by MicroPython integer type, if it's smaller\nthan platform max value (that is the case for MicroPython ports without\nlong int support)." + }, + "sys.modules": { + "message": "module", + "description": "(field name) Dictionary of loaded modules. " + }, + "sys.modules.summary": { + "message": "Wörterbuch der geladenen Module. ", + "description": "Dictionary of loaded modules. " + }, + "sys.path": { + "message": "path", + "description": "(field name) A mutable list of directories to search for imported modules." + }, + "sys.path.summary": { + "message": "Eine veränderbare Liste von Verzeichnissen zum Suchen nach importierten Modulen.", + "description": "A mutable list of directories to search for imported modules." + }, + "sys.platform": { + "message": "plattform", + "description": "(field name) The platform that MicroPython is running on. " + }, + "sys.platform.summary": { + "message": "Die Plattform, auf der MicroPython läuft. ", + "description": "The platform that MicroPython is running on. " + }, + "sys.version": { + "message": "Version", + "description": "(field name) Python language version that this implementation conforms to, as a string." + }, + "sys.version.summary": { + "message": "Python-Sprachversion, der diese Implementierung als String entspricht.", + "description": "Python language version that this implementation conforms to, as a string." + }, + "sys.version_info": { + "message": "Versionsinformationen", + "description": "(field name) Python language version that this implementation conforms to, as a tuple of ints." + }, + "sys.version_info.summary": { + "message": "Python-Sprachversion, der diese Implementierung als Tuple mit Ints entspricht.", + "description": "Python language version that this implementation conforms to, as a tuple of ints." + }, + "time": { + "message": "Zeit", + "description": "(module name) Measure time and add delays to programs." + }, + "time.summary": { + "message": "Messe Zeit und füge Verzögerung zu Programmen hinzu.", + "description": "Measure time and add delays to programs." + }, + "time.sleep": { + "message": "sleep", + "description": "(function name) Delay a number of seconds." + }, + "time.sleep.summary": { + "message": "Warte eine bestimmte Zahl in Sekunden.", + "description": "Delay a number of seconds." + }, + "time.sleep.param-name.seconds": { + "message": "sekunden", + "description": "(parameter name) The number of seconds to sleep for.\nUse a floating-point number to sleep for a fractional number of seconds." + }, + "time.sleep.param-doc.seconds": { + "message": "Die Anzahl der Sekunden für die der Ruhezustand angezeigt wird.\nBenutze eine Gleitkommazahl für eine Bruchzahl von Sekunden.", + "description": "Parameter docs" + }, + "time.sleep_ms": { + "message": "schlafe ms", + "description": "(function name) Delay for given number of milliseconds." + }, + "time.sleep_ms.summary": { + "message": "Verzögerung für die angegebene Anzahl von Millisekunden.", + "description": "Delay for given number of milliseconds." + }, + "time.sleep_ms.param-name.ms": { + "message": "ms", + "description": "(parameter name) The number of milliseconds delay (>= 0)." + }, + "time.sleep_ms.param-doc.ms": { + "message": "Die Anzahl der zu wartenden Millisekunden (>= 0).", + "description": "Parameter docs" + }, + "time.sleep_us": { + "message": "sleep us", + "description": "(function name) Delay for given number of microseconds." + }, + "time.sleep_us.summary": { + "message": "Verzögerung für die angegebene Anzahl von Mikrosekunden.", + "description": "Delay for given number of microseconds." + }, + "time.sleep_us.param-name.us": { + "message": "us", + "description": "(parameter name) The number of microseconds delay (>= 0)." + }, + "time.sleep_us.param-doc.us": { + "message": "Die Anzahl der zu wartenden Mikrosekunden (>= 0).", + "description": "Parameter docs" + }, + "time.ticks_ms": { + "message": "ticks ms", + "description": "(function name) Get an increasing, millisecond counter with an arbitrary reference point,\nthat wraps around after some value." + }, + "time.ticks_ms.summary": { + "message": "Holt einen ansteigenden Millisekunden-Zähler mit einem beliebigen Referenzpunkt, der nach einem bestimmten Wert weiterläuft.", + "description": "Get an increasing, millisecond counter with an arbitrary reference point,\nthat wraps around after some value." + }, + "time.ticks_us": { + "message": "ticks us", + "description": "(function name) Get an increasing, microsecond counter with an arbitrary reference point,\nthat wraps around after some value." + }, + "time.ticks_us.summary": { + "message": "Holt einen ansteigenden Mikrosekunden-Zähler mit einem beliebigen Referenzpunkt, der nach einem bestimmten Wert weiterläuft.", + "description": "Get an increasing, microsecond counter with an arbitrary reference point,\nthat wraps around after some value." + }, + "time.ticks_add": { + "message": "ticks add", + "description": "(function name) Offset ticks value by a given number, which can be either positive or\nnegative." + }, + "time.ticks_add.summary": { + "message": "Versetzt den Tick-Wert um eine bestimmte Zahl, die entweder positiv oder negativ sein kann.", + "description": "Offset ticks value by a given number, which can be either positive or\nnegative." + }, + "time.ticks_add.param-name.delta": { + "message": "delta", + "description": "(parameter name) An integer offset" + }, + "time.ticks_add.param-doc.delta": { + "message": "Ein ganzzahliger Offset", + "description": "Parameter docs" + }, + "time.ticks_add.param-name.ticks": { + "message": "ticks", + "description": "(parameter name) A ticks value" + }, + "time.ticks_add.param-doc.ticks": { + "message": "Ein Tick-Wert", + "description": "Parameter docs" + }, + "time.ticks_diff": { + "message": "ticks diff", + "description": "(function name) Measure ticks difference between values returned from\n``time.ticks_ms()`` or ``ticks_us()``, as a signed value\nwhich may wrap around." + }, + "time.ticks_diff.summary": { + "message": "Messung der Ticks-Differenz zwischen den Werten, die von {{time.ticks_ms()}} oder {{ticks_us()}} zurückgegeben werden, als vorzeichenbehafteter Wert der umgeschlagen werden kann.", + "description": "Measure ticks difference between values returned from\n``time.ticks_ms()`` or ``ticks_us()``, as a signed value\nwhich may wrap around." + }, + "time.ticks_diff.param-name.ticks1": { + "message": "ticks1", + "description": "(parameter name) The value to subtract from" + }, + "time.ticks_diff.param-doc.ticks1": { + "message": "Der zu subtrahierende Wert von", + "description": "Parameter docs" + }, + "time.ticks_diff.param-name.ticks2": { + "message": "ticks2", + "description": "(parameter name) The value to subtract" + }, + "time.ticks_diff.param-doc.ticks2": { + "message": "Der zu subtrahierende Wert", + "description": "Parameter docs" + } +} \ No newline at end of file diff --git a/crowdin/translated/api.es-es.json b/crowdin/translated/api.es-es.json index 900bd26..7479f1a 100644 --- a/crowdin/translated/api.es-es.json +++ b/crowdin/translated/api.es-es.json @@ -128,11 +128,11 @@ "description": "Set up the log file header." }, "log.set_labels.param-name.*labels": { - "message": "*labels", + "message": "*Etiquetas", "description": "(parameter name) Any number of positional arguments, each corresponding to an entry in the log header." }, "log.set_labels.param-doc.*labels": { - "message": "Any number of positional arguments, each corresponding to an entry in the log header.", + "message": "Cualquier número de argumentos posicionales, cada uno correspondiente a una entrada en el encabezado del registro.", "description": "Parameter docs" }, "log.set_labels.param-name.timestamp": { @@ -140,7 +140,7 @@ "description": "(parameter name) Select the timestamp unit that will be automatically added as the first column in every row. Timestamp values can be one of ``log.MILLISECONDS``, ``log.SECONDS``, ``log.MINUTES``, ``log.HOURS``, ``log.DAYS`` or ``None`` to disable the timestamp. The default value is ``log.SECONDS``." }, "log.set_labels.param-doc.timestamp": { - "message": "Select the timestamp unit that will be automatically added as the first column in every row. Timestamp values can be one of {{log.MILLISECONDS}}, {{log.SECONDS}}, {{log.MINUTES}}, {{log.HOURS}}, {{log.DAYS}} or {{None}} to disable the timestamp. The default value is {{log.SECONDS}}.", + "message": "Seleccione la unidad de marca de tiempo que se añadirá automáticamente como la primera columna de cada fila. Los valores de la marca de tiempo pueden ser {{log.MILLISECONDS}}, {{log.SECONDS}}, {{log.MINUTES}}, {{log.HOURS}}, {{log.DAYS}} o {{None}} para desactivar la marca de tiempo. El valor por defecto es {{log.SECONDS}}.", "description": "Parameter docs" }, "log.add-1": { @@ -152,11 +152,11 @@ "description": "Add a data row to the log by passing a dictionary of headers and values." }, "log.add-1.param-name.data_dictionary": { - "message": "data dictionary", + "message": "diccionario de datos", "description": "(parameter name) The data to log as a dictionary with a key for each header." }, "log.add-1.param-doc.data_dictionary": { - "message": "The data to log as a dictionary with a key for each header.", + "message": "Los datos a registrar como un diccionario con una clave para cada cabecera.", "description": "Parameter docs" }, "log.add-2": { @@ -180,7 +180,7 @@ "description": "(parameter name) ``True`` selects a “full” erase and ``False`` selects the “fast” erase method." }, "log.delete.param-doc.full": { - "message": "{{True}} selects a “full” erase and {{False}} selects the “fast” erase method.", + "message": "{{True}} selecciona un borrador “completo” y {{False}} selecciona el método de borrado “rápido”.", "description": "Parameter docs" }, "log.set_mirroring": { @@ -188,7 +188,7 @@ "description": "(function name) Configure mirroring of the data logging activity to the serial output." }, "log.set_mirroring.summary": { - "message": "Configure mirroring of the data logging activity to the serial output.", + "message": "Configure la duplicación de la actividad de registro de datos en la salida en serie.", "description": "Configure mirroring of the data logging activity to the serial output." }, "log.set_mirroring.param-name.serial": { @@ -196,7 +196,7 @@ "description": "(parameter name) ``True`` enables mirroring data to the serial output." }, "log.set_mirroring.param-doc.serial": { - "message": "{{True}} enables mirroring data to the serial output.", + "message": "{{True}} habilita la reproducción de datos en la salida de serie.", "description": "Parameter docs" }, "machine": { @@ -844,7 +844,7 @@ "description": "(function name) Schedule to run a function at the interval specified by the time arguments **V2 only**." }, "microbit.run_every.summary": { - "message": "Schedule to run a function at the interval specified by the time arguments **V2 only**.", + "message": "Programe para ejecutar una función en el intervalo especificado por los argumentos de tiempo **V2 solamente**.", "description": "Schedule to run a function at the interval specified by the time arguments **V2 only**." }, "microbit.run_every.param-name.callback": { @@ -852,7 +852,7 @@ "description": "(parameter name) Function to call at the provided interval. Omit when using as a decorator." }, "microbit.run_every.param-doc.callback": { - "message": "Function to call at the provided interval. Omit when using as a decorator.", + "message": "Función para llamar al intervalo proporcionado. Omitir cuando se utiliza como decorador.", "description": "Parameter docs" }, "microbit.run_every.param-name.days": { @@ -860,7 +860,7 @@ "description": "(parameter name) Sets the day mark for the scheduling." }, "microbit.run_every.param-doc.days": { - "message": "Sets the day mark for the scheduling.", + "message": "Establece la marca del día para la programación.", "description": "Parameter docs" }, "microbit.run_every.param-name.h": { @@ -868,7 +868,7 @@ "description": "(parameter name) Sets the hour mark for the scheduling." }, "microbit.run_every.param-doc.h": { - "message": "Sets the hour mark for the scheduling.", + "message": "Establece la marca de hora para la programación.", "description": "Parameter docs" }, "microbit.run_every.param-name.min": { @@ -876,7 +876,7 @@ "description": "(parameter name) Sets the minute mark for the scheduling." }, "microbit.run_every.param-doc.min": { - "message": "Sets the minute mark for the scheduling.", + "message": "Establece la marca de minuto para la programación.", "description": "Parameter docs" }, "microbit.run_every.param-name.ms": { @@ -884,7 +884,7 @@ "description": "(parameter name) Sets the millisecond mark for the scheduling." }, "microbit.run_every.param-doc.ms": { - "message": "Sets the millisecond mark for the scheduling.", + "message": "Establece la marca de milisegundos para la programación.", "description": "Parameter docs" }, "microbit.run_every.param-name.s": { @@ -892,7 +892,7 @@ "description": "(parameter name) Sets the second mark for the scheduling." }, "microbit.run_every.param-doc.s": { - "message": "Sets the second mark for the scheduling.", + "message": "Establece la segunda marca para la programación.", "description": "Parameter docs" }, "microbit.panic": { @@ -920,27 +920,27 @@ "description": "Restart the board." }, "microbit.scale-1": { - "message": "scale", + "message": "escala", "description": "(function name) Converts a value from a range to an integer range." }, "microbit.scale-1.summary": { - "message": "Converts a value from a range to an integer range.", + "message": "Convierte un valor de un rango a un rango de números enteros.", "description": "Converts a value from a range to an integer range." }, "microbit.scale-1.param-name.from_": { - "message": "from", + "message": "de", "description": "(parameter name) A tuple to define the range to convert from." }, "microbit.scale-1.param-doc.from_": { - "message": "A tuple to define the range to convert from.", + "message": "Una tupla para definir el rango desde el que convertir.", "description": "Parameter docs" }, "microbit.scale-1.param-name.to": { - "message": "to", + "message": "a", "description": "(parameter name) A tuple to define the range to convert to." }, "microbit.scale-1.param-doc.to": { - "message": "A tuple to define the range to convert to.", + "message": "Una tupla para definir el rango al que convertir.", "description": "Parameter docs" }, "microbit.scale-1.param-name.value": { @@ -948,31 +948,31 @@ "description": "(parameter name) A number to convert." }, "microbit.scale-1.param-doc.value": { - "message": "A number to convert.", + "message": "Un número a convertir.", "description": "Parameter docs" }, "microbit.scale-2": { - "message": "scale", + "message": "escala", "description": "(function name) Converts a value from a range to a floating point range." }, "microbit.scale-2.summary": { - "message": "Converts a value from a range to a floating point range.", + "message": "Convierte un valor de un rango a un rango de punto flotante.", "description": "Converts a value from a range to a floating point range." }, "microbit.scale-2.param-name.from_": { - "message": "from", + "message": "de", "description": "(parameter name) A tuple to define the range to convert from." }, "microbit.scale-2.param-doc.from_": { - "message": "A tuple to define the range to convert from.", + "message": "Una tupla para definir el rango desde el que convertir.", "description": "Parameter docs" }, "microbit.scale-2.param-name.to": { - "message": "to", + "message": "a", "description": "(parameter name) A tuple to define the range to convert to." }, "microbit.scale-2.param-doc.to": { - "message": "A tuple to define the range to convert to.", + "message": "Una tupla para definir el rango al que convertir.", "description": "Parameter docs" }, "microbit.scale-2.param-name.value": { @@ -980,7 +980,7 @@ "description": "(parameter name) A number to convert." }, "microbit.scale-2.param-doc.value": { - "message": "A number to convert.", + "message": "Un número a convertir.", "description": "Parameter docs" }, "microbit.sleep": { @@ -1920,11 +1920,11 @@ "description": "Snake image." }, "microbit.Image.SCISSORS": { - "message": "scissors", + "message": "tijeras", "description": "(field name) Scissors image." }, "microbit.Image.SCISSORS.summary": { - "message": "Scissors image.", + "message": "Imagen de tijeras.", "description": "Scissors image." }, "microbit.Image.ALL_CLOCKS": { @@ -2488,11 +2488,11 @@ "description": "Get the acceleration measurements in all axes at once as a tuple." }, "microbit.accelerometer.get_strength": { - "message": "get strength", + "message": "obtener fuerza", "description": "(function name) Get the acceleration measurement of all axes combined, as a positive integer. This is the Pythagorean sum of the X, Y and Z axes." }, "microbit.accelerometer.get_strength.summary": { - "message": "Get the acceleration measurement of all axes combined, as a positive integer. This is the Pythagorean sum of the X, Y and Z axes.", + "message": "Obtener la medición de aceleración de todos los ejes combinados, como un entero positivo. Esta es la suma de Pitagórica de los ejes X, Y y Z.", "description": "Get the acceleration measurement of all axes combined, as a positive integer. This is the Pythagorean sum of the X, Y and Z axes." }, "microbit.accelerometer.current_gesture": { @@ -2544,11 +2544,11 @@ "description": "Return a tuple of the gesture history." }, "microbit.accelerometer.set_range": { - "message": "set range", + "message": "establecer rango", "description": "(function name) Set the accelerometer sensitivity range, in g (standard gravity), to the closest values supported by the hardware, so it rounds to either ``2``, ``4``, or ``8`` g." }, "microbit.accelerometer.set_range.summary": { - "message": "Set the accelerometer sensitivity range, in g (standard gravity), to the closest values supported by the hardware, so it rounds to either {{2}}, {{4}}, or {{8}} g.", + "message": "Establecer el rango de sensibilidad acelerómetro, en g (gravedad estándar), a los valores más cercanos soportados por el hardware, así que se redondea a {{2}}, {{4}}o {{8}} g.", "description": "Set the accelerometer sensitivity range, in g (standard gravity), to the closest values supported by the hardware, so it rounds to either ``2``, ``4``, or ``8`` g." }, "microbit.accelerometer.set_range.param-name.value": { @@ -2556,7 +2556,7 @@ "description": "(parameter name) New range for the accelerometer, an integer in ``g``." }, "microbit.accelerometer.set_range.param-doc.value": { - "message": "New range for the accelerometer, an integer in {{g}}.", + "message": "Nuevo rango para el acelerómetro, un entero en {{g}}.", "description": "Parameter docs" }, "microbit.audio": { @@ -2572,7 +2572,7 @@ "description": "(function name) Play a built-in sound, sound effect or custom audio frames." }, "microbit.audio.play.summary": { - "message": "Play a built-in sound, sound effect or custom audio frames.", + "message": "Reproducir un sonido, un efecto de sonido o marcos de audio personalizados.", "description": "Play a built-in sound, sound effect or custom audio frames." }, "microbit.audio.play.param-name.pin": { @@ -2596,7 +2596,7 @@ "description": "(parameter name) A built-in ``Sound`` such as ``Sound.GIGGLE``, a ``SoundEffect`` or sample data as an iterable of ``AudioFrame`` objects." }, "microbit.audio.play.param-doc.source": { - "message": "A built-in {{Sound}} such as {{Sound.GIGGLE}}, a {{SoundEffect}} or sample data as an iterable of {{AudioFrame}} objects.", + "message": "Un {{Sound}} integrado como {{Sound.GIGGLE}}, un {{SoundEffect}} o datos de muestra como un iterable de objetos {{AudioFrame}}.", "description": "Parameter docs" }, "microbit.audio.play.param-name.wait": { @@ -2624,83 +2624,83 @@ "description": "Stop all audio playback." }, "microbit.audio.SoundEffect": { - "message": "soundeffect", + "message": "efecto de sonido", "description": "(class name) A sound effect, composed by a set of parameters configured via the constructor or attributes." }, "microbit.audio.SoundEffect.summary": { - "message": "A sound effect, composed by a set of parameters configured via the constructor or attributes.", + "message": "Un efecto de sonido, compuesto por un conjunto de parámetros configurados a través del constructor o atributos.", "description": "A sound effect, composed by a set of parameters configured via the constructor or attributes." }, "microbit.audio.SoundEffect.WAVEFORM_SINE": { - "message": "waveform sine", + "message": "forma de onda sinusoidal", "description": "(field name) Sine wave option used for the ``waveform`` parameter." }, "microbit.audio.SoundEffect.WAVEFORM_SINE.summary": { - "message": "Sine wave option used for the {{waveform}} parameter.", + "message": "Opción de onda sinusoidal utilizada para el parámetro {{waveform}}.", "description": "Sine wave option used for the ``waveform`` parameter." }, "microbit.audio.SoundEffect.WAVEFORM_SAWTOOTH": { - "message": "waveform sawtooth", + "message": "diente de sierra de forma de onda", "description": "(field name) Sawtooth wave option used for the ``waveform`` parameter." }, "microbit.audio.SoundEffect.WAVEFORM_SAWTOOTH.summary": { - "message": "Sawtooth wave option used for the {{waveform}} parameter.", + "message": "Opción de onda con diente de sierra usada para el parámetro {{waveform}}.", "description": "Sawtooth wave option used for the ``waveform`` parameter." }, "microbit.audio.SoundEffect.WAVEFORM_TRIANGLE": { - "message": "waveform triangle", + "message": "forma de onda triangular", "description": "(field name) Triangle wave option used for the ``waveform`` parameter." }, "microbit.audio.SoundEffect.WAVEFORM_TRIANGLE.summary": { - "message": "Triangle wave option used for the {{waveform}} parameter.", + "message": "Opción de onda triangular usada para el parámetro {{waveform}}.", "description": "Triangle wave option used for the ``waveform`` parameter." }, "microbit.audio.SoundEffect.WAVEFORM_SQUARE": { - "message": "waveform square", + "message": "forma de onda cuadrada", "description": "(field name) Square wave option used for the ``waveform`` parameter." }, "microbit.audio.SoundEffect.WAVEFORM_SQUARE.summary": { - "message": "Square wave option used for the {{waveform}} parameter.", + "message": "Opción de onda cuadrada usada para el parámetro {{waveform}}.", "description": "Square wave option used for the ``waveform`` parameter." }, "microbit.audio.SoundEffect.WAVEFORM_NOISE": { - "message": "waveform noise", + "message": "forma de onda de ruido", "description": "(field name) Noise option used for the ``waveform`` parameter." }, "microbit.audio.SoundEffect.WAVEFORM_NOISE.summary": { - "message": "Noise option used for the {{waveform}} parameter.", + "message": "Opción de ruido usada para el parámetro {{waveform}}.", "description": "Noise option used for the ``waveform`` parameter." }, "microbit.audio.SoundEffect.SHAPE_LINEAR": { - "message": "shape linear", + "message": "forma lineal", "description": "(field name) Linear interpolation option used for the ``shape`` parameter." }, "microbit.audio.SoundEffect.SHAPE_LINEAR.summary": { - "message": "Linear interpolation option used for the {{shape}} parameter.", + "message": "Opción de interpolación lineal usada para el parámetro {{shape}}.", "description": "Linear interpolation option used for the ``shape`` parameter." }, "microbit.audio.SoundEffect.SHAPE_CURVE": { - "message": "shape curve", + "message": "forma curva", "description": "(field name) Curve interpolation option used for the ``shape`` parameter." }, "microbit.audio.SoundEffect.SHAPE_CURVE.summary": { - "message": "Curve interpolation option used for the {{shape}} parameter.", + "message": "Opción de interpolación de curva usada para el parámetro {{shape}}.", "description": "Curve interpolation option used for the ``shape`` parameter." }, "microbit.audio.SoundEffect.SHAPE_LOG": { - "message": "shape log", + "message": "registro de forma", "description": "(field name) Logarithmic interpolation option used for the ``shape`` parameter." }, "microbit.audio.SoundEffect.SHAPE_LOG.summary": { - "message": "Logarithmic interpolation option used for the {{shape}} parameter.", + "message": "Opción de interpolación logarítmica usada para el parámetro {{shape}}.", "description": "Logarithmic interpolation option used for the ``shape`` parameter." }, "microbit.audio.SoundEffect.FX_NONE": { - "message": "fx none", + "message": "fx ninguno", "description": "(field name) No effect option used for the ``fx`` parameter." }, "microbit.audio.SoundEffect.FX_NONE.summary": { - "message": "No effect option used for the {{fx}} parameter.", + "message": "Ninguna opción de efecto usada para el parámetro {{fx}}.", "description": "No effect option used for the ``fx`` parameter." }, "microbit.audio.SoundEffect.FX_TREMOLO": { @@ -2708,7 +2708,7 @@ "description": "(field name) Tremolo effect option used for the ``fx`` parameter." }, "microbit.audio.SoundEffect.FX_TREMOLO.summary": { - "message": "Tremolo effect option used for the {{fx}} parameter.", + "message": "Opción de efecto Trémolo usada para el parámetro {{fx}}.", "description": "Tremolo effect option used for the ``fx`` parameter." }, "microbit.audio.SoundEffect.FX_VIBRATO": { @@ -2716,31 +2716,31 @@ "description": "(field name) Vibrato effect option used for the ``fx`` parameter." }, "microbit.audio.SoundEffect.FX_VIBRATO.summary": { - "message": "Vibrato effect option used for the {{fx}} parameter.", + "message": "Opción de efecto vibrato utilizada para el parámetro {{fx}}.", "description": "Vibrato effect option used for the ``fx`` parameter." }, "microbit.audio.SoundEffect.FX_WARBLE": { - "message": "fx warble", + "message": "fx gorjeo", "description": "(field name) Warble effect option used for the ``fx`` parameter." }, "microbit.audio.SoundEffect.FX_WARBLE.summary": { - "message": "Warble effect option used for the {{fx}} parameter.", + "message": "Opción de efecto gorjeo utilizada para el parámetro {{fx}}.", "description": "Warble effect option used for the ``fx`` parameter." }, "microbit.audio.SoundEffect.freq_start": { - "message": "freq start", + "message": "frecuencia de inicio", "description": "(field name) Start frequency in Hertz (Hz), a number between ``0`` and ``9999``" }, "microbit.audio.SoundEffect.freq_start.summary": { - "message": "Start frequency in Hertz (Hz), a number between {{0}} and {{9999}}", + "message": "Frecuencia de inicio en Hertz (Hz), un número entre {{0}} y {{9999}}", "description": "Start frequency in Hertz (Hz), a number between ``0`` and ``9999``" }, "microbit.audio.SoundEffect.freq_end": { - "message": "freq end", + "message": "frecuencia final", "description": "(field name) End frequency in Hertz (Hz), a number between ``0`` and ``9999``" }, "microbit.audio.SoundEffect.freq_end.summary": { - "message": "End frequency in Hertz (Hz), a number between {{0}} and {{9999}}", + "message": "Frecuencia final en Hertz (Hz), un número entre {{0}} y {{9999}}", "description": "End frequency in Hertz (Hz), a number between ``0`` and ``9999``" }, "microbit.audio.SoundEffect.duration": { @@ -2748,31 +2748,31 @@ "description": "(field name) Duration of the sound in milliseconds, a number between ``0`` and ``9999``" }, "microbit.audio.SoundEffect.duration.summary": { - "message": "Duration of the sound in milliseconds, a number between {{0}} and {{9999}}", + "message": "Duración del sonido en milisegundos, un número entre {{0}} y {{9999}}", "description": "Duration of the sound in milliseconds, a number between ``0`` and ``9999``" }, "microbit.audio.SoundEffect.vol_start": { - "message": "vol start", + "message": "volumen de inicio", "description": "(field name) Start volume value, a number between ``0`` and ``255``" }, "microbit.audio.SoundEffect.vol_start.summary": { - "message": "Start volume value, a number between {{0}} and {{255}}", + "message": "Valor de volumen inicial, un número entre {{0}} y {{255}}", "description": "Start volume value, a number between ``0`` and ``255``" }, "microbit.audio.SoundEffect.vol_end": { - "message": "vol end", + "message": "volumen final", "description": "(field name) End volume value, a number between ``0`` and ``255``" }, "microbit.audio.SoundEffect.vol_end.summary": { - "message": "End volume value, a number between {{0}} and {{255}}", + "message": "Valor final del volumen, un número entre {{0}} y {{255}}", "description": "End volume value, a number between ``0`` and ``255``" }, "microbit.audio.SoundEffect.waveform": { - "message": "waveform", + "message": "forma de onda", "description": "(field name) Type of waveform shape, one of these values: ``WAVEFORM_SINE``, ``WAVEFORM_SAWTOOTH``, ``WAVEFORM_TRIANGLE``, ``WAVEFORM_SQUARE``, ``WAVEFORM_NOISE`` (randomly generated noise)" }, "microbit.audio.SoundEffect.waveform.summary": { - "message": "Type of waveform shape, one of these values: {{WAVEFORM_SINE}}, {{WAVEFORM_SAWTOOTH}}, {{WAVEFORM_TRIANGLE}}, {{WAVEFORM_SQUARE}}, {{WAVEFORM_NOISE}} (randomly generated noise)", + "message": "Tipo de forma ondulada, uno de estos valores: {{WAVEFORM_SINE}}, {{WAVEFORM_SAWTOOTH}}, {{WAVEFORM_TRIANGLE}}, {{WAVEFORM_SQUARE}}, {{WAVEFORM_NOISE}} (ruido generado aleatoriamente)", "description": "Type of waveform shape, one of these values: ``WAVEFORM_SINE``, ``WAVEFORM_SAWTOOTH``, ``WAVEFORM_TRIANGLE``, ``WAVEFORM_SQUARE``, ``WAVEFORM_NOISE`` (randomly generated noise)" }, "microbit.audio.SoundEffect.fx": { @@ -2780,15 +2780,15 @@ "description": "(field name) Effect to add on the sound, one of the following values: ``FX_TREMOLO``, ``FX_VIBRATO``, ``FX_WARBLE``, or ``FX_NONE``" }, "microbit.audio.SoundEffect.fx.summary": { - "message": "Effect to add on the sound, one of the following values: {{FX_TREMOLO}}, {{FX_VIBRATO}}, {{FX_WARBLE}}, or {{FX_NONE}}", + "message": "Efecto para añadir en el sonido, uno de los siguientes valores: {{FX_TREMOLO}}, {{FX_VIBRATO}}, {{FX_WARBLE}}o {{FX_NONE}}", "description": "Effect to add on the sound, one of the following values: ``FX_TREMOLO``, ``FX_VIBRATO``, ``FX_WARBLE``, or ``FX_NONE``" }, "microbit.audio.SoundEffect.shape": { - "message": "shape", + "message": "forma", "description": "(field name) The type of the interpolation curve between the start and end frequencies, different wave shapes have different rates of change in frequency. One of the following values: ``SHAPE_LINEAR``, ``SHAPE_CURVE``, ``SHAPE_LOG``" }, "microbit.audio.SoundEffect.shape.summary": { - "message": "The type of the interpolation curve between the start and end frequencies, different wave shapes have different rates of change in frequency. One of the following values: {{SHAPE_LINEAR}}, {{SHAPE_CURVE}}, {{SHAPE_LOG}}", + "message": "El tipo de curva de interpolación entre las frecuencias de inicio y final, diferentes formas de onda tienen diferentes tasas de cambio en la frecuencia. Uno de los siguientes valores: {{SHAPE_LINEAR}}, {{SHAPE_CURVE}}, {{SHAPE_LOG}}", "description": "The type of the interpolation curve between the start and end frequencies, different wave shapes have different rates of change in frequency. One of the following values: ``SHAPE_LINEAR``, ``SHAPE_CURVE``, ``SHAPE_LOG``" }, "microbit.audio.SoundEffect.__init__": { @@ -2796,7 +2796,7 @@ "description": "(function name) Create a new sound effect." }, "microbit.audio.SoundEffect.__init__.summary": { - "message": "Create a new sound effect.", + "message": "Crear un nuevo efecto de sonido.", "description": "Create a new sound effect." }, "microbit.audio.SoundEffect.__init__.param-name.duration": { @@ -2804,23 +2804,23 @@ "description": "(parameter name) Duration of the sound in milliseconds, a number between ``0`` and ``9999``." }, "microbit.audio.SoundEffect.__init__.param-doc.duration": { - "message": "Duration of the sound in milliseconds, a number between {{0}} and {{9999}}.", + "message": "Duración del sonido en milisegundos, un número entre {{0}} y {{9999}}.", "description": "Parameter docs" }, "microbit.audio.SoundEffect.__init__.param-name.freq_end": { - "message": "freq end", + "message": "frecuencia final", "description": "(parameter name) End frequency in Hertz (Hz), a number between ``0`` and ``9999``." }, "microbit.audio.SoundEffect.__init__.param-doc.freq_end": { - "message": "End frequency in Hertz (Hz), a number between {{0}} and {{9999}}.", + "message": "Frecuencia final en Hertz (Hz), un número entre {{0}} y {{9999}}.", "description": "Parameter docs" }, "microbit.audio.SoundEffect.__init__.param-name.freq_start": { - "message": "freq start", + "message": "frecuencia de inicio", "description": "(parameter name) Start frequency in Hertz (Hz), a number between ``0`` and ``9999``." }, "microbit.audio.SoundEffect.__init__.param-doc.freq_start": { - "message": "Start frequency in Hertz (Hz), a number between {{0}} and {{9999}}.", + "message": "Frecuencia de inicio en Hertz (Hz), un número entre {{0}} y {{9999}}.", "description": "Parameter docs" }, "microbit.audio.SoundEffect.__init__.param-name.fx": { @@ -2828,39 +2828,39 @@ "description": "(parameter name) Effect to add on the sound, one of the following values: ``FX_TREMOLO``, ``FX_VIBRATO``, ``FX_WARBLE``, or ``FX_NONE``." }, "microbit.audio.SoundEffect.__init__.param-doc.fx": { - "message": "Effect to add on the sound, one of the following values: {{FX_TREMOLO}}, {{FX_VIBRATO}}, {{FX_WARBLE}}, or {{FX_NONE}}.", + "message": "Efecto para añadir en el sonido, uno de los siguientes valores: {{FX_TREMOLO}}, {{FX_VIBRATO}}, {{FX_WARBLE}}o {{FX_NONE}}.", "description": "Parameter docs" }, "microbit.audio.SoundEffect.__init__.param-name.shape": { - "message": "shape", + "message": "forma", "description": "(parameter name) The type of the interpolation curve between the start and end frequencies, different wave shapes have different rates of change in frequency. One of the following values: ``SHAPE_LINEAR``, ``SHAPE_CURVE``, ``SHAPE_LOG``." }, "microbit.audio.SoundEffect.__init__.param-doc.shape": { - "message": "The type of the interpolation curve between the start and end frequencies, different wave shapes have different rates of change in frequency. One of the following values: {{SHAPE_LINEAR}}, {{SHAPE_CURVE}}, {{SHAPE_LOG}}.", + "message": "El tipo de curva de interpolación entre las frecuencias de inicio y final, diferentes formas de onda tienen diferentes tasas de cambio en la frecuencia. Uno de los siguientes valores: {{SHAPE_LINEAR}}, {{SHAPE_CURVE}}, {{SHAPE_LOG}}.", "description": "Parameter docs" }, "microbit.audio.SoundEffect.__init__.param-name.vol_end": { - "message": "vol end", + "message": "volumen final", "description": "(parameter name) End volume value, a number between ``0`` and ``255``." }, "microbit.audio.SoundEffect.__init__.param-doc.vol_end": { - "message": "End volume value, a number between {{0}} and {{255}}.", + "message": "Valor de volumen final, un número entre {{0}} y {{255}}.", "description": "Parameter docs" }, "microbit.audio.SoundEffect.__init__.param-name.vol_start": { - "message": "vol start", + "message": "volumen inicial", "description": "(parameter name) Start volume value, a number between ``0`` and ``255``." }, "microbit.audio.SoundEffect.__init__.param-doc.vol_start": { - "message": "Start volume value, a number between {{0}} and {{255}}.", + "message": "Valor de volumen inicial, un número entre {{0}} y {{255}}.", "description": "Parameter docs" }, "microbit.audio.SoundEffect.__init__.param-name.waveform": { - "message": "waveform", + "message": "forma de onda", "description": "(parameter name) Type of waveform shape, one of these values: ``WAVEFORM_SINE``, ``WAVEFORM_SAWTOOTH``, ``WAVEFORM_TRIANGLE``, ``WAVEFORM_SQUARE``, ``WAVEFORM_NOISE`` (randomly generated noise)." }, "microbit.audio.SoundEffect.__init__.param-doc.waveform": { - "message": "Type of waveform shape, one of these values: {{WAVEFORM_SINE}}, {{WAVEFORM_SAWTOOTH}}, {{WAVEFORM_TRIANGLE}}, {{WAVEFORM_SQUARE}}, {{WAVEFORM_NOISE}} (randomly generated noise).", + "message": "Tipo de forma de onda, uno de estos valores: {{WAVEFORM_SINE}}, {{WAVEFORM_SAWTOOTH}}, {{WAVEFORM_TRIANGLE}}, {{WAVEFORM_SQUARE}}, {{WAVEFORM_NOISE}} (ruido generado aleatoriamente).", "description": "Parameter docs" }, "microbit.audio.SoundEffect.copy": { @@ -2868,7 +2868,7 @@ "description": "(function name) Create a copy of this ``SoundEffect``." }, "microbit.audio.SoundEffect.copy.summary": { - "message": "Create a copy of this {{SoundEffect}}.", + "message": "Crear una copia de este {{SoundEffect}}.", "description": "Create a copy of this ``SoundEffect``." }, "microbit.audio.AudioFrame": { @@ -2880,11 +2880,11 @@ "description": "An ``AudioFrame`` object is a list of 32 samples each of which is a unsigned byte\n(whole number between 0 and 255)." }, "microbit.audio.AudioFrame.copyfrom": { - "message": "copyfrom", + "message": "copiar forma", "description": "(function name) Overwrite the data in this ``AudioFrame`` with the data from another ``AudioFrame`` instance." }, "microbit.audio.AudioFrame.copyfrom.summary": { - "message": "Overwrite the data in this {{AudioFrame}} with the data from another {{AudioFrame}} instance.", + "message": "Sobrescribir los datos en este {{AudioFrame}} con los datos de otra instancia de {{AudioFrame}}.", "description": "Overwrite the data in this ``AudioFrame`` with the data from another ``AudioFrame`` instance." }, "microbit.audio.AudioFrame.copyfrom.param-name.other": { @@ -2892,7 +2892,7 @@ "description": "(parameter name) ``AudioFrame`` instance from which to copy the data." }, "microbit.audio.AudioFrame.copyfrom.param-doc.other": { - "message": "{{AudioFrame}} instance from which to copy the data.", + "message": "Instancia {{AudioFrame}} desde la que copiar los datos.", "description": "Parameter docs" }, "microbit.compass": { diff --git a/crowdin/translated/api.ja.json b/crowdin/translated/api.ja.json index 4da1532..f320ef9 100644 --- a/crowdin/translated/api.ja.json +++ b/crowdin/translated/api.ja.json @@ -884,7 +884,7 @@ "description": "(parameter name) Sets the millisecond mark for the scheduling." }, "microbit.run_every.param-doc.ms": { - "message": "スケジューリングのための秒を設定します。", + "message": "スケジューリングのためのミリ秒を設定します。", "description": "Parameter docs" }, "microbit.run_every.param-name.s": { @@ -892,7 +892,7 @@ "description": "(parameter name) Sets the second mark for the scheduling." }, "microbit.run_every.param-doc.s": { - "message": "スケジューリングのためのミリ秒を設定します。", + "message": "スケジューリングのための秒を設定します。", "description": "Parameter docs" }, "microbit.panic": { @@ -1932,7 +1932,7 @@ "description": "(field name) A list containing all the CLOCK_ images in sequence." }, "microbit.Image.ALL_CLOCKS.summary": { - "message": "すべての CLOCK_ イメージを順番に並べたリスト。", + "message": "すべての時計イメージを順番に並べたリスト。", "description": "A list containing all the CLOCK_ images in sequence." }, "microbit.Image.ALL_ARROWS": { @@ -1940,7 +1940,7 @@ "description": "(field name) A list containing all the ARROW_ images in sequence." }, "microbit.Image.ALL_ARROWS.summary": { - "message": "すべての ARROW_ イメージを順番に並べたリスト。", + "message": "すべての矢印イメージを順番に並べたリスト。", "description": "A list containing all the ARROW_ images in sequence." }, "microbit.Image.__init__-1": { @@ -2660,7 +2660,7 @@ "description": "(field name) Square wave option used for the ``waveform`` parameter." }, "microbit.audio.SoundEffect.WAVEFORM_SQUARE.summary": { - "message": "{{waveform}} パラメータに指定できる「方形波」オプション。", + "message": "{{waveform}} パラメータに指定できる「矩形波」オプション。", "description": "Square wave option used for the ``waveform`` parameter." }, "microbit.audio.SoundEffect.WAVEFORM_NOISE": { @@ -2724,7 +2724,7 @@ "description": "(field name) Warble effect option used for the ``fx`` parameter." }, "microbit.audio.SoundEffect.FX_WARBLE.summary": { - "message": "{{fx}} パラメータに指定できる「さえずり効果」オプション。", + "message": "{{fx}} パラメータに指定できる「ワブル効果」オプション。", "description": "Warble effect option used for the ``fx`` parameter." }, "microbit.audio.SoundEffect.freq_start": { diff --git a/lang/ca/typeshed/stdlib/neopixel.pyi b/lang/ca/typeshed/stdlib/neopixel.pyi index c5ec33b..ec85e74 100644 --- a/lang/ca/typeshed/stdlib/neopixel.pyi +++ b/lang/ca/typeshed/stdlib/neopixel.pyi @@ -22,7 +22,7 @@ See `the online docs None: diff --git a/lang/de/typeshed/stdlib/VERSIONS b/lang/de/typeshed/stdlib/VERSIONS new file mode 100644 index 0000000..67b710f --- /dev/null +++ b/lang/de/typeshed/stdlib/VERSIONS @@ -0,0 +1,50 @@ +# The structure of this file is as follows: +# - Blank lines and comments starting with `#` are ignored. +# - Lines contain the name of a module, followed by a colon, +# a space, and a version range (for example: `symbol: 2.7-3.9`). +# +# Version ranges may be of the form "X.Y-A.B" or "X.Y-". The +# first form means that a module was introduced in version X.Y and last +# available in version A.B. The second form means that the module was +# introduced in version X.Y and is still available in the latest +# version of Python. +# +# If a submodule is not listed separately, it has the same lifetime as +# its parent module. +# +# Python versions before 2.7 are ignored, so any module that was already +# present in 2.7 will have "2.7" as its minimum version. Version ranges +# for unsupported versions of Python 3 (currently 3.5 and lower) are +# generally accurate but we do not guarantee their correctness. + +antigravity: 3.0- +array: 3.0- +audio: 3.0- +builtins: 3.0- +errno: 3.0- +gc: 3.0- +love: 3.0- +machine: 3.0- +math: 3.0- +microbit: 3.0- +micropython: 3.0- +music: 3.0- +neopixel: 3.0- +os: 3.0- +radio: 3.0- +random: 3.0- +speech: 3.0- +struct: 3.0- +sys: 3.0- +this: 3.0- +time: 3.0- +typing_extensions: 3.0- +typing: 3.0- +uarray: 3.0- +ucollections: 3.0- +uerrno: 3.0- +uos: 3.0- +urandom: 3.0- +ustruct: 3.0- +usys: 3.0- +utime: 3.0- \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/_typeshed/__init__.pyi b/lang/de/typeshed/stdlib/_typeshed/__init__.pyi new file mode 100644 index 0000000..7bf6e72 --- /dev/null +++ b/lang/de/typeshed/stdlib/_typeshed/__init__.pyi @@ -0,0 +1,168 @@ +# Utility types for typeshed +# +# See the README.md file in this directory for more information. + +import array +import sys +from os import PathLike +from typing import AbstractSet, Any, Container, Iterable, Protocol, Tuple, TypeVar, Union +from typing_extensions import Literal, final + +_KT = TypeVar("_KT") +_KT_co = TypeVar("_KT_co", covariant=True) +_KT_contra = TypeVar("_KT_contra", contravariant=True) +_VT = TypeVar("_VT") +_VT_co = TypeVar("_VT_co", covariant=True) +_T = TypeVar("_T") +_T_co = TypeVar("_T_co", covariant=True) +_T_contra = TypeVar("_T_contra", contravariant=True) + +# Use for "self" annotations: +# def __enter__(self: Self) -> Self: ... +Self = TypeVar("Self") # noqa Y001 + +# stable +class IdentityFunction(Protocol): + def __call__(self, __x: _T) -> _T: ... + +class SupportsLessThan(Protocol): + def __lt__(self, __other: Any) -> bool: ... + +SupportsLessThanT = TypeVar("SupportsLessThanT", bound=SupportsLessThan) # noqa: Y001 + +class SupportsDivMod(Protocol[_T_contra, _T_co]): + def __divmod__(self, __other: _T_contra) -> _T_co: ... + +class SupportsRDivMod(Protocol[_T_contra, _T_co]): + def __rdivmod__(self, __other: _T_contra) -> _T_co: ... + +class SupportsLenAndGetItem(Protocol[_T_co]): + def __len__(self) -> int: ... + def __getitem__(self, __k: int) -> _T_co: ... + +# Mapping-like protocols + +# stable +class SupportsItems(Protocol[_KT_co, _VT_co]): + def items(self) -> AbstractSet[Tuple[_KT_co, _VT_co]]: ... + +# stable +class SupportsKeysAndGetItem(Protocol[_KT, _VT_co]): + def keys(self) -> Iterable[_KT]: ... + def __getitem__(self, __k: _KT) -> _VT_co: ... + +# stable +class SupportsGetItem(Container[_KT_contra], Protocol[_KT_contra, _VT_co]): + def __getitem__(self, __k: _KT_contra) -> _VT_co: ... + +# stable +class SupportsItemAccess(SupportsGetItem[_KT_contra, _VT], Protocol[_KT_contra, _VT]): + def __setitem__(self, __k: _KT_contra, __v: _VT) -> None: ... + def __delitem__(self, __v: _KT_contra) -> None: ... + +# These aliases are simple strings in Python 2. +StrPath = Union[str, PathLike[str]] # stable +BytesPath = Union[bytes, PathLike[bytes]] # stable +StrOrBytesPath = Union[str, bytes, PathLike[str], PathLike[bytes]] # stable + +OpenTextModeUpdating = Literal[ + "r+", + "+r", + "rt+", + "r+t", + "+rt", + "tr+", + "t+r", + "+tr", + "w+", + "+w", + "wt+", + "w+t", + "+wt", + "tw+", + "t+w", + "+tw", + "a+", + "+a", + "at+", + "a+t", + "+at", + "ta+", + "t+a", + "+ta", + "x+", + "+x", + "xt+", + "x+t", + "+xt", + "tx+", + "t+x", + "+tx", +] +OpenTextModeWriting = Literal["w", "wt", "tw", "a", "at", "ta", "x", "xt", "tx"] +OpenTextModeReading = Literal["r", "rt", "tr", "U", "rU", "Ur", "rtU", "rUt", "Urt", "trU", "tUr", "Utr"] +OpenTextMode = Union[OpenTextModeUpdating, OpenTextModeWriting, OpenTextModeReading] +OpenBinaryModeUpdating = Literal[ + "rb+", + "r+b", + "+rb", + "br+", + "b+r", + "+br", + "wb+", + "w+b", + "+wb", + "bw+", + "b+w", + "+bw", + "ab+", + "a+b", + "+ab", + "ba+", + "b+a", + "+ba", + "xb+", + "x+b", + "+xb", + "bx+", + "b+x", + "+bx", +] +OpenBinaryModeWriting = Literal["wb", "bw", "ab", "ba", "xb", "bx"] +OpenBinaryModeReading = Literal["rb", "br", "rbU", "rUb", "Urb", "brU", "bUr", "Ubr"] +OpenBinaryMode = Union[OpenBinaryModeUpdating, OpenBinaryModeReading, OpenBinaryModeWriting] + +# stable +class HasFileno(Protocol): + def fileno(self) -> int: ... + +FileDescriptor = int # stable +FileDescriptorLike = Union[int, HasFileno] # stable + +# stable +class SupportsRead(Protocol[_T_co]): + def read(self, __length: int = ...) -> _T_co: ... + +# stable +class SupportsReadline(Protocol[_T_co]): + def readline(self, __length: int = ...) -> _T_co: ... + +# stable +class SupportsNoArgReadline(Protocol[_T_co]): + def readline(self) -> _T_co: ... + +# stable +class SupportsWrite(Protocol[_T_contra]): + def write(self, __s: _T_contra) -> Any: ... + +ReadableBuffer = Union[bytes, bytearray, memoryview, array.array[Any]] # stable +WriteableBuffer = Union[bytearray, memoryview, array.array[Any]] # stable + +# stable +if sys.version_info >= (3, 10): + from types import NoneType as NoneType +else: + # Used by type checkers for checks involving None (does not exist at runtime) + @final + class NoneType: + def __bool__(self) -> Literal[False]: ... diff --git a/lang/de/typeshed/stdlib/abc.pyi b/lang/de/typeshed/stdlib/abc.pyi new file mode 100644 index 0000000..18bb090 --- /dev/null +++ b/lang/de/typeshed/stdlib/abc.pyi @@ -0,0 +1,28 @@ +from _typeshed import SupportsWrite +from typing import Any, Callable, Tuple, Type, TypeVar + +_T = TypeVar("_T") +_FuncT = TypeVar("_FuncT", bound=Callable[..., Any]) + +# These definitions have special processing in mypy +class ABCMeta(type): + __abstractmethods__: frozenset[str] + def __init__( + self, name: str, bases: Tuple[type, ...], namespace: dict[str, Any] + ) -> None: ... + def __instancecheck__(cls: ABCMeta, instance: Any) -> Any: ... + def __subclasscheck__(cls: ABCMeta, subclass: Any) -> Any: ... + def _dump_registry(cls: ABCMeta, file: SupportsWrite[str] | None = ...) -> None: ... + def register(cls: ABCMeta, subclass: Type[_T]) -> Type[_T]: ... + +def abstractmethod(funcobj: _FuncT) -> _FuncT: ... + +class abstractproperty(property): ... + +# These two are deprecated and not supported by mypy +def abstractstaticmethod(callable: _FuncT) -> _FuncT: ... +def abstractclassmethod(callable: _FuncT) -> _FuncT: ... + +class ABC(metaclass=ABCMeta): ... + +def get_cache_token() -> object: ... diff --git a/lang/de/typeshed/stdlib/antigravity.pyi b/lang/de/typeshed/stdlib/antigravity.pyi new file mode 100644 index 0000000..e69de29 diff --git a/lang/de/typeshed/stdlib/array.pyi b/lang/de/typeshed/stdlib/array.pyi new file mode 100644 index 0000000..1e4e630 --- /dev/null +++ b/lang/de/typeshed/stdlib/array.pyi @@ -0,0 +1,42 @@ +from typing import Generic, Iterable, MutableSequence, TypeVar, Union, overload +from typing_extensions import Literal + +_IntTypeCode = Literal["b", "B", "h", "H", "i", "I", "l", "L", "q", "Q"] +_FloatTypeCode = Literal["f", "d"] +_TypeCode = Union[_IntTypeCode, _FloatTypeCode] + +_T = TypeVar("_T", int, float) + +class array(MutableSequence[_T], Generic[_T]): + @overload + def __init__( + self: array[int], + typecode: _IntTypeCode, + __initializer: Union[bytes, Iterable[_T]] = ..., + ) -> None: ... + @overload + def __init__( + self: array[float], + typecode: _FloatTypeCode, + __initializer: Union[bytes, Iterable[_T]] = ..., + ) -> None: ... + @overload + def __init__( + self, typecode: str, __initializer: Union[bytes, Iterable[_T]] = ... + ) -> None: ... + def append(self, __v: _T) -> None: ... + def decode(self) -> str: ... + def extend(self, __bb: Iterable[_T]) -> None: ... + def __len__(self) -> int: ... + @overload + def __getitem__(self, i: int) -> _T: ... + @overload + def __getitem__(self, s: slice) -> array[_T]: ... + @overload # type: ignore # Overrides MutableSequence + def __setitem__(self, i: int, o: _T) -> None: ... + @overload + def __setitem__(self, s: slice, o: array[_T]) -> None: ... + def __add__(self, x: array[_T]) -> array[_T]: ... + def __iadd__(self, x: array[_T]) -> array[_T]: ... # type: ignore # Overrides MutableSequence + +ArrayType = array diff --git a/lang/de/typeshed/stdlib/audio.pyi b/lang/de/typeshed/stdlib/audio.pyi new file mode 100644 index 0000000..b1d39c7 --- /dev/null +++ b/lang/de/typeshed/stdlib/audio.pyi @@ -0,0 +1,11 @@ +"""Play sounds using the micro:bit (import ``audio`` for V1 compatibility). +""" + +# Re-export for V1 compatibility. +from .microbit.audio import ( + is_playing as is_playing, + play as play, + stop as stop, + AudioFrame as AudioFrame, + SoundEffect as SoundEffect, +) diff --git a/lang/de/typeshed/stdlib/builtins.pyi b/lang/de/typeshed/stdlib/builtins.pyi new file mode 100644 index 0000000..8b7dfb9 --- /dev/null +++ b/lang/de/typeshed/stdlib/builtins.pyi @@ -0,0 +1,1334 @@ +import sys +import types +from _typeshed import ( + OpenBinaryMode, + OpenTextMode, + ReadableBuffer, + Self, + StrOrBytesPath, + SupportsDivMod, + SupportsKeysAndGetItem, + SupportsLenAndGetItem, + SupportsLessThan, + SupportsLessThanT, + SupportsRDivMod, + SupportsWrite, +) +from types import CodeType, TracebackType +from typing import ( + IO, + AbstractSet, + Any, + AsyncIterable, + AsyncIterator, + BinaryIO, + ByteString, + Callable, + FrozenSet, + Generic, + ItemsView, + Iterable, + Iterator, + KeysView, + Mapping, + MutableMapping, + MutableSequence, + MutableSet, + NoReturn, + Protocol, + Reversible, + Sequence, + Set, + Sized, + SupportsAbs, + SupportsBytes, + SupportsComplex, + SupportsFloat, + SupportsInt, + SupportsRound, + TextIO, + Tuple, + Type, + TypeVar, + Union, + ValuesView, + overload, +) +from typing_extensions import Literal, SupportsIndex, final + +if sys.version_info >= (3, 9): + from types import GenericAlias + +class _SupportsTrunc(Protocol): + def __trunc__(self) -> int: ... + +_T = TypeVar("_T") +_T_co = TypeVar("_T_co", covariant=True) +_T_contra = TypeVar("_T_contra", contravariant=True) +_KT = TypeVar("_KT") +_VT = TypeVar("_VT") +_S = TypeVar("_S") +_T1 = TypeVar("_T1") +_T2 = TypeVar("_T2") +_T3 = TypeVar("_T3") +_T4 = TypeVar("_T4") +_T5 = TypeVar("_T5") +_TT = TypeVar("_TT", bound="type") +_TBE = TypeVar("_TBE", bound="BaseException") + +class object: + __doc__: str | None + __dict__: dict[str, Any] + __slots__: str | Iterable[str] + __module__: str + __annotations__: dict[str, Any] + @property + def __class__(self: _T) -> Type[_T]: ... + # Ignore errors about type mismatch between property getter and setter + @__class__.setter + def __class__(self, __type: Type[object]) -> None: ... # type: ignore # noqa: F811 + def __init__(self) -> None: ... + def __new__(cls: Type[_T]) -> _T: ... + def __setattr__(self, name: str, value: Any) -> None: ... + def __eq__(self, o: object) -> bool: ... + def __ne__(self, o: object) -> bool: ... + def __str__(self) -> str: ... + def __repr__(self) -> str: ... + def __hash__(self) -> int: ... + def __format__(self, format_spec: str) -> str: ... + def __getattribute__(self, name: str) -> Any: ... + def __delattr__(self, name: str) -> None: ... + def __sizeof__(self) -> int: ... + def __reduce__(self) -> str | Tuple[Any, ...]: ... + if sys.version_info >= (3, 8): + def __reduce_ex__(self, protocol: SupportsIndex) -> str | Tuple[Any, ...]: ... + else: + def __reduce_ex__(self, protocol: int) -> str | Tuple[Any, ...]: ... + def __dir__(self) -> Iterable[str]: ... + def __init_subclass__(cls) -> None: ... + +class staticmethod(object): # Special, only valid as a decorator. + __func__: Callable[..., Any] + __isabstractmethod__: bool + def __init__(self, f: Callable[..., Any]) -> None: ... + def __new__(cls: Type[_T], *args: Any, **kwargs: Any) -> _T: ... + def __get__(self, obj: _T, type: Type[_T] | None = ...) -> Callable[..., Any]: ... + +class classmethod(object): # Special, only valid as a decorator. + __func__: Callable[..., Any] + __isabstractmethod__: bool + def __init__(self, f: Callable[..., Any]) -> None: ... + def __new__(cls: Type[_T], *args: Any, **kwargs: Any) -> _T: ... + def __get__(self, obj: _T, type: Type[_T] | None = ...) -> Callable[..., Any]: ... + +class type(object): + __base__: type + __bases__: Tuple[type, ...] + __basicsize__: int + __dict__: dict[str, Any] + __dictoffset__: int + __flags__: int + __itemsize__: int + __module__: str + __name__: str + __qualname__: str + __text_signature__: str | None + __weakrefoffset__: int + @overload + def __init__(self, o: object) -> None: ... + @overload + def __init__( + self, name: str, bases: Tuple[type, ...], dict: dict[str, Any], **kwds: Any + ) -> None: ... + @overload + def __new__(cls, o: object) -> type: ... + @overload + def __new__( + cls: Type[_TT], + name: str, + bases: Tuple[type, ...], + namespace: dict[str, Any], + **kwds: Any, + ) -> _TT: ... + def __call__(self, *args: Any, **kwds: Any) -> Any: ... + def __subclasses__(self: _TT) -> list[_TT]: ... + def __instancecheck__(self, instance: Any) -> bool: ... + def __subclasscheck__(self, subclass: type) -> bool: ... + @classmethod + def __prepare__( + metacls, __name: str, __bases: Tuple[type, ...], **kwds: Any + ) -> Mapping[str, Any]: ... + if sys.version_info >= (3, 10): + def __or__(self, t: Any) -> types.UnionType: ... + def __ror__(self, t: Any) -> types.UnionType: ... + +class super(object): + @overload + def __init__(self, t: Any, obj: Any) -> None: ... + @overload + def __init__(self, t: Any) -> None: ... + @overload + def __init__(self) -> None: ... + +class int: + @overload + def __new__( + cls: Type[_T], + x: str | bytes | SupportsInt | SupportsIndex | _SupportsTrunc = ..., + ) -> _T: ... + @overload + def __new__( + cls: Type[_T], x: str | bytes | bytearray, base: SupportsIndex + ) -> _T: ... + def to_bytes( + self, + length: SupportsIndex, + byteorder: Literal["little", "big"], + *, + signed: bool = ..., + ) -> bytes: ... + @classmethod + def from_bytes( + cls, + bytes: Iterable[SupportsIndex] | SupportsBytes, + byteorder: Literal["little", "big"], + *, + signed: bool = ..., + ) -> int: ... # TODO buffer object argument + def __add__(self, x: int) -> int: ... + def __sub__(self, x: int) -> int: ... + def __mul__(self, x: int) -> int: ... + def __floordiv__(self, x: int) -> int: ... + def __truediv__(self, x: int) -> float: ... + def __mod__(self, x: int) -> int: ... + def __divmod__(self, x: int) -> Tuple[int, int]: ... + def __radd__(self, x: int) -> int: ... + def __rsub__(self, x: int) -> int: ... + def __rmul__(self, x: int) -> int: ... + def __rfloordiv__(self, x: int) -> int: ... + def __rtruediv__(self, x: int) -> float: ... + def __rmod__(self, x: int) -> int: ... + def __rdivmod__(self, x: int) -> Tuple[int, int]: ... + @overload + def __pow__(self, __x: Literal[2], __modulo: int | None = ...) -> int: ... + @overload + def __pow__( + self, __x: int, __modulo: int | None = ... + ) -> Any: ... # Return type can be int or float, depending on x. + def __rpow__(self, x: int, mod: int | None = ...) -> Any: ... + def __and__(self, n: int) -> int: ... + def __or__(self, n: int) -> int: ... + def __xor__(self, n: int) -> int: ... + def __lshift__(self, n: int) -> int: ... + def __rshift__(self, n: int) -> int: ... + def __rand__(self, n: int) -> int: ... + def __ror__(self, n: int) -> int: ... + def __rxor__(self, n: int) -> int: ... + def __rlshift__(self, n: int) -> int: ... + def __rrshift__(self, n: int) -> int: ... + def __neg__(self) -> int: ... + def __pos__(self) -> int: ... + def __invert__(self) -> int: ... + def __trunc__(self) -> int: ... + def __ceil__(self) -> int: ... + def __floor__(self) -> int: ... + def __round__(self, ndigits: SupportsIndex = ...) -> int: ... + def __getnewargs__(self) -> Tuple[int]: ... + def __eq__(self, x: object) -> bool: ... + def __ne__(self, x: object) -> bool: ... + def __lt__(self, x: int) -> bool: ... + def __le__(self, x: int) -> bool: ... + def __gt__(self, x: int) -> bool: ... + def __ge__(self, x: int) -> bool: ... + def __str__(self) -> str: ... + def __float__(self) -> float: ... + def __int__(self) -> int: ... + def __abs__(self) -> int: ... + def __hash__(self) -> int: ... + def __bool__(self) -> bool: ... + def __index__(self) -> int: ... + +class float: + def __new__( + cls: Type[_T], x: SupportsFloat | SupportsIndex | str | bytes | bytearray = ... + ) -> _T: ... + def __add__(self, x: float) -> float: ... + def __sub__(self, x: float) -> float: ... + def __mul__(self, x: float) -> float: ... + def __floordiv__(self, x: float) -> float: ... + def __truediv__(self, x: float) -> float: ... + def __mod__(self, x: float) -> float: ... + def __divmod__(self, x: float) -> Tuple[float, float]: ... + def __pow__( + self, x: float, mod: None = ... + ) -> float: ... # In Python 3, returns complex if self is negative and x is not whole + def __radd__(self, x: float) -> float: ... + def __rsub__(self, x: float) -> float: ... + def __rmul__(self, x: float) -> float: ... + def __rfloordiv__(self, x: float) -> float: ... + def __rtruediv__(self, x: float) -> float: ... + def __rmod__(self, x: float) -> float: ... + def __rdivmod__(self, x: float) -> Tuple[float, float]: ... + def __rpow__(self, x: float, mod: None = ...) -> float: ... + def __getnewargs__(self) -> Tuple[float]: ... + def __trunc__(self) -> int: ... + if sys.version_info >= (3, 9): + def __ceil__(self) -> int: ... + def __floor__(self) -> int: ... + @overload + def __round__(self, ndigits: None = ...) -> int: ... + @overload + def __round__(self, ndigits: SupportsIndex) -> float: ... + def __eq__(self, x: object) -> bool: ... + def __ne__(self, x: object) -> bool: ... + def __lt__(self, x: float) -> bool: ... + def __le__(self, x: float) -> bool: ... + def __gt__(self, x: float) -> bool: ... + def __ge__(self, x: float) -> bool: ... + def __neg__(self) -> float: ... + def __pos__(self) -> float: ... + def __str__(self) -> str: ... + def __int__(self) -> int: ... + def __float__(self) -> float: ... + def __abs__(self) -> float: ... + def __hash__(self) -> int: ... + def __bool__(self) -> bool: ... + +class complex: + @overload + def __new__(cls: Type[_T], real: float = ..., imag: float = ...) -> _T: ... + @overload + def __new__( + cls: Type[_T], real: str | SupportsComplex | SupportsIndex | complex + ) -> _T: ... + @property + def real(self) -> float: ... + @property + def imag(self) -> float: ... + def __add__(self, x: complex) -> complex: ... + def __sub__(self, x: complex) -> complex: ... + def __mul__(self, x: complex) -> complex: ... + def __pow__(self, x: complex, mod: None = ...) -> complex: ... + def __truediv__(self, x: complex) -> complex: ... + def __radd__(self, x: complex) -> complex: ... + def __rsub__(self, x: complex) -> complex: ... + def __rmul__(self, x: complex) -> complex: ... + def __rpow__(self, x: complex, mod: None = ...) -> complex: ... + def __rtruediv__(self, x: complex) -> complex: ... + def __eq__(self, x: object) -> bool: ... + def __ne__(self, x: object) -> bool: ... + def __neg__(self) -> complex: ... + def __pos__(self) -> complex: ... + def __str__(self) -> str: ... + def __abs__(self) -> float: ... + def __hash__(self) -> int: ... + def __bool__(self) -> bool: ... + +class str(Sequence[str]): + @overload + def __new__(cls: Type[_T], o: object = ...) -> _T: ... + @overload + def __new__( + cls: Type[_T], o: bytes, encoding: str = ..., errors: str = ... + ) -> _T: ... + def count( + self, + x: str, + __start: SupportsIndex | None = ..., + __end: SupportsIndex | None = ..., + ) -> int: ... + def encode(self, encoding: str = ..., errors: str = ...) -> bytes: ... + def endswith( + self, + __suffix: str | Tuple[str, ...], + __start: SupportsIndex | None = ..., + __end: SupportsIndex | None = ..., + ) -> bool: ... + def find( + self, + __sub: str, + __start: SupportsIndex | None = ..., + __end: SupportsIndex | None = ..., + ) -> int: ... + def format(self, *args: object, **kwargs: object) -> str: ... + def index( + self, + __sub: str, + __start: SupportsIndex | None = ..., + __end: SupportsIndex | None = ..., + ) -> int: ... + def isalpha(self) -> bool: ... + def isdigit(self) -> bool: ... + def islower(self) -> bool: ... + def isspace(self) -> bool: ... + def isupper(self) -> bool: ... + def join(self, __iterable: Iterable[str]) -> str: ... + def lower(self) -> str: ... + def lstrip(self, __chars: str | None = ...) -> str: ... + def replace(self, __old: str, __new: str, __count: SupportsIndex = ...) -> str: ... + def rfind( + self, + __sub: str, + __start: SupportsIndex | None = ..., + __end: SupportsIndex | None = ..., + ) -> int: ... + def rindex( + self, + __sub: str, + __start: SupportsIndex | None = ..., + __end: SupportsIndex | None = ..., + ) -> int: ... + def rsplit( + self, sep: str | None = ..., maxsplit: SupportsIndex = ... + ) -> list[str]: ... + def rstrip(self, __chars: str | None = ...) -> str: ... + def split( + self, sep: str | None = ..., maxsplit: SupportsIndex = ... + ) -> list[str]: ... + def startswith( + self, + __prefix: str | Tuple[str, ...], + __start: SupportsIndex | None = ..., + __end: SupportsIndex | None = ..., + ) -> bool: ... + def strip(self, __chars: str | None = ...) -> str: ... + def upper(self) -> str: ... + def __add__(self, s: str) -> str: ... + # Incompatible with Sequence.__contains__ + def __contains__(self, o: str) -> bool: ... # type: ignore + def __eq__(self, x: object) -> bool: ... + def __ge__(self, x: str) -> bool: ... + def __getitem__(self, i: int | slice) -> str: ... + def __gt__(self, x: str) -> bool: ... + def __hash__(self) -> int: ... + def __iter__(self) -> Iterator[str]: ... + def __le__(self, x: str) -> bool: ... + def __len__(self) -> int: ... + def __lt__(self, x: str) -> bool: ... + def __mod__(self, x: Any) -> str: ... + def __mul__(self, n: SupportsIndex) -> str: ... + def __ne__(self, x: object) -> bool: ... + def __repr__(self) -> str: ... + def __rmul__(self, n: SupportsIndex) -> str: ... + def __str__(self) -> str: ... + def __getnewargs__(self) -> Tuple[str]: ... + +class bytes(ByteString): + @overload + def __new__(cls: Type[_T], ints: Iterable[SupportsIndex]) -> _T: ... + @overload + def __new__(cls: Type[_T], string: str, encoding: str, errors: str = ...) -> _T: ... + @overload + def __new__(cls: Type[_T], length: SupportsIndex) -> _T: ... + @overload + def __new__(cls: Type[_T]) -> _T: ... + @overload + def __new__(cls: Type[_T], o: SupportsBytes) -> _T: ... + def count( + self, + __sub: bytes | SupportsIndex, + __start: SupportsIndex | None = ..., + __end: SupportsIndex | None = ..., + ) -> int: ... + def decode(self, encoding: str = ..., errors: str = ...) -> str: ... + def endswith( + self, + __suffix: bytes | Tuple[bytes, ...], + __start: SupportsIndex | None = ..., + __end: SupportsIndex | None = ..., + ) -> bool: ... + def find( + self, + __sub: bytes | SupportsIndex, + __start: SupportsIndex | None = ..., + __end: SupportsIndex | None = ..., + ) -> int: ... + def index( + self, + __sub: bytes | SupportsIndex, + __start: SupportsIndex | None = ..., + __end: SupportsIndex | None = ..., + ) -> int: ... + def isalpha(self) -> bool: ... + def isdigit(self) -> bool: ... + def islower(self) -> bool: ... + def isspace(self) -> bool: ... + def isupper(self) -> bool: ... + def join(self, __iterable_of_bytes: Iterable[ByteString | memoryview]) -> bytes: ... + def lower(self) -> bytes: ... + def lstrip(self, __bytes: bytes | None = ...) -> bytes: ... + def replace( + self, __old: bytes, __new: bytes, __count: SupportsIndex = ... + ) -> bytes: ... + def rfind( + self, + __sub: bytes | SupportsIndex, + __start: SupportsIndex | None = ..., + __end: SupportsIndex | None = ..., + ) -> int: ... + def rindex( + self, + __sub: bytes | SupportsIndex, + __start: SupportsIndex | None = ..., + __end: SupportsIndex | None = ..., + ) -> int: ... + def rsplit( + self, sep: bytes | None = ..., maxsplit: SupportsIndex = ... + ) -> list[bytes]: ... + def rstrip(self, __bytes: bytes | None = ...) -> bytes: ... + def split( + self, sep: bytes | None = ..., maxsplit: SupportsIndex = ... + ) -> list[bytes]: ... + def startswith( + self, + __prefix: bytes | Tuple[bytes, ...], + __start: SupportsIndex | None = ..., + __end: SupportsIndex | None = ..., + ) -> bool: ... + def strip(self, __bytes: bytes | None = ...) -> bytes: ... + def upper(self) -> bytes: ... + def __len__(self) -> int: ... + def __iter__(self) -> Iterator[int]: ... + def __str__(self) -> str: ... + def __repr__(self) -> str: ... + def __hash__(self) -> int: ... + @overload + def __getitem__(self, i: SupportsIndex) -> int: ... + @overload + def __getitem__(self, s: slice) -> bytes: ... + def __add__(self, s: bytes) -> bytes: ... + def __mul__(self, n: SupportsIndex) -> bytes: ... + def __rmul__(self, n: SupportsIndex) -> bytes: ... + def __mod__(self, value: Any) -> bytes: ... + # Incompatible with Sequence.__contains__ + def __contains__(self, o: SupportsIndex | bytes) -> bool: ... # type: ignore + def __eq__(self, x: object) -> bool: ... + def __ne__(self, x: object) -> bool: ... + def __lt__(self, x: bytes) -> bool: ... + def __le__(self, x: bytes) -> bool: ... + def __gt__(self, x: bytes) -> bool: ... + def __ge__(self, x: bytes) -> bool: ... + def __getnewargs__(self) -> Tuple[bytes]: ... + +class bytearray: + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, ints: Iterable[SupportsIndex]) -> None: ... + @overload + def __init__(self, string: str, encoding: str, errors: str = ...) -> None: ... + @overload + def __init__(self, length: SupportsIndex) -> None: ... + def append(self, __item: SupportsIndex) -> None: ... + def decode(self, encoding: str = ..., errors: str = ...) -> str: ... + def extend(self, __iterable_of_ints: Iterable[SupportsIndex]) -> None: ... + def __len__(self) -> int: ... + def __iter__(self) -> Iterator[int]: ... + def __str__(self) -> str: ... + def __repr__(self) -> str: ... + __hash__: None # type: ignore + @overload + def __getitem__(self, i: SupportsIndex) -> int: ... + @overload + def __getitem__(self, s: slice) -> bytearray: ... + @overload + def __setitem__(self, i: SupportsIndex, x: SupportsIndex) -> None: ... + @overload + def __setitem__(self, s: slice, x: Iterable[SupportsIndex] | bytes) -> None: ... + def __delitem__(self, i: SupportsIndex | slice) -> None: ... + def __add__(self, s: bytes) -> bytearray: ... + def __iadd__(self, s: Iterable[int]) -> bytearray: ... + def __mul__(self, n: SupportsIndex) -> bytearray: ... + def __rmul__(self, n: SupportsIndex) -> bytearray: ... + def __imul__(self, n: SupportsIndex) -> bytearray: ... + def __mod__(self, value: Any) -> bytes: ... + # Incompatible with Sequence.__contains__ + def __contains__(self, o: SupportsIndex | bytes) -> bool: ... # type: ignore + def __eq__(self, x: object) -> bool: ... + def __ne__(self, x: object) -> bool: ... + def __lt__(self, x: bytes) -> bool: ... + def __le__(self, x: bytes) -> bool: ... + def __gt__(self, x: bytes) -> bool: ... + def __ge__(self, x: bytes) -> bool: ... + +class memoryview(Sized, Sequence[int]): + def __init__(self, obj: ReadableBuffer) -> None: ... + @overload + def __getitem__(self, i: SupportsIndex) -> int: ... + @overload + def __getitem__(self, s: slice) -> memoryview: ... + def __contains__(self, x: object) -> bool: ... + def __iter__(self) -> Iterator[int]: ... + def __len__(self) -> int: ... + @overload + def __setitem__(self, s: slice, o: bytes) -> None: ... + @overload + def __setitem__(self, i: SupportsIndex, o: SupportsIndex) -> None: ... + +@final +class bool(int): + def __new__(cls: Type[_T], __o: object = ...) -> _T: ... + @overload + def __and__(self, x: bool) -> bool: ... + @overload + def __and__(self, x: int) -> int: ... + @overload + def __or__(self, x: bool) -> bool: ... + @overload + def __or__(self, x: int) -> int: ... + @overload + def __xor__(self, x: bool) -> bool: ... + @overload + def __xor__(self, x: int) -> int: ... + @overload + def __rand__(self, x: bool) -> bool: ... + @overload + def __rand__(self, x: int) -> int: ... + @overload + def __ror__(self, x: bool) -> bool: ... + @overload + def __ror__(self, x: int) -> int: ... + @overload + def __rxor__(self, x: bool) -> bool: ... + @overload + def __rxor__(self, x: int) -> int: ... + def __getnewargs__(self) -> Tuple[int]: ... + +class slice(object): + start: Any + step: Any + stop: Any + __hash__: None # type: ignore + def indices(self, len: SupportsIndex) -> Tuple[int, int, int]: ... + +class tuple(Sequence[_T_co], Generic[_T_co]): + def __new__(cls: Type[_T], iterable: Iterable[_T_co] = ...) -> _T: ... + def __len__(self) -> int: ... + def __contains__(self, x: object) -> bool: ... + @overload + def __getitem__(self, x: int) -> _T_co: ... + @overload + def __getitem__(self, x: slice) -> Tuple[_T_co, ...]: ... + def __iter__(self) -> Iterator[_T_co]: ... + def __lt__(self, x: Tuple[_T_co, ...]) -> bool: ... + def __le__(self, x: Tuple[_T_co, ...]) -> bool: ... + def __gt__(self, x: Tuple[_T_co, ...]) -> bool: ... + def __ge__(self, x: Tuple[_T_co, ...]) -> bool: ... + @overload + def __add__(self, x: Tuple[_T_co, ...]) -> Tuple[_T_co, ...]: ... + @overload + def __add__(self, x: Tuple[_T, ...]) -> Tuple[_T_co | _T, ...]: ... + def __mul__(self, n: SupportsIndex) -> Tuple[_T_co, ...]: ... + def __rmul__(self, n: SupportsIndex) -> Tuple[_T_co, ...]: ... + def count(self, __value: Any) -> int: ... + def index( + self, __value: Any, __start: SupportsIndex = ..., __stop: SupportsIndex = ... + ) -> int: ... + +# Can we remove this? +class function: + # TODO not defined in builtins! + __name__: str + __module__: str + __code__: CodeType + __qualname__: str + __annotations__: dict[str, Any] + +class frozenset(AbstractSet[_T_co], Generic[_T_co]): + @overload + def __new__(cls: type[Self]) -> Self: ... + @overload + def __new__(cls: type[Self], __iterable: Iterable[_T_co]) -> Self: ... + def copy(self) -> FrozenSet[_T_co]: ... + def difference(self, *s: Iterable[object]) -> FrozenSet[_T_co]: ... + def intersection(self, *s: Iterable[object]) -> FrozenSet[_T_co]: ... + def isdisjoint(self, s: Iterable[_T_co]) -> bool: ... + def issubset(self, s: Iterable[object]) -> bool: ... + def issuperset(self, s: Iterable[object]) -> bool: ... + def symmetric_difference(self, s: Iterable[_T_co]) -> FrozenSet[_T_co]: ... + def union(self, *s: Iterable[_T_co]) -> FrozenSet[_T_co]: ... + def __len__(self) -> int: ... + def __contains__(self, o: object) -> bool: ... + def __iter__(self) -> Iterator[_T_co]: ... + def __str__(self) -> str: ... + def __and__(self, s: AbstractSet[_T_co]) -> FrozenSet[_T_co]: ... + def __or__(self, s: AbstractSet[_S]) -> FrozenSet[_T_co | _S]: ... + def __sub__(self, s: AbstractSet[_T_co]) -> FrozenSet[_T_co]: ... + def __xor__(self, s: AbstractSet[_S]) -> FrozenSet[_T_co | _S]: ... + def __le__(self, s: AbstractSet[object]) -> bool: ... + def __lt__(self, s: AbstractSet[object]) -> bool: ... + def __ge__(self, s: AbstractSet[object]) -> bool: ... + def __gt__(self, s: AbstractSet[object]) -> bool: ... + if sys.version_info >= (3, 9): + def __class_getitem__(cls, item: Any) -> GenericAlias: ... + +class list(MutableSequence[_T], Generic[_T]): + @overload + def __init__(self) -> None: ... + @overload + def __init__(self, iterable: Iterable[_T]) -> None: ... + def clear(self) -> None: ... + def copy(self) -> list[_T]: ... + def append(self, __object: _T) -> None: ... + def extend(self, __iterable: Iterable[_T]) -> None: ... + def pop(self, __index: SupportsIndex = ...) -> _T: ... + def index( + self, __value: _T, __start: SupportsIndex = ..., __stop: SupportsIndex = ... + ) -> int: ... + def count(self, __value: _T) -> int: ... + def insert(self, __index: SupportsIndex, __object: _T) -> None: ... + def remove(self, __value: _T) -> None: ... + def reverse(self) -> None: ... + @overload + def sort( + self: list[SupportsLessThanT], *, key: None = ..., reverse: bool = ... + ) -> None: ... + @overload + def sort( + self, *, key: Callable[[_T], SupportsLessThan], reverse: bool = ... + ) -> None: ... + def __len__(self) -> int: ... + def __iter__(self) -> Iterator[_T]: ... + def __str__(self) -> str: ... + __hash__: None # type: ignore + @overload + def __getitem__(self, i: SupportsIndex) -> _T: ... + @overload + def __getitem__(self, s: slice) -> list[_T]: ... + @overload + def __setitem__(self, i: SupportsIndex, o: _T) -> None: ... + @overload + def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ... + def __delitem__(self, i: SupportsIndex | slice) -> None: ... + def __add__(self, x: list[_T]) -> list[_T]: ... + def __iadd__(self: _S, x: Iterable[_T]) -> _S: ... + def __mul__(self, n: SupportsIndex) -> list[_T]: ... + def __rmul__(self, n: SupportsIndex) -> list[_T]: ... + def __imul__(self: _S, n: SupportsIndex) -> _S: ... + def __contains__(self, o: object) -> bool: ... + def __reversed__(self) -> Iterator[_T]: ... + def __gt__(self, x: list[_T]) -> bool: ... + def __ge__(self, x: list[_T]) -> bool: ... + def __lt__(self, x: list[_T]) -> bool: ... + def __le__(self, x: list[_T]) -> bool: ... + if sys.version_info >= (3, 9): + def __class_getitem__(cls, item: Any) -> GenericAlias: ... + +class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT]): + @overload + def __init__(self: dict[_KT, _VT]) -> None: ... + @overload + def __init__(self: dict[str, _VT], **kwargs: _VT) -> None: ... + @overload + def __init__( + self, map: SupportsKeysAndGetItem[_KT, _VT], **kwargs: _VT + ) -> None: ... + @overload + def __init__(self, iterable: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ... + def __new__(cls: Type[_T1], *args: Any, **kwargs: Any) -> _T1: ... + def clear(self) -> None: ... + def copy(self) -> dict[_KT, _VT]: ... + def popitem(self) -> Tuple[_KT, _VT]: ... + def setdefault(self, __key: _KT, __default: _VT = ...) -> _VT: ... + @overload + def update(self, __m: Mapping[_KT, _VT], **kwargs: _VT) -> None: ... + @overload + def update(self, __m: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ... + @overload + def update(self, **kwargs: _VT) -> None: ... + def keys(self) -> KeysView[_KT]: ... + def values(self) -> ValuesView[_VT]: ... + def items(self) -> ItemsView[_KT, _VT]: ... + @classmethod + @overload + def fromkeys( + cls, __iterable: Iterable[_T], __value: None = ... + ) -> dict[_T, Any | None]: ... + @classmethod + @overload + def fromkeys(cls, __iterable: Iterable[_T], __value: _S) -> dict[_T, _S]: ... + def __len__(self) -> int: ... + def __getitem__(self, k: _KT) -> _VT: ... + def __setitem__(self, k: _KT, v: _VT) -> None: ... + def __delitem__(self, v: _KT) -> None: ... + def __iter__(self) -> Iterator[_KT]: ... + if sys.version_info >= (3, 8): + def __reversed__(self) -> Iterator[_KT]: ... + def __str__(self) -> str: ... + __hash__: None # type: ignore + if sys.version_info >= (3, 9): + def __class_getitem__(cls, item: Any) -> GenericAlias: ... + def __or__(self, __value: Mapping[_T1, _T2]) -> dict[_KT | _T1, _VT | _T2]: ... + def __ror__(self, __value: Mapping[_T1, _T2]) -> dict[_KT | _T1, _VT | _T2]: ... + def __ior__(self, __value: Mapping[_KT, _VT]) -> dict[_KT, _VT]: ... # type: ignore + +class set(MutableSet[_T], Generic[_T]): + def __init__(self, iterable: Iterable[_T] = ...) -> None: ... + def add(self, element: _T) -> None: ... + def clear(self) -> None: ... + def copy(self) -> Set[_T]: ... + def difference(self, *s: Iterable[Any]) -> Set[_T]: ... + def difference_update(self, *s: Iterable[Any]) -> None: ... + def discard(self, element: _T) -> None: ... + def intersection(self, *s: Iterable[Any]) -> Set[_T]: ... + def intersection_update(self, *s: Iterable[Any]) -> None: ... + def isdisjoint(self, s: Iterable[Any]) -> bool: ... + def issubset(self, s: Iterable[Any]) -> bool: ... + def issuperset(self, s: Iterable[Any]) -> bool: ... + def pop(self) -> _T: ... + def remove(self, element: _T) -> None: ... + def symmetric_difference(self, s: Iterable[_T]) -> Set[_T]: ... + def symmetric_difference_update(self, s: Iterable[_T]) -> None: ... + def union(self, *s: Iterable[_T]) -> Set[_T]: ... + def update(self, *s: Iterable[_T]) -> None: ... + def __len__(self) -> int: ... + def __contains__(self, o: object) -> bool: ... + def __iter__(self) -> Iterator[_T]: ... + def __str__(self) -> str: ... + def __and__(self, s: AbstractSet[object]) -> Set[_T]: ... + def __iand__(self, s: AbstractSet[object]) -> Set[_T]: ... + def __or__(self, s: AbstractSet[_S]) -> Set[_T | _S]: ... + def __ior__(self, s: AbstractSet[_S]) -> Set[_T | _S]: ... + def __sub__(self, s: AbstractSet[_T | None]) -> Set[_T]: ... + def __isub__(self, s: AbstractSet[_T | None]) -> Set[_T]: ... + def __xor__(self, s: AbstractSet[_S]) -> Set[_T | _S]: ... + def __ixor__(self, s: AbstractSet[_S]) -> Set[_T | _S]: ... + def __le__(self, s: AbstractSet[object]) -> bool: ... + def __lt__(self, s: AbstractSet[object]) -> bool: ... + def __ge__(self, s: AbstractSet[object]) -> bool: ... + def __gt__(self, s: AbstractSet[object]) -> bool: ... + __hash__: None # type: ignore + if sys.version_info >= (3, 9): + def __class_getitem__(cls, item: Any) -> GenericAlias: ... + +class enumerate(Iterator[Tuple[int, _T]], Generic[_T]): + def __init__(self, iterable: Iterable[_T], start: int = ...) -> None: ... + def __iter__(self) -> Iterator[Tuple[int, _T]]: ... + def __next__(self) -> Tuple[int, _T]: ... + if sys.version_info >= (3, 9): + def __class_getitem__(cls, item: Any) -> GenericAlias: ... + +class range(Sequence[int]): + start: int + stop: int + step: int + @overload + def __init__(self, stop: SupportsIndex) -> None: ... + @overload + def __init__( + self, start: SupportsIndex, stop: SupportsIndex, step: SupportsIndex = ... + ) -> None: ... + def __len__(self) -> int: ... + def __contains__(self, o: object) -> bool: ... + def __iter__(self) -> Iterator[int]: ... + @overload + def __getitem__(self, i: SupportsIndex) -> int: ... + @overload + def __getitem__(self, s: slice) -> range: ... + def __repr__(self) -> str: ... + def __reversed__(self) -> Iterator[int]: ... + +class property(object): + fget: Callable[[Any], Any] | None + fset: Callable[[Any, Any], None] | None + fdel: Callable[[Any], None] | None + def __init__( + self, + fget: Callable[[Any], Any] | None = ..., + fset: Callable[[Any, Any], None] | None = ..., + fdel: Callable[[Any], None] | None = ..., + doc: str | None = ..., + ) -> None: ... + def getter(self, fget: Callable[[Any], Any]) -> property: ... + def setter(self, fset: Callable[[Any, Any], None]) -> property: ... + def deleter(self, fdel: Callable[[Any], None]) -> property: ... + def __get__(self, obj: Any, type: type | None = ...) -> Any: ... + def __set__(self, obj: Any, value: Any) -> None: ... + def __delete__(self, obj: Any) -> None: ... + +class _NotImplementedType(Any): # type: ignore + # A little weird, but typing the __call__ as NotImplemented makes the error message + # for NotImplemented() much better + __call__: NotImplemented # type: ignore + +NotImplemented: _NotImplementedType + +def abs(__x: SupportsAbs[_T]) -> _T: ... +def all(__iterable: Iterable[object]) -> bool: ... +def any(__iterable: Iterable[object]) -> bool: ... +def bin(__number: int | SupportsIndex) -> str: ... + +if sys.version_info >= (3, 7): + def breakpoint(*args: Any, **kws: Any) -> None: ... + +def callable(__obj: object) -> bool: ... +def chr(__i: int) -> str: ... + +# We define this here instead of using os.PathLike to avoid import cycle issues. +# See https://github.com/python/typeshed/pull/991#issuecomment-288160993 +_AnyStr_co = TypeVar("_AnyStr_co", str, bytes, covariant=True) + +class _PathLike(Protocol[_AnyStr_co]): + def __fspath__(self) -> _AnyStr_co: ... + +if sys.version_info >= (3, 10): + def aiter(__iterable: AsyncIterable[_T]) -> AsyncIterator[_T]: ... + @overload + async def anext(__i: AsyncIterator[_T]) -> _T: ... + @overload + async def anext(__i: AsyncIterator[_T], default: _VT) -> _T | _VT: ... + +def delattr(__obj: Any, __name: str) -> None: ... +def dir(__o: object = ...) -> list[str]: ... +@overload +def divmod(__x: SupportsDivMod[_T_contra, _T_co], __y: _T_contra) -> _T_co: ... +@overload +def divmod(__x: _T_contra, __y: SupportsRDivMod[_T_contra, _T_co]) -> _T_co: ... +def eval( + __source: str | bytes | CodeType, + __globals: dict[str, Any] | None = ..., + __locals: Mapping[str, Any] | None = ..., +) -> Any: ... +def exec( + __source: str | bytes | CodeType, + __globals: dict[str, Any] | None = ..., + __locals: Mapping[str, Any] | None = ..., +) -> Any: ... + +class filter(Iterator[_T], Generic[_T]): + @overload + def __init__(self, __function: None, __iterable: Iterable[_T | None]) -> None: ... + @overload + def __init__( + self, __function: Callable[[_T], Any], __iterable: Iterable[_T] + ) -> None: ... + def __iter__(self) -> Iterator[_T]: ... + def __next__(self) -> _T: ... + +@overload +def getattr(__o: object, name: str) -> Any: ... + +# While technically covered by the last overload, spelling out the types for None and bool +# help mypy out in some tricky situations involving type context (aka bidirectional inference) +@overload +def getattr(__o: object, name: str, __default: None) -> Any | None: ... +@overload +def getattr(__o: object, name: str, __default: bool) -> Any | bool: ... +@overload +def getattr(__o: object, name: str, __default: _T) -> Any | _T: ... +def globals() -> dict[str, Any]: ... +def hasattr(__obj: object, __name: str) -> bool: ... +def hash(__obj: object) -> int: ... +def help(*args: Any, **kwds: Any) -> None: ... +def hex(__number: int | SupportsIndex) -> str: ... +def id(__obj: object) -> int: ... +def input(__prompt: Any = ...) -> str: ... +@overload +def iter(__iterable: Iterable[_T]) -> Iterator[_T]: ... +@overload +def iter(__function: Callable[[], _T | None], __sentinel: None) -> Iterator[_T]: ... +@overload +def iter(__function: Callable[[], _T], __sentinel: Any) -> Iterator[_T]: ... + +if sys.version_info >= (3, 10): + def isinstance( + __obj: object, + __class_or_tuple: type + | types.UnionType + | Tuple[type | types.UnionType | Tuple[Any, ...], ...], + ) -> bool: ... + def issubclass( + __cls: type, + __class_or_tuple: type + | types.UnionType + | Tuple[type | types.UnionType | Tuple[Any, ...], ...], + ) -> bool: ... + +else: + def isinstance( + __obj: object, __class_or_tuple: type | Tuple[type | Tuple[Any, ...], ...] + ) -> bool: ... + def issubclass( + __cls: type, __class_or_tuple: type | Tuple[type | Tuple[Any, ...], ...] + ) -> bool: ... + +def len(__obj: Sized) -> int: ... +def locals() -> dict[str, Any]: ... + +class map(Iterator[_S], Generic[_S]): + @overload + def __init__(self, __func: Callable[[_T1], _S], __iter1: Iterable[_T1]) -> None: ... + @overload + def __init__( + self, + __func: Callable[[_T1, _T2], _S], + __iter1: Iterable[_T1], + __iter2: Iterable[_T2], + ) -> None: ... + @overload + def __init__( + self, + __func: Callable[[_T1, _T2, _T3], _S], + __iter1: Iterable[_T1], + __iter2: Iterable[_T2], + __iter3: Iterable[_T3], + ) -> None: ... + @overload + def __init__( + self, + __func: Callable[[_T1, _T2, _T3, _T4], _S], + __iter1: Iterable[_T1], + __iter2: Iterable[_T2], + __iter3: Iterable[_T3], + __iter4: Iterable[_T4], + ) -> None: ... + @overload + def __init__( + self, + __func: Callable[[_T1, _T2, _T3, _T4, _T5], _S], + __iter1: Iterable[_T1], + __iter2: Iterable[_T2], + __iter3: Iterable[_T3], + __iter4: Iterable[_T4], + __iter5: Iterable[_T5], + ) -> None: ... + @overload + def __init__( + self, + __func: Callable[..., _S], + __iter1: Iterable[Any], + __iter2: Iterable[Any], + __iter3: Iterable[Any], + __iter4: Iterable[Any], + __iter5: Iterable[Any], + __iter6: Iterable[Any], + *iterables: Iterable[Any], + ) -> None: ... + def __iter__(self) -> Iterator[_S]: ... + def __next__(self) -> _S: ... + +@overload +def max( + __arg1: SupportsLessThanT, + __arg2: SupportsLessThanT, + *_args: SupportsLessThanT, + key: None = ..., +) -> SupportsLessThanT: ... +@overload +def max( + __arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], SupportsLessThan] +) -> _T: ... +@overload +def max( + __iterable: Iterable[SupportsLessThanT], *, key: None = ... +) -> SupportsLessThanT: ... +@overload +def max(__iterable: Iterable[_T], *, key: Callable[[_T], SupportsLessThan]) -> _T: ... +@overload +def max( + __iterable: Iterable[SupportsLessThanT], *, key: None = ..., default: _T +) -> SupportsLessThanT | _T: ... +@overload +def max( + __iterable: Iterable[_T1], *, key: Callable[[_T1], SupportsLessThan], default: _T2 +) -> _T1 | _T2: ... +@overload +def min( + __arg1: SupportsLessThanT, + __arg2: SupportsLessThanT, + *_args: SupportsLessThanT, + key: None = ..., +) -> SupportsLessThanT: ... +@overload +def min( + __arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], SupportsLessThan] +) -> _T: ... +@overload +def min( + __iterable: Iterable[SupportsLessThanT], *, key: None = ... +) -> SupportsLessThanT: ... +@overload +def min(__iterable: Iterable[_T], *, key: Callable[[_T], SupportsLessThan]) -> _T: ... +@overload +def min( + __iterable: Iterable[SupportsLessThanT], *, key: None = ..., default: _T +) -> SupportsLessThanT | _T: ... +@overload +def min( + __iterable: Iterable[_T1], *, key: Callable[[_T1], SupportsLessThan], default: _T2 +) -> _T1 | _T2: ... +@overload +def next(__i: Iterator[_T]) -> _T: ... +@overload +def next(__i: Iterator[_T], default: _VT) -> _T | _VT: ... +def oct(__number: int | SupportsIndex) -> str: ... + +_OpenFile = Union[StrOrBytesPath, int] +_Opener = Callable[[str, int], int] + +# Text mode: always returns a TextIOWrapper +@overload +def open( + file: _OpenFile, + mode: OpenTextMode = ..., + buffering: int = ..., + encoding: str | None = ..., + errors: str | None = ..., + newline: str | None = ..., + closefd: bool = ..., + opener: _Opener | None = ..., +) -> TextIO: ... + +# Unbuffered binary mode: returns a FileIO +@overload +def open( + file: _OpenFile, + mode: OpenBinaryMode, + buffering: int = ..., + encoding: None = ..., + errors: None = ..., + newline: None = ..., + closefd: bool = ..., + opener: _Opener | None = ..., +) -> BinaryIO: ... + +# Fallback if mode is not specified +@overload +def open( + file: _OpenFile, + mode: str, + buffering: int = ..., + encoding: str | None = ..., + errors: str | None = ..., + newline: str | None = ..., + closefd: bool = ..., + opener: _Opener | None = ..., +) -> IO[Any]: ... +def ord(__c: str | bytes) -> int: ... +def print( + *values: object, + sep: str | None = ..., + end: str | None = ..., + file: SupportsWrite[str] | None = ..., + flush: bool = ..., +) -> None: ... + +_E = TypeVar("_E", contravariant=True) +_M = TypeVar("_M", contravariant=True) + +class _SupportsPow2(Protocol[_E, _T_co]): + def __pow__(self, __other: _E) -> _T_co: ... + +class _SupportsPow3(Protocol[_E, _M, _T_co]): + def __pow__(self, __other: _E, __modulo: _M) -> _T_co: ... + +if sys.version_info >= (3, 8): + @overload + def pow( + base: int, exp: int, mod: None = ... + ) -> Any: ... # returns int or float depending on whether exp is non-negative + @overload + def pow(base: int, exp: int, mod: int) -> int: ... + @overload + def pow(base: float, exp: float, mod: None = ...) -> float: ... + @overload + def pow(base: _SupportsPow2[_E, _T_co], exp: _E) -> _T_co: ... + @overload + def pow(base: _SupportsPow3[_E, _M, _T_co], exp: _E, mod: _M) -> _T_co: ... + +else: + @overload + def pow( + __base: int, __exp: int, __mod: None = ... + ) -> Any: ... # returns int or float depending on whether exp is non-negative + @overload + def pow(__base: int, __exp: int, __mod: int) -> int: ... + @overload + def pow(__base: float, __exp: float, __mod: None = ...) -> float: ... + @overload + def pow(__base: _SupportsPow2[_E, _T_co], __exp: _E) -> _T_co: ... + @overload + def pow(__base: _SupportsPow3[_E, _M, _T_co], __exp: _E, __mod: _M) -> _T_co: ... + +class reversed(Iterator[_T], Generic[_T]): + @overload + def __init__(self, __sequence: Reversible[_T]) -> None: ... + @overload + def __init__(self, __sequence: SupportsLenAndGetItem[_T]) -> None: ... + def __iter__(self) -> Iterator[_T]: ... + def __next__(self) -> _T: ... + +def repr(__obj: object) -> str: ... +@overload +def round(number: SupportsRound[Any]) -> int: ... +@overload +def round(number: SupportsRound[Any], ndigits: None) -> int: ... +@overload +def round(number: SupportsRound[_T], ndigits: SupportsIndex) -> _T: ... +def setattr(__obj: object, __name: str, __value: Any) -> None: ... +@overload +def sorted( + __iterable: Iterable[SupportsLessThanT], *, key: None = ..., reverse: bool = ... +) -> list[SupportsLessThanT]: ... +@overload +def sorted( + __iterable: Iterable[_T], + *, + key: Callable[[_T], SupportsLessThan], + reverse: bool = ..., +) -> list[_T]: ... + +if sys.version_info >= (3, 8): + @overload + def sum(__iterable: Iterable[_T]) -> _T | int: ... + @overload + def sum(__iterable: Iterable[_T], start: _S) -> _T | _S: ... + +else: + @overload + def sum(__iterable: Iterable[_T]) -> _T | int: ... + @overload + def sum(__iterable: Iterable[_T], __start: _S) -> _T | _S: ... + +class zip(Iterator[_T_co], Generic[_T_co]): + @overload + def __new__(cls, __iter1: Iterable[_T1]) -> zip[Tuple[_T1]]: ... + @overload + def __new__( + cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2] + ) -> zip[Tuple[_T1, _T2]]: ... + @overload + def __new__( + cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3] + ) -> zip[Tuple[_T1, _T2, _T3]]: ... + @overload + def __new__( + cls, + __iter1: Iterable[_T1], + __iter2: Iterable[_T2], + __iter3: Iterable[_T3], + __iter4: Iterable[_T4], + ) -> zip[Tuple[_T1, _T2, _T3, _T4]]: ... + @overload + def __new__( + cls, + __iter1: Iterable[_T1], + __iter2: Iterable[_T2], + __iter3: Iterable[_T3], + __iter4: Iterable[_T4], + __iter5: Iterable[_T5], + ) -> zip[Tuple[_T1, _T2, _T3, _T4, _T5]]: ... + @overload + def __new__( + cls, + __iter1: Iterable[Any], + __iter2: Iterable[Any], + __iter3: Iterable[Any], + __iter4: Iterable[Any], + __iter5: Iterable[Any], + __iter6: Iterable[Any], + *iterables: Iterable[Any], + ) -> zip[Tuple[Any, ...]]: ... + def __iter__(self) -> Iterator[_T_co]: ... + def __next__(self) -> _T_co: ... + +def __import__( + name: str, + globals: Mapping[str, Any] | None = ..., + locals: Mapping[str, Any] | None = ..., + fromlist: Sequence[str] = ..., + level: int = ..., +) -> Any: ... + +# Actually the type of Ellipsis is , but since it's +# not exposed anywhere under that name, we make it private here. +class ellipsis: ... + +Ellipsis: ellipsis + +class BaseException(object): + args: Tuple[Any, ...] + __cause__: BaseException | None + __context__: BaseException | None + __suppress_context__: bool + __traceback__: TracebackType | None + def __init__(self, *args: object) -> None: ... + def __str__(self) -> str: ... + def __repr__(self) -> str: ... + def with_traceback(self: _TBE, tb: TracebackType | None) -> _TBE: ... + +class GeneratorExit(BaseException): ... +class KeyboardInterrupt(BaseException): ... + +class SystemExit(BaseException): + code: int + +class Exception(BaseException): ... + +class StopIteration(Exception): + value: Any + +_StandardError = Exception + +class OSError(Exception): + errno: int + strerror: str + # filename, filename2 are actually str | bytes | None + filename: Any + filename2: Any + if sys.platform == "win32": + winerror: int + +if sys.platform == "win32": + WindowsError = OSError + +class ArithmeticError(_StandardError): ... +class AssertionError(_StandardError): ... + +class AttributeError(_StandardError): + if sys.version_info >= (3, 10): + name: str + obj: object + +class EOFError(_StandardError): ... + +class ImportError(_StandardError): + def __init__( + self, *args: object, name: str | None = ..., path: str | None = ... + ) -> None: ... + name: str | None + path: str | None + msg: str # undocumented + +class LookupError(_StandardError): ... +class MemoryError(_StandardError): ... + +class NameError(_StandardError): + if sys.version_info >= (3, 10): + name: str + +class RuntimeError(_StandardError): ... + +class StopAsyncIteration(Exception): + value: Any + +class SyntaxError(_StandardError): + msg: str + lineno: int | None + offset: int | None + text: str | None + filename: str | None + if sys.version_info >= (3, 10): + end_lineno: int | None + end_offset: int | None + +class TypeError(_StandardError): ... +class ValueError(_StandardError): ... +class FloatingPointError(ArithmeticError): ... +class OverflowError(ArithmeticError): ... +class ZeroDivisionError(ArithmeticError): ... +class IndexError(LookupError): ... +class KeyError(LookupError): ... +class NotImplementedError(RuntimeError): ... +class IndentationError(SyntaxError): ... +class TabError(IndentationError): ... diff --git a/lang/de/typeshed/stdlib/collections/__init__.pyi b/lang/de/typeshed/stdlib/collections/__init__.pyi new file mode 100644 index 0000000..8815a4b --- /dev/null +++ b/lang/de/typeshed/stdlib/collections/__init__.pyi @@ -0,0 +1,60 @@ +import sys +from typing import ( + Any, + Dict, + Generic, + ItemsView, + Iterable, + Iterator, + KeysView, + Optional, + Reversible, + Tuple, + Type, + TypeVar, + Union, + ValuesView, +) + +_S = TypeVar("_S") +_T = TypeVar("_T") +_KT = TypeVar("_KT") +_VT = TypeVar("_VT") + +if sys.version_info >= (3, 7): + def namedtuple( + typename: str, + field_names: Union[str, Iterable[str]], + *, + rename: bool = ..., + module: Optional[str] = ..., + defaults: Optional[Iterable[Any]] = ..., + ) -> Type[Tuple[Any, ...]]: ... + +else: + def namedtuple( + typename: str, + field_names: Union[str, Iterable[str]], + *, + verbose: bool = ..., + rename: bool = ..., + module: Optional[str] = ..., + ) -> Type[Tuple[Any, ...]]: ... + +class _OrderedDictKeysView(KeysView[_KT], Reversible[_KT]): + def __reversed__(self) -> Iterator[_KT]: ... + +class _OrderedDictItemsView(ItemsView[_KT, _VT], Reversible[Tuple[_KT, _VT]]): + def __reversed__(self) -> Iterator[Tuple[_KT, _VT]]: ... + +class _OrderedDictValuesView(ValuesView[_VT], Reversible[_VT]): + def __reversed__(self) -> Iterator[_VT]: ... + +class OrderedDict(Dict[_KT, _VT], Reversible[_KT], Generic[_KT, _VT]): + def popitem(self, last: bool = ...) -> Tuple[_KT, _VT]: ... + def move_to_end(self, key: _KT, last: bool = ...) -> None: ... + def copy(self: _S) -> _S: ... + def __reversed__(self) -> Iterator[_KT]: ... + def keys(self) -> _OrderedDictKeysView[_KT]: ... + def items(self) -> _OrderedDictItemsView[_KT, _VT]: ... + def values(self) -> _OrderedDictValuesView[_VT]: ... diff --git a/lang/de/typeshed/stdlib/errno.pyi b/lang/de/typeshed/stdlib/errno.pyi new file mode 100644 index 0000000..6ff1c70 --- /dev/null +++ b/lang/de/typeshed/stdlib/errno.pyi @@ -0,0 +1,26 @@ +from typing import Mapping + +errorcode: Mapping[int, str] + +EACCES: int +EADDRINUSE: int +EAGAIN: int +EALREADY: int +EBADF: int +ECONNABORTED: int +ECONNREFUSED: int +ECONNRESET: int +EEXIST: int +EHOSTUNREACH: int +EINPROGRESS: int +EINVAL: int +EIO: int +EISDIR: int +ENOBUFS: int +ENODEV: int +ENOENT: int +ENOMEM: int +ENOTCONN: int +EOPNOTSUPP: int +EPERM: int +ETIMEDOUT: int diff --git a/lang/de/typeshed/stdlib/gc.pyi b/lang/de/typeshed/stdlib/gc.pyi new file mode 100644 index 0000000..0d8aee5 --- /dev/null +++ b/lang/de/typeshed/stdlib/gc.pyi @@ -0,0 +1,68 @@ +"""Steuerung des Garbage Collectors""" +from typing import overload + +def enable() -> None: + """Automatische Garbage Collection aktivieren.""" + ... + +def disable() -> None: + """Automatische Garbage Collection deaktivieren. + +Heap memory can still be allocated, +and garbage collection can still be initiated manually using ``gc.collect``.""" + +def collect() -> None: + """Garbage Collection ausführen.""" + ... + +def mem_alloc() -> int: + """Ermittelt die Anzahl der dem Heap-Speicher zugewiesen Bytes. + +:return: The number of bytes allocated. + +This function is MicroPython extension.""" + ... + +def mem_free() -> int: + """Gibt die Anzahl der Bytes des verfügbaren dynamischen Speichers zurück. -1 wird zurückgegeben, wenn dieser Wert unbekannt ist. + +:return: The number of bytes free. + +This function is MicroPython extension.""" + ... + +@overload +def threshold() -> int: + """Den zusätzlichen GC-Zuteilungsschwellwert abfragen. + +:return: The GC allocation threshold. + +This function is a MicroPython extension. CPython has a similar +function - ``set_threshold()``, but due to different GC +implementations, its signature and semantics are different.""" + ... + +@overload +def threshold(amount: int) -> None: + """Den zusätzlichen GC-Schwellenwert festlegen. + +Normally, a collection is triggered only when a new allocation +cannot be satisfied, i.e. on an out-of-memory (OOM) condition. +If this function is called, in addition to OOM, a collection +will be triggered each time after ``amount`` bytes have been +allocated (in total, since the previous time such an amount of bytes +have been allocated). ``amount`` is usually specified as less than the +full heap size, with the intention to trigger a collection earlier than when the +heap becomes exhausted, and in the hope that an early collection will prevent +excessive memory fragmentation. This is a heuristic measure, the effect +of which will vary from application to application, as well as +the optimal value of the ``amount`` parameter. + +A value of -1 means a disabled allocation threshold. + +This function is a MicroPython extension. CPython has a similar +function - ``set_threshold()``, but due to different GC +implementations, its signature and semantics are different. + +:param amount: Die Anzahl der Bytes, nach denen eine Garbage Collection ausgelöst werden soll.""" + ... \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/log.pyi b/lang/de/typeshed/stdlib/log.pyi new file mode 100644 index 0000000..281e68d --- /dev/null +++ b/lang/de/typeshed/stdlib/log.pyi @@ -0,0 +1,89 @@ +"""Zeichne Daten auf deinem micro:bit V2 auf.""" +from typing import Literal, Mapping, Optional, Union, overload +MILLISECONDS = 1 +"""Millisekunden Zeitstempelformat. (millisekunden)""" +SECONDS = 10 +"""Sekunden Zeitstempelformat. (sekunden)""" +MINUTES = 600 +"""Minuten Zeitstempelformat. (minuten)""" +HOURS = 36000 +"""Stunden Zeitstempelformat. (stunden)""" +DAYS = 864000 +"""Tage Zeitstempelformat. (tage)""" + +def set_labels(*labels: str, timestamp: Optional[Literal[1, 10, 36000, 864000]]=SECONDS) -> None: + """Den Logdatei-Header setzen (Beschriftungen festlegen) + +Example: ``log.set_labels('X', 'Y', 'Z', timestamp=log.MINUTES)`` + +Ideally this function should be called a single time, before any data is +logged, to configure the data table header once. + +If a log file already exists when the program starts, or if this function +is called multiple times, it will check the labels already defined in the +log file. If this function call contains any new labels not already +present, it will generate a new header row with the additional columns. + +By default the first column contains a timestamp for each row. The time +unit can be selected via the timestamp argument. + +:param *labels: Eine beliebige Anzahl von Positionsargumenten, die jeweils einem Eintrag in der Kopfzeile des Logs entsprechen. +:param timestamp: (Zeitstempel) Wähle die Zeitstempel-Einheit, die automatisch als erste Spalte in jeder Zeile hinzugefügt wird. Der Zeitstempel kann einen der folgenden Werte annehmen: ``log.MILLISECONDS``, ``log.SECONDS``, ``log.MINUTES``, ``log.HOURS``, ``log.DAYS`` oder ``None``, um den Zeitstempel zu deaktivieren. Der Standardwert ist ``log.SECONDS``.""" + ... + +@overload +def add(data_dictionary: Optional[Mapping[str, Union[str, int, float]]]) -> None: + """Füge dem Protokoll eine Datenzeile hinzu, indem du ein Dictionary mit Kopfzeileneinträgen und Werten übergibst. (hinzufügen) + +Example: ``log.add({ 'temp': temperature() })`` + +Each call to this function adds a row to the log. + +New labels not previously specified via the set_labels function, or by a +previous call to this function, will trigger a new header entry to be added +to the log with the extra labels. + +Labels previously specified and not present in a call to this function will +be skipped with an empty value in the log row. + +:param data_dictionary: (daten wörterbuch) Die zu protokollierenden Daten in Form eines Dictionarys mit einem Schlüssel für jeden Kopfzeileneintrag.""" + ... + +@overload +def add(**kwargs: Union[str, int, float]) -> None: + """Füge dem Protokoll eine Datenzeile mit Schlüsselwörtern als Argumenten hinzu. (hinzufügen) + +Example: ``log.add(temp=temperature())`` + +Each call to this function adds a row to the log. + +New labels not previously specified via the set_labels function, or by a +previous call to this function, will trigger a new header entry to be added +to the log with the extra labels. + +Labels previously specified and not present in a call to this function will +be skipped with an empty value in the log row.""" + ... + +def delete(full=False): + """Löscht den Inhalt des Protokolls, einschließlich der Kopfzeilen. (löschen) + +Example: ``log.delete()`` + +To add the log headers again the ``set_labels`` function should to be called after this function. + +There are two erase modes; “full” completely removes the data from the physical storage, +and “fast” invalidates the data without removing it. + +:param full: (vollständig) Mit ``True`` wird ein " vollständiges" Löschen und mit ``False`` die "schnelle" Löschmethode gewählt.""" + ... + +def set_mirroring(serial: bool): + """Richte die Spiegelung der Datenprotokollierung auf dem seriellen Ausgang ein. (spiegeln) + +Example: ``log.set_mirroring(True)`` + +Serial mirroring is disabled by default. When enabled, it will print to serial each row logged into the log file. + +:param serial: (seriell) ``True`` aktiviert die Spiegelung von Daten auf dem seriellen Ausgang.""" + ... \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/love.pyi b/lang/de/typeshed/stdlib/love.pyi new file mode 100644 index 0000000..9018624 --- /dev/null +++ b/lang/de/typeshed/stdlib/love.pyi @@ -0,0 +1 @@ +def badaboom() -> None: ... diff --git a/lang/de/typeshed/stdlib/machine.pyi b/lang/de/typeshed/stdlib/machine.pyi new file mode 100644 index 0000000..eda1989 --- /dev/null +++ b/lang/de/typeshed/stdlib/machine.pyi @@ -0,0 +1,84 @@ +"""Low-Level-Utilities. (maschine)""" +from typing import Any +from .microbit import MicroBitDigitalPin + +def unique_id() -> bytes: + """Liefert eine Byte-Zeichenkette mit einem eindeutigen Bezeichner für ein Board. (Eindeutige ID) + +Example: ``machine.unique_id()`` + +:return: An identifier that varies from one board instance to another.""" + ... + +def reset() -> None: + """Setzt das Gerät zurück, als würde man die externe RESET-Taste drückt. (zurücksetzen) + +Example: ``machine.reset()``""" + ... + +def freq() -> int: + """Ermittelt die Taktfrequenz der CPU in Hertz. + +Example: ``machine.freq()`` + +:return: The CPU frequency.""" + ... + +def disable_irq() -> Any: + """Deaktiviere Interrupt-Anforderungen. (IRQ deaktivieren) + +Example: ``interrupt_state = machine.disable_irq()`` + +:return: the previous IRQ state which should be considered an opaque value + +The return value should be passed to the ``enable_irq`` function to restore +interrupts to their original state.""" + ... + +def enable_irq(state: Any) -> None: + """Interrupt-Anfragen wieder aktivieren. (IRQ aktivieren) + +Example: ``machine.enable_irq(interrupt_state)`` + +:param state: Der Wert, der beim letzten Aufruf der Funktion ``disable_irq`` zurückgegeben wurde.""" + ... + +def time_pulse_us(pin: MicroBitDigitalPin, pulse_level: int, timeout_us: int=1000000) -> int: + """Gibt die Dauer eines Impulses an einem Pin zurück. (zeitimpuls us) + +Example: ``time_pulse_us(pin0, 1)`` + +If the current input value of the pin is different to ``pulse_level``, the +function first waits until the pin input becomes equal to +``pulse_level``, then times the duration that the pin is equal to +``pulse_level``. If the pin is already equal to ``pulse_level`` then timing +starts straight away. + +:param pin: Der zu verwendende Pin +:param pulse_level: (pulsstufe) 0, um einen Low-Impuls oder 1, um einen High-Impuls zu messen +:param timeout_us: Eine Verzögerung in Mikrosekunden +:return: The duration of the pulse in microseconds, or -1 for a timeout waiting for the level to match ``pulse_level``, or -2 on timeout waiting for the pulse to end""" + ... + +class mem: + """Die Klasse für die ``mem8``, ``mem16`` und ``mem32`` Speicheranzeigen.""" + + def __getitem__(self, address: int) -> int: + """Greife auf einen Wert im Speicher zu. + +:param address: (adresse) Die Speicheradresse. +:return: The value at that address as an integer.""" + ... + + def __setitem__(self, address: int, value: int) -> None: + """Setzt einen Wert an der angegebenen Adresse. + +:param address: (adresse) Die Speicheradresse. +:param value: (wert) Der zu setzende Integer-Wert.""" + ... +mem8: mem +"""8-Bit (Byte) Ansicht des Speichers.""" +mem16: mem +"""16-Bit (Byte) Ansicht des Speichers.""" +mem32: mem +"""32-Bit (Byte) Ansicht des Speichers.""" \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/math.pyi b/lang/de/typeshed/stdlib/math.pyi new file mode 100644 index 0000000..c81f9d0 --- /dev/null +++ b/lang/de/typeshed/stdlib/math.pyi @@ -0,0 +1,246 @@ +"""Mathematische Funktionen.""" +from typing import Tuple + +def acos(x: float) -> float: + """Berechnet den Arkuskosinus. + +Example: ``math.acos(1)`` + +:param x: Eine Zahl +:return: The inverse cosine of ``x``""" + ... + +def asin(x: float) -> float: + """Berechnet den Arkussinus. + +Example: ``math.asin(0)`` + +:param x: Eine Zahl +:return: The inverse sine of ``x``""" + ... + +def atan(x: float) -> float: + """Berechnet den Arkustangens. + +Example: ``math.atan(0)`` + +:param x: Eine Zahl +:return: The inverse tangent of ``x``""" + ... + +def atan2(y: float, x: float) -> float: + """Berechnet den Hauptwert des Arkustangens von ``y/x``. + +Example: ``math.atan2(0, -1)`` + +:param y: Eine Zahl +:param x: Eine Zahl +:return: The principal value of the inverse tangent of ``y/x``""" + ... + +def ceil(x: float) -> float: + """Rundet eine Zahl in Richtung positiver Unendlichkeit. + +Example: ``math.ceil(0.1)`` + +:param x: Eine Zahl +:return: ``x`` rounded towards positive infinity.""" + ... + +def copysign(x: float, y: float) -> float: + """Berechne ``x`` mit dem Vorzeichen von ``y``. + +Example: ``math.copysign(1, -1)`` + +:param x: Eine Zahl +:param y: Die Herkunft des Vorzeichens für den Rückgabewert +:return: ``x`` with the sign of ``y``""" + ... + +def cos(x: float) -> float: + """Berechnet den Kosinus von ``x``. + +Example: ``math.cos(0)`` + +:param x: Eine Zahl +:return: The cosine of ``x``""" + ... + +def degrees(x: float) -> float: + """Wandelt Bogenmaß (Radiant) in Grad um. + +Example: ``math.degrees(2 * math.pi)`` + +:param x: Ein Wert in Radiant +:return: The value converted to degrees""" + ... + +def exp(x: float) -> float: + """Berechnet den Exponentialwert von ``x``. + +Example: ``math.exp(1)`` + +:param x: Eine Zahl +:return: The exponential of ``x``.""" + ... + +def fabs(x: float) -> float: + """Gibt den absoluten Wert von ``x`` zurück. + +Example: ``math.fabs(-0.1)`` + +:param x: Eine Zahl +:return: The absolute value of ``x``""" + ... + +def floor(x: float) -> int: + """Rundet eine Zahl in Richtung negativer Unendlichkeit. + +Example: ``math.floor(0.9)`` + +:param x: Eine Zahl +:return: ``x`` rounded towards negative infinity.""" + ... + +def fmod(x: float, y: float) -> float: + """Berechne den Rest von ``x/y``. + +Example: ``math.fmod(10, 3)`` + +:param x: Der Zähler +:param y: Der Nenner""" + ... + +def frexp(x: float) -> Tuple[float, int]: + """Zerlegt eine Gleitkommazahl in ihre Mantisse und ihren Exponenten. + +Example: ``mantissa, exponent = math.frexp(2)`` + +The returned value is the tuple ``(m, e)`` such that ``x == m * 2**e`` +exactly. If ``x == 0`` then the function returns ``(0.0, 0)``, otherwise +the relation ``0.5 <= abs(m) < 1`` holds. + +:param x: Eine Fließkommazahl +:return: A tuple of length two containing its mantissa then exponent""" + ... + +def isfinite(x: float) -> bool: + """Überprüft, ob ein Wert endlich ist. + +Example: ``math.isfinite(float('inf'))`` + +:param x: Eine Zahl. +:return: ``True`` if ``x`` is finite, ``False`` otherwise.""" + ... + +def isinf(x: float) -> bool: + """Überprüft, ob ein Wert unendlich ist. + +Example: ``math.isinf(float('-inf'))`` + +:param x: Eine Zahl. +:return: ``True`` if ``x`` is infinite, ``False`` otherwise.""" + ... + +def isnan(x: float) -> bool: + """Prüft, ob ein Wert keine Zahl (NaN ... Not A Number) ist. + +Example: ``math.isnan(float('nan'))`` + +:param x: Eine Zahl +:return: ``True`` if ``x`` is not-a-number (NaN), ``False`` otherwise.""" + ... + +def ldexp(x: float, exp: int) -> float: + """Berechne ``x * (2**exp)``. + +Example: ``math.ldexp(0.5, 2)`` + +:param x: Eine Zahl +:param exp: Ganzzahl-Exponent +:return: ``x * (2**exp)``""" + ... + +def log(x: float, base: float=e) -> float: + """Berechnet den Logarithmus von ``x`` zur angegebenen Basis (standardmäßig den natürlichen Logarithmus). + +Example: ``math.log(math.e)`` + +With one argument, return the natural logarithm of x (to base e). + +With two arguments, return the logarithm of x to the given base, calculated as ``log(x)/log(base)``. + +:param x: Eine Zahl +:param base: Die zu verwendende Basis +:return: The natural logarithm of ``x``""" + ... + +def modf(x: float) -> Tuple[float, float]: + """Berechne die gebrochenen und ganzzahligen Teile von ``x``. + +Example: ``fractional, integral = math.modf(1.5)`` + +:param x: Eine Zahl +:return: A tuple of two floats representing the fractional then integral parts of ``x``. + +Both the fractional and integral values have the same sign as ``x``.""" + ... + +def pow(x: float, y: float) -> float: + """Gibt ``x`` hoch ``y`` zurück. + +Example: ``math.pow(4, 0.5)`` + +:param x: Eine Zahl +:param y: Der Exponent +:return: ``x`` to the power of ``y``""" + ... + +def radians(x: float) -> float: + """Wandelt Grad in Bogenmaß (Radiant) um. + +Example: ``math.radians(360)`` + +:param x: Ein Wert in Grad +:return: The value converted to radians""" + ... + +def sin(x: float) -> float: + """Berechnet den Sinus von ``x``. + +Example: ``math.sin(math.pi/2)`` + +:param x: Eine Zahl +:return: The sine of ``x``""" + ... + +def sqrt(x: float) -> float: + """Berechnet die Quadratwurzel von ``x``. + +Example: ``math.sqrt(4)`` + +:param x: Eine Zahl +:return: The square root of ``x``""" + ... + +def tan(x: float) -> float: + """Berechnet den Tangens von ``x``. + +Example: ``math.tan(0)`` + +:param x: Eine Zahl +:return: The tangent of ``x``.""" + ... + +def trunc(x: float) -> int: + """Rundet eine Zahl gegen 0 ab. + +Example: ``math.trunc(-0.9)`` + +:param x: Eine Zahl +:return: ``x`` rounded towards zero.""" + ... +e: float +"""Basis des natürlichen Logarithmus""" +pi: float +"""Das Verhältnis des Umfangs eines Kreises zu seinem Durchmesser""" \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/microbit/__init__.pyi b/lang/de/typeshed/stdlib/microbit/__init__.pyi new file mode 100644 index 0000000..eeeff8d --- /dev/null +++ b/lang/de/typeshed/stdlib/microbit/__init__.pyi @@ -0,0 +1,706 @@ +"""Pins, Bilder, Töne, Temperatur und Lautstärke.""" +from typing import Any, Callable, List, Optional, Tuple, Union, overload +from _typeshed import ReadableBuffer +from . import accelerometer as accelerometer +from . import audio as audio +from . import compass as compass +from . import display as display +from . import i2c as i2c +from . import microphone as microphone +from . import speaker as speaker +from . import spi as spi +from . import uart as uart + +def run_every(callback: Optional[Callable[[], None]]=None, days: int=0, h: int=0, min: int=0, s: int=0, ms: int=0) -> Callable[[Callable[[], None]], Callable[[], None]]: + """Plant die Ausführung einer Funktion in dem durch die Zeitargumente festgelegten Intervall **nur V2**. + +Example: ``run_every(my_logging, min=5)`` + +``run_every`` can be used in two ways: + +As a Decorator - placed on top of the function to schedule. For example:: + + @run_every(h=1, min=20, s=30, ms=50) + def my_function(): + # Do something here + +As a Function - passing the callback as a positional argument. For example:: + + def my_function(): + # Do something here + run_every(my_function, s=30) + +Each argument corresponds to a different time unit and they are additive. +So ``run_every(min=1, s=30)`` schedules the callback every minute and a half. + +When an exception is thrown inside the callback function it deschedules the +function. To avoid this you can catch exceptions with ``try/except``. + +:param callback: Funktion, die in dem angegebenen Intervall aufgerufen wird. Bei Verwendung als Dekorator weglassen. +:param days: (tage) Legt den Tag für die Planung fest. +:param h: Legt die Uhrzeit für die Planung fest. +:param min: Legt die Minute für die Planung fest. +:param s: Legt die Sekunde für die Planung fest. +:param ms: Legt die Millisekunde für die Planung fest.""" + +def panic(n: int) -> None: + """In einen Panik-Modus gehen. + +Example: ``panic(127)`` + +:param n: Eine beliebige ganze Zahl <= 255, um einen Status anzugeben. + +Requires restart.""" + +def reset() -> None: + """Board neu starten.""" + +@overload +def scale(value: float, from_: Tuple[float, float], to: Tuple[int, int]) -> int: + """Konvertiert einen Wert aus einem Bereich in einen Ganzzahlenbereich. + +Example: ``volume = scale(accelerometer.get_x(), from_=(-2000, 2000), to=(0, 255))`` + +For example, to convert an accelerometer X value to a speaker volume. + +If one of the numbers in the ``to`` parameter is a floating point +(i.e a decimal number like ``10.0``), this function will return a +floating point number. + + temp_fahrenheit = scale(30, from_=(0.0, 100.0), to=(32.0, 212.0)) + +:param value: (wert) Eine umzurechnende Zahl. +:param from_: Ein Tupel, das den Bereich definiert, aus dem konvertiert werden soll. +:param to: Ein Tupel, das den Bereich definiert, in den konvertiert werden soll. +:return: The ``value`` converted to the ``to`` range.""" + +@overload +def scale(value: float, from_: Tuple[float, float], to: Tuple[float, float]) -> float: + """Konvertiert einen Wert von einem Bereich in einen Gleitkommabereich. + +Example: ``temp_fahrenheit = scale(30, from_=(0.0, 100.0), to=(32.0, 212.0))`` + +For example, to convert temperature from a Celsius scale to Fahrenheit. + +If one of the numbers in the ``to`` parameter is a floating point +(i.e a decimal number like ``10.0``), this function will return a +floating point number. +If they are both integers (i.e ``10``), it will return an integer:: + + returns_int = scale(accelerometer.get_x(), from_=(-2000, 2000), to=(0, 255)) + +:param value: (wert) Eine umzurechnende Zahl. +:param from_: Ein Tupel, das den Bereich definiert, aus dem konvertiert werden soll. +:param to: Ein Tupel, das den Bereich definiert, in den konvertiert werden soll. +:return: The ``value`` converted to the ``to`` range.""" + +def sleep(n: float) -> None: + """Warte auf ``n`` Millisekunden. + +Example: ``sleep(1000)`` + +:param n: Die Anzahl der zu wartenden Millisekunden + +One second is 1000 milliseconds, so:: + + microbit.sleep(1000) + +will pause the execution for one second.""" + +def running_time() -> int: + """Ermittelt die Laufzeit des Boards. + +:return: The number of milliseconds since the board was switched on or restarted.""" + +def temperature() -> int: + """Ermittelt die Temperatur des micro:bit in Grad Celcius.""" + +def set_volume(v: int) -> None: + """Legt die Lautstärke fest. + +Example: ``set_volume(127)`` + +:param v: ein Wert zwischen 0 (niedrig) und 255 (hoch). + +Out of range values will be clamped to 0 or 255. + +**V2** only.""" + ... + +class Button: + """Die Klasse für die Tasten ``button_a`` und ``button_b``.""" + + def is_pressed(self) -> bool: + """Überprüft, ob die Taste gedrückt ist. + +:return: ``True`` if the specified button ``button`` is pressed, and ``False`` otherwise.""" + ... + + def was_pressed(self) -> bool: + """Überprüft, ob die Taste seit dem Start des Geräts oder dem letzten Aufruf dieser Methode gedrückt wurde. + +Calling this method will clear the press state so +that the button must be pressed again before this method will return +``True`` again. + +:return: ``True`` if the specified button ``button`` was pressed, and ``False`` otherwise""" + ... + + def get_presses(self) -> int: + """Ermittelt die Gesamtzahl der Tastendrücke und setzt diese Summe auf Null zurück, bevor sie zurückgegeben wird. + +:return: The number of presses since the device started or the last time this method was called""" + ... +button_a: Button +"""Das ``Button``-Objekt der linken Taste.""" +button_b: Button +"""Das ``Button``-Objekt der rechten Taste.""" + +class MicroBitDigitalPin: + """Ein digitaler Pin. + +Some pins support analog and touch features using the ``MicroBitAnalogDigitalPin`` and ``MicroBitTouchPin`` subclasses.""" + NO_PULL: int + PULL_UP: int + PULL_DOWN: int + + def read_digital(self) -> int: + """Ermittelt den digitalen Wert des Pins. + +Example: ``value = pin0.read_digital()`` + +:return: 1 if the pin is high, and 0 if it's low.""" + ... + + def write_digital(self, value: int) -> None: + """Stellt den digitalen Wert des Pins ein. (digital schreiben) + +Example: ``pin0.write_digital(1)`` + +:param value: (wert) 1, um den Pin zu aktivieren, oder 0, um den Pin zu deaktivieren""" + ... + + def set_pull(self, value: int) -> None: + """Setze den Status des Pull-Widerstands auf einen von drei möglichen Werten: ``PULL_UP``, ``PULL_DOWN`` oder ``NO_PULL``. (setze Pull-Widerstand) + +Example: ``pin0.set_pull(pin0.PULL_UP)`` + +:param value: (wert) Der Status des Pull-Widerstands vom relevanten Pin, z.B. ``pin0.PULL_UP``.""" + ... + + def get_pull(self) -> int: + """Abrufen des Status des Pull-Widerstands eines Pins. (gib Pull-Widerstand) + +Example: ``pin0.get_pull()`` + +:return: ``NO_PULL``, ``PULL_DOWN``, or ``PULL_UP`` + +These are set using the ``set_pull()`` method or automatically configured +when a pin mode requires it.""" + ... + + def get_mode(self) -> str: + """Gibt den Pin-Modus zurück. (gib Pin-Modus) + +Example: ``pin0.get_mode()`` + +When a pin is used for a specific function, like +writing a digital value, or reading an analog value, the pin mode +changes. + +:return: ``"unused"``, ``"analog"``, ``"read_digital"``, ``"write_digital"``, ``"display"``, ``"button"``, ``"music"``, ``"audio"``, ``"touch"``, ``"i2c"``, or ``"spi"``""" + ... + + def write_analog(self, value: int) -> None: + """Erzeugt ein PWM-Signal am Pin mit der Einschaltdauer proportional zu ``value``. (analog schreiben) + +Example: ``pin0.write_analog(254)`` + +:param value: (wert) Eine Ganzzahl oder eine Gleitpunktzahl zwischen 0 (0% Einschaltdauer) und 1023 (100% Einschaltdauer).""" + + def set_analog_period(self, period: int) -> None: + """Setzt die Periodendauer des PWM-Signals, das ausgegeben wird, auf ``period`` in Millisekunden. (setze analoge Periodendauer) + +Example: ``pin0.set_analog_period(10)`` + +:param period: (Periodendauer) Der Periodendauer in Millisekunden mit einem Mindestwert von 1ms.""" + + def set_analog_period_microseconds(self, period: int) -> None: + """Setze die Periodendauer für die Ausgabe des PWM-Signals auf ``period`` in Mikrosekunden. (setze analoge Periodendauer) + +Example: ``pin0.set_analog_period_microseconds(512)`` + +:param period: (Periodendauer) Die Periodendauer in Mikrosekunden mit einem Mindestwert von 256μs.""" + +class MicroBitAnalogDigitalPin(MicroBitDigitalPin): + """Ein Pin, der analogen und digitalen Signale erlaubt.""" + + def read_analog(self) -> int: + """Einlesen der Spannung, die am Pin anliegt. (analog lesen) + +Example: ``pin0.read_analog()`` + +:return: An integer between 0 (meaning 0V) and 1023 (meaning 3.3V).""" + +class MicroBitTouchPin(MicroBitAnalogDigitalPin): + """Ein Pin mit analogen, digitalen und Touchfunktionen.""" + CAPACITIVE: int + RESISTIVE: int + + def is_touched(self) -> bool: + """Überprüft, ob der Pin berührt wird. (wird berührt) + +Example: ``pin0.is_touched()`` + +The default touch mode for the pins on the edge connector is ``resistive``. +The default for the logo pin **V2** is ``capacitive``. + +**Resistive touch** +This test is done by measuring how much resistance there is between the +pin and ground. A low resistance gives a reading of ``True``. To get +a reliable reading using a finger you may need to touch the ground pin +with another part of your body, for example your other hand. + +**Capacitive touch** +This test is done by interacting with the electric field of a capacitor +using a finger as a conductor. `Capacitive touch +`_ +does not require you to make a ground connection as part of a circuit. + +:return: ``True`` if the pin is being touched with a finger, otherwise return ``False``.""" + ... + + def set_touch_mode(self, value: int) -> None: + """Legt den Touchmodus für den Pin fest. (definiert Berührungsmodus) + +Example: ``pin0.set_touch_mode(pin0.CAPACITIVE)`` + +The default touch mode for the pins on the edge connector is +``resistive``. The default for the logo pin **V2** is ``capacitive``. + +:param value: (wert) ``CAPACITIVE`` oder ``RESISTIVE`` Touchmodus des entsprechenden Pins.""" + ... +pin0: MicroBitTouchPin +"""Pin mit digitalen, analogen und Touchfunktionen.""" +pin1: MicroBitTouchPin +"""Pin mit digitalen, analogen und Touchfunktionen.""" +pin2: MicroBitTouchPin +"""Pin mit digitalen, analogen und Touchfunktionen.""" +pin3: MicroBitAnalogDigitalPin +"""Pin mit digitalen und analogen Funktionen.""" +pin4: MicroBitAnalogDigitalPin +"""Pin mit digitalen und analogen Funktionen.""" +pin5: MicroBitDigitalPin +"""Pin mit Unterstützung für digitale Signale.""" +pin6: MicroBitDigitalPin +"""Pin mit Unterstützung für digitale Signale.""" +pin7: MicroBitDigitalPin +"""Pin mit digitalen Funktionen.""" +pin8: MicroBitDigitalPin +"""Pin mit digitalen Funktionen.""" +pin9: MicroBitDigitalPin +"""Pin mit digitalen Funktionen.""" +pin10: MicroBitAnalogDigitalPin +"""Pin mit digitalen und analogen Funktionen.""" +pin11: MicroBitDigitalPin +"""Pin mit digitalen Funktionen.""" +pin12: MicroBitDigitalPin +"""Pin mit digitalen Funktionen.""" +pin13: MicroBitDigitalPin +"""Pin mit digitalen Funktionen.""" +pin14: MicroBitDigitalPin +"""Pin mit digitalen Funktionen.""" +pin15: MicroBitDigitalPin +"""Pin mit digitalen Funktionen.""" +pin16: MicroBitDigitalPin +"""Pin mit digitalen Funktionen.""" +pin19: MicroBitDigitalPin +"""Pin mit digitalen Funktionen.""" +pin20: MicroBitDigitalPin +"""Pin mit digitalen Funktionen.""" +pin_logo: MicroBitTouchPin +"""Ein berührungsempfindlicher Logo-Pin auf der Vorderseite des micro:bit, der standardmäßig auf den kapazitiven Touch-Modus eingestellt ist.""" +pin_speaker: MicroBitAnalogDigitalPin +"""Ein Pin zur Ansteuerung des micro:bit Lautsprechers. + +This API is intended only for use in Pulse-Width Modulation pin operations e.g. pin_speaker.write_analog(128). +""" + +class Image: + """Ein Bild, das auf dem micro:bit LED-Display angezeigt werden soll. + +Given an image object it's possible to display it via the ``display`` API:: + + display.show(Image.HAPPY)""" + HEART: Image + """Herz-Bild.""" + HEART_SMALL: Image + """Kleines Herz-Bild.""" + HAPPY: Image + """Glückliches Gesichtsbild.""" + SMILE: Image + """Lächelndes Gesichtsbild.""" + SAD: Image + """Trauriges Gesichtsbild.""" + CONFUSED: Image + """Verwirrtes Gesichtsbild.""" + ANGRY: Image + """Wütendes Gesichtsbild.""" + ASLEEP: Image + """Schlafendes Gesichtsbild.""" + SURPRISED: Image + """Überraschtes Gesichtsbild.""" + SILLY: Image + """Albernes Gesichtsbild.""" + FABULOUS: Image + """Bild mit Sonnenbrillengesicht. (fabelhaft)""" + MEH: Image + """Gleichgültiges Gesicht Bild.""" + YES: Image + """abgehakt-Bild""" + NO: Image + """angekreuzt-Bild""" + CLOCK12: Image + """Bild mit Linie, die auf 12 Uhr zeigt.""" + CLOCK11: Image + """Bild mit Linie, die auf 11 Uhr zeigt.""" + CLOCK10: Image + """Bild mit Linie, die auf 10 Uhr zeigt.""" + CLOCK9: Image + """Bild mit Linie, die auf 9 Uhr zeigt.""" + CLOCK8: Image + """Bild mit Linie, die auf 8 Uhr zeigt.""" + CLOCK7: Image + """Bild mit Linie, die auf 7 Uhr zeigt.""" + CLOCK6: Image + """Bild mit Linie, die auf 6 Uhr zeigt.""" + CLOCK5: Image + """Bild mit Linie, die auf 5 Uhr zeigt.""" + CLOCK4: Image + """Bild mit Linie, die auf 4 Uhr zeigt.""" + CLOCK3: Image + """Bild mit Linie, die auf 3 Uhr zeigt.""" + CLOCK2: Image + """Bild mit Linie, die auf 2 Uhr zeigt.""" + CLOCK1: Image + """Bild mit Linie, die auf 1 Uhr zeigt.""" + ARROW_N: Image + """Bild eines Pfeils, der nach Norden zeigt.""" + ARROW_NE: Image + """Bild eines Pfeils, der nach Nordosten zeigt.""" + ARROW_E: Image + """Bild eines Pfeils, der nach Osten zeigt.""" + ARROW_SE: Image + """Bild eines Pfeils, der nach Südosten zeigt.""" + ARROW_S: Image + """Bild eines Pfeils, der nach Süden zeigt.""" + ARROW_SW: Image + """Bild eines Pfeils, der nach Südwesten zeigt.""" + ARROW_W: Image + """Bild eines Pfeils, der nach Westen zeigt.""" + ARROW_NW: Image + """Bild eines Pfeils, der nach Nordwesten zeigt.""" + TRIANGLE: Image + """Bild eines Dreiecks, das nach oben zeigt.""" + TRIANGLE_LEFT: Image + """Bild eines Dreiecks in der linken Ecke.""" + CHESSBOARD: Image + """Abwechselnd leuchtende LEDs in einem Schachbrettmuster.""" + DIAMOND: Image + """Diamant-Bild.""" + DIAMOND_SMALL: Image + """Kleines Diamant-Bild.""" + SQUARE: Image + """Quadrat-Bild""" + SQUARE_SMALL: Image + """Kleines Quadrat-Bild.""" + RABBIT: Image + """Kaninchen-Bild.""" + COW: Image + """Kuh-Bild.""" + MUSIC_CROTCHET: Image + """Viertelnoten-Bild.""" + MUSIC_QUAVER: Image + """Achtelnoten-Bild.""" + MUSIC_QUAVERS: Image + """Achtelnotenpaar-Bild.""" + PITCHFORK: Image + """Heugabel-Bild""" + XMAS: Image + """Weihnachtsbaum-Bild.""" + PACMAN: Image + """Pac-Man Spielfigurenbild.""" + TARGET: Image + """Ziel-Bild""" + TSHIRT: Image + """T-Shirt-Bild.""" + ROLLERSKATE: Image + """Rollerskate-Bild.""" + DUCK: Image + """Ente-Bild""" + HOUSE: Image + """Haus-Bild""" + TORTOISE: Image + """Schildkröte-Bild""" + BUTTERFLY: Image + """Schmetterling-Bild.""" + STICKFIGURE: Image + """Strichmännchen-Bild.""" + GHOST: Image + """Geist-Bild.""" + SWORD: Image + """Schwert-Bild""" + GIRAFFE: Image + """Giraffe-Bild.""" + SKULL: Image + """Schädel-Bild.""" + UMBRELLA: Image + """Bild eines Schirms.""" + SNAKE: Image + """Bild einer Schlange. (Schlange)""" + SCISSORS: Image + """BIld einer Schere. (Schere)""" + ALL_CLOCKS: List[Image] + """Eine Liste mit allen CLOCK_ Bildern. (alle Uhren)""" + ALL_ARROWS: List[Image] + """Eine Liste mit allen ARROW_ Bildern. (alle Pfeile)""" + + @overload + def __init__(self, string: str) -> None: + """Erstellen Sie ein Bild aus einer Zeichenkette, die beschreibt, welche LEDs leuchten. + +``string`` has to consist of digits 0-9 arranged into lines, +describing the image, for example:: + + image = Image("90009:" + "09090:" + "00900:" + "09090:" + "90009") + +will create a 5×5 image of an X. The end of a line is indicated by a +colon. It's also possible to use newlines (\\n) insead of the colons. + +:param string: (Zeichenkette) Eine Zeichenkette, die das Bild beschreibt.""" + ... + + @overload + def __init__(self, width: int=5, height: int=5, buffer: ReadableBuffer=None) -> None: + """Erstelle ein leeres Bild mit ``width`` Spalten und ``height`` Zeilen. + +:param width: (Breite) Optionale Breite des Bildes +:param height: (Höhe) Optionale Höhe des Bildes +:param buffer: (Puffer) Optionales Array oder Bytes von ``width``×``height`` Ganzzahlen im Bereich 0-9 um das Bild zu initialisieren + +Examples:: + + Image(2, 2, b'\x08\x08\x08\x08') + Image(2, 2, bytearray([9,9,9,9])) + +These create 2 x 2 pixel images at full brightness.""" + ... + + def width(self) -> int: + """Ermittelt die Anzahl der Spalten. (Breite) + +:return: The number of columns in the image""" + ... + + def height(self) -> int: + """Ermittelt die Anzahl der Zeilen. (Höhe) + +:return: The number of rows in the image""" + ... + + def set_pixel(self, x: int, y: int, value: int) -> None: + """Legt die Helligkeit eines Pixels fest. (Pixelwerte setzen) + +Example: ``my_image.set_pixel(0, 0, 9)`` + +:param x: Die Spaltennummer +:param y: Die Zeilennummer +:param value: (wert) Die Helligkeit als Ganzzahl zwischen 0 (dunkel) und 9 (hell) + +This method will raise an exception when called on any of the built-in +read-only images, like ``Image.HEART``.""" + ... + + def get_pixel(self, x: int, y: int) -> int: + """Ermittle die Helligkeit eines Pixels. (Pixelwerte holen) + +Example: ``my_image.get_pixel(0, 0)`` + +:param x: Die Spaltennummer +:param y: Die Zeilennummer +:return: The brightness as an integer between 0 and 9.""" + ... + + def shift_left(self, n: int) -> Image: + """Erstellen Sie ein neues Bild, indem Sie das Bild nach links verschieben. (links verschieben) + +Example: ``Image.HEART_SMALL.shift_left(1)`` + +:param n: Die Anzahl der Spalten um die verschoben wird +:return: The shifted image""" + ... + + def shift_right(self, n: int) -> Image: + """Erstellen Sie ein neues Bild, indem Sie das Bild nach rechts verschieben. (rechts verschieben) + +Example: ``Image.HEART_SMALL.shift_right(1)`` + +:param n: Die Anzahl der Spalten um die verschoben wird +:return: The shifted image""" + ... + + def shift_up(self, n: int) -> Image: + """Erstellen Sie ein neues Bild, indem Sie das Bild nach oben verschoben wird. (nach oben verschieben) + +Example: ``Image.HEART_SMALL.shift_up(1)`` + +:param n: Die Anzahl der Zeilen um die verschoben wird +:return: The shifted image""" + ... + + def shift_down(self, n: int) -> Image: + """Erstellen Sie ein neues Bild, indem Sie das Bild nach unten verschoben wird. (nach unten verschieben) + +Example: ``Image.HEART_SMALL.shift_down(1)`` + +:param n: Die Anzahl der Zeilen um die verschoben wird +:return: The shifted image""" + ... + + def crop(self, x: int, y: int, w: int, h: int) -> Image: + """Erstellen Sie ein neues Bild, indem das Bild zugeschnitten wird. + +Example: ``Image.HEART.crop(1, 1, 3, 3)`` + +:param x: Die Offset-Spalte des Zuschneidens +:param y: Die Offset-Zeile des Zuschneidens +:param w: Die Zuschneide-Breite +:param h: Die Zuschneide-Höhe +:return: The new image""" + ... + + def copy(self) -> Image: + """Erstellt eine exakte Kopie des Bildes. (kopieren) + +Example: ``Image.HEART.copy()`` + +:return: The new image""" + ... + + def invert(self) -> Image: + """Erstellt ein neues Bild, indem es die Helligkeit der Pixel des Ausgangsbildes invertiert. + +Example: ``Image.SMALL_HEART.invert()`` + +:return: The new image.""" + ... + + def fill(self, value: int) -> None: + """Legt die Helligkeit für alle Pixel des Bildes fest. + +Example: ``my_image.fill(5)`` + +:param value: Die neue Helligkeit als Zahl zwischen 0 (dunkel) und 9 (hell). + +This method will raise an exception when called on any of the built-in +read-only images, like ``Image.HEART``.""" + ... + + def blit(self, src: Image, x: int, y: int, w: int, h: int, xdest: int=0, ydest: int=0) -> None: + """Kopiert einen Bereich aus einem anderen Bild in dieses Bild. + +Example: ``my_image.blit(Image.HEART, 1, 1, 3, 3, 1, 1)`` + +:param src: Das Ausgangsbild +:param x: Der Anfangsspalten-Offset im Ausgangsbild +:param y: Der Anfangszeilen-Offset im Ausgangsbild +:param w: Die Anzahl der zu kopierenden Spalten +:param h: Die Anzahl der zu kopierenden Zeilen +:param xdest: Der Spalten-Offset, der in diesem Bild geändert werden soll +:param ydest: Der Zeilen-Offset, der in diesem Bild geändert werden soll + +Pixels outside the source image are treated as having a brightness of 0. + +``shift_left()``, ``shift_right()``, ``shift_up()``, ``shift_down()`` +and ``crop()`` can are all implemented by using ``blit()``. + +For example, img.crop(x, y, w, h) can be implemented as:: + + def crop(self, x, y, w, h): + res = Image(w, h) + res.blit(self, x, y, w, h) + return res""" + ... + + def __repr__(self) -> str: + """Liefert eine kompakte Stringrepräsentation des Bildes.""" + ... + + def __str__(self) -> str: + """Liefert eine lesbare String-Repräsentation des Bildes.""" + ... + + def __add__(self, other: Image) -> Image: + """Erstellt ein neues Bild, indem für jedes Pixel die Helligkeitswerte der beiden Bilder addiert werden. + +Example: ``Image.HEART + Image.HAPPY`` + +:param other: Das zu addierende Bild.""" + ... + + def __sub__(self, other: Image) -> Image: + """Erstellt ein neues Bild, indem für jedes Pixel die Helligkeitswerte der beiden Bilder subtrahiert werden. + +Example: ``Image.HEART - Image.HEART_SMALL`` + +:param other: Das zu subtrahierende Bild.""" + ... + + def __mul__(self, n: float) -> Image: + """Erstellt ein neues Bild, indem der Helligkeitswert jedes Pixels mit ``n`` multipliziert wird. + +Example: ``Image.HEART * 0.5`` + +:param n: Der Wert, mit dem multipliziert werden soll.""" + ... + + def __truediv__(self, n: float) -> Image: + """Erstellt ein neues Bild, indem der Helligkeitswert jedes Pixels durch ``n`` dividiert wird. + +Example: ``Image.HEART / 2`` + +:param n: Der Wert, durch den dividiert werden soll.""" + ... + +class SoundEvent: + LOUD: SoundEvent + """Stellt den Übergang von Klangereignissen von ``quiet`` auf ``loud`` dar; wie beim Klatschen oder Rufen.""" + QUIET: SoundEvent + """Stellt den Übergang von akustischen Ereignissen, wie Sprechen oder Hintergrundmusik, von ``loud`` zu ``quiet`` dar. (stumm)""" + +class Sound: + """Die eingebauten Klänge können mit ``audio.play(Sound.NAME)`` aufgerufen werden.""" + GIGGLE: Sound + """Kichern-Sound.""" + HAPPY: Sound + """Happy-Sound.""" + HELLO: Sound + """Begrüßung-Sound""" + MYSTERIOUS: Sound + """Geheimnisvoll-Sound""" + SAD: Sound + """Traurig-Sound.""" + SLIDE: Sound + """Gleitender Ton.""" + SOARING: Sound + """Aufsteigender Klang. (aufsteigend)""" + SPRING: Sound + """Springfeder Klang (Sppringfeder)""" + TWINKLE: Sound + """Funkeln Klang (Funkeln)""" + YAWN: Sound + """Gähnen Klang""" \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/microbit/accelerometer.pyi b/lang/de/typeshed/stdlib/microbit/accelerometer.pyi new file mode 100644 index 0000000..a63507d --- /dev/null +++ b/lang/de/typeshed/stdlib/microbit/accelerometer.pyi @@ -0,0 +1,103 @@ +"""Messen Sie die Beschleunigung des micro:bit und erkennen Sie Gesten. (Beschleunigungssensor)""" +from typing import Tuple + +def get_x() -> int: + """Erhalte die Beschleunigungsmessung in der ``x`` -Achse in Milli-g. (erhalte x) + +Example: ``accelerometer.get_x()`` + +:return: A positive or negative integer depending on direction in the range +/- 2000mg.""" + ... + +def get_y() -> int: + """Erhalte die Beschleunigungsmessung in der ``y`` -Achse in Milli-g. (erhalte y) + +Example: ``accelerometer.get_y()`` + +:return: A positive or negative integer depending on direction in the range +/- 2000mg.""" + ... + +def get_z() -> int: + """Erhalte die Beschleunigungsmessung in der ``z`` -Achse in Milli-g. (erhalte z) + +Example: ``accelerometer.get_z()`` + +:return: A positive or negative integer depending on direction in the range +/- 2000mg.""" + ... + +def get_values() -> Tuple[int, int, int]: + """Erhalten Sie die Beschleunigungsmessungen in allen Achsen auf einmal als Tupel. (Werte erhalten) + +Example: ``x, y, z = accelerometer.get_values()`` + +:return: a three-element tuple of integers ordered as X, Y, Z, each value a positive or negative integer depending on direction in the range +/- 2000mg""" + ... + +def get_strength() -> int: + """Erhalte die Beschleunigungsmessung aller Achsen als positive Ganzzahl. Dies ist die euklidische Summe der X-, Y- und Z-Achsen. (erhalte Stärke) + +Example: ``accelerometer.get_strength()`` + +:return: The combined acceleration strength of all the axes, in milli-g.""" + ... + +def current_gesture() -> str: + """Erhalte den Namen der aktuellen Geste. (derzeitige Geste) + +Example: ``accelerometer.current_gesture()`` + +MicroPython understands the following gesture names: ``"up"``, ``"down"``, +``"left"``, ``"right"``, ``"face up"``, ``"face down"``, ``"freefall"``, +``"3g"``, ``"6g"``, ``"8g"``, ``"shake"``. Gestures are always +represented as strings. + +:return: The current gesture""" + ... + +def is_gesture(name: str) -> bool: + """Überprüft, ob die benannte Geste derzeit aktiv ist. (ist Geste) + +Example: ``accelerometer.is_gesture('shake')`` + +MicroPython understands the following gesture names: ``"up"``, ``"down"``, +``"left"``, ``"right"``, ``"face up"``, ``"face down"``, ``"freefall"``, +``"3g"``, ``"6g"``, ``"8g"``, ``"shake"``. Gestures are always +represented as strings. + +:param name: Der Name der Geste. +:return: ``True`` if the gesture is active, ``False`` otherwise.""" + ... + +def was_gesture(name: str) -> bool: + """Überprüft, ob die benannte Geste seit dem letzten Aufruf aktiv war. (war Geste) + +Example: ``accelerometer.was_gesture('shake')`` + +MicroPython understands the following gesture names: ``"up"``, ``"down"``, +``"left"``, ``"right"``, ``"face up"``, ``"face down"``, ``"freefall"``, +``"3g"``, ``"6g"``, ``"8g"``, ``"shake"``. Gestures are always +represented as strings. + +:param name: Der Name der Geste. +:return: ``True`` if the gesture was active since the last call, ``False`` otherwise.""" + +def get_gestures() -> Tuple[str, ...]: + """Gibt ein Tupel der vergangenen Gesten zurück. (erhalte Gesten) + +Example: ``accelerometer.get_gestures()`` + +Clears the gesture history before returning. + +Gestures are not updated in the background so there needs to be constant +calls to some accelerometer method to do the gesture detection. Usually +gestures can be detected using a loop with a small :func:`microbit.sleep` delay. + +:return: The history as a tuple, most recent last.""" + ... + +def set_range(value: int) -> None: + """Legen Sie den Bereich des Beschleunigungsmessers in g (Fallbeschleunigung) auf den nächstgelegenen Wert fest, welcher von der Hardware unterstützt wird. Diese sind ``2``, ``4``oder ``8`` g. (Bereich einstellen) + +Example: ``accelerometer.set_range(8)`` + +:param value: (wert) Neuer Bereich für den Beschleunigungssensor, eine Ganzzahl in ``g``.""" \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/microbit/audio.pyi b/lang/de/typeshed/stdlib/microbit/audio.pyi new file mode 100644 index 0000000..8faf67a --- /dev/null +++ b/lang/de/typeshed/stdlib/microbit/audio.pyi @@ -0,0 +1,124 @@ +"""Töne mit dem micro:bit abspielen (Importiere ``audio`` für V1-Kompatibilität). (Audio)""" +from ..microbit import MicroBitDigitalPin, Sound, pin0 +from typing import ClassVar, Iterable, Union + +def play(source: Union[Iterable[AudioFrame], Sound, SoundEffect], wait: bool=True, pin: MicroBitDigitalPin=pin0, return_pin: Union[MicroBitDigitalPin, None]=None) -> None: + """Wiedergeben eines eingebauten Sounds, Soundeffekts oder benutzerdefinierten Aufnahme . + +Example: ``audio.play(Sound.GIGGLE)`` + +:param source: (Quelle) Ein eingebauter ``Sound`` wie ``Sound.GIGGLE``, ein ``SoundEffect`` oder Beispieldaten als Teil eines ``AudioFrame`` Objekts. +:param wait: Wenn ``wait`` ``True`` ist, wird diese Funktion blockiert, bis der Klang abgeschlossen ist. +:param pin: Ein optionales Argument für den Ausgabepin kann angegeben werden, um die Standardeinstellung von ``pin0``zu überschreiben. Wenn kein Ton wiedergegeben werden soll, kann ``pin=None`` verwendet werden. +:param return_pin: (erhalte Pin) Bestimmt einen Pin, mit dem der externen Lautsprecher anstatt mit Ground verbunden wird. Dies wird bei der **V2** Revision ignoriert.""" + +def is_playing() -> bool: + """Überprüfen Sie, ob ein Ton abgespielt wird. (spielt gerade) + +Example: ``audio.is_playing()`` + +:return: ``True`` if audio is playing, otherwise ``False``.""" + ... + +def stop() -> None: + """Stoppe jede Audio-Wiedergabe. (Stop) + +Example: ``audio.stop()``""" + ... + +class SoundEffect: + """Ein Soundeffekt, zusammengestellt aus einer Reihe von Parametern, die über den Konstruktor oder durch Attribute konfiguriert werden.""" + WAVEFORM_SINE: ClassVar[int] + """Sinuswelle als Parameter für ``waveform``. (Sinuswelle)""" + WAVEFORM_SAWTOOTH: ClassVar[int] + """Sägezahnkurve als Parameter für ``waveform``. (Sägezahnkurve)""" + WAVEFORM_TRIANGLE: ClassVar[int] + """Dreiecksignal als Parameter für ``waveform``. (Dreiecksignal)""" + WAVEFORM_SQUARE: ClassVar[int] + """Rechtecksignal als Parameter für ``waveform``. (Rechtecksignal)""" + WAVEFORM_NOISE: ClassVar[int] + """Rauschsignal als Parameter für ``waveform``. (Rauschsignal)""" + SHAPE_LINEAR: ClassVar[int] + """Lineare Interpolation als Parameter für ``shape``. (lineare Interpolation)""" + SHAPE_CURVE: ClassVar[int] + """Kurven-Interpolation als Parameter für ``shape``. (geschwungene Kurve)""" + SHAPE_LOG: ClassVar[int] + """Logarithmische Interpolation als Parameter für ``shape``. (logarithmische Interpolation)""" + FX_NONE: ClassVar[int] + """Kein Effekt für ``fx`` verwendet. (kein fx)""" + FX_TREMOLO: ClassVar[int] + """Tremelo-Effekt als Parameter für ``fx``. (fx Tremolo)""" + FX_VIBRATO: ClassVar[int] + """Vibrato-Effekt als Parameter für ``fx``. (fx Vibrato)""" + FX_WARBLE: ClassVar[int] + """Triller-Effekt als Parameter für ``fx``. (fx Trillereffekt)""" + freq_start: int + """Startfrequenz in Hertz (Hz), eine Zahl zwischen ``0`` und ``9999`` (Startfrequenz)""" + freq_end: int + """Endfrequenz in Hertz (Hz), eine Zahl zwischen ``0`` und ``9999`` (Endfrequenz)""" + duration: int + """Dauer des Klangs in Millisekunden, eine Zahl zwischen ``0`` und ``9999`` (Dauer)""" + vol_start: int + """Startlautstärke, eine Zahl zwischen ``0`` und ``255`` (vol Start)""" + vol_end: int + """Endlautstärke, eine Nummer zwischen ``0`` und ``255`` (vol Ende)""" + waveform: int + """Typ der Sinuswelle, einer dieser Werte: ``WAVEFORM_SINE``, ``WAVEFORM_SAWTOOTH``, ``WAVEFORM_TRIANGLE``, ``WAVEFORM_SQUARE``, ``WAVEFORM_NOISE`` (zufällig generiertes Geräusch)""" + fx: int + """Effekt, der dem Sound hinzugefügt werden soll, in Frage kommende Werte: ``FX_TREMOLO``, ``FX_VIBRATO``, ``FX_WARBLE``, oder ``FX_NONE``""" + shape: int + """Die Art der Interpolationskurve zwischen der Anfangs- und der Endfrequenz. Verschiedene Wellenformen haben unterschiedliche Frequenzänderungsraten. In Frage kommende Werte: ``SHAPE_LINEAR``, ``SHAPE_CURVE``, ``SHAPE_LOG``""" + + def __init__(self, freq_start: int=500, freq_end: int=2500, duration: int=500, vol_start: int=255, vol_end: int=0, waveform: int=WAVEFORM_SQUARE, fx: int=FX_NONE, shape: int=SHAPE_LOG): + """Erstelle einen neuen Soundeffekt. + +Example: ``my_effect = SoundEffect(duration=1000)`` + +All the parameters are optional, with default values as shown above, and +they can all be modified via attributes of the same name. For example, we +can first create an effect ``my_effect = SoundEffect(duration=1000)``, +and then change its attributes ``my_effect.duration = 500``. + +:param freq_start: (Startfrequenz) Startfrequenz in Hertz (Hz), eine Zahl zwischen ``0`` und ``9999``. +:param freq_end: (Endfrequenz) Endfrequenz in Hertz (Hz), eine Zahl zwischen ``0`` und ``9999``. +:param duration: (Dauer) Dauer des Tons in Millisekunden, eine Zahl zwischen ``0`` und ``9999``. +:param vol_start: (vol Start) Startlautstärke, eine Zahl zwischen ``0`` und ``255``. +:param vol_end: (vol Ende) Endlautstärke, eine Nummer zwischen ``0`` und ``255``. +:param waveform: Typ der Sinuswelle, einer dieser Werte: ``WAVEFORM_SINE``, ``WAVEFORM_SAWTOOTH``, ``WAVEFORM_TRIANGLE``, ``WAVEFORM_SQUARE``, ``WAVEFORM_NOISE`` (zufällig generiertes Geräusch). +:param fx: Effekt, der dem Sound hinzugefügt werden soll, in Frage kommende Werte: ``FX_TREMOLO``, ``FX_VIBRATO``, ``FX_WARBLE``, oder ``FX_NONE``. +:param shape: Die Art der Interpolationskurve zwischen der Anfangs- und der Endfrequenz. Verschiedene Wellenformen haben unterschiedliche Frequenzänderungsraten. In Frage kommende Werte: ``SHAPE_LINEAR``, ``SHAPE_CURVE``, ``SHAPE_LOG``.""" + + def copy(self) -> SoundEffect: + """Erstelle eine Kopie dieses ``SoundEffect``. (kopieren) + +Example: ``sound_2 = sound_1.copy()`` + +:return: A copy of the SoundEffect.""" + +class AudioFrame: + """Ein ``AudioFrame``-Objekt ist eine Liste von 32 Samples, von denen jedes ein vorzeichenloses Byte ist +(ganze Zahl zwischen 0 und 255). + +It takes just over 4 ms to play a single frame. + +Example:: + + frame = AudioFrame() + for i in range(len(frame)): + frame[i] = 252 - i * 8""" + + def copyfrom(self, other: AudioFrame) -> None: + """Überschreibe die Daten in diesem ``AudioFrame`` mit den Daten einer anderen ``AudioFrame`` Instanz. + +Example: ``my_frame.copyfrom(source_frame)`` + +:param other: ``AudioFrame`` Instanz von der die Daten kopiert werden sollen.""" + + def __len__(self) -> int: + ... + + def __setitem__(self, key: int, value: int) -> None: + ... + + def __getitem__(self, key: int) -> int: + ... \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/microbit/compass.pyi b/lang/de/typeshed/stdlib/microbit/compass.pyi new file mode 100644 index 0000000..77321dc --- /dev/null +++ b/lang/de/typeshed/stdlib/microbit/compass.pyi @@ -0,0 +1,70 @@ +"""Benutze den eingebauten Kompass. (Kompass)""" + +def calibrate() -> None: + """Startet den Kalibrierungsprozess. + +Example: ``compass.calibrate()`` + +An instructive message will be scrolled to the user after which they will need +to rotate the device in order to draw a circle on the LED display.""" + ... + +def is_calibrated() -> bool: + """Überprüfe, dass der Kompass kalibriert ist. (ist kalibriert) + +Example: ``compass.is_calibrated()`` + +:return: ``True`` if the compass has been successfully calibrated, ``False`` otherwise.""" + ... + +def clear_calibration() -> None: + """Setzt die Kalibrierung zurück, sodass der Kompass nicht mehr kalibriert ist. + +Example: ``compass.clear_calibration()``""" + ... + +def get_x() -> int: + """Ermittle die Magnetfeldstärke der ``x``-Achse. (erhalte x) + +Example: ``compass.get_x()`` + +Call ``calibrate`` first or the results will be inaccurate. + +:return: A positive or negative integer in nano tesla representing the magnitude and direction of the field.""" + ... + +def get_y() -> int: + """Ermittle die Magnetfeldstärke der ``y``-Achse. (erhalte y) + +Example: ``compass.get_y()`` + +Call ``calibrate`` first or the results will be inaccurate. + +:return: A positive or negative integer in nano tesla representing the magnitude and direction of the field.""" + ... + +def get_z() -> int: + """Ermittle die Magnetfeldstärke der ``z``-Achse. (erhalte z) + +Example: ``compass.get_z()`` + +Call ``calibrate`` first or the results will be inaccurate. + +:return: A positive or negative integer in nano tesla representing the magnitude and direction of the field.""" + ... + +def heading() -> int: + """Ermittle die Kompassrichtung. (Ausrichtung) + +Example: ``compass.heading()`` + +:return: An integer in the range from 0 to 360, representing the angle in degrees, clockwise, with north as 0.""" + ... + +def get_field_strength() -> int: + """Ermittle die Größe des Magnetfelds um das Gerät herum. + +Example: ``compass.get_field_strength()`` + +:return: An integer indication of the magnitude of the magnetic field in nano tesla.""" + ... \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/microbit/display.pyi b/lang/de/typeshed/stdlib/microbit/display.pyi new file mode 100644 index 0000000..24a1d82 --- /dev/null +++ b/lang/de/typeshed/stdlib/microbit/display.pyi @@ -0,0 +1,92 @@ +"""Texte, Bilder und Animationen auf dem 5x5 LED-Display anzeigen. (Display)""" +from ..microbit import Image +from typing import Union, overload, Iterable + +def get_pixel(x: int, y: int) -> int: + """Ermittle die Helligkeit der LED auf Spalte ``x`` und Zeile ``y``. (Pixelwerte holen) + +Example: ``display.get_pixel(0, 0)`` + +:param x: Die Anzeige-Spalte (0..4) +:param y: Die Anzeigezeile (0..4) +:return: A number between 0 (off) and 9 (bright)""" + ... + +def set_pixel(x: int, y: int, value: int) -> None: + """Ändere die Helligkeit der LED auf Spalte ``x`` und Zeile ``y``. (Pixelwerte setzen) + +Example: ``display.set_pixel(0, 0, 9)`` + +:param x: Die Anzeige-Spalte (0..4) +:param y: Die Anzeigezeile (0..4) +:param value: (wert) Die Helligkeit zwischen 0 (aus) und 9 (am hellsten)""" + ... + +def clear() -> None: + """Setzt die Helligkeit aller LEDs auf 0 (aus). (löschen) + +Example: ``display.clear()``""" + ... + +def show(image: Union[str, float, int, Image, Iterable[Image]], delay: int=400, wait: bool=True, loop: bool=False, clear: bool=False) -> None: + """Zeigt Bilder, Buchstaben oder Ziffern auf der LED-Anzeige an. + +Example: ``display.show(Image.HEART)`` + +When ``image`` is an image or a list of images then each image is displayed in turn. +If ``image`` is a string or number, each letter or digit is displayed in turn. + +:param image: Eine Zeichenkette, Nummer, Bild oder Liste der anzuzeigenden Bilder. +:param delay: (Verzögerung) Jeder Buchstabe, Ziffer oder Bild wird mit ``delay`` Millisekunden zwischen ihnen angezeigt. +:param wait: Wenn ``wait`` ``True``ist, wird diese Funktion blockiert, bis die Animation beendet ist, andernfalls wird die Animation im Hintergrund stattfinden. +:param loop: Wenn ``loop`` ``True``ist, wird sich die Animation für immer wiederholen. +:param clear: (löschen) Wenn ``clear`` ``True``ist, wird die Anzeige ausgeschaltet, nachdem die Sequenz beendet ist. + +The ``wait``, ``loop`` and ``clear`` arguments must be specified using their keyword.""" + ... + +def scroll(text: Union[str, float, int], delay: int=150, wait: bool=True, loop: bool=False, monospace: bool=False) -> None: + """Scrollt eine Zahl oder einen Text auf dem LED-Display. (scrollen) + +Example: ``display.scroll('micro:bit')`` + +:param text: Der zu wiederzugebende String. Wenn ``text`` eine Ganzzahl oder ein Float ist, wird er zuerst mit ``str()`` in einen String konvertiert. +:param delay: (Verzögerung) Der ``delay`` -Parameter bestimmt, wie schnell der Text scrollt. +:param wait: Wenn ``wait`` ``True``ist, wird diese Funktion blockiert, bis die Animation beendet ist, andernfalls wird die Animation im Hintergrund stattfinden. +:param loop: Wenn ``loop`` ``True``ist, wird sich die Animation für immer wiederholen. +:param monospace: (Monospace) Wenn ``monospace`` ``True``ist, werden alle Zeichen 5 Pixel breit sein. Zwischen den Zeichen gibt es beim scrollen genau 1 leere Pixelspalte. + +The ``wait``, ``loop`` and ``monospace`` arguments must be specified +using their keyword.""" + ... + +def on() -> None: + """Schalten Sie das LED-Display ein. (an) + +Example: ``display.on()``""" + ... + +def off() -> None: + """Schalten Sie die LED-Anzeige aus (das Deaktivieren des Displays erlaubt es Ihnen, die GPIO-Pins für andere Zwecke zu verwenden). + +Example: ``display.off()``""" + ... + +def is_on() -> bool: + """Überprüfen Sie, ob die LED-Anzeige aktiviert ist. (ist an) + +Example: ``display.is_on()`` + +:return: ``True`` if the display is on, otherwise returns ``False``.""" + ... + +def read_light_level() -> int: + """Bestimmt die Lichtintensität. (bestimme Licht Intensität) + +Example: ``display.read_light_level()`` + +Uses the display's LEDs in reverse-bias mode to sense the amount of light +falling on the display. + +:return: An integer between 0 and 255 representing the light level, with larger meaning more light.""" + ... \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/microbit/i2c.pyi b/lang/de/typeshed/stdlib/microbit/i2c.pyi new file mode 100644 index 0000000..5258d5b --- /dev/null +++ b/lang/de/typeshed/stdlib/microbit/i2c.pyi @@ -0,0 +1,49 @@ +"""Kommunikation mit Geräten über das I2C-Busprotokoll.""" +from _typeshed import ReadableBuffer +from ..microbit import MicroBitDigitalPin, pin19, pin20 +from typing import List + +def init(freq: int=100000, sda: MicroBitDigitalPin=pin20, scl: MicroBitDigitalPin=pin19) -> None: + """Eine Peripherie neu initialisieren. + +Example: ``i2c.init()`` + +:param freq: Taktfrequenz +:param sda: ``sda`` Pin (standardmäßig 20) +:param scl: ``scl`` Pin (standardmäßig 19) + +On a micro:bit V1 board, changing the I²C pins from defaults will make +the accelerometer and compass stop working, as they are connected +internally to those pins. This warning does not apply to the **V2** +revision of the micro:bit as this has `separate I²C lines `_ +for the motion sensors and the edge connector.""" + ... + +def scan() -> List[int]: + """Scannt den Bus nach Geräten. + +Example: ``i2c.scan()`` + +:return: A list of 7-bit addresses corresponding to those devices that responded to the scan.""" + ... + +def read(addr: int, n: int, repeat: bool=False) -> bytes: + """Liest Bytes von einem Gerät.. + +Example: ``i2c.read(0x50, 64)`` + +:param addr: Die 7-Bit-Adresse des Geräts +:param n: Die Anzahl der zu lesenden Bytes +:param repeat: (wiederholen) Wenn ``True``wird kein Stop-Bit gesendet +:return: The bytes read""" + ... + +def write(addr: int, buf: ReadableBuffer, repeat: bool=False) -> None: + """Schreibe Bytes auf ein Gerät. (schreiben) + +Example: ``i2c.write(0x50, bytes([1, 2, 3]))`` + +:param addr: Die 7-Bit-Adresse des Geräts +:param buf: Ein Puffer mit den zu schreibenden Bytes +:param repeat: (wiederholen) Wenn ``True``wird kein Stop-Bit gesendet""" + ... \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/microbit/microphone.pyi b/lang/de/typeshed/stdlib/microbit/microphone.pyi new file mode 100644 index 0000000..2b09e41 --- /dev/null +++ b/lang/de/typeshed/stdlib/microbit/microphone.pyi @@ -0,0 +1,62 @@ +"""Reagiere auf Ton mithilfe des integrierten Mikrofons (nur V2). (Mikrofon)""" +from typing import Optional, Tuple +from ..microbit import SoundEvent + +def current_event() -> Optional[SoundEvent]: + """Abrufen des letzten aufgezeichneten Sound-Ereignisses + +Example: ``microphone.current_event()`` + +:return: The event, ``SoundEvent('loud')`` or ``SoundEvent('quiet')``.""" + ... + +def was_event(event: SoundEvent) -> bool: + """Überprüfung, ob seit dem letzten Anruf mindestens einmal ein Geräusch gehört wurde. + +Example: ``microphone.was_event(SoundEvent.LOUD)`` + +This call clears the sound history before returning. + +:param event: Das Ereignis, auf das geprüft werden soll, z. B. ``SoundEvent.LOUD`` oder ``SoundEvent.QUIET`` +:return: ``True`` if sound was heard at least once since the last call, otherwise ``False``.""" + ... + +def is_event(event: SoundEvent) -> bool: + """Überprüfe das zuletzt erkannte Sound-Ereignis. + +Example: ``microphone.is_event(SoundEvent.LOUD)`` + +This call does not clear the sound event history. + +:param event: Das Ereignis, auf das geprüft werden soll, z. B. ``SoundEvent.LOUD`` oder ``SoundEvent.QUIET`` +:return: ``True`` if sound was the most recent heard, ``False`` otherwise.""" + ... + +def get_events() -> Tuple[SoundEvent, ...]: + """Liefert den Verlauf der Sound-Ereignisse in Form eines Tupels. + +Example: ``microphone.get_events()`` + +This call clears the sound history before returning. + +:return: A tuple of the event history with the most recent event last.""" + ... + +def set_threshold(event: SoundEvent, value: int) -> None: + """Legt den Schwellenwert für ein Sound-Ereignis fest. + +Example: ``microphone.set_threshold(SoundEvent.LOUD, 250)`` + +A high threshold means the event will only trigger if the sound is very loud (>= 250 in the example). + +:param event: Ein Sound-Ereignis, wie ``SoundEvent.LOUD`` oder ``SoundEvent.QUIET``. +:param value: (wert) Der Schwellenwert im Bereich 0-255.""" + ... + +def sound_level() -> int: + """Ermittle den Schalldruckpegel. (Lautstärke) + +Example: ``microphone.sound_level()`` + +:return: A representation of the sound pressure level in the range 0 to 255.""" + ... \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/microbit/speaker.pyi b/lang/de/typeshed/stdlib/microbit/speaker.pyi new file mode 100644 index 0000000..39adac2 --- /dev/null +++ b/lang/de/typeshed/stdlib/microbit/speaker.pyi @@ -0,0 +1,15 @@ +"""Steuere den integrierten Lautsprecher (nur V2). (Lautsprecher)""" + +def off() -> None: + """Lautsprecher ausschalten. + +Example: ``speaker.off()`` + +This does not disable sound output to an edge connector pin.""" + ... + +def on() -> None: + """Lautsprecher einschalten. (an) + +Example: ``speaker.on()``""" + ... \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/microbit/spi.pyi b/lang/de/typeshed/stdlib/microbit/spi.pyi new file mode 100644 index 0000000..fb33f5e --- /dev/null +++ b/lang/de/typeshed/stdlib/microbit/spi.pyi @@ -0,0 +1,46 @@ +"""Kommunikation mit Geräten über die serielle Schnittstelle (SPI).""" +from _typeshed import ReadableBuffer, WriteableBuffer +from ..microbit import pin13, pin14, pin15, MicroBitDigitalPin + +def init(baudrate: int=1000000, bits: int=8, mode: int=0, sclk: MicroBitDigitalPin=pin13, mosi: MicroBitDigitalPin=pin15, miso: MicroBitDigitalPin=pin14) -> None: + """SPI-Kommunikation initialisieren. + +Example: ``spi.init()`` + +For correct communication, the parameters have to be the same on both communicating devices. + +:param baudrate: Die Übertragungsgeschwindigkeit. +:param bits: Die Breite in Bits jeder Übertragung. Derzeit wird nur ``bits=8`` unterstützt. Dies kann sich jedoch in Zukunft ändern. +:param mode: Legt die Kombination aus Taktpolarität und Phase fest - `siehe Online-Tabelle `_. +:param sclk: SCLK Pin (standardmäßig 13) +:param mosi: MOSI Pin (standardmäßig 15) +:param miso: miso pin (Voreinstellung 14)""" + ... + +def read(nbytes: int) -> bytes: + """Bytes lesen. + +Example: ``spi.read(64)`` + +:param nbytes: Maximum der zu lesenden Bytes. +:return: The bytes read.""" + ... + +def write(buffer: ReadableBuffer) -> None: + """Schreibe Bytes auf den Bus. (schreiben) + +Example: ``spi.write(bytes([1, 2, 3]))`` + +:param buffer: (Puffer) Ein Puffer, von dem Daten gelesen werden.""" + ... + +def write_readinto(out: WriteableBuffer, in_: ReadableBuffer) -> None: + """Schreibe den ``out`` Zwischenspeicher (Buffer) auf den Bus und lies jede Antwort in den ``in_`` Buffer. + +Example: ``spi.write_readinto(out_buffer, in_buffer)`` + +The length of the buffers should be the same. The buffers can be the same object. + +:param out: Der Puffer, in den eine Antwort geschrieben werden soll. +:param in_: Der Puffer, von dem Daten gelesen werden.""" + ... \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/microbit/uart.pyi b/lang/de/typeshed/stdlib/microbit/uart.pyi new file mode 100644 index 0000000..979692c --- /dev/null +++ b/lang/de/typeshed/stdlib/microbit/uart.pyi @@ -0,0 +1,79 @@ +"""Verbindet mit einem Gerät über eine serielle Schnittstelle.""" +from _typeshed import WriteableBuffer +from ..microbit import MicroBitDigitalPin +from typing import Optional, Union +ODD: int +"""Ungerade Parität""" +EVEN: int +"""Gerade Parität (gerade)""" + +def init(baudrate: int=9600, bits: int=8, parity: Optional[int]=None, stop: int=1, tx: Optional[MicroBitDigitalPin]=None, rx: Optional[MicroBitDigitalPin]=None) -> None: + """Initialisiere die serielle Kommunikation. + +Example: ``uart.init(115200, tx=pin0, rx=pin1)`` + +:param baudrate: (Baudrate) Die Übertragungsgeschwindigkeit. +:param bits: (Bits) Die Größe der Bytes die übertragen werden. micro:bit unterstützt nur 8. +:param parity: (Parität) Wie Parität geprüft wird, ``None``, ``uart.ODD`` oder ``uart.EVEN``. +:param stop: (Stop) Die Anzahl der Stopbits, muss 1 für micro:bit sein. +:param tx: Sendepin. +:param rx: Empfangspin. + +Initializing the UART on external pins will cause the Python console on +USB to become unaccessible, as it uses the same hardware. To bring the +console back you must reinitialize the UART without passing anything for +``tx`` or ``rx`` (or passing ``None`` to these arguments). This means +that calling ``uart.init(115200)`` is enough to restore the Python console. + +For more details see `the online documentation `_.""" + ... + +def any() -> bool: + """Überprüfen Sie, ob irgendwelche Daten warten. + +Example: ``uart.any()`` + +:return: ``True`` if any data is waiting, else ``False``.""" + ... + +def read(nbytes: Optional[int]=None) -> Optional[bytes]: + """Bytes lesen. + +Example: ``uart.read()`` + +:param nbytes: Wenn ``nbytes`` angegeben ist, werden höchstens so viele Bytes gelesen. Andernfalls werden so viele Bytes wie möglich gelesen. +:return: A bytes object or ``None`` on timeout""" + ... + +def readinto(buf: WriteableBuffer, nbytes: Optional[int]=None) -> Optional[int]: + """Lese Bytes in ``buf``. + +Example: ``uart.readinto(input_buffer)`` + +:param buf: Der Puffer, in den geschrieben werden soll. +:param nbytes: Wenn ``nbytes`` angegeben ist, werden höchstens so viele Bytes gelesen. Andernfalls werden ``len(buf)`` Bytes gelesen. +:return: number of bytes read and stored into ``buf`` or ``None`` on timeout.""" + ... + +def readline() -> Optional[bytes]: + """Liest eine Zeile bis zum Zeilenumbruch. + +Example: ``uart.readline()`` + +:return: The line read or ``None`` on timeout. The newline character is included in the returned bytes.""" + ... + +def write(buf: Union[bytes, str]) -> Optional[int]: + """Schreibt einen Puffer auf den Bus. (schreiben) + +Example: ``uart.write('hello world')`` + +:param buf: Ein Byte-Objekt oder ein String. +:return: The number of bytes written, or ``None`` on timeout. + +Examples:: + + uart.write('hello world') + uart.write(b'hello world') + uart.write(bytes([1, 2, 3]))""" + ... \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/micropython.pyi b/lang/de/typeshed/stdlib/micropython.pyi new file mode 100644 index 0000000..78b3834 --- /dev/null +++ b/lang/de/typeshed/stdlib/micropython.pyi @@ -0,0 +1,131 @@ +"""MicroPython Grundlagen.""" +from typing import Any, TypeVar, overload +_T = TypeVar('_T') + +def const(expr: _T) -> _T: + """Wird verwendet, um zu deklarieren, dass der Ausdruck eine Konstante ist, damit der Compiler ihn optimieren kann. + +The use of this function should be as follows:: + + from micropython import const + CONST_X = const(123) + CONST_Y = const(2 * CONST_X + 1) + +Constants declared this way are still accessible as global variables from +outside the module they are declared in. On the other hand, if a constant +begins with an underscore then it is hidden, it is not available as a +global variable, and does not take up any memory during execution. + +:param expr: Ein konstant bleibender Ausdruck.""" + ... + +@overload +def opt_level() -> int: + """Ermittelt die aktuelle Optimierungsstufe für die Kompilierung von Skripten. + +Example: ``micropython.opt_level()`` + +The optimisation level controls the following compilation features: + +- Assertions: at level 0 assertion statements are enabled and compiled + into the bytecode; at levels 1 and higher assertions are not compiled. + +- Built-in ``__debug__`` variable: at level 0 this variable expands to + True; at levels 1 and higher it expands to False. + +- Source-code line numbers: at levels 0, 1 and 2 source-code line number + are stored along with the bytecode so that exceptions can report the + line number they occurred at; at levels 3 and higher line numbers are + not stored. + +:return: An integer representing the current level.""" + ... + +@overload +def opt_level(level: int) -> None: + """Legt die Optimierungsstufe für die nachfolgende Kompilierung von Skripten fest. + +Example: ``micropython.opt_level(1)`` + +The optimisation level controls the following compilation features: + +- Assertions: at level 0 assertion statements are enabled and compiled + into the bytecode; at levels 1 and higher assertions are not compiled. + +- Built-in ``__debug__`` variable: at level 0 this variable expands to + True; at levels 1 and higher it expands to False. + +- Source-code line numbers: at levels 0, 1 and 2 source-code line number + are stored along with the bytecode so that exceptions can report the + line number they occurred at; at levels 3 and higher line numbers are + not stored. + +The default optimisation level is usually level 0. + +:param level: Eine ganzzahlige Optimierungsstufe.""" + ... + +def mem_info(verbose: Any=None) -> None: + """Gibt Informationen über den aktuell verwendeten Speicher zurück. + +Example: ``micropython.mem_info()`` + +:param verbose: Wenn das Argument ``verbose`` angegeben wird, werden zusätzliche Informationen ausgegeben.""" + ... + +def qstr_info(verbose: Any=None) -> None: + """Gibt Informationen zu aktuell eingebetteten Strings zurück. + +Example: ``micropython.qstr_info()`` + +:param verbose: Wenn das Argument ``verbose`` angegeben wird, werden zusätzliche Informationen ausgegeben. + +The information that is printed is implementation dependent, but currently +includes the number of interned strings and the amount of RAM they use. In +verbose mode it prints out the names of all RAM-interned strings.""" + ... + +def stack_use() -> int: + """Gibt einen Integerwert zurück, der dem aktuell verwendeten Stack-Speicher entspricht. + +Example: ``micropython.stack_use()`` + +The absolute value of this is not particularly useful, rather it +should be used to compute differences in stack usage at different points. + +:return: An integer representing current stack use.""" + ... + +def heap_lock() -> None: + """Heap-Speicher sperren. + +Example: ``micropython.heap_lock()`` + +When locked no memory allocation can occur and a ``MemoryError`` will be +raised if any heap allocation is attempted.""" + ... + +def heap_unlock() -> None: + """Heap-Speicher entsperren. + +Example: ``micropython.heap_unlock()`` + +When locked no memory allocation can occur and a ``MemoryError`` will be +raised if any heap allocation is attempted.""" + ... + +def kbd_intr(chr: int) -> None: + """Zeichen festlegen, das eine ``KeyboardInterrupt``-Exception auslöst. + +Example: ``micropython.kbd_intr(-1)`` + +:param chr: Zeichencode, um den Interrupt auszulösen, oder -1, um die Erfassung von Ctrl-C zu deaktivieren. + +By default this is set to 3 during script execution, corresponding to Ctrl-C. +Passing -1 to this function will disable capture of Ctrl-C, and passing 3 +will restore it. + +This function can be used to prevent the capturing of Ctrl-C on the +incoming stream of characters that is usually used for the REPL, in case +that stream is used for other purposes.""" + ... \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/music.pyi b/lang/de/typeshed/stdlib/music.pyi new file mode 100644 index 0000000..7204b55 --- /dev/null +++ b/lang/de/typeshed/stdlib/music.pyi @@ -0,0 +1,128 @@ +"""Erstelle und spiele Lieder. (Musik)""" +from typing import Optional, Tuple, Union, List +from .microbit import MicroBitDigitalPin, pin0 +DADADADUM: Tuple[str, ...] +"""Melodie: der Anfang von Beethovens 5. Symphonie in c-Moll. (dadadadaam)""" +ENTERTAINER: Tuple[str, ...] +"""Melodie: die ersten Takte des Ragtime-Klassikers "The Entertainer" von Scott Joplin. (Entertainer)""" +PRELUDE: Tuple[str, ...] +"""Melodie: Beginn des ersten Präludiums in C-Dur der 48 Präludien und Fugen von J.S. Bach.""" +ODE: Tuple[str, ...] +"""Melodie: Die „Ode an die Freude“ von Beethovens neunter Symphonie in d-Moll. (Ode)""" +NYAN: Tuple[str, ...] +"""Melodie: Die Nyan-Katze (http://www.nyan.cat/) (Nyan) + +The composer is unknown. This is fair use for educational porpoises (as they say in New York).""" +RINGTONE: Tuple[str, ...] +"""Melodie: Etwas das wie ein Handy-Klingelton klingt. (Klingelton) + +To be used to indicate an incoming message. +""" +FUNK: Tuple[str, ...] +"""Melodie: eine funkige Basslinie für Geheimagenten und Superschurken. (Funk)""" +BLUES: Tuple[str, ...] +"""Melodie: ein 12-taktiger Boogie-Woogie-Blues mit Walking Bass. (Blues)""" +BIRTHDAY: Tuple[str, ...] +"""Melodie: „Alles Gute zum Geburtstag…“ (Geburtstag) + +For copyright status see: http://www.bbc.co.uk/news/world-us-canada-34332853 +""" +WEDDING: Tuple[str, ...] +"""Melodie: der Hochzeitschor aus Wagners Oper "Lohengrin". (Hochzeit)""" +FUNERAL: Tuple[str, ...] +"""Melodie: der "Trauermarsch", auch bekannt als Frédéric Chopins Klaviersonate Nr. 2 in b-Moll, op. 35. (Beerdigung)""" +PUNCHLINE: Tuple[str, ...] +"""Melodie: ein lustiges Fragment, das anzeigt, dass ein Scherz gemacht worden ist.""" +PYTHON: Tuple[str, ...] +"""Melodie: John Philip Sousas Marsch "Liberty Bell", auch bekannt als das Thema von "Monty Python's Flying Circus" (nach dem die Programmiersprache Python benannt ist).""" +BADDY: Tuple[str, ...] +"""Melodie: Auftritt eines Stummfilm-Bösewichts.""" +CHASE: Tuple[str, ...] +"""Melodie: Stummfilm-Verfolgungsszene.""" +BA_DING: Tuple[str, ...] +"""Melodie: ein kurzes Signal, um anzuzeigen, dass etwas passiert ist.""" +WAWAWAWAA: Tuple[str, ...] +"""Melody: Eine sehr traurige Posaune.""" +JUMP_UP: Tuple[str, ...] +"""Melodie: zur Verwendung in einem Spiel, um eine Aufwärtsbewegung zu untermalen.""" +JUMP_DOWN: Tuple[str, ...] +"""Melodie: zur Verwendung in einem Spiel, um eine Abwärtsbewegung zu untermalen.""" +POWER_UP: Tuple[str, ...] +"""Melodie: eine Fanfare, die einen Erfolg anzeigt oder dass etwas freigeschalten wurde.""" +POWER_DOWN: Tuple[str, ...] +"""Melodie: eine traurige Fanfare, wenn etwas nicht geklappt hat.""" + +def set_tempo(ticks: int=4, bpm: int=120) -> None: + """Legt das ungefähre Tempo für die Wiedergabe fest. + +Example: ``music.set_tempo(bpm=120)`` + +:param ticks: Die Anzahl der Ticks in einem Beat. +:param bpm: Ein Integerwert, der die Beats pro Minute angibt. + +Suggested default values allow the following useful behaviour: + +- music.set_tempo() – reset the tempo to default of ticks = 4, bpm = 120 +- music.set_tempo(ticks=8) – change the “definition” of a beat +- music.set_tempo(bpm=180) – just change the tempo + +To work out the length of a tick in milliseconds is very simple arithmetic: +60000/bpm/ticks_per_beat. For the default values that’s +60000/120/4 = 125 milliseconds or 1 beat = 500 milliseconds.""" + ... + +def get_tempo() -> Tuple[int, int]: + """Gibt das aktuelle Tempo als Tupel von Integerwerten zurück: ``(ticks, bpm)``. + +Example: ``ticks, beats = music.get_tempo()`` + +:return: The temp as a tuple with two integer values, the ticks then the beats per minute.""" + ... + +def play(music: Union[str, List[str], Tuple[str, ...]], pin: Optional[MicroBitDigitalPin]=pin0, wait: bool=True, loop: bool=False) -> None: + """Spielt Musik. + +Example: ``music.play(music.NYAN)`` + +:param music: (Musik) Musik, die in `einer speziellen Notation `_ angegeben ist +:param pin: der Ausgangspin zur Verwendung mit einem externen Lautsprecher (Voreinstellung ``pin0``), ``None`` für keinen Ton. +:param wait: Wenn ``wait`` auf ``True`` gesetzt ist, stoppt diese Funktion die weitere Codeausführung. +:param loop: Wenn ``loop`` auf ``True`` gesetzt ist, wird die Melodie wiederholt, bis ``stop`` aufgerufen oder der blockierende Aufruf unterbrochen wird. + +Many built-in melodies are defined in this module.""" + ... + +def pitch(frequency: int, duration: int=-1, pin: Optional[MicroBitDigitalPin]=pin0, wait: bool=True) -> None: + """Musiknoten spielen (Tonhöhe) + +Example: ``music.pitch(185, 1000)`` + +:param frequency: (Frequenz) Eine ganzzahlige Frequenz +:param duration: (Dauer) Eine Dauer in Millisekunden. Bei negativem Wert erhält man bis zum nächsten Aufruf oder einem Aufruf von ``stop`` einen Dauerton. +:param pin: Optionaler Ausgabepin (Standard ``pin0``). +:param wait: Wenn ``wait`` auf ``True`` gesetzt ist, stoppt diese Funktion die weitere Codeausführung. + +For example, if the frequency is set to 440 and the length to +1000 then we hear a standard concert A for one second. + +You can only play one pitch on one pin at any one time.""" + ... + +def stop(pin: Optional[MicroBitDigitalPin]=pin0) -> None: + """Stoppt die Musikwiedergabe über den eingebauten Lautsprecher sowie jeden Pin, der Sound ausgibt. + +Example: ``music.stop()`` + +:param pin: Ein optionales Argument kann zur Angabe eines Pins angegeben werden, z. B. ``music.stop(pin1)``.""" + +def reset() -> None: + """Setzt Ticks, bpm, Dauer und Oktave auf ihre Standardwerte zurück. (zurücksetzen) + +Example: ``music.reset()`` + +Values: +- ``ticks = 4`` +- ``bpm = 120`` +- ``duration = 4`` +- ``octave = 4``""" + ... \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/neopixel.pyi b/lang/de/typeshed/stdlib/neopixel.pyi new file mode 100644 index 0000000..07c23c8 --- /dev/null +++ b/lang/de/typeshed/stdlib/neopixel.pyi @@ -0,0 +1,81 @@ +"""Individuell adressierbare RGB- und RGBW-LED-Streifen.""" +from .microbit import MicroBitDigitalPin +from typing import Tuple + +class NeoPixel: + + def __init__(self, pin: MicroBitDigitalPin, n: int, bpp: int=3) -> None: + """Initialisierung eines neuen Streifens von Neopixel-LEDs, die über einen Pin gesteuert werden. + +Example: ``np = neopixel.NeoPixel(pin0, 8)`` + +To support RGBW neopixels, a third argument can be passed to +``NeoPixel`` to indicate the number of bytes per pixel (``bpp``). +For RGBW, this is is 4 rather than the default of 3 for RGB and GRB. + +Each pixel is addressed by a position (starting from 0). Neopixels are +given RGB (red, green, blue) / RGBW (red, green, blue, white) values +between 0-255 as a tuple. For example, in RGB, ``(255,255,255)`` is +white. In RGBW, ``(255,255,255,0)`` or ``(0,0,0,255)`` is white. + +See `the online docs `_ for warnings and other advice. + +:param pin: Der Pin, der den Neopixelstreifen steuert. +:param n: Die Anzahl der Neopixel auf dem Streifen. +:param bpp: Bytes pro Pixel. Für die RGBW Neopixel-Unterstützung, müssen 4 statt der standardmäßigen 3 Bytes pro Pixel für RGB und GRB übergeben werden.""" + ... + + def clear(self) -> None: + """Lösche alle Pixel. (löschen) + +Example: ``np.clear()``""" + ... + + def show(self) -> None: + """Die Pixel anzeigen. + +Example: ``np.show()`` + +Must be called for any updates to become visible.""" + ... + + def write(self) -> None: + """Pixel anzeigen (nur micro:bit V2) (schreiben) + +Example: ``np.write()`` + +Must be called for any updates to become visible. + +Equivalent to ``show``.""" + ... + + def fill(self, colour: Tuple[int, ...]) -> None: + """Alle Pixel mit einem bestimmten RGB/RGBW-Wert färben. + +Example: ``np.fill((0, 0, 255))`` + +:param colour: (Farbe) Ein Tupel mit der gleichen Länge wie die Anzahl der Bytes pro Pixel (bpp). + +Use in conjunction with ``show()`` to update the neopixels.""" + ... + + def __setitem__(self, key: int, value: Tuple[int, ...]) -> None: + """Eine Pixelfarbe festlegen. + +Example: ``np[0] = (255, 0, 0)`` + +:param key: Die Pixelnummer. +:param value: (wert) Die Farbe.""" + + def __getitem__(self, key: int) -> Tuple[int, ...]: + """Eine Pixelfarbe erfassen. + +Example: ``r, g, b = np[0]`` + +:param key: Die Pixelnummer. +:return: The colour tuple.""" + + def __len__(self) -> int: + """Erhalte die Länge des Pixelstreifens. + +Example: ``len(np)``""" \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/os.pyi b/lang/de/typeshed/stdlib/os.pyi new file mode 100644 index 0000000..1fd4638 --- /dev/null +++ b/lang/de/typeshed/stdlib/os.pyi @@ -0,0 +1,63 @@ +"""Auf das Dateisystem zugreifen.""" +from typing import Tuple +from typing import List + +def listdir() -> List[str]: + """Dateien auflisten. + +Example: ``os.listdir()`` + +:return: A list of the names of all the files contained within the local +persistent on-device file system.""" + ... + +def remove(filename: str) -> None: + """Entferne (lösche) eine Datei. (Entfernen) + +Example: ``os.remove('data.txt')`` + +:param filename: (Dateiname) Die zu löschende Datei. + +If the file does not exist an ``OSError`` exception will occur.""" + ... + +def size(filename: str) -> int: + """Gibt die Größe einer Datei zurück + +Example: ``os.size('data.txt')`` + +:param filename: (Dateiname) Die Datei +:return: The size in bytes. + +If the file does not exist an ``OSError`` exception will occur.""" + +class uname_result(Tuple[str, str, str, str, str]): + """Ergebnis von ``os.uname()``""" + sysname: str + """Name des Betriebssystems.""" + nodename: str + """Name des Rechners im Netz (durch die Implementierung definiert). (Knotenname)""" + release: str + """Betriebssystemveröffentlichung. (Veröffentlichung)""" + version: str + """Betriebssystemversion. (Version)""" + machine: str + """Hardware-Kennung. (maschine)""" + +def uname() -> uname_result: + """Gibt Informationen zum aktuellen Betriebssystem zurück. + +Example: ``os.uname()`` + +The return value is an object with five attributes: + +- ``sysname`` - operating system name +- ``nodename`` - name of machine on network (implementation-defined) +- ``release`` - operating system release +- ``version`` - operating system version +- ``machine`` - hardware identifier + +There is no underlying operating system in MicroPython. As a result the +information returned by the ``uname`` function is mostly useful for +versioning details.""" + ... \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/power.pyi b/lang/de/typeshed/stdlib/power.pyi new file mode 100644 index 0000000..2be8b27 --- /dev/null +++ b/lang/de/typeshed/stdlib/power.pyi @@ -0,0 +1,53 @@ +"""Manage the power modes of the micro:bit (V2 only). +""" + +from microbit import MicroBitDigitalPin, Button +from typing import Optional, Tuple, Union + +def off() -> None: + """Power down the board to the lowest possible power mode. + + Example: ``power.off()`` + + This is the equivalent to pressing the reset button for a few seconds, + to set the board in "Off mode". + + The micro:bit will only wake up if the reset button is pressed or, + if on battery power, when a USB cable is connected. + + When the board wakes up it will start for a reset state, so your program + will start running from the beginning. + """ + ... + +def deep_sleep( + ms: Optional[int] = None, + wake_on: Optional[ + Union[MicroBitDigitalPin, Button] | Tuple[MicroBitDigitalPin | Button, ...] + ] = None, + run_every: bool = True, +) -> None: + """Set the micro:bit into a low power mode where it can wake up and continue operation. + + Example: ``power.deep_sleep(wake_on=(button_a, button_b))`` + + The program state is preserved and when it wakes up it will resume + operation where it left off. + + Deep Sleep mode will consume more battery power than Off mode. + + The wake up sources are configured via arguments. + + The board will always wake up when receiving UART data, when the reset + button is pressed (which resets the board) or, in battery power, + when the USB cable is inserted. + + When the ``run_every`` parameter is set to ``True`` (the default), any + function scheduled with ``run_every`` will momentarily wake up the board + to run and when it finishes it will go back to sleep. + + :param ms: A time in milliseconds to wait before it wakes up. + :param wake_on: A single instance or a tuple of pins and/or buttons to wake up the board, e.g. ``deep_sleep(wake_on=button_a)`` or ``deep_sleep(wake_on=(pin0, pin2, button_b))``. + :param run_every: A boolean to configure if the functions scheduled with ``microbit.run_every`` will continue to run while it sleeps. + """ + ... diff --git a/lang/de/typeshed/stdlib/radio.pyi b/lang/de/typeshed/stdlib/radio.pyi new file mode 100644 index 0000000..66f13f2 --- /dev/null +++ b/lang/de/typeshed/stdlib/radio.pyi @@ -0,0 +1,126 @@ +"""Kommunikation zwischen micro:bits mit dem integrierten Funk.""" +from _typeshed import WriteableBuffer +from typing import Optional, Tuple +RATE_1MBIT: int +"""Konstante zur Angabe eines Durchsatzes von 1 MBit pro Sekunde.""" +RATE_2MBIT: int +"""Konstante zur Angabe eines Durchsatzes von 2 MBit pro Sekunde.""" + +def on() -> None: + """Schaltet den Funk ein. (an) + +Example: ``radio.on()`` + +This needs to be explicitly called since the radio draws power and takes +up memory that you may otherwise need.""" + ... + +def off() -> None: + """Schaltet den Funk aus, um Strom und Speicherplatz zu sparen. + +Example: ``radio.off()``""" + ... + +def config(length: int=32, queue: int=3, channel: int=7, power: int=6, address: int=1969383796, group: int=0, data_rate: int=RATE_1MBIT) -> None: + """Konfiguriert den Funk. + +Example: ``radio.config(group=42)`` + +The default configuration is suitable for most use. + +:param length: (default=32) legt die maximale Länge einer über Funk gesendeten Nachricht in Bytes fest. Sie kann bis zu 251 Bytes lang sein (254 - 3 Bytes für S0, LENGTH und S1-Präambel). +:param queue: (default=3) gibt die Anzahl der Nachrichten an, die in der Warteschlange für eingehende Nachrichten gespeichert werden können. Wenn in der Warteschlange kein Platz mehr für eingehende Nachrichten ist, wird die eingehende Nachricht verworfen. +:param channel: (default=7) ein Integer-Wert zwischen 0 und 83 (einschließlich), der einen beliebigen "Kanal" definiert, auf den der Funk eingestellt ist. +Nachrichten werden über diesen Kanal gesendet und nur Nachrichten, die über diesen Kanal empfangen werden, werden in die Warteschlange der eingehenden Nachricht aufgenommen. Jeder Schritt ist 1MHz breit, beginnend mit 2400MHz. +:param power: (default=6) ist ein ganzzahliger Wert von 0 bis 7 (einschließlich), der die Stärke des Signals angibt, das beim Senden einer Nachricht verwendet wird. Je höher der Wert, desto stärker ist das Signal, aber desto mehr Strom wird vom Gerät verbraucht. Die Nummerierung entspricht den Positionen in der folgenden Liste von dBm-Werten (Dezibel Milliwatt): -30, -20, -16, -12, -8, -4, 0, 4. +:param address: (adresse) (default=0x75626974) ein beliebiger Name, ausgedrückt als 32-Bit-Adresse, der verwendet wird, um eingehende Pakete auf der Hardware-Ebene zu filtern und nur diejenigen zu behalten, die mit der eingestellten Adresse übereinstimmen. +Die Standardeinstellung, die von anderen micro:bit-verwandten Plattformen verwendet wird, wird auch hier verwendet. +:param group: (default=0) ein 8-Bit-Wert (0-255), der zusammen mit ``address`` beim Filtern von Nachrichten verwendet wird. "address" ist wie eine Haus-/Büroadresse und "group" ist wie die Person an dieser Adresse, an die die Nachricht gesendet werden soll. +:param data_rate: (default=``radio.RATE_1MBIT``) zeigt die Geschwindigkeit an, mit der der Datendurchsatz stattfindet. +Kann eine der folgenden Konstanten sein, die im Modul ``radio`` definiert sind: ``RATE_250KBIT``, ``RATE_1MBIT`` oder ``RATE_2MBIT``. + +If ``config`` is not called then the defaults described above are assumed.""" + ... + +def reset() -> None: + """Setzt die Einstellungen auf ihre Standardwerte zurück. (zurücksetzen) + +Example: ``radio.reset()`` + +The defaults as as per the ``config`` function above.""" + ... + +def send_bytes(message: bytes) -> None: + """Sendet eine Nachricht bestehend aus Bytes. + +Example: ``radio.send_bytes(b'hello')`` + +:param message: Die zu sendenden Bytes.""" + ... + +def receive_bytes() -> Optional[bytes]: + """Empfängt die nächste eingehende Nachricht in der Nachrichtenwarteschlange. + +Example: ``radio.receive_bytes()`` + +:return: The message bytes if any, otherwise ``None``.""" + ... + +def receive_bytes_into(buffer: WriteableBuffer) -> Optional[int]: + """Kopiert die nächste eingehende Nachricht in der Nachrichtenwarteschlange in einen Puffer. + +Example: ``radio.receive_bytes_info(buffer)`` + +:param buffer: (Puffer) Der Zielpuffer. Die Nachricht wird abgeschnitten, wenn sie größer als der Puffer ist. +:return: ``None`` if there are no pending messages, otherwise it returns the length of the message (which might be more than the length of the buffer).""" + ... + +def send(message: str) -> None: + """Sendet eine Nachricht als String. + +Example: ``radio.send('hello')`` + +This is the equivalent of ``radio.send_bytes(bytes(message, 'utf8'))`` but with ``b'\x01\x00\x01'`` +prepended to the front (to make it compatible with other platforms that target the micro:bit). + +:param message: Der zu sendende String.""" + ... + +def receive() -> Optional[str]: + """Funktioniert genauso wie ``receive_bytes``, gibt aber zurück, was gesendet wurde. + +Example: ``radio.receive()`` + +Equivalent to ``str(receive_bytes(), 'utf8')`` but with a check that the the first +three bytes are ``b'\x01\x00\x01'`` (to make it compatible with other platforms that +may target the micro:bit). + +:return: The message with the prepended bytes stripped and converted to a string. + +A ``ValueError`` exception is raised if conversion to string fails.""" + ... + +def receive_full() -> Optional[Tuple[bytes, int, int]]: + """Gibt ein Tupel mit drei Werten zurück, die die nächste eingehende Nachricht in der Nachrichtenwarteschlange darstellen. + +Example: ``radio.receive_full()`` + +If there are no pending messages then ``None`` is returned. + +The three values in the tuple represent: + +- the next incoming message on the message queue as bytes. +- the RSSI (signal strength): a value between 0 (strongest) and -255 (weakest) as measured in dBm. +- a microsecond timestamp: the value returned by ``time.ticks_us()`` when the message was received. + +For example:: + + details = radio.receive_full() + if details: + msg, rssi, timestamp = details + +This function is useful for providing information needed for triangulation +and/or trilateration with other micro:bit devices. + +:return: ``None`` if there is no message, otherwise a tuple of length three with the bytes, strength and timestamp values.""" + ... \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/random.pyi b/lang/de/typeshed/stdlib/random.pyi new file mode 100644 index 0000000..10b688e --- /dev/null +++ b/lang/de/typeshed/stdlib/random.pyi @@ -0,0 +1,80 @@ +"""Gibt eine Zufallszahl zurück.""" +from typing import TypeVar, Sequence, Union, overload + +def getrandbits(n: int) -> int: + """Erzeugt einen Integerwert mit ``n`` zufälligen Bits. + +Example: ``random.getrandbits(1)`` + +:param n: Ein Wert zwischen 1-30 (einschließlich).""" + ... + +def seed(n: int) -> None: + """Initialisiert den Zufallszahlengenerator. + +Example: ``random.seed(0)`` + +:param n: Der Integer-Seed + +This will give you reproducibly deterministic randomness from a given starting +state (``n``).""" + ... + +def randint(a: int, b: int) -> int: + """Wählt eine zufällige Ganzzahl zwischen ``a`` und ``b`` (einschließlich) aus. + +Example: ``random.randint(0, 9)`` + +:param a: Anfangswert für den Bereich (inklusiv) +:param b: Endwert für den Bereich (inklusiv) + +Alias for ``randrange(a, b + 1)``.""" + ... + +@overload +def randrange(stop: int) -> int: + """Wählt eine zufällige Ganzzahl zwischen Null und ``stop`` (exklusiv) aus. + +Example: ``random.randrange(10)`` + +:param stop: Endwert für den Bereich (exklusiv)""" + ... + +@overload +def randrange(start: int, stop: int, step: int=1) -> int: + """Wählt ein zufälliges Element aus ``range(start, stop, step)``. + +Example: ``random.randrange(0, 10)`` + +:param start: Anfang des Bereichs (inklusiv) +:param stop: Das Ende des Bereichs (exklusiv) +:param step: Schrittweite""" + ... +_T = TypeVar('_T') + +def choice(seq: Sequence[_T]) -> _T: + """Wählt ein zufälliges Element aus der nicht leeren Sequenz ``seq``. + +Example: ``random.choice([Image.HAPPY, Image.SAD])`` + +:param seq: Eine Sequenz. + +If ``seq`` is empty, raises ``IndexError``.""" + ... + +def random() -> float: + """Erzeugt eine zufällige Fließkommazahl im Bereich [0.0, 1.0). + +Example: ``random.random()`` + +:return: The random floating point number""" + ... + +def uniform(a: float, b: float) -> float: + """Gibt eine zufällige Fließkommazahl zwischen ``a`` und ``b`` inklusiv aus. + +Example: ``random.uniform(0, 9)`` + +:param a: Anfangswert für den Bereich (inklusiv) +:param b: Endwert für den Bereich (inklusiv)""" + ... \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/speech.pyi b/lang/de/typeshed/stdlib/speech.pyi new file mode 100644 index 0000000..237802a --- /dev/null +++ b/lang/de/typeshed/stdlib/speech.pyi @@ -0,0 +1,76 @@ +"""Bringe den micro:bit dazu zu Sprechen, zu Singen und andere sprachähnliche Geräusche zu machen.""" +from typing import Optional +from .microbit import MicroBitDigitalPin, pin0 + +def translate(words: str) -> str: + """Übersetze englische Wörter in Sprache. + +Example: ``speech.translate('hello world')`` + +:param words: (Wörter) Ein String englischer Wörter. +:return: A string containing a best guess at the appropriate phonemes to pronounce. +The output is generated from this `text to phoneme translation table `_. + +This function should be used to generate a first approximation of phonemes +that can be further hand-edited to improve accuracy, inflection and +emphasis. + +See `the online documentation `_ for detailed information.""" + ... + +def pronounce(phonemes: str, pitch: int=64, speed: int=72, mouth: int=128, throat: int=128, pin: Optional[MicroBitDigitalPin]=pin0) -> None: + """Laute aussprechen. + +Example: ``speech.pronounce(' /HEHLOW WERLD')`` + +:param phonemes: (Phoneme) Die auszusprechenden Phoneme als Zeichenkette +:param pitch: (Tonhöhe) Eine Zahl, die die Tonhöhe der Stimme angibt +:param speed: (tempo) Eine Zahl, die die Geschwindigkeit der Stimme angibt +:param mouth: (Mund) Eine Zahl, die den Mund der Stimme repräsentiert +:param throat: (klang) Eine Zahl, die den Klang der Stimme angibt +:param pin: Optionales Argument, um den Ausgangspin anzugeben, kann verwendet werden, um den Standardwert von ``pin0`` zu überschreiben. Wenn wir keinen Ton über die Pins abspielen wollen, können wir ``pin=None`` verwenden. nur micro:bit V2. + +Override the optional pitch, speed, mouth and throat settings to change the +timbre (quality) of the voice. + +See `the online documentation `_ for detailed information.""" + ... + +def say(words: str, pitch: int=64, speed: int=72, mouth: int=128, throat: int=128, pin: MicroBitDigitalPin=pin0) -> None: + """Sage englische Wörter (sage) + +Example: ``speech.say('hello world')`` + +:param words: (Wörter) Der zu sagene String +:param pitch: (Tonhöhe) Eine Zahl, die die Tonhöhe der Stimme angibt +:param speed: (tempo) Eine Zahl, die die Geschwindigkeit der Stimme angibt +:param mouth: (Mund) Eine Zahl, die den Mund der Stimme repräsentiert +:param throat: (klang) Eine Zahl, die den Klang der Stimme angibt +:param pin: Optionales Argument, um den Ausgangspin anzugeben, kann verwendet werden, um den Standardwert von ``pin0`` zu überschreiben. Wenn wir keinen Ton über die Pins abspielen wollen, können wir ``pin=None`` verwenden. nur micro:bit V2. + +The result is semi-accurate for English. Override the optional pitch, speed, +mouth and throat settings to change the timbre (quality) of the voice. + +This is a short-hand equivalent of: +``speech.pronounce(speech.translate(words))`` + +See `the online documentation `_ for detailed information.""" + ... + +def sing(phonemes: str, pitch: int=64, speed: int=72, mouth: int=128, throat: int=128, pin: MicroBitDigitalPin=pin0) -> None: + """Singe Phoneme + +Example: ``speech.sing(' /HEHLOW WERLD')`` + +:param phonemes: (Phoneme) Der zu singende String +:param pitch: (Tonhöhe) Eine Zahl, die die Tonhöhe der Stimme angibt +:param speed: (tempo) Eine Zahl, die die Geschwindigkeit der Stimme angibt +:param mouth: (Mund) Eine Zahl, die den Mund der Stimme repräsentiert +:param throat: (klang) Eine Zahl, die den Klang der Stimme angibt +:param pin: Optionales Argument, um den Ausgangspin anzugeben, kann verwendet werden, um den Standardwert von ``pin0`` zu überschreiben. Wenn wir keinen Ton über die Pins abspielen wollen, können wir ``pin=None`` verwenden. nur micro:bit V2. + +Override the optional pitch, speed, mouth and throat settings to change +the timbre (quality) of the voice. + +See `the online documentation `_ for detailed information.""" + ... \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/struct.pyi b/lang/de/typeshed/stdlib/struct.pyi new file mode 100644 index 0000000..143f24c --- /dev/null +++ b/lang/de/typeshed/stdlib/struct.pyi @@ -0,0 +1,56 @@ +"""Packe und entpacke primitive Datentypen. (struktur)""" +from _typeshed import ReadableBuffer, WriteableBuffer +from typing import Any, Tuple, Union + +def calcsize(fmt: str) -> int: + """Rufe die Anzahl der benötigten Bytes ab, um den angegebenen ``fmt`` zu speichern. + +Example: ``struct.calcsize('hf')`` + +:param fmt: Ein Format-String. +:return The number of bytes needed to store such a value.""" + ... + +def pack(fmt: str, v1: Any, *vn: Any) -> bytes: + """Werte nach einem Format-String packen. (packen) + +Example: ``struct.pack('hf', 1, 3.1415)`` + +:param fmt: Der Formatstring +:param v1: Der erste Wert. +:param *vn: Die verbleibenden Werte. +:return A bytes object encoding the values.""" + ... + +def pack_into(fmt: str, buffer: WriteableBuffer, offset: int, v1: Any, *vn: Any) -> None: + """Werte nach einem Format-String packen. (packen in) + +Example: ``struct.pack_info('hf', buffer, 1, 3.1415)`` + +:param fmt: Der Formatstring +:param buffer: (Puffer) Der Buffer, in den geschrieben werden soll. +:param offset: Der Offset in den Puffer. Kann negativ sein, um vom Ende des Puffers aus zu zählen. +:param v1: Der erste Wert. +:param *vn: Die verbleibenden Werte.""" + ... + +def unpack(fmt: str, data: ReadableBuffer) -> Tuple[Any, ...]: + """Daten nach einem Format-String entpacken. + +Example: ``v1, v2 = struct.unpack('hf', buffer)`` + +:param fmt: Der Formatstring +:param data: (Daten) Die Daten. +:return: A tuple of the unpacked values.""" + ... + +def unpack_from(fmt: str, buffer: ReadableBuffer, offset: int=0) -> Tuple: + """Daten aus einem Puffer nach einem Format-String entpacken. (entpacken von) + +Example: ``v1, v2 = struct.unpack_from('hf', buffer)`` + +:param fmt: Der Formatstring +:param buffer: (Puffer) Der Quellpuffer, von dem gelesen werden soll. +:param offset: Der Offset in den Puffer. Kann negativ sein, um vom Ende des Puffers aus zu zählen. +:return: A tuple of the unpacked values.""" + ... \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/sys.pyi b/lang/de/typeshed/stdlib/sys.pyi new file mode 100644 index 0000000..c6fe0f5 --- /dev/null +++ b/lang/de/typeshed/stdlib/sys.pyi @@ -0,0 +1,93 @@ +"""Systemspezifische Funktionen""" +from typing import Any, Dict, List, NoReturn, TextIO, Tuple + +def exit(retval: object=...) -> NoReturn: + """Ein Programm mit dem gegebenen Exit-Code beenden. + +Example: ``sys.exit(1)`` + +This function raises a ``SystemExit`` exception. If an argument is given, its +value given as an argument to ``SystemExit``. + +:param retval: Der Exit-Code oder die Nachricht.""" + ... + +def print_exception(exc: Exception) -> None: + """Eine Ausnahme mit einem Traceback ausgeben. (Ausnahme ausgeben) + +Example: ``sys.print_exception(e)`` + +:param exc: Die auszugebende Ausnahme + +This is simplified version of a function which appears in the +``traceback`` module in CPython.""" +argv: List[str] +"""Eine veränderbare Liste von Argumenten, mit denen das aktuelle Programm gestartet wurde.""" +byteorder: str +"""Die Byte-Reihenfolge des Systems (``"little"`` oder ``"big"``).""" + +class _implementation: + name: str + version: Tuple[int, int, int] +implementation: _implementation +"""Objekt mit Informationen über die aktuelle Python-Implementierung. (Implementierung) + +For MicroPython, it has following attributes: + +- ``name`` - string "micropython" +- ``version`` - tuple (major, minor, micro), e.g. (1, 7, 0) + +This object is the recommended way to distinguish MicroPython from other +Python implementations (note that it still may not exist in the very +minimal ports). + +CPython mandates more attributes for this object, but the actual useful +bare minimum is implemented in MicroPython. +""" +maxsize: int +""" +Maximaler Wert, den ein nativer Integer-Typ auf der aktuellen Plattform halten kann, oder maximaler Wert, der durch den MicroPython-Integer-Typ darstellbar ist, wenn er kleiner ist als der maximale Plattformwert (das ist der Fall bei MicroPython-Ports ohne "long int"-Unterstützung). + +This attribute is useful for detecting "bitness" of a platform (32-bit vs +64-bit, etc.). It's recommended to not compare this attribute to some +value directly, but instead count number of bits in it:: + + bits = 0 + v = sys.maxsize + while v: + bits += 1 + v >>= 1 + if bits > 32: + # 64-bit (or more) platform + ... + else: + # 32-bit (or less) platform + # Note that on 32-bit platform, value of bits may be less than 32 + # (e.g. 31) due to peculiarities described above, so use "> 16", + # "> 32", "> 64" style of comparisons. +""" +modules: Dict[str, Any] +"""Wörterbuch der geladenen Module. (module) + +On some ports, it may not include builtin modules.""" +path: List[str] +"""Eine veränderbare Liste von Verzeichnissen zum Suchen nach importierten Modulen.""" +platform: str +"""Die Plattform, auf der MicroPython läuft. (plattform) + +For OS/RTOS ports, this is usually an identifier of the OS, e.g. ``"linux"``. +For baremetal ports it is an identifier of a board, e.g. ``"pyboard"`` for +the original MicroPython reference board. It thus can be used to +distinguish one board from another. + +If you need to check whether your program runs on MicroPython (vs other +Python implementation), use ``sys.implementation`` instead. +""" +version: str +"""Python-Sprachversion, der diese Implementierung als String entspricht. (Version)""" +version_info: Tuple[int, int, int] +"""Python-Sprachversion, der diese Implementierung als Tuple mit Ints entspricht. (Versionsinformationen) + +Only the first three version numbers (major, minor, micro) are supported and +they can be referenced only by index, not by name. +""" \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/this.pyi b/lang/de/typeshed/stdlib/this.pyi new file mode 100644 index 0000000..faf492b --- /dev/null +++ b/lang/de/typeshed/stdlib/this.pyi @@ -0,0 +1 @@ +def authors() -> str: ... diff --git a/lang/de/typeshed/stdlib/time.pyi b/lang/de/typeshed/stdlib/time.pyi new file mode 100644 index 0000000..b60805f --- /dev/null +++ b/lang/de/typeshed/stdlib/time.pyi @@ -0,0 +1,111 @@ +"""Messe Zeit und füge Verzögerung zu Programmen hinzu. (Zeit)""" +from typing import Union + +def sleep(seconds: Union[int, float]) -> None: + """Warte eine bestimmte Zahl in Sekunden. + +Example: ``time.sleep(1)`` + +:param seconds: (sekunden) Die Anzahl der Sekunden für die der Ruhezustand angezeigt wird. +Benutze eine Gleitkommazahl für eine Bruchzahl von Sekunden.""" + ... + +def sleep_ms(ms: int) -> None: + """Verzögerung für die angegebene Anzahl von Millisekunden. (schlafe ms) + +Example: ``time.sleep_ms(1_000_000)`` + +:param ms: Die Anzahl der zu wartenden Millisekunden (>= 0).""" + ... + +def sleep_us(us: int) -> None: + """Verzögerung für die angegebene Anzahl von Mikrosekunden. + +Example: ``time.sleep_us(1000)`` + +:param us: Die Anzahl der zu wartenden Mikrosekunden (>= 0).""" + ... + +def ticks_ms() -> int: + """Holt einen ansteigenden Millisekunden-Zähler mit einem beliebigen Referenzpunkt, der nach einem bestimmten Wert weiterläuft. + +Example: ``time.ticks_ms()`` + +:return: The counter value in milliseconds.""" + ... + +def ticks_us() -> int: + """Holt einen ansteigenden Mikrosekunden-Zähler mit einem beliebigen Referenzpunkt, der nach einem bestimmten Wert weiterläuft. + +Example: ``time.ticks_us()`` + +:return: The counter value in microseconds.""" + ... + +def ticks_add(ticks: int, delta: int) -> int: + """Versetzt den Tick-Wert um eine bestimmte Zahl, die entweder positiv oder negativ sein kann. + +Example: ``time.ticks_add(time.ticks_ms(), 200)`` + +Given a ticks value, this function allows to calculate ticks +value delta ticks before or after it, following modular-arithmetic +definition of tick values. + +:param ticks: Ein Tick-Wert +:param delta: Ein ganzzahliger Offset + +Example:: + + # Find out what ticks value there was 100ms ago + print(ticks_add(time.ticks_ms(), -100)) + + # Calculate deadline for operation and test for it + deadline = ticks_add(time.ticks_ms(), 200) + while ticks_diff(deadline, time.ticks_ms()) > 0: + do_a_little_of_something() + + # Find out TICKS_MAX used by this port + print(ticks_add(0, -1))""" + ... + +def ticks_diff(ticks1: int, ticks2: int) -> int: + """Messung der Ticks-Differenz zwischen den Werten, die von ``time.ticks_ms()`` oder ``ticks_us()`` zurückgegeben werden, als vorzeichenbehafteter Wert der umgeschlagen werden kann. + +Example: ``time.ticks_diff(scheduled_time, now)`` + +:param ticks1: Der zu subtrahierende Wert von +:param ticks2: Der zu subtrahierende Wert + +The argument order is the same as for subtraction operator, +``ticks_diff(ticks1, ticks2)`` has the same meaning as ``ticks1 - ticks2``. + +``ticks_diff()`` is designed to accommodate various usage +patterns, among them: + +Polling with timeout. In this case, the order of events is known, and you +will deal only with positive results of :func:`time.ticks_diff()`:: + + # Wait for GPIO pin to be asserted, but at most 500us + start = time.ticks_us() + while pin.value() == 0: + if time.ticks_diff(time.ticks_us(), start) > 500: + raise TimeoutError + + +Scheduling events. In this case, :func:`time.ticks_diff()` result may be +negative if an event is overdue:: + + # This code snippet is not optimized + now = time.ticks_ms() + scheduled_time = task.scheduled_time() + if ticks_diff(scheduled_time, now) > 0: + print("Too early, let's nap") + sleep_ms(ticks_diff(scheduled_time, now)) + task.run() + elif ticks_diff(scheduled_time, now) == 0: + print("Right at time!") + task.run() + elif ticks_diff(scheduled_time, now) < 0: + print("Oops, running late, tell task to run faster!") + task.run(run_faster=True)""" + ... \ No newline at end of file diff --git a/lang/de/typeshed/stdlib/types.pyi b/lang/de/typeshed/stdlib/types.pyi new file mode 100644 index 0000000..752b2de --- /dev/null +++ b/lang/de/typeshed/stdlib/types.pyi @@ -0,0 +1,413 @@ +import sys +from typing import ( + Any, + AsyncGenerator, + Awaitable, + Callable, + Generator, + Generic, + ItemsView, + Iterable, + Iterator, + KeysView, + Mapping, + Tuple, + Type, + TypeVar, + ValuesView, + overload, +) +from typing_extensions import Literal, final + +# Note, all classes "defined" here require special handling. + +_T = TypeVar("_T") +_T1 = TypeVar("_T1") +_T2 = TypeVar("_T2") +_T_co = TypeVar("_T_co", covariant=True) +_T_contra = TypeVar("_T_contra", contravariant=True) +_KT = TypeVar("_KT") +_VT_co = TypeVar("_VT_co", covariant=True) +_V_co = TypeVar("_V_co", covariant=True) + +@final +class _Cell: + __hash__: None # type: ignore + cell_contents: Any + +@final +class FunctionType: + __closure__: Tuple[_Cell, ...] | None + __code__: CodeType + __defaults__: Tuple[Any, ...] | None + __dict__: dict[str, Any] + __globals__: dict[str, Any] + __name__: str + __qualname__: str + __annotations__: dict[str, Any] + __kwdefaults__: dict[str, Any] + def __init__( + self, + code: CodeType, + globals: dict[str, Any], + name: str | None = ..., + argdefs: Tuple[object, ...] | None = ..., + closure: Tuple[_Cell, ...] | None = ..., + ) -> None: ... + def __call__(self, *args: Any, **kwargs: Any) -> Any: ... + def __get__(self, obj: object | None, type: type | None) -> MethodType: ... + +LambdaType = FunctionType + +@final +class CodeType: + """Create a code object. Not for the faint of heart.""" + + co_argcount: int + if sys.version_info >= (3, 8): + co_posonlyargcount: int + co_kwonlyargcount: int + co_nlocals: int + co_stacksize: int + co_flags: int + co_code: bytes + co_consts: Tuple[Any, ...] + co_names: Tuple[str, ...] + co_varnames: Tuple[str, ...] + co_filename: str + co_name: str + co_firstlineno: int + co_lnotab: bytes + co_freevars: Tuple[str, ...] + co_cellvars: Tuple[str, ...] + if sys.version_info >= (3, 8): + def __init__( + self, + argcount: int, + posonlyargcount: int, + kwonlyargcount: int, + nlocals: int, + stacksize: int, + flags: int, + codestring: bytes, + constants: Tuple[Any, ...], + names: Tuple[str, ...], + varnames: Tuple[str, ...], + filename: str, + name: str, + firstlineno: int, + lnotab: bytes, + freevars: Tuple[str, ...] = ..., + cellvars: Tuple[str, ...] = ..., + ) -> None: ... + else: + def __init__( + self, + argcount: int, + kwonlyargcount: int, + nlocals: int, + stacksize: int, + flags: int, + codestring: bytes, + constants: Tuple[Any, ...], + names: Tuple[str, ...], + varnames: Tuple[str, ...], + filename: str, + name: str, + firstlineno: int, + lnotab: bytes, + freevars: Tuple[str, ...] = ..., + cellvars: Tuple[str, ...] = ..., + ) -> None: ... + if sys.version_info >= (3, 8): + def replace( + self, + *, + co_argcount: int = ..., + co_posonlyargcount: int = ..., + co_kwonlyargcount: int = ..., + co_nlocals: int = ..., + co_stacksize: int = ..., + co_flags: int = ..., + co_firstlineno: int = ..., + co_code: bytes = ..., + co_consts: Tuple[Any, ...] = ..., + co_names: Tuple[str, ...] = ..., + co_varnames: Tuple[str, ...] = ..., + co_freevars: Tuple[str, ...] = ..., + co_cellvars: Tuple[str, ...] = ..., + co_filename: str = ..., + co_name: str = ..., + co_lnotab: bytes = ..., + ) -> CodeType: ... + +@final +class MappingProxyType(Mapping[_KT, _VT_co], Generic[_KT, _VT_co]): + __hash__: None # type: ignore + def __init__(self, mapping: Mapping[_KT, _VT_co]) -> None: ... + def __getitem__(self, k: _KT) -> _VT_co: ... + def __iter__(self) -> Iterator[_KT]: ... + def __len__(self) -> int: ... + def copy(self) -> dict[_KT, _VT_co]: ... + def keys(self) -> KeysView[_KT]: ... + def values(self) -> ValuesView[_VT_co]: ... + def items(self) -> ItemsView[_KT, _VT_co]: ... + if sys.version_info >= (3, 9): + def __class_getitem__(cls, item: Any) -> GenericAlias: ... + def __reversed__(self) -> Iterator[_KT]: ... + def __or__( + self, __value: Mapping[_T1, _T2] + ) -> dict[_KT | _T1, _VT_co | _T2]: ... + def __ror__( + self, __value: Mapping[_T1, _T2] + ) -> dict[_KT | _T1, _VT_co | _T2]: ... + +class SimpleNamespace: + __hash__: None # type: ignore + def __init__(self, **kwargs: Any) -> None: ... + def __getattribute__(self, name: str) -> Any: ... + def __setattr__(self, name: str, value: Any) -> None: ... + def __delattr__(self, name: str) -> None: ... + +class ModuleType: + __name__: str + __file__: str + __dict__: dict[str, Any] + __package__: str | None + def __init__(self, name: str, doc: str | None = ...) -> None: ... + +@final +class GeneratorType(Generator[_T_co, _T_contra, _V_co]): + gi_code: CodeType + gi_frame: FrameType + gi_running: bool + gi_yieldfrom: GeneratorType[_T_co, _T_contra, Any] | None + def __iter__(self) -> GeneratorType[_T_co, _T_contra, _V_co]: ... + def __next__(self) -> _T_co: ... + def close(self) -> None: ... + def send(self, __arg: _T_contra) -> _T_co: ... + @overload + def throw( + self, + __typ: Type[BaseException], + __val: BaseException | object = ..., + __tb: TracebackType | None = ..., + ) -> _T_co: ... + @overload + def throw( + self, __typ: BaseException, __val: None = ..., __tb: TracebackType | None = ... + ) -> _T_co: ... + +@final +class AsyncGeneratorType(AsyncGenerator[_T_co, _T_contra]): + ag_await: Awaitable[Any] | None + ag_frame: FrameType + ag_running: bool + ag_code: CodeType + def __aiter__(self) -> AsyncGeneratorType[_T_co, _T_contra]: ... + def __anext__(self) -> Awaitable[_T_co]: ... + def asend(self, __val: _T_contra) -> Awaitable[_T_co]: ... + @overload + def athrow( + self, + __typ: Type[BaseException], + __val: BaseException | object = ..., + __tb: TracebackType | None = ..., + ) -> Awaitable[_T_co]: ... + @overload + def athrow( + self, __typ: BaseException, __val: None = ..., __tb: TracebackType | None = ... + ) -> Awaitable[_T_co]: ... + def aclose(self) -> Awaitable[None]: ... + +@final +class CoroutineType: + cr_await: Any | None + cr_code: CodeType + cr_frame: FrameType + cr_running: bool + def close(self) -> None: ... + def send(self, __arg: Any) -> Any: ... + @overload + def throw( + self, + __typ: Type[BaseException], + __val: BaseException | object = ..., + __tb: TracebackType | None = ..., + ) -> Any: ... + @overload + def throw( + self, __typ: BaseException, __val: None = ..., __tb: TracebackType | None = ... + ) -> Any: ... + +class _StaticFunctionType: + """Fictional type to correct the type of MethodType.__func__. + + FunctionType is a descriptor, so mypy follows the descriptor protocol and + converts MethodType.__func__ back to MethodType (the return type of + FunctionType.__get__). But this is actually a special case; MethodType is + implemented in C and its attribute access doesn't go through + __getattribute__. + + By wrapping FunctionType in _StaticFunctionType, we get the right result; + similar to wrapping a function in staticmethod() at runtime to prevent it + being bound as a method. + """ + + def __get__(self, obj: object | None, type: type | None) -> FunctionType: ... + +@final +class MethodType: + __closure__: Tuple[_Cell, ...] | None # inherited from the added function + __defaults__: Tuple[Any, ...] | None # inherited from the added function + __func__: _StaticFunctionType + __self__: object + __name__: str # inherited from the added function + __qualname__: str # inherited from the added function + def __init__(self, func: Callable[..., Any], obj: object) -> None: ... + def __call__(self, *args: Any, **kwargs: Any) -> Any: ... + +@final +class BuiltinFunctionType: + __self__: object | ModuleType + __name__: str + __qualname__: str + def __call__(self, *args: Any, **kwargs: Any) -> Any: ... + +BuiltinMethodType = BuiltinFunctionType + +if sys.version_info >= (3, 7): + @final + class WrapperDescriptorType: + __name__: str + __qualname__: str + __objclass__: type + def __call__(self, *args: Any, **kwargs: Any) -> Any: ... + def __get__(self, obj: Any, type: type = ...) -> Any: ... + @final + class MethodWrapperType: + __self__: object + __name__: str + __qualname__: str + __objclass__: type + def __call__(self, *args: Any, **kwargs: Any) -> Any: ... + def __eq__(self, other: Any) -> bool: ... + def __ne__(self, other: Any) -> bool: ... + @final + class MethodDescriptorType: + __name__: str + __qualname__: str + __objclass__: type + def __call__(self, *args: Any, **kwargs: Any) -> Any: ... + def __get__(self, obj: Any, type: type = ...) -> Any: ... + @final + class ClassMethodDescriptorType: + __name__: str + __qualname__: str + __objclass__: type + def __call__(self, *args: Any, **kwargs: Any) -> Any: ... + def __get__(self, obj: Any, type: type = ...) -> Any: ... + +@final +class TracebackType: + if sys.version_info >= (3, 7): + def __init__( + self, + tb_next: TracebackType | None, + tb_frame: FrameType, + tb_lasti: int, + tb_lineno: int, + ) -> None: ... + tb_next: TracebackType | None + else: + @property + def tb_next(self) -> TracebackType | None: ... + # the rest are read-only even in 3.7 + @property + def tb_frame(self) -> FrameType: ... + @property + def tb_lasti(self) -> int: ... + @property + def tb_lineno(self) -> int: ... + +@final +class FrameType: + f_back: FrameType | None + f_builtins: dict[str, Any] + f_code: CodeType + f_globals: dict[str, Any] + f_lasti: int + f_lineno: int + f_locals: dict[str, Any] + f_trace: Callable[[FrameType, str, Any], Any] | None + if sys.version_info >= (3, 7): + f_trace_lines: bool + f_trace_opcodes: bool + def clear(self) -> None: ... + +@final +class GetSetDescriptorType: + __name__: str + __objclass__: type + def __get__(self, __obj: Any, __type: type = ...) -> Any: ... + def __set__(self, __instance: Any, __value: Any) -> None: ... + def __delete__(self, obj: Any) -> None: ... + +@final +class MemberDescriptorType: + __name__: str + __objclass__: type + def __get__(self, __obj: Any, __type: type = ...) -> Any: ... + def __set__(self, __instance: Any, __value: Any) -> None: ... + def __delete__(self, obj: Any) -> None: ... + +if sys.version_info >= (3, 7): + def new_class( + name: str, + bases: Iterable[object] = ..., + kwds: dict[str, Any] | None = ..., + exec_body: Callable[[dict[str, Any]], None] | None = ..., + ) -> type: ... + def resolve_bases(bases: Iterable[object]) -> Tuple[Any, ...]: ... + +else: + def new_class( + name: str, + bases: Tuple[type, ...] = ..., + kwds: dict[str, Any] | None = ..., + exec_body: Callable[[dict[str, Any]], None] | None = ..., + ) -> type: ... + +def prepare_class( + name: str, bases: Tuple[type, ...] = ..., kwds: dict[str, Any] | None = ... +) -> Tuple[type, dict[str, Any], dict[str, Any]]: ... + +# Actually a different type, but `property` is special and we want that too. +DynamicClassAttribute = property + +def coroutine(func: Callable[..., Any]) -> CoroutineType: ... + +if sys.version_info >= (3, 8): + CellType = _Cell + +if sys.version_info >= (3, 9): + class GenericAlias: + __origin__: type + __args__: Tuple[Any, ...] + __parameters__: Tuple[Any, ...] + def __init__(self, origin: type, args: Any) -> None: ... + def __getattr__(self, name: str) -> Any: ... # incomplete + +if sys.version_info >= (3, 10): + @final + class NoneType: + def __bool__(self) -> Literal[False]: ... + EllipsisType = ellipsis # noqa F811 from builtins + from builtins import _NotImplementedType + + NotImplementedType = _NotImplementedType # noqa F811 from builtins + @final + class UnionType: + __args__: Tuple[Any, ...] + def __or__(self, obj: Any) -> UnionType: ... + def __ror__(self, obj: Any) -> UnionType: ... diff --git a/lang/de/typeshed/stdlib/typing.pyi b/lang/de/typeshed/stdlib/typing.pyi new file mode 100644 index 0000000..a494557 --- /dev/null +++ b/lang/de/typeshed/stdlib/typing.pyi @@ -0,0 +1,716 @@ +import collections # Needed by aliases like DefaultDict, see mypy issue 2986 +import sys +from abc import ABCMeta, abstractmethod +from types import BuiltinFunctionType, CodeType, FrameType, FunctionType, MethodType, ModuleType, TracebackType +from typing_extensions import Literal as _Literal + +if sys.version_info >= (3, 7): + from types import MethodDescriptorType, MethodWrapperType, WrapperDescriptorType + +if sys.version_info >= (3, 9): + from types import GenericAlias + +# Definitions of special type checking related constructs. Their definitions +# are not used, so their value does not matter. + +Any = object() + +class TypeVar: + __name__: str + __bound__: Optional[Type[Any]] + __constraints__: Tuple[Type[Any], ...] + __covariant__: bool + __contravariant__: bool + def __init__( + self, + name: str, + *constraints: Type[Any], + bound: Union[None, Type[Any], str] = ..., + covariant: bool = ..., + contravariant: bool = ..., + ) -> None: ... + +_promote = object() + +class _SpecialForm: + def __getitem__(self, typeargs: Any) -> object: ... + +_F = TypeVar("_F", bound=Callable[..., Any]) + +def overload(func: _F) -> _F: ... + +Union: _SpecialForm = ... +Optional: _SpecialForm = ... +Tuple: _SpecialForm = ... +Generic: _SpecialForm = ... +# Protocol is only present in 3.8 and later, but mypy needs it unconditionally +Protocol: _SpecialForm = ... +Callable: _SpecialForm = ... +Type: _SpecialForm = ... +ClassVar: _SpecialForm = ... +if sys.version_info >= (3, 8): + Final: _SpecialForm = ... + def final(f: _F) -> _F: ... + Literal: _SpecialForm = ... + # TypedDict is a (non-subscriptable) special form. + TypedDict: object + +if sys.version_info < (3, 7): + class GenericMeta(type): ... + +if sys.version_info >= (3, 10): + class ParamSpecArgs: + __origin__: ParamSpec + def __init__(self, origin: ParamSpec) -> None: ... + class ParamSpecKwargs: + __origin__: ParamSpec + def __init__(self, origin: ParamSpec) -> None: ... + class ParamSpec: + __name__: str + __bound__: Optional[Type[Any]] + __covariant__: bool + __contravariant__: bool + def __init__( + self, name: str, *, bound: Union[None, Type[Any], str] = ..., contravariant: bool = ..., covariant: bool = ... + ) -> None: ... + @property + def args(self) -> ParamSpecArgs: ... + @property + def kwargs(self) -> ParamSpecKwargs: ... + Concatenate: _SpecialForm = ... + TypeAlias: _SpecialForm = ... + TypeGuard: _SpecialForm = ... + +# Return type that indicates a function does not return. +# This type is equivalent to the None type, but the no-op Union is necessary to +# distinguish the None type from the None value. +NoReturn = Union[None] + +# These type variables are used by the container types. +_T = TypeVar("_T") +_S = TypeVar("_S") +_KT = TypeVar("_KT") # Key type. +_VT = TypeVar("_VT") # Value type. +_T_co = TypeVar("_T_co", covariant=True) # Any type covariant containers. +_V_co = TypeVar("_V_co", covariant=True) # Any type covariant containers. +_KT_co = TypeVar("_KT_co", covariant=True) # Key type covariant containers. +_VT_co = TypeVar("_VT_co", covariant=True) # Value type covariant containers. +_T_contra = TypeVar("_T_contra", contravariant=True) # Ditto contravariant. +_TC = TypeVar("_TC", bound=Type[object]) + +def no_type_check(arg: _F) -> _F: ... +def no_type_check_decorator(decorator: _F) -> _F: ... + +# Type aliases and type constructors + +class _Alias: + # Class for defining generic aliases for library types. + def __getitem__(self, typeargs: Any) -> Any: ... + +List = _Alias() +Dict = _Alias() +DefaultDict = _Alias() +Set = _Alias() +FrozenSet = _Alias() +Counter = _Alias() +Deque = _Alias() +ChainMap = _Alias() + +if sys.version_info >= (3, 7): + OrderedDict = _Alias() + +if sys.version_info >= (3, 9): + Annotated: _SpecialForm = ... + +# Predefined type variables. +AnyStr = TypeVar("AnyStr", str, bytes) + +# Abstract base classes. + +def runtime_checkable(cls: _TC) -> _TC: ... +@runtime_checkable +class SupportsInt(Protocol, metaclass=ABCMeta): + @abstractmethod + def __int__(self) -> int: ... + +@runtime_checkable +class SupportsFloat(Protocol, metaclass=ABCMeta): + @abstractmethod + def __float__(self) -> float: ... + +@runtime_checkable +class SupportsComplex(Protocol, metaclass=ABCMeta): + @abstractmethod + def __complex__(self) -> complex: ... + +@runtime_checkable +class SupportsBytes(Protocol, metaclass=ABCMeta): + @abstractmethod + def __bytes__(self) -> bytes: ... + +if sys.version_info >= (3, 8): + @runtime_checkable + class SupportsIndex(Protocol, metaclass=ABCMeta): + @abstractmethod + def __index__(self) -> int: ... + +@runtime_checkable +class SupportsAbs(Protocol[_T_co]): + @abstractmethod + def __abs__(self) -> _T_co: ... + +@runtime_checkable +class SupportsRound(Protocol[_T_co]): + @overload + @abstractmethod + def __round__(self) -> int: ... + @overload + @abstractmethod + def __round__(self, ndigits: int) -> _T_co: ... + +@runtime_checkable +class Sized(Protocol, metaclass=ABCMeta): + @abstractmethod + def __len__(self) -> int: ... + +@runtime_checkable +class Hashable(Protocol, metaclass=ABCMeta): + # TODO: This is special, in that a subclass of a hashable class may not be hashable + # (for example, list vs. object). It's not obvious how to represent this. This class + # is currently mostly useless for static checking. + @abstractmethod + def __hash__(self) -> int: ... + +@runtime_checkable +class Iterable(Protocol[_T_co]): + @abstractmethod + def __iter__(self) -> Iterator[_T_co]: ... + +@runtime_checkable +class Iterator(Iterable[_T_co], Protocol[_T_co]): + @abstractmethod + def __next__(self) -> _T_co: ... + def __iter__(self) -> Iterator[_T_co]: ... + +@runtime_checkable +class Reversible(Iterable[_T_co], Protocol[_T_co]): + @abstractmethod + def __reversed__(self) -> Iterator[_T_co]: ... + +class Generator(Iterator[_T_co], Generic[_T_co, _T_contra, _V_co]): + def __next__(self) -> _T_co: ... + @abstractmethod + def send(self, __value: _T_contra) -> _T_co: ... + @overload + @abstractmethod + def throw( + self, __typ: Type[BaseException], __val: Union[BaseException, object] = ..., __tb: Optional[TracebackType] = ... + ) -> _T_co: ... + @overload + @abstractmethod + def throw(self, __typ: BaseException, __val: None = ..., __tb: Optional[TracebackType] = ...) -> _T_co: ... + def close(self) -> None: ... + def __iter__(self) -> Generator[_T_co, _T_contra, _V_co]: ... + @property + def gi_code(self) -> CodeType: ... + @property + def gi_frame(self) -> FrameType: ... + @property + def gi_running(self) -> bool: ... + @property + def gi_yieldfrom(self) -> Optional[Generator[Any, Any, Any]]: ... + +@runtime_checkable +class Awaitable(Protocol[_T_co]): + @abstractmethod + def __await__(self) -> Generator[Any, None, _T_co]: ... + +class Coroutine(Awaitable[_V_co], Generic[_T_co, _T_contra, _V_co]): + __name__: str + __qualname__: str + @property + def cr_await(self) -> Optional[Any]: ... + @property + def cr_code(self) -> CodeType: ... + @property + def cr_frame(self) -> FrameType: ... + @property + def cr_running(self) -> bool: ... + @abstractmethod + def send(self, __value: _T_contra) -> _T_co: ... + @overload + @abstractmethod + def throw( + self, __typ: Type[BaseException], __val: Union[BaseException, object] = ..., __tb: Optional[TracebackType] = ... + ) -> _T_co: ... + @overload + @abstractmethod + def throw(self, __typ: BaseException, __val: None = ..., __tb: Optional[TracebackType] = ...) -> _T_co: ... + @abstractmethod + def close(self) -> None: ... + +# NOTE: This type does not exist in typing.py or PEP 484. +# The parameters correspond to Generator, but the 4th is the original type. +class AwaitableGenerator( + Awaitable[_V_co], Generator[_T_co, _T_contra, _V_co], Generic[_T_co, _T_contra, _V_co, _S], metaclass=ABCMeta +): ... + +@runtime_checkable +class AsyncIterable(Protocol[_T_co]): + @abstractmethod + def __aiter__(self) -> AsyncIterator[_T_co]: ... + +@runtime_checkable +class AsyncIterator(AsyncIterable[_T_co], Protocol[_T_co]): + @abstractmethod + def __anext__(self) -> Awaitable[_T_co]: ... + def __aiter__(self) -> AsyncIterator[_T_co]: ... + +class AsyncGenerator(AsyncIterator[_T_co], Generic[_T_co, _T_contra]): + @abstractmethod + def __anext__(self) -> Awaitable[_T_co]: ... + @abstractmethod + def asend(self, __value: _T_contra) -> Awaitable[_T_co]: ... + @overload + @abstractmethod + def athrow( + self, __typ: Type[BaseException], __val: Union[BaseException, object] = ..., __tb: Optional[TracebackType] = ... + ) -> Awaitable[_T_co]: ... + @overload + @abstractmethod + def athrow(self, __typ: BaseException, __val: None = ..., __tb: Optional[TracebackType] = ...) -> Awaitable[_T_co]: ... + @abstractmethod + def aclose(self) -> Awaitable[None]: ... + @abstractmethod + def __aiter__(self) -> AsyncGenerator[_T_co, _T_contra]: ... + @property + def ag_await(self) -> Any: ... + @property + def ag_code(self) -> CodeType: ... + @property + def ag_frame(self) -> FrameType: ... + @property + def ag_running(self) -> bool: ... + +@runtime_checkable +class Container(Protocol[_T_co]): + @abstractmethod + def __contains__(self, __x: object) -> bool: ... + +@runtime_checkable +class Collection(Iterable[_T_co], Container[_T_co], Protocol[_T_co]): + # Implement Sized (but don't have it as a base class). + @abstractmethod + def __len__(self) -> int: ... + +_Collection = Collection[_T_co] + +class Sequence(_Collection[_T_co], Reversible[_T_co], Generic[_T_co]): + @overload + @abstractmethod + def __getitem__(self, i: int) -> _T_co: ... + @overload + @abstractmethod + def __getitem__(self, s: slice) -> Sequence[_T_co]: ... + # Mixin methods + def index(self, value: Any, start: int = ..., stop: int = ...) -> int: ... + def count(self, value: Any) -> int: ... + def __contains__(self, x: object) -> bool: ... + def __iter__(self) -> Iterator[_T_co]: ... + def __reversed__(self) -> Iterator[_T_co]: ... + +class MutableSequence(Sequence[_T], Generic[_T]): + @abstractmethod + def insert(self, index: int, value: _T) -> None: ... + @overload + @abstractmethod + def __getitem__(self, i: int) -> _T: ... + @overload + @abstractmethod + def __getitem__(self, s: slice) -> MutableSequence[_T]: ... + @overload + @abstractmethod + def __setitem__(self, i: int, o: _T) -> None: ... + @overload + @abstractmethod + def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ... + @overload + @abstractmethod + def __delitem__(self, i: int) -> None: ... + @overload + @abstractmethod + def __delitem__(self, i: slice) -> None: ... + # Mixin methods + def append(self, value: _T) -> None: ... + def clear(self) -> None: ... + def extend(self, values: Iterable[_T]) -> None: ... + def reverse(self) -> None: ... + def pop(self, index: int = ...) -> _T: ... + def remove(self, value: _T) -> None: ... + def __iadd__(self, x: Iterable[_T]) -> MutableSequence[_T]: ... + +class AbstractSet(_Collection[_T_co], Generic[_T_co]): + @abstractmethod + def __contains__(self, x: object) -> bool: ... + # Mixin methods + def __le__(self, s: AbstractSet[Any]) -> bool: ... + def __lt__(self, s: AbstractSet[Any]) -> bool: ... + def __gt__(self, s: AbstractSet[Any]) -> bool: ... + def __ge__(self, s: AbstractSet[Any]) -> bool: ... + def __and__(self, s: AbstractSet[Any]) -> AbstractSet[_T_co]: ... + def __or__(self, s: AbstractSet[_T]) -> AbstractSet[Union[_T_co, _T]]: ... + def __sub__(self, s: AbstractSet[Any]) -> AbstractSet[_T_co]: ... + def __xor__(self, s: AbstractSet[_T]) -> AbstractSet[Union[_T_co, _T]]: ... + def isdisjoint(self, other: Iterable[Any]) -> bool: ... + +class MutableSet(AbstractSet[_T], Generic[_T]): + @abstractmethod + def add(self, value: _T) -> None: ... + @abstractmethod + def discard(self, value: _T) -> None: ... + # Mixin methods + def clear(self) -> None: ... + def pop(self) -> _T: ... + def remove(self, value: _T) -> None: ... + def __ior__(self, s: AbstractSet[_S]) -> MutableSet[Union[_T, _S]]: ... + def __iand__(self, s: AbstractSet[Any]) -> MutableSet[_T]: ... + def __ixor__(self, s: AbstractSet[_S]) -> MutableSet[Union[_T, _S]]: ... + def __isub__(self, s: AbstractSet[Any]) -> MutableSet[_T]: ... + +class MappingView(Sized): + def __init__(self, mapping: Mapping[Any, Any]) -> None: ... # undocumented + def __len__(self) -> int: ... + +class ItemsView(MappingView, AbstractSet[Tuple[_KT_co, _VT_co]], Generic[_KT_co, _VT_co]): + def __init__(self, mapping: Mapping[_KT_co, _VT_co]) -> None: ... # undocumented + def __and__(self, o: Iterable[Any]) -> Set[Tuple[_KT_co, _VT_co]]: ... + def __rand__(self, o: Iterable[_T]) -> Set[_T]: ... + def __contains__(self, o: object) -> bool: ... + def __iter__(self) -> Iterator[Tuple[_KT_co, _VT_co]]: ... + if sys.version_info >= (3, 8): + def __reversed__(self) -> Iterator[Tuple[_KT_co, _VT_co]]: ... + def __or__(self, o: Iterable[_T]) -> Set[Union[Tuple[_KT_co, _VT_co], _T]]: ... + def __ror__(self, o: Iterable[_T]) -> Set[Union[Tuple[_KT_co, _VT_co], _T]]: ... + def __sub__(self, o: Iterable[Any]) -> Set[Tuple[_KT_co, _VT_co]]: ... + def __rsub__(self, o: Iterable[_T]) -> Set[_T]: ... + def __xor__(self, o: Iterable[_T]) -> Set[Union[Tuple[_KT_co, _VT_co], _T]]: ... + def __rxor__(self, o: Iterable[_T]) -> Set[Union[Tuple[_KT_co, _VT_co], _T]]: ... + +class KeysView(MappingView, AbstractSet[_KT_co], Generic[_KT_co]): + def __init__(self, mapping: Mapping[_KT_co, Any]) -> None: ... # undocumented + def __and__(self, o: Iterable[Any]) -> Set[_KT_co]: ... + def __rand__(self, o: Iterable[_T]) -> Set[_T]: ... + def __contains__(self, o: object) -> bool: ... + def __iter__(self) -> Iterator[_KT_co]: ... + if sys.version_info >= (3, 8): + def __reversed__(self) -> Iterator[_KT_co]: ... + def __or__(self, o: Iterable[_T]) -> Set[Union[_KT_co, _T]]: ... + def __ror__(self, o: Iterable[_T]) -> Set[Union[_KT_co, _T]]: ... + def __sub__(self, o: Iterable[Any]) -> Set[_KT_co]: ... + def __rsub__(self, o: Iterable[_T]) -> Set[_T]: ... + def __xor__(self, o: Iterable[_T]) -> Set[Union[_KT_co, _T]]: ... + def __rxor__(self, o: Iterable[_T]) -> Set[Union[_KT_co, _T]]: ... + +class ValuesView(MappingView, Iterable[_VT_co], Generic[_VT_co]): + def __init__(self, mapping: Mapping[Any, _VT_co]) -> None: ... # undocumented + def __contains__(self, o: object) -> bool: ... + def __iter__(self) -> Iterator[_VT_co]: ... + if sys.version_info >= (3, 8): + def __reversed__(self) -> Iterator[_VT_co]: ... + +@runtime_checkable +class ContextManager(Protocol[_T_co]): + def __enter__(self) -> _T_co: ... + def __exit__( + self, + __exc_type: Optional[Type[BaseException]], + __exc_value: Optional[BaseException], + __traceback: Optional[TracebackType], + ) -> Optional[bool]: ... + +@runtime_checkable +class AsyncContextManager(Protocol[_T_co]): + def __aenter__(self) -> Awaitable[_T_co]: ... + def __aexit__( + self, exc_type: Optional[Type[BaseException]], exc_value: Optional[BaseException], traceback: Optional[TracebackType] + ) -> Awaitable[Optional[bool]]: ... + +class Mapping(_Collection[_KT], Generic[_KT, _VT_co]): + # TODO: We wish the key type could also be covariant, but that doesn't work, + # see discussion in https: //github.com/python/typing/pull/273. + @abstractmethod + def __getitem__(self, k: _KT) -> _VT_co: ... + # Mixin methods + @overload + def get(self, key: _KT) -> Optional[_VT_co]: ... + @overload + def get(self, key: _KT, default: Union[_VT_co, _T]) -> Union[_VT_co, _T]: ... + def items(self) -> AbstractSet[Tuple[_KT, _VT_co]]: ... + def keys(self) -> AbstractSet[_KT]: ... + def values(self) -> ValuesView[_VT_co]: ... + def __contains__(self, o: object) -> bool: ... + +class MutableMapping(Mapping[_KT, _VT], Generic[_KT, _VT]): + @abstractmethod + def __setitem__(self, k: _KT, v: _VT) -> None: ... + @abstractmethod + def __delitem__(self, v: _KT) -> None: ... + def clear(self) -> None: ... + @overload + def pop(self, key: _KT) -> _VT: ... + @overload + def pop(self, key: _KT, default: Union[_VT, _T] = ...) -> Union[_VT, _T]: ... + def popitem(self) -> Tuple[_KT, _VT]: ... + def setdefault(self, key: _KT, default: _VT = ...) -> _VT: ... + # 'update' used to take a Union, but using overloading is better. + # The second overloaded type here is a bit too general, because + # Mapping[Tuple[_KT, _VT], W] is a subclass of Iterable[Tuple[_KT, _VT]], + # but will always have the behavior of the first overloaded type + # at runtime, leading to keys of a mix of types _KT and Tuple[_KT, _VT]. + # We don't currently have any way of forcing all Mappings to use + # the first overload, but by using overloading rather than a Union, + # mypy will commit to using the first overload when the argument is + # known to be a Mapping with unknown type parameters, which is closer + # to the behavior we want. See mypy issue #1430. + @overload + def update(self, __m: Mapping[_KT, _VT], **kwargs: _VT) -> None: ... + @overload + def update(self, __m: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ... + @overload + def update(self, **kwargs: _VT) -> None: ... + +Text = str + +TYPE_CHECKING = True + +class IO(Iterator[AnyStr], Generic[AnyStr]): + # TODO use abstract properties + @property + def mode(self) -> str: ... + @property + def name(self) -> str: ... + @abstractmethod + def close(self) -> None: ... + @property + def closed(self) -> bool: ... + @abstractmethod + def fileno(self) -> int: ... + @abstractmethod + def flush(self) -> None: ... + @abstractmethod + def isatty(self) -> bool: ... + @abstractmethod + def read(self, n: int = ...) -> AnyStr: ... + @abstractmethod + def readable(self) -> bool: ... + @abstractmethod + def readline(self, limit: int = ...) -> AnyStr: ... + @abstractmethod + def readlines(self, hint: int = ...) -> list[AnyStr]: ... + @abstractmethod + def seek(self, offset: int, whence: int = ...) -> int: ... + @abstractmethod + def seekable(self) -> bool: ... + @abstractmethod + def tell(self) -> int: ... + @abstractmethod + def truncate(self, size: Optional[int] = ...) -> int: ... + @abstractmethod + def writable(self) -> bool: ... + @abstractmethod + def write(self, s: AnyStr) -> int: ... + @abstractmethod + def writelines(self, lines: Iterable[AnyStr]) -> None: ... + @abstractmethod + def __next__(self) -> AnyStr: ... + @abstractmethod + def __iter__(self) -> Iterator[AnyStr]: ... + @abstractmethod + def __enter__(self) -> IO[AnyStr]: ... + @abstractmethod + def __exit__( + self, t: Optional[Type[BaseException]], value: Optional[BaseException], traceback: Optional[TracebackType] + ) -> Optional[bool]: ... + +class BinaryIO(IO[bytes]): + @abstractmethod + def __enter__(self) -> BinaryIO: ... + +class TextIO(IO[str]): + # TODO use abstractproperty + @property + def buffer(self) -> BinaryIO: ... + @property + def encoding(self) -> str: ... + @property + def errors(self) -> Optional[str]: ... + @property + def line_buffering(self) -> int: ... # int on PyPy, bool on CPython + @property + def newlines(self) -> Any: ... # None, str or tuple + @abstractmethod + def __enter__(self) -> TextIO: ... + +class ByteString(Sequence[int], metaclass=ABCMeta): ... + +class Match(Generic[AnyStr]): + pos: int + endpos: int + lastindex: Optional[int] + lastgroup: Optional[AnyStr] + string: AnyStr + + # The regular expression object whose match() or search() method produced + # this match instance. + re: Pattern[AnyStr] + def expand(self, template: AnyStr) -> AnyStr: ... + # group() returns "AnyStr" or "AnyStr | None", depending on the pattern. + @overload + def group(self, __group: _Literal[0] = ...) -> AnyStr: ... + @overload + def group(self, __group: str | int) -> AnyStr | Any: ... + @overload + def group(self, __group1: str | int, __group2: str | int, *groups: str | int) -> Tuple[AnyStr | Any, ...]: ... + # Each item of groups()'s return tuple is either "AnyStr" or + # "AnyStr | None", depending on the pattern. + @overload + def groups(self) -> Tuple[AnyStr | Any, ...]: ... + @overload + def groups(self, default: _T) -> Tuple[AnyStr | _T, ...]: ... + # Each value in groupdict()'s return dict is either "AnyStr" or + # "AnyStr | None", depending on the pattern. + @overload + def groupdict(self) -> dict[str, AnyStr | Any]: ... + @overload + def groupdict(self, default: _T) -> dict[str, AnyStr | _T]: ... + def start(self, __group: Union[int, str] = ...) -> int: ... + def end(self, __group: Union[int, str] = ...) -> int: ... + def span(self, __group: Union[int, str] = ...) -> Tuple[int, int]: ... + @property + def regs(self) -> Tuple[Tuple[int, int], ...]: ... # undocumented + # __getitem__() returns "AnyStr" or "AnyStr | None", depending on the pattern. + @overload + def __getitem__(self, __key: _Literal[0]) -> AnyStr: ... + @overload + def __getitem__(self, __key: int | str) -> AnyStr | Any: ... + if sys.version_info >= (3, 9): + def __class_getitem__(cls, item: Any) -> GenericAlias: ... + +class Pattern(Generic[AnyStr]): + flags: int + groupindex: Mapping[str, int] + groups: int + pattern: AnyStr + def search(self, string: AnyStr, pos: int = ..., endpos: int = ...) -> Optional[Match[AnyStr]]: ... + def match(self, string: AnyStr, pos: int = ..., endpos: int = ...) -> Optional[Match[AnyStr]]: ... + def fullmatch(self, string: AnyStr, pos: int = ..., endpos: int = ...) -> Optional[Match[AnyStr]]: ... + def split(self, string: AnyStr, maxsplit: int = ...) -> list[AnyStr]: ... + def findall(self, string: AnyStr, pos: int = ..., endpos: int = ...) -> list[Any]: ... + def finditer(self, string: AnyStr, pos: int = ..., endpos: int = ...) -> Iterator[Match[AnyStr]]: ... + @overload + def sub(self, repl: AnyStr, string: AnyStr, count: int = ...) -> AnyStr: ... + @overload + def sub(self, repl: Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = ...) -> AnyStr: ... + @overload + def subn(self, repl: AnyStr, string: AnyStr, count: int = ...) -> Tuple[AnyStr, int]: ... + @overload + def subn(self, repl: Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = ...) -> Tuple[AnyStr, int]: ... + if sys.version_info >= (3, 9): + def __class_getitem__(cls, item: Any) -> GenericAlias: ... + +# Functions + +if sys.version_info >= (3, 7): + _get_type_hints_obj_allowed_types = Union[ + object, + Callable[..., Any], + FunctionType, + BuiltinFunctionType, + MethodType, + ModuleType, + WrapperDescriptorType, + MethodWrapperType, + MethodDescriptorType, + ] +else: + _get_type_hints_obj_allowed_types = Union[ + object, Callable[..., Any], FunctionType, BuiltinFunctionType, MethodType, ModuleType, + ] + +if sys.version_info >= (3, 9): + def get_type_hints( + obj: _get_type_hints_obj_allowed_types, + globalns: Optional[Dict[str, Any]] = ..., + localns: Optional[Dict[str, Any]] = ..., + include_extras: bool = ..., + ) -> Dict[str, Any]: ... + +else: + def get_type_hints( + obj: _get_type_hints_obj_allowed_types, globalns: Optional[Dict[str, Any]] = ..., localns: Optional[Dict[str, Any]] = ... + ) -> Dict[str, Any]: ... + +if sys.version_info >= (3, 8): + def get_origin(tp: Any) -> Optional[Any]: ... + def get_args(tp: Any) -> Tuple[Any, ...]: ... + +@overload +def cast(typ: Type[_T], val: Any) -> _T: ... +@overload +def cast(typ: str, val: Any) -> Any: ... +@overload +def cast(typ: object, val: Any) -> Any: ... + +# Type constructors + +# NamedTuple is special-cased in the type checker +class NamedTuple(Tuple[Any, ...]): + _field_types: collections.OrderedDict[str, Type[Any]] + _field_defaults: Dict[str, Any] = ... + _fields: Tuple[str, ...] + _source: str + def __init__(self, typename: str, fields: Iterable[Tuple[str, Any]] = ..., **kwargs: Any) -> None: ... + @classmethod + def _make(cls: Type[_T], iterable: Iterable[Any]) -> _T: ... + if sys.version_info >= (3, 8): + def _asdict(self) -> Dict[str, Any]: ... + else: + def _asdict(self) -> collections.OrderedDict[str, Any]: ... + def _replace(self: _T, **kwargs: Any) -> _T: ... + +# Internal mypy fallback type for all typed dicts (does not exist at runtime) +class _TypedDict(Mapping[str, object], metaclass=ABCMeta): + def copy(self: _T) -> _T: ... + # Using NoReturn so that only calls using mypy plugin hook that specialize the signature + # can go through. + def setdefault(self, k: NoReturn, default: object) -> object: ... + # Mypy plugin hook for 'pop' expects that 'default' has a type variable type. + def pop(self, k: NoReturn, default: _T = ...) -> object: ... # type: ignore + def update(self: _T, __m: _T) -> None: ... + def __delitem__(self, k: NoReturn) -> None: ... + def items(self) -> ItemsView[str, object]: ... + def keys(self) -> KeysView[str]: ... + def values(self) -> ValuesView[object]: ... + def __or__(self: _T, __value: _T) -> _T: ... + def __ior__(self: _T, __value: _T) -> _T: ... + +def NewType(name: str, tp: Type[_T]) -> Type[_T]: ... + +# This itself is only available during type checking +def type_check_only(func_or_cls: _F) -> _F: ... + +if sys.version_info >= (3, 7): + class ForwardRef: + __forward_arg__: str + __forward_code__: CodeType + __forward_evaluated__: bool + __forward_value__: Optional[Any] + __forward_is_argument__: bool + def __init__(self, arg: str, is_argument: bool = ...) -> None: ... + def _evaluate(self, globalns: Optional[Dict[str, Any]], localns: Optional[Dict[str, Any]]) -> Optional[Any]: ... + def __eq__(self, other: Any) -> bool: ... + def __hash__(self) -> int: ... + def __repr__(self) -> str: ... + +if sys.version_info >= (3, 10): + def is_typeddict(tp: Any) -> bool: ... diff --git a/lang/de/typeshed/stdlib/typing_extensions.pyi b/lang/de/typeshed/stdlib/typing_extensions.pyi new file mode 100644 index 0000000..59fe3df --- /dev/null +++ b/lang/de/typeshed/stdlib/typing_extensions.pyi @@ -0,0 +1,115 @@ +import abc +import sys +from typing import ( + TYPE_CHECKING as TYPE_CHECKING, + Any, + AsyncContextManager as AsyncContextManager, + AsyncGenerator as AsyncGenerator, + AsyncIterable as AsyncIterable, + AsyncIterator as AsyncIterator, + Awaitable as Awaitable, + Callable, + ChainMap as ChainMap, + ClassVar as ClassVar, + ContextManager as ContextManager, + Coroutine as Coroutine, + Counter as Counter, + DefaultDict as DefaultDict, + Deque as Deque, + ItemsView, + KeysView, + Mapping, + NewType as NewType, + NoReturn as NoReturn, + Text as Text, + Tuple, + Type as Type, + TypeVar, + ValuesView, + _Alias, + overload as overload, +) + +_T = TypeVar("_T") +_F = TypeVar("_F", bound=Callable[..., Any]) +_TC = TypeVar("_TC", bound=Type[object]) + +class _SpecialForm: + def __getitem__(self, typeargs: Any) -> Any: ... + +def runtime_checkable(cls: _TC) -> _TC: ... + +# This alias for above is kept here for backwards compatibility. +runtime = runtime_checkable +Protocol: _SpecialForm = ... +Final: _SpecialForm = ... + +def final(f: _F) -> _F: ... + +Literal: _SpecialForm = ... + +def IntVar(name: str) -> Any: ... # returns a new TypeVar + +# Internal mypy fallback type for all typed dicts (does not exist at runtime) +class _TypedDict(Mapping[str, object], metaclass=abc.ABCMeta): + def copy(self: _T) -> _T: ... + # Using NoReturn so that only calls using mypy plugin hook that specialize the signature + # can go through. + def setdefault(self, k: NoReturn, default: object) -> object: ... + # Mypy plugin hook for 'pop' expects that 'default' has a type variable type. + def pop(self, k: NoReturn, default: _T = ...) -> object: ... # type: ignore + def update(self: _T, __m: _T) -> None: ... + def items(self) -> ItemsView[str, object]: ... + def keys(self) -> KeysView[str]: ... + def values(self) -> ValuesView[object]: ... + def __delitem__(self, k: NoReturn) -> None: ... + +# TypedDict is a (non-subscriptable) special form. +TypedDict: object = ... + +OrderedDict = _Alias() + +def get_type_hints( + obj: Callable[..., Any], + globalns: dict[str, Any] | None = ..., + localns: dict[str, Any] | None = ..., + include_extras: bool = ..., +) -> dict[str, Any]: ... + +if sys.version_info >= (3, 7): + def get_args(tp: Any) -> Tuple[Any, ...]: ... + def get_origin(tp: Any) -> Any | None: ... + +Annotated: _SpecialForm = ... +_AnnotatedAlias: Any = ... # undocumented + +@runtime_checkable +class SupportsIndex(Protocol, metaclass=abc.ABCMeta): + @abc.abstractmethod + def __index__(self) -> int: ... + +# PEP 612 support for Python < 3.9 +if sys.version_info >= (3, 10): + from typing import Concatenate as Concatenate, ParamSpec as ParamSpec, TypeAlias as TypeAlias, TypeGuard as TypeGuard +else: + class ParamSpecArgs: + __origin__: ParamSpec + def __init__(self, origin: ParamSpec) -> None: ... + class ParamSpecKwargs: + __origin__: ParamSpec + def __init__(self, origin: ParamSpec) -> None: ... + class ParamSpec: + __name__: str + __bound__: Type[Any] | None + __covariant__: bool + __contravariant__: bool + def __init__( + self, name: str, *, bound: None | Type[Any] | str = ..., contravariant: bool = ..., covariant: bool = ... + ) -> None: ... + @property + def args(self) -> ParamSpecArgs: ... + @property + def kwargs(self) -> ParamSpecKwargs: ... + Concatenate: _SpecialForm = ... + TypeAlias: _SpecialForm = ... + TypeGuard: _SpecialForm = ... diff --git a/lang/de/typeshed/stdlib/uarray.pyi b/lang/de/typeshed/stdlib/uarray.pyi new file mode 100644 index 0000000..d1ba4d9 --- /dev/null +++ b/lang/de/typeshed/stdlib/uarray.pyi @@ -0,0 +1 @@ +from array import * diff --git a/lang/de/typeshed/stdlib/ucollections.pyi b/lang/de/typeshed/stdlib/ucollections.pyi new file mode 100644 index 0000000..9400561 --- /dev/null +++ b/lang/de/typeshed/stdlib/ucollections.pyi @@ -0,0 +1 @@ +from collections import * diff --git a/lang/de/typeshed/stdlib/uerrno.pyi b/lang/de/typeshed/stdlib/uerrno.pyi new file mode 100644 index 0000000..5ecb44d --- /dev/null +++ b/lang/de/typeshed/stdlib/uerrno.pyi @@ -0,0 +1 @@ +from errno import * diff --git a/lang/de/typeshed/stdlib/urandom.pyi b/lang/de/typeshed/stdlib/urandom.pyi new file mode 100644 index 0000000..1c31bde --- /dev/null +++ b/lang/de/typeshed/stdlib/urandom.pyi @@ -0,0 +1 @@ +from random import * diff --git a/lang/de/typeshed/stdlib/ustruct.pyi b/lang/de/typeshed/stdlib/ustruct.pyi new file mode 100644 index 0000000..ee3a9fc --- /dev/null +++ b/lang/de/typeshed/stdlib/ustruct.pyi @@ -0,0 +1 @@ +from struct import * diff --git a/lang/de/typeshed/stdlib/usys.pyi b/lang/de/typeshed/stdlib/usys.pyi new file mode 100644 index 0000000..104052c --- /dev/null +++ b/lang/de/typeshed/stdlib/usys.pyi @@ -0,0 +1 @@ +from sys import * diff --git a/lang/de/typeshed/stdlib/utime.pyi b/lang/de/typeshed/stdlib/utime.pyi new file mode 100644 index 0000000..72705db --- /dev/null +++ b/lang/de/typeshed/stdlib/utime.pyi @@ -0,0 +1 @@ +from time import * diff --git a/lang/es-es/typeshed/stdlib/log.pyi b/lang/es-es/typeshed/stdlib/log.pyi index 985f9cc..826660c 100644 --- a/lang/es-es/typeshed/stdlib/log.pyi +++ b/lang/es-es/typeshed/stdlib/log.pyi @@ -27,8 +27,8 @@ present, it will generate a new header row with the additional columns. By default the first column contains a timestamp for each row. The time unit can be selected via the timestamp argument. -:param *labels: Any number of positional arguments, each corresponding to an entry in the log header. -:param timestamp: (marca de tiempo) Select the timestamp unit that will be automatically added as the first column in every row. Timestamp values can be one of ``log.MILLISECONDS``, ``log.SECONDS``, ``log.MINUTES``, ``log.HOURS``, ``log.DAYS`` or ``None`` to disable the timestamp. The default value is ``log.SECONDS``.""" +:param *labels: (*Etiquetas) Cualquier número de argumentos posicionales, cada uno correspondiente a una entrada en el encabezado del registro. +:param timestamp: (marca de tiempo) Seleccione la unidad de marca de tiempo que se añadirá automáticamente como la primera columna de cada fila. Los valores de la marca de tiempo pueden ser ``log.MILLISECONDS``, ``log.SECONDS``, ``log.MINUTES``, ``log.HOURS``, ``log.DAYS`` o ``None`` para desactivar la marca de tiempo. El valor por defecto es ``log.SECONDS``.""" ... @overload @@ -46,7 +46,7 @@ to the log with the extra labels. Labels previously specified and not present in a call to this function will be skipped with an empty value in the log row. -:param data_dictionary: The data to log as a dictionary with a key for each header.""" +:param data_dictionary: (diccionario de datos) Los datos a registrar como un diccionario con una clave para cada cabecera.""" ... @overload @@ -75,15 +75,15 @@ To add the log headers again the ``set_labels`` function should to be called aft There are two erase modes; “full” completely removes the data from the physical storage, and “fast” invalidates the data without removing it. -:param full: (completo) ``True`` selects a “full” erase and ``False`` selects the “fast” erase method.""" +:param full: (completo) ``True`` selecciona un borrador “completo” y ``False`` selecciona el método de borrado “rápido”.""" ... def set_mirroring(serial: bool): - """Configure mirroring of the data logging activity to the serial output. (configurar replicación) + """Configure la duplicación de la actividad de registro de datos en la salida en serie. (configurar replicación) Example: ``log.set_mirroring(True)`` Serial mirroring is disabled by default. When enabled, it will print to serial each row logged into the log file. -:param serial: (serie) ``True`` enables mirroring data to the serial output.""" +:param serial: (serie) ``True`` habilita la reproducción de datos en la salida de serie.""" ... \ No newline at end of file diff --git a/lang/es-es/typeshed/stdlib/microbit/__init__.pyi b/lang/es-es/typeshed/stdlib/microbit/__init__.pyi index 48dbb14..d0c8207 100644 --- a/lang/es-es/typeshed/stdlib/microbit/__init__.pyi +++ b/lang/es-es/typeshed/stdlib/microbit/__init__.pyi @@ -12,7 +12,7 @@ from . import spi as spi from . import uart as uart def run_every(callback: Optional[Callable[[], None]]=None, days: int=0, h: int=0, min: int=0, s: int=0, ms: int=0) -> Callable[[Callable[[], None]], Callable[[], None]]: - """Schedule to run a function at the interval specified by the time arguments **V2 only**. (ejecutar cada) + """Programe para ejecutar una función en el intervalo especificado por los argumentos de tiempo **V2 solamente**. (ejecutar cada) Example: ``run_every(my_logging, min=5)`` @@ -36,12 +36,12 @@ So ``run_every(min=1, s=30)`` schedules the callback every minute and a half. When an exception is thrown inside the callback function it deschedules the function. To avoid this you can catch exceptions with ``try/except``. -:param callback: Function to call at the provided interval. Omit when using as a decorator. -:param days: (días) Sets the day mark for the scheduling. -:param h: Sets the hour mark for the scheduling. -:param min: Sets the minute mark for the scheduling. -:param s: Sets the second mark for the scheduling. -:param ms: Sets the millisecond mark for the scheduling.""" +:param callback: Función para llamar al intervalo proporcionado. Omitir cuando se utiliza como decorador. +:param days: (días) Establece la marca del día para la programación. +:param h: Establece la marca de hora para la programación. +:param min: Establece la marca de minuto para la programación. +:param s: Establece la segunda marca para la programación. +:param ms: Establece la marca de milisegundos para la programación.""" def panic(n: int) -> None: """Entra en modo pánico (pánico) @@ -57,7 +57,7 @@ def reset() -> None: @overload def scale(value: float, from_: Tuple[float, float], to: Tuple[int, int]) -> int: - """Converts a value from a range to an integer range. + """Convierte un valor de un rango a un rango de números enteros. (escala) Example: ``volume = scale(accelerometer.get_x(), from_=(-2000, 2000), to=(0, 255))`` @@ -69,14 +69,14 @@ floating point number. temp_fahrenheit = scale(30, from_=(0.0, 100.0), to=(32.0, 212.0)) -:param value: (valor) A number to convert. -:param from_: A tuple to define the range to convert from. -:param to: A tuple to define the range to convert to. +:param value: (valor) Un número a convertir. +:param from_: (de) Una tupla para definir el rango desde el que convertir. +:param to: (a) Una tupla para definir el rango al que convertir. :return: The ``value`` converted to the ``to`` range.""" @overload def scale(value: float, from_: Tuple[float, float], to: Tuple[float, float]) -> float: - """Converts a value from a range to a floating point range. + """Convierte un valor de un rango a un rango de punto flotante. (escala) Example: ``temp_fahrenheit = scale(30, from_=(0.0, 100.0), to=(32.0, 212.0))`` @@ -89,9 +89,9 @@ If they are both integers (i.e ``10``), it will return an integer:: returns_int = scale(accelerometer.get_x(), from_=(-2000, 2000), to=(0, 255)) -:param value: (valor) A number to convert. -:param from_: A tuple to define the range to convert from. -:param to: A tuple to define the range to convert to. +:param value: (valor) Un número a convertir. +:param from_: (de) Una tupla para definir el rango desde el que convertir. +:param to: (a) Una tupla para definir el rango al que convertir. :return: The ``value`` converted to the ``to`` range.""" def sleep(n: float) -> None: @@ -460,7 +460,7 @@ Given an image object it's possible to display it via the ``display`` API:: SNAKE: Image """Imagen de una serpiente. (serpiente)""" SCISSORS: Image - """Scissors image.""" + """Imagen de tijeras. (tijeras)""" ALL_CLOCKS: List[Image] """Una lista que contiene todas las imágenes CLOCK_ en secuencia. (todos los relojes)""" ALL_ARROWS: List[Image] diff --git a/lang/es-es/typeshed/stdlib/microbit/accelerometer.pyi b/lang/es-es/typeshed/stdlib/microbit/accelerometer.pyi index fdc235b..6941721 100644 --- a/lang/es-es/typeshed/stdlib/microbit/accelerometer.pyi +++ b/lang/es-es/typeshed/stdlib/microbit/accelerometer.pyi @@ -34,7 +34,7 @@ Example: ``x, y, z = accelerometer.get_values()`` ... def get_strength() -> int: - """Get the acceleration measurement of all axes combined, as a positive integer. This is the Pythagorean sum of the X, Y and Z axes. + """Obtener la medición de aceleración de todos los ejes combinados, como un entero positivo. Esta es la suma de Pitagórica de los ejes X, Y y Z. (obtener fuerza) Example: ``accelerometer.get_strength()`` @@ -96,8 +96,8 @@ gestures can be detected using a loop with a small :func:`microbit.sleep` delay. ... def set_range(value: int) -> None: - """Set the accelerometer sensitivity range, in g (standard gravity), to the closest values supported by the hardware, so it rounds to either ``2``, ``4``, or ``8`` g. + """Establecer el rango de sensibilidad acelerómetro, en g (gravedad estándar), a los valores más cercanos soportados por el hardware, así que se redondea a ``2``, ``4``o ``8`` g. (establecer rango) Example: ``accelerometer.set_range(8)`` -:param value: (valor) New range for the accelerometer, an integer in ``g``.""" \ No newline at end of file +:param value: (valor) Nuevo rango para el acelerómetro, un entero en ``g``.""" \ No newline at end of file diff --git a/lang/es-es/typeshed/stdlib/microbit/audio.pyi b/lang/es-es/typeshed/stdlib/microbit/audio.pyi index 6eee826..7386050 100644 --- a/lang/es-es/typeshed/stdlib/microbit/audio.pyi +++ b/lang/es-es/typeshed/stdlib/microbit/audio.pyi @@ -3,11 +3,11 @@ from ..microbit import MicroBitDigitalPin, Sound, pin0 from typing import ClassVar, Iterable, Union def play(source: Union[Iterable[AudioFrame], Sound, SoundEffect], wait: bool=True, pin: MicroBitDigitalPin=pin0, return_pin: Union[MicroBitDigitalPin, None]=None) -> None: - """Play a built-in sound, sound effect or custom audio frames. (reproducir) + """Reproducir un sonido, un efecto de sonido o marcos de audio personalizados. (reproducir) Example: ``audio.play(Sound.GIGGLE)`` -:param source: (origen) A built-in ``Sound`` such as ``Sound.GIGGLE``, a ``SoundEffect`` or sample data as an iterable of ``AudioFrame`` objects. +:param source: (origen) Un ``Sound`` integrado como ``Sound.GIGGLE``, un ``SoundEffect`` o datos de muestra como un iterable de objetos ``AudioFrame``. :param wait: (esperar) Si ``wait`` es ``True`` (verdadero), la función se bloqueará hasta que el sonido finalice. :param pin: Se puede usar un argumento opcional para especificar el pin de salida, reemplazando el valor predeterminado de ``pin0``. Si no queremos que se reproduzca ningún sonido, podemos usar ``pin=None``. :param return_pin: (devolver pin) Especifica un pin de conector de borde diferencial para conectarse a un altavoz externo en lugar de tierra. Esto se ignora para la revisión **V2**.""" @@ -27,50 +27,50 @@ Example: ``audio.stop()``""" ... class SoundEffect: - """A sound effect, composed by a set of parameters configured via the constructor or attributes.""" + """Un efecto de sonido, compuesto por un conjunto de parámetros configurados a través del constructor o atributos. (efecto de sonido)""" WAVEFORM_SINE: ClassVar[int] - """Sine wave option used for the ``waveform`` parameter.""" + """Opción de onda sinusoidal utilizada para el parámetro ``waveform``. (forma de onda sinusoidal)""" WAVEFORM_SAWTOOTH: ClassVar[int] - """Sawtooth wave option used for the ``waveform`` parameter.""" + """Opción de onda con diente de sierra usada para el parámetro ``waveform``. (diente de sierra de forma de onda)""" WAVEFORM_TRIANGLE: ClassVar[int] - """Triangle wave option used for the ``waveform`` parameter.""" + """Opción de onda triangular usada para el parámetro ``waveform``. (forma de onda triangular)""" WAVEFORM_SQUARE: ClassVar[int] - """Square wave option used for the ``waveform`` parameter.""" + """Opción de onda cuadrada usada para el parámetro ``waveform``. (forma de onda cuadrada)""" WAVEFORM_NOISE: ClassVar[int] - """Noise option used for the ``waveform`` parameter.""" + """Opción de ruido usada para el parámetro ``waveform``. (forma de onda de ruido)""" SHAPE_LINEAR: ClassVar[int] - """Linear interpolation option used for the ``shape`` parameter.""" + """Opción de interpolación lineal usada para el parámetro ``shape``. (forma lineal)""" SHAPE_CURVE: ClassVar[int] - """Curve interpolation option used for the ``shape`` parameter.""" + """Opción de interpolación de curva usada para el parámetro ``shape``. (forma curva)""" SHAPE_LOG: ClassVar[int] - """Logarithmic interpolation option used for the ``shape`` parameter.""" + """Opción de interpolación logarítmica usada para el parámetro ``shape``. (registro de forma)""" FX_NONE: ClassVar[int] - """No effect option used for the ``fx`` parameter.""" + """Ninguna opción de efecto usada para el parámetro ``fx``. (fx ninguno)""" FX_TREMOLO: ClassVar[int] - """Tremolo effect option used for the ``fx`` parameter.""" + """Opción de efecto Trémolo usada para el parámetro ``fx``.""" FX_VIBRATO: ClassVar[int] - """Vibrato effect option used for the ``fx`` parameter.""" + """Opción de efecto vibrato utilizada para el parámetro ``fx``.""" FX_WARBLE: ClassVar[int] - """Warble effect option used for the ``fx`` parameter.""" + """Opción de efecto gorjeo utilizada para el parámetro ``fx``. (fx gorjeo)""" freq_start: int - """Start frequency in Hertz (Hz), a number between ``0`` and ``9999``""" + """Frecuencia de inicio en Hertz (Hz), un número entre ``0`` y ``9999`` (frecuencia de inicio)""" freq_end: int - """End frequency in Hertz (Hz), a number between ``0`` and ``9999``""" + """Frecuencia final en Hertz (Hz), un número entre ``0`` y ``9999`` (frecuencia final)""" duration: int - """Duration of the sound in milliseconds, a number between ``0`` and ``9999`` (duración)""" + """Duración del sonido en milisegundos, un número entre ``0`` y ``9999`` (duración)""" vol_start: int - """Start volume value, a number between ``0`` and ``255``""" + """Valor de volumen inicial, un número entre ``0`` y ``255`` (volumen de inicio)""" vol_end: int - """End volume value, a number between ``0`` and ``255``""" + """Valor final del volumen, un número entre ``0`` y ``255`` (volumen final)""" waveform: int - """Type of waveform shape, one of these values: ``WAVEFORM_SINE``, ``WAVEFORM_SAWTOOTH``, ``WAVEFORM_TRIANGLE``, ``WAVEFORM_SQUARE``, ``WAVEFORM_NOISE`` (randomly generated noise)""" + """Tipo de forma ondulada, uno de estos valores: ``WAVEFORM_SINE``, ``WAVEFORM_SAWTOOTH``, ``WAVEFORM_TRIANGLE``, ``WAVEFORM_SQUARE``, ``WAVEFORM_NOISE`` (ruido generado aleatoriamente) (forma de onda)""" fx: int - """Effect to add on the sound, one of the following values: ``FX_TREMOLO``, ``FX_VIBRATO``, ``FX_WARBLE``, or ``FX_NONE``""" + """Efecto para añadir en el sonido, uno de los siguientes valores: ``FX_TREMOLO``, ``FX_VIBRATO``, ``FX_WARBLE``o ``FX_NONE``""" shape: int - """The type of the interpolation curve between the start and end frequencies, different wave shapes have different rates of change in frequency. One of the following values: ``SHAPE_LINEAR``, ``SHAPE_CURVE``, ``SHAPE_LOG``""" + """El tipo de curva de interpolación entre las frecuencias de inicio y final, diferentes formas de onda tienen diferentes tasas de cambio en la frecuencia. Uno de los siguientes valores: ``SHAPE_LINEAR``, ``SHAPE_CURVE``, ``SHAPE_LOG`` (forma)""" def __init__(self, freq_start: int=500, freq_end: int=2500, duration: int=500, vol_start: int=255, vol_end: int=0, waveform: int=WAVEFORM_SQUARE, fx: int=FX_NONE, shape: int=SHAPE_LOG): - """Create a new sound effect. + """Crear un nuevo efecto de sonido. Example: ``my_effect = SoundEffect(duration=1000)`` @@ -79,17 +79,17 @@ they can all be modified via attributes of the same name. For example, we can first create an effect ``my_effect = SoundEffect(duration=1000)``, and then change its attributes ``my_effect.duration = 500``. -:param freq_start: Start frequency in Hertz (Hz), a number between ``0`` and ``9999``. -:param freq_end: End frequency in Hertz (Hz), a number between ``0`` and ``9999``. -:param duration: (duración) Duration of the sound in milliseconds, a number between ``0`` and ``9999``. -:param vol_start: Start volume value, a number between ``0`` and ``255``. -:param vol_end: End volume value, a number between ``0`` and ``255``. -:param waveform: Type of waveform shape, one of these values: ``WAVEFORM_SINE``, ``WAVEFORM_SAWTOOTH``, ``WAVEFORM_TRIANGLE``, ``WAVEFORM_SQUARE``, ``WAVEFORM_NOISE`` (randomly generated noise). -:param fx: Effect to add on the sound, one of the following values: ``FX_TREMOLO``, ``FX_VIBRATO``, ``FX_WARBLE``, or ``FX_NONE``. -:param shape: The type of the interpolation curve between the start and end frequencies, different wave shapes have different rates of change in frequency. One of the following values: ``SHAPE_LINEAR``, ``SHAPE_CURVE``, ``SHAPE_LOG``.""" +:param freq_start: (frecuencia de inicio) Frecuencia de inicio en Hertz (Hz), un número entre ``0`` y ``9999``. +:param freq_end: (frecuencia final) Frecuencia final en Hertz (Hz), un número entre ``0`` y ``9999``. +:param duration: (duración) Duración del sonido en milisegundos, un número entre ``0`` y ``9999``. +:param vol_start: (volumen inicial) Valor de volumen inicial, un número entre ``0`` y ``255``. +:param vol_end: (volumen final) Valor de volumen final, un número entre ``0`` y ``255``. +:param waveform: (forma de onda) Tipo de forma de onda, uno de estos valores: ``WAVEFORM_SINE``, ``WAVEFORM_SAWTOOTH``, ``WAVEFORM_TRIANGLE``, ``WAVEFORM_SQUARE``, ``WAVEFORM_NOISE`` (ruido generado aleatoriamente). +:param fx: Efecto para añadir en el sonido, uno de los siguientes valores: ``FX_TREMOLO``, ``FX_VIBRATO``, ``FX_WARBLE``o ``FX_NONE``. +:param shape: (forma) El tipo de curva de interpolación entre las frecuencias de inicio y final, diferentes formas de onda tienen diferentes tasas de cambio en la frecuencia. Uno de los siguientes valores: ``SHAPE_LINEAR``, ``SHAPE_CURVE``, ``SHAPE_LOG``.""" def copy(self) -> SoundEffect: - """Create a copy of this ``SoundEffect``. (copiar) + """Crear una copia de este ``SoundEffect``. (copiar) Example: ``sound_2 = sound_1.copy()`` @@ -108,11 +108,11 @@ Example:: frame[i] = 252 - i * 8""" def copyfrom(self, other: AudioFrame) -> None: - """Overwrite the data in this ``AudioFrame`` with the data from another ``AudioFrame`` instance. + """Sobrescribir los datos en este ``AudioFrame`` con los datos de otra instancia de ``AudioFrame``. (copiar forma) Example: ``my_frame.copyfrom(source_frame)`` -:param other: (otro) ``AudioFrame`` instance from which to copy the data.""" +:param other: (otro) Instancia ``AudioFrame`` desde la que copiar los datos.""" def __len__(self) -> int: ... diff --git a/lang/ja/typeshed/stdlib/microbit/__init__.pyi b/lang/ja/typeshed/stdlib/microbit/__init__.pyi index fe85638..06c42bb 100644 --- a/lang/ja/typeshed/stdlib/microbit/__init__.pyi +++ b/lang/ja/typeshed/stdlib/microbit/__init__.pyi @@ -40,8 +40,8 @@ function. To avoid this you can catch exceptions with ``try/except``. :param days: スケジューリングのための日数を設定します。 :param h: スケジューリングのための時間を設定します。 :param min: スケジューリングのための分を設定します。 -:param s: スケジューリングのためのミリ秒を設定します。 -:param ms: スケジューリングのための秒を設定します。""" +:param s: スケジューリングのための秒を設定します。 +:param ms: スケジューリングのためのミリ秒を設定します。""" def panic(n: int) -> None: """パニックモードに入ります。 @@ -461,9 +461,9 @@ Given an image object it's possible to display it via the ``display`` API:: SCISSORS: Image """「はさみ」イメージ。""" ALL_CLOCKS: List[Image] - """すべての CLOCK_ イメージを順番に並べたリスト。""" + """すべての時計イメージを順番に並べたリスト。""" ALL_ARROWS: List[Image] - """すべての ARROW_ イメージを順番に並べたリスト。""" + """すべての矢印イメージを順番に並べたリスト。""" @overload def __init__(self, string: str) -> None: diff --git a/lang/ja/typeshed/stdlib/microbit/audio.pyi b/lang/ja/typeshed/stdlib/microbit/audio.pyi index b3df246..309077d 100644 --- a/lang/ja/typeshed/stdlib/microbit/audio.pyi +++ b/lang/ja/typeshed/stdlib/microbit/audio.pyi @@ -36,7 +36,7 @@ class SoundEffect: WAVEFORM_TRIANGLE: ClassVar[int] """``waveform`` パラメータに指定できる「三角波」オプション。""" WAVEFORM_SQUARE: ClassVar[int] - """``waveform`` パラメータに指定できる「方形波」オプション。""" + """``waveform`` パラメータに指定できる「矩形波」オプション。""" WAVEFORM_NOISE: ClassVar[int] """``waveform`` パラメータに指定できる「ノイズ」オプション。""" SHAPE_LINEAR: ClassVar[int] @@ -52,7 +52,7 @@ class SoundEffect: FX_VIBRATO: ClassVar[int] """``fx`` パラメータに指定できる「ビブラート効果」オプション。""" FX_WARBLE: ClassVar[int] - """``fx`` パラメータに指定できる「さえずり効果」オプション。""" + """``fx`` パラメータに指定できる「ワブル効果」オプション。""" freq_start: int """開始周波数。単位はヘルツ(Hz)で、``0``から``9999``の範囲の数値です。""" freq_end: int diff --git a/scripts/build-translations.sh b/scripts/build-translations.sh index 70b4597..d2a4b93 100755 --- a/scripts/build-translations.sh +++ b/scripts/build-translations.sh @@ -5,7 +5,7 @@ set -euxo pipefail -languages="ca fr es-ES ja ko nl zh-CN zh-TW" +languages="ca de fr es-ES ja ko nl zh-CN zh-TW" for language in $languages; do lower="${language,,}"