From 192ed02b78a32db8c0c711f632a4c503b3b93fa2 Mon Sep 17 00:00:00 2001 From: Matt Hillsdon Date: Mon, 9 Jun 2025 17:35:54 +0100 Subject: [PATCH 1/2] ga-IE translation --- crowdin/translated/api.ga-ie.json | 5266 +++++++++++++++++ lang/ga-ie/typeshed/stdlib/VERSIONS | 50 + .../typeshed/stdlib/_typeshed/__init__.pyi | 168 + lang/ga-ie/typeshed/stdlib/abc.pyi | 28 + lang/ga-ie/typeshed/stdlib/antigravity.pyi | 0 lang/ga-ie/typeshed/stdlib/array.pyi | 42 + lang/ga-ie/typeshed/stdlib/audio.pyi | 11 + lang/ga-ie/typeshed/stdlib/builtins.pyi | 1334 +++++ .../typeshed/stdlib/collections/__init__.pyi | 60 + lang/ga-ie/typeshed/stdlib/errno.pyi | 26 + lang/ga-ie/typeshed/stdlib/gc.pyi | 68 + lang/ga-ie/typeshed/stdlib/log.pyi | 89 + lang/ga-ie/typeshed/stdlib/love.pyi | 1 + lang/ga-ie/typeshed/stdlib/machine.pyi | 84 + lang/ga-ie/typeshed/stdlib/math.pyi | 246 + .../typeshed/stdlib/microbit/__init__.pyi | 712 +++ .../stdlib/microbit/accelerometer.pyi | 103 + lang/ga-ie/typeshed/stdlib/microbit/audio.pyi | 124 + .../typeshed/stdlib/microbit/compass.pyi | 70 + .../typeshed/stdlib/microbit/display.pyi | 92 + lang/ga-ie/typeshed/stdlib/microbit/i2c.pyi | 49 + .../typeshed/stdlib/microbit/microphone.pyi | 62 + .../typeshed/stdlib/microbit/speaker.pyi | 15 + lang/ga-ie/typeshed/stdlib/microbit/spi.pyi | 47 + lang/ga-ie/typeshed/stdlib/microbit/uart.pyi | 79 + lang/ga-ie/typeshed/stdlib/micropython.pyi | 133 + lang/ga-ie/typeshed/stdlib/music.pyi | 128 + lang/ga-ie/typeshed/stdlib/neopixel.pyi | 81 + lang/ga-ie/typeshed/stdlib/os.pyi | 63 + lang/ga-ie/typeshed/stdlib/power.pyi | 53 + lang/ga-ie/typeshed/stdlib/radio.pyi | 130 + lang/ga-ie/typeshed/stdlib/random.pyi | 81 + lang/ga-ie/typeshed/stdlib/speech.pyi | 79 + lang/ga-ie/typeshed/stdlib/struct.pyi | 56 + lang/ga-ie/typeshed/stdlib/sys.pyi | 96 + lang/ga-ie/typeshed/stdlib/this.pyi | 1 + lang/ga-ie/typeshed/stdlib/time.pyi | 116 + lang/ga-ie/typeshed/stdlib/types.pyi | 413 ++ lang/ga-ie/typeshed/stdlib/typing.pyi | 716 +++ .../typeshed/stdlib/typing_extensions.pyi | 115 + lang/ga-ie/typeshed/stdlib/uarray.pyi | 1 + lang/ga-ie/typeshed/stdlib/ucollections.pyi | 1 + lang/ga-ie/typeshed/stdlib/uerrno.pyi | 1 + lang/ga-ie/typeshed/stdlib/urandom.pyi | 1 + lang/ga-ie/typeshed/stdlib/ustruct.pyi | 1 + lang/ga-ie/typeshed/stdlib/usys.pyi | 1 + lang/ga-ie/typeshed/stdlib/utime.pyi | 1 + scripts/build-translations.sh | 2 +- 48 files changed, 11095 insertions(+), 1 deletion(-) create mode 100644 crowdin/translated/api.ga-ie.json create mode 100644 lang/ga-ie/typeshed/stdlib/VERSIONS create mode 100644 lang/ga-ie/typeshed/stdlib/_typeshed/__init__.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/abc.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/antigravity.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/array.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/audio.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/builtins.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/collections/__init__.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/errno.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/gc.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/log.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/love.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/machine.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/math.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/microbit/__init__.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/microbit/accelerometer.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/microbit/audio.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/microbit/compass.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/microbit/display.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/microbit/i2c.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/microbit/microphone.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/microbit/speaker.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/microbit/spi.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/microbit/uart.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/micropython.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/music.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/neopixel.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/os.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/power.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/radio.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/random.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/speech.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/struct.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/sys.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/this.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/time.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/types.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/typing.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/typing_extensions.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/uarray.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/ucollections.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/uerrno.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/urandom.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/ustruct.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/usys.pyi create mode 100644 lang/ga-ie/typeshed/stdlib/utime.pyi diff --git a/crowdin/translated/api.ga-ie.json b/crowdin/translated/api.ga-ie.json new file mode 100644 index 0000000..1732425 --- /dev/null +++ b/crowdin/translated/api.ga-ie.json @@ -0,0 +1,5266 @@ +{ + "gc": { + "message": "gc", + "description": "(module name) Control the garbage collector" + }, + "gc.summary": { + "message": "Rialú ar an bailitheoir truflais", + "description": "Control the garbage collector" + }, + "gc.enable": { + "message": "chumasú", + "description": "(function name) Enable automatic garbage collection." + }, + "gc.enable.summary": { + "message": "Cumasaigh bailiú truflais uathoibríoch.", + "description": "Enable automatic garbage collection." + }, + "gc.disable": { + "message": "dhíchumasú", + "description": "(function name) Disable automatic garbage collection." + }, + "gc.disable.summary": { + "message": "Díchumasaigh bailiú truflais uathoibríoch.", + "description": "Disable automatic garbage collection." + }, + "gc.collect": { + "message": "bhailiú", + "description": "(function name) Run a garbage collection." + }, + "gc.collect.summary": { + "message": "Rith bailiúchán truflais.", + "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": "Faigh líon na mbeart de RAM carn atá leithdháilte.", + "description": "Get the number of bytes of heap RAM that are allocated." + }, + "gc.mem_free": { + "message": "cuimhne saor", + "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": "Faigh líon na mbeart de RAM gcarn atá ar fáil, nó -1 mura bhfuil an méid seo ar eolas.", + "description": "Get the number of bytes of available heap RAM, or -1 if this amount is not known." + }, + "gc.threshold-1": { + "message": "tairseach", + "description": "(function name) Query the additional GC allocation threshold." + }, + "gc.threshold-1.summary": { + "message": "Ceistigh an tairseach leithdháilte GC bhreise.", + "description": "Query the additional GC allocation threshold." + }, + "gc.threshold-2": { + "message": "tairseach", + "description": "(function name) Set the additional GC allocation threshold." + }, + "gc.threshold-2.summary": { + "message": "Socraigh an tairseach leithdháilte GC breise.", + "description": "Set the additional GC allocation threshold." + }, + "gc.threshold-2.param-name.amount": { + "message": "méid", + "description": "(parameter name) The number of bytes after which a garbage collection should be triggered." + }, + "gc.threshold-2.param-doc.amount": { + "message": "Líon na mbeart ina dhiaidh sin ba cheart bailiúchán truflais a spreagadh.", + "description": "Parameter docs" + }, + "log": { + "message": "loga", + "description": "(module name) Log data to your micro:bit V2." + }, + "log.summary": { + "message": "Logáil sonraí chuig do micro:bit V2.", + "description": "Log data to your micro:bit V2." + }, + "log.MILLISECONDS": { + "message": "milleasoicindí", + "description": "(field name) Milliseconds timestamp format." + }, + "log.MILLISECONDS.summary": { + "message": "Formáid stampa ama milleasoicindí.", + "description": "Milliseconds timestamp format." + }, + "log.SECONDS": { + "message": "soicindí", + "description": "(field name) Seconds timestamp format." + }, + "log.SECONDS.summary": { + "message": "Formáid stampa ama soicindí.", + "description": "Seconds timestamp format." + }, + "log.MINUTES": { + "message": "nóiméad", + "description": "(field name) Minutes timestamp format." + }, + "log.MINUTES.summary": { + "message": "Formáid stampa ama nóiméad.", + "description": "Minutes timestamp format." + }, + "log.HOURS": { + "message": "uair an chloig", + "description": "(field name) Hours timestamp format." + }, + "log.HOURS.summary": { + "message": "Formáid stampa ama uaireanta.", + "description": "Hours timestamp format." + }, + "log.DAYS": { + "message": "laethanta", + "description": "(field name) Days timestamp format." + }, + "log.DAYS.summary": { + "message": "Formáid stampa ama na laethanta.", + "description": "Days timestamp format." + }, + "log.set_labels": { + "message": "lipéid a shocrú", + "description": "(function name) Set up the log file header." + }, + "log.set_labels.summary": { + "message": "Socraigh ceanntásc an chomhaid logála.", + "description": "Set up the log file header." + }, + "log.set_labels.param-name.*labels": { + "message": "*lipéid", + "description": "(parameter name) Any number of positional arguments, each corresponding to an entry in the log header." + }, + "log.set_labels.param-doc.*labels": { + "message": "Aon líon argóintí suímh, gach ceann ag freagairt d'iontráil sa cheanntásc loga.", + "description": "Parameter docs" + }, + "log.set_labels.param-name.timestamp": { + "message": "stampa ama", + "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": "Roghnaigh an t-aonad stampa ama a chuirfear leis go huathoibríoch mar an chéad cholún i ngach ró. Is féidir le luachanna stampa ama a bheith mar cheann de {{log.MILLISECONDS}}, {{log.SECONDS}}, {{log.MINUTES}}, {{log.HOURS}}, {{log.DAYS}} nó {{None}} chun an stampa ama a dhíchumasú. Is é {{log.SECONDS}} an luach réamhshocraithe.", + "description": "Parameter docs" + }, + "log.add-1": { + "message": "cuir leis", + "description": "(function name) Add a data row to the log by passing a dictionary of headers and values." + }, + "log.add-1.summary": { + "message": "Cuir ró sonraí leis an loga trí fhoclóir ceanntásca agus luachanna a rith.", + "description": "Add a data row to the log by passing a dictionary of headers and values." + }, + "log.add-1.param-name.data_dictionary": { + "message": "foclóir sonraí", + "description": "(parameter name) The data to log as a dictionary with a key for each header." + }, + "log.add-1.param-doc.data_dictionary": { + "message": "Na sonraí le logáil mar fhoclóir le heochair do gach ceanntásc.", + "description": "Parameter docs" + }, + "log.add-2": { + "message": "suimigh", + "description": "(function name) Add a data row to the log using keyword arguments." + }, + "log.add-2.summary": { + "message": "Cuir ró sonraí leis an logáil ag baint úsáide as argóintí eochairfhocail.", + "description": "Add a data row to the log using keyword arguments." + }, + "log.delete": { + "message": "scrios", + "description": "(function name) Deletes the contents of the log, including headers." + }, + "log.delete.summary": { + "message": "Scrios inneachar an loga, lena n-áirítear ceanntásca.", + "description": "Deletes the contents of the log, including headers." + }, + "log.delete.param-name.full": { + "message": "iomlán", + "description": "(parameter name) ``True`` selects a “full” erase and ``False`` selects the “fast” erase method." + }, + "log.delete.param-doc.full": { + "message": "Roghnaíonn {{True}} scriosadh “lán” agus roghnaíonn {{False}} an modh scriosta “tapa”.", + "description": "Parameter docs" + }, + "log.set_mirroring": { + "message": "scáthánú socraithe", + "description": "(function name) Configure mirroring of the data logging activity to the serial output." + }, + "log.set_mirroring.summary": { + "message": "Cumraigh scáthánú na gníomhaíochta logála sonraí chuig an aschur sraitheach.", + "description": "Configure mirroring of the data logging activity to the serial output." + }, + "log.set_mirroring.param-name.serial": { + "message": "sraitheach", + "description": "(parameter name) ``True`` enables mirroring data to the serial output." + }, + "log.set_mirroring.param-doc.serial": { + "message": "Cumasaíonn {{True}} sonraí a scáthánú leis an aschur sraitheach.", + "description": "Parameter docs" + }, + "machine": { + "message": "meaisín", + "description": "(module name) Low-level utilities." + }, + "machine.summary": { + "message": "Fóntais leibhéal íseal.", + "description": "Low-level utilities." + }, + "machine.unique_id": { + "message": "id uathúil", + "description": "(function name) Get a byte string with a unique identifier of a board." + }, + "machine.unique_id.summary": { + "message": "Faigh beart teaghrán le haitheantóir uathúil cláir.", + "description": "Get a byte string with a unique identifier of a board." + }, + "machine.reset": { + "message": "athshocrú", + "description": "(function name) Reset the device in a manner similar to pushing the external RESET button." + }, + "machine.reset.summary": { + "message": "Athshocraigh an gléas ar bhealach cosúil le brúigh an cnaipe ATHSHOCRAITHE seachtrach.", + "description": "Reset the device in a manner similar to pushing the external RESET button." + }, + "machine.freq": { + "message": "minicíocht", + "description": "(function name) Get the CPU frequency in hertz." + }, + "machine.freq.summary": { + "message": "Faigh an minicíocht LAP i hertz.", + "description": "Get the CPU frequency in hertz." + }, + "machine.disable_irq": { + "message": "díchumasaigh irq", + "description": "(function name) Disable interrupt requests." + }, + "machine.disable_irq.summary": { + "message": "Díchumasaigh iarratais idirbhriste.", + "description": "Disable interrupt requests." + }, + "machine.enable_irq": { + "message": "cumasaigh irq", + "description": "(function name) Re-enable interrupt requests." + }, + "machine.enable_irq.summary": { + "message": "Athchumasaigh iarratais idirbhriste.", + "description": "Re-enable interrupt requests." + }, + "machine.enable_irq.param-name.state": { + "message": "stát", + "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": "An luach a cuireadh ar ais ón nglao is déanaí chuig an bhfeidhm {{disable_irq}}.", + "description": "Parameter docs" + }, + "machine.time_pulse_us": { + "message": "cuisle ama us", + "description": "(function name) Time a pulse on a pin." + }, + "machine.time_pulse_us.summary": { + "message": "Am buille ar bhioráin.", + "description": "Time a pulse on a pin." + }, + "machine.time_pulse_us.param-name.pin": { + "message": "bioráin", + "description": "(parameter name) The pin to use" + }, + "machine.time_pulse_us.param-doc.pin": { + "message": "An biorán le húsáid", + "description": "Parameter docs" + }, + "machine.time_pulse_us.param-name.pulse_level": { + "message": "leibhéal cuisle", + "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 go ham cuisle íseal nó 1 go ham cuisle ard", + "description": "Parameter docs" + }, + "machine.time_pulse_us.param-name.timeout_us": { + "message": "am istigh linn", + "description": "(parameter name) A microsecond timeout" + }, + "machine.time_pulse_us.param-doc.timeout_us": { + "message": "Teorainn ama micrea soicind", + "description": "Parameter docs" + }, + "machine.mem": { + "message": "cuimhne", + "description": "(class name) The class for the ``mem8``, ``mem16`` and ``mem32`` memory views." + }, + "machine.mem.summary": { + "message": "An rang le haghaidh radharcanna cuimhne {{mem8}}, {{mem16}} agus {{mem32}}.", + "description": "The class for the ``mem8``, ``mem16`` and ``mem32`` memory views." + }, + "machine.mem.__getitem__": { + "message": "faigh-mír", + "description": "(function name) Access a value from memory." + }, + "machine.mem.__getitem__.summary": { + "message": "Faigh luach ó chuimhne.", + "description": "Access a value from memory." + }, + "machine.mem.__getitem__.param-name.address": { + "message": "seoladh", + "description": "(parameter name) The memory address." + }, + "machine.mem.__getitem__.param-doc.address": { + "message": "An seoladh cuimhne.", + "description": "Parameter docs" + }, + "machine.mem.__setitem__": { + "message": "socraigh-mír", + "description": "(function name) Set a value at the given address." + }, + "machine.mem.__setitem__.summary": { + "message": "Socraigh luach ag an seoladh a thugtar.", + "description": "Set a value at the given address." + }, + "machine.mem.__setitem__.param-name.address": { + "message": "seoladh", + "description": "(parameter name) The memory address." + }, + "machine.mem.__setitem__.param-doc.address": { + "message": "An seoladh cuimhne.", + "description": "Parameter docs" + }, + "machine.mem.__setitem__.param-name.value": { + "message": "luach", + "description": "(parameter name) The integer value to set." + }, + "machine.mem.__setitem__.param-doc.value": { + "message": "An luach slánuimhir a shocrú.", + "description": "Parameter docs" + }, + "machine.mem8": { + "message": "cuimhne8", + "description": "(field name) 8-bit (byte) view of memory." + }, + "machine.mem8.summary": { + "message": "Amharc 8-giotán (beart) ar chuimhne.", + "description": "8-bit (byte) view of memory." + }, + "machine.mem16": { + "message": "cuimhne16", + "description": "(field name) 16-bit view of memory." + }, + "machine.mem16.summary": { + "message": "Radharc 16-giotán ar chuimhne.", + "description": "16-bit view of memory." + }, + "machine.mem32": { + "message": "cuimhne32", + "description": "(field name) 32-bit view of memory." + }, + "machine.mem32.summary": { + "message": "Amharc 32-giotán ar chuimhne.", + "description": "32-bit view of memory." + }, + "math": { + "message": "mata", + "description": "(module name) Mathematical functions." + }, + "math.summary": { + "message": "Feidhmeanna matamaiticiúla.", + "description": "Mathematical functions." + }, + "math.acos": { + "message": "acos", + "description": "(function name) Calculate the inverse cosine." + }, + "math.acos.summary": { + "message": "Ríomh an cosine inbhéartach.", + "description": "Calculate the inverse cosine." + }, + "math.acos.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.acos.param-doc.x": { + "message": "Uimhir", + "description": "Parameter docs" + }, + "math.asin": { + "message": "asin", + "description": "(function name) Calculate the inverse sine." + }, + "math.asin.summary": { + "message": "Ríomh an sine inbhéartach.", + "description": "Calculate the inverse sine." + }, + "math.asin.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.asin.param-doc.x": { + "message": "Uimhir", + "description": "Parameter docs" + }, + "math.atan": { + "message": "atan", + "description": "(function name) Calculate the inverse tangent." + }, + "math.atan.summary": { + "message": "Ríomh an tadhlaí inbhéartach.", + "description": "Calculate the inverse tangent." + }, + "math.atan.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.atan.param-doc.x": { + "message": "Uimhir", + "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": "Ríomh príomhluach an tadhlaí inbhéartach de {{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": "Uimhir", + "description": "Parameter docs" + }, + "math.atan2.param-name.y": { + "message": "y", + "description": "(parameter name) A number" + }, + "math.atan2.param-doc.y": { + "message": "Uimhir", + "description": "Parameter docs" + }, + "math.ceil": { + "message": "síleáil", + "description": "(function name) Round a number towards positive infinity." + }, + "math.ceil.summary": { + "message": "Déan roinnt a shlánú i dtreo éigríochta dearfach.", + "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": "Uimhir", + "description": "Parameter docs" + }, + "math.copysign": { + "message": "cóipchomhartha", + "description": "(function name) Calculate ``x`` with the sign of ``y``." + }, + "math.copysign.summary": { + "message": "Ríomh {{x}} le comhartha {{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": "Uimhir", + "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": "Foinse an chomhartha don luach fillte", + "description": "Parameter docs" + }, + "math.cos": { + "message": "cos", + "description": "(function name) Calculate the cosine of ``x``." + }, + "math.cos.summary": { + "message": "Ríomh an comhshíneas de {{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": "Uimhir", + "description": "Parameter docs" + }, + "math.degrees": { + "message": "céimeanna", + "description": "(function name) Convert radians to degrees." + }, + "math.degrees.summary": { + "message": "Raidian Tiontaigh go céimeanna.", + "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": "Luach i radaíní", + "description": "Parameter docs" + }, + "math.exp": { + "message": "exp", + "description": "(function name) Calculate the exponential of ``x``." + }, + "math.exp.summary": { + "message": "Ríomh easpónantúil {{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": "Uimhir", + "description": "Parameter docs" + }, + "math.fabs": { + "message": "fabs", + "description": "(function name) Return the absolute value of ``x``." + }, + "math.fabs.summary": { + "message": "Tabhair luach absalóideach {{x}}ar ais.", + "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": "Uimhir", + "description": "Parameter docs" + }, + "math.floor": { + "message": "urlár", + "description": "(function name) Round a number towards negative infinity." + }, + "math.floor.summary": { + "message": "Babhtaigh uimhir i dtreo éigríoch diúltach.", + "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": "Uimhir", + "description": "Parameter docs" + }, + "math.fmod": { + "message": "fmod", + "description": "(function name) Calculate the remainder of ``x/y``." + }, + "math.fmod.summary": { + "message": "Ríomh an chuid eile de {{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": "An t-uimhreoir", + "description": "Parameter docs" + }, + "math.fmod.param-name.y": { + "message": "y", + "description": "(parameter name) The denominator" + }, + "math.fmod.param-doc.y": { + "message": "An t-ainmneoir", + "description": "Parameter docs" + }, + "math.frexp": { + "message": "frexp", + "description": "(function name) Decomposes a floating-point number into its mantissa and exponent." + }, + "math.frexp.summary": { + "message": "Díscaoileann sé uimhir snámhphointe isteach ina mantissa agus ina easpónant.", + "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": "Uimhir snámhphointe", + "description": "Parameter docs" + }, + "math.isfinite": { + "message": "isfinideach", + "description": "(function name) Check if a value is finite." + }, + "math.isfinite.summary": { + "message": "Seiceáil an bhfuil luach críochta.", + "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": "Uimhir.", + "description": "Parameter docs" + }, + "math.isinf": { + "message": "isinf", + "description": "(function name) Check if a value is infinite." + }, + "math.isinf.summary": { + "message": "Seiceáil an bhfuil luach gan teorainn.", + "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": "Uimhir", + "description": "Parameter docs" + }, + "math.isnan": { + "message": "isnan", + "description": "(function name) Check if a value is not-a-number (NaN)." + }, + "math.isnan.summary": { + "message": "Seiceáil an luach nach uimhir é (NaN).", + "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": "Uimhir", + "description": "Parameter docs" + }, + "math.ldexp": { + "message": "ldexp", + "description": "(function name) Calculate ``x * (2**exp)``." + }, + "math.ldexp.summary": { + "message": "Ríomh {{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": "Easpónant slánuimhir", + "description": "Parameter docs" + }, + "math.ldexp.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.ldexp.param-doc.x": { + "message": "Uimhir", + "description": "Parameter docs" + }, + "math.log": { + "message": "loga", + "description": "(function name) Calculate the logarithm of ``x`` to the given base (defaults to natural logorithm)." + }, + "math.log.summary": { + "message": "Ríomh logarithm {{x}} go dtí an bonn tugtha (réamhshocraithe don logarithm nádúrtha).", + "description": "Calculate the logarithm of ``x`` to the given base (defaults to natural logorithm)." + }, + "math.log.param-name.base": { + "message": "bonn", + "description": "(parameter name) The base to use" + }, + "math.log.param-doc.base": { + "message": "An bonn le húsáid", + "description": "Parameter docs" + }, + "math.log.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.log.param-doc.x": { + "message": "Uimhir", + "description": "Parameter docs" + }, + "math.modf": { + "message": "modf", + "description": "(function name) Calculate the fractional and integral parts of ``x``." + }, + "math.modf.summary": { + "message": "Ríomh na codanna codánacha agus lárnacha de {{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": "Uimhir", + "description": "Parameter docs" + }, + "math.pow": { + "message": "pow", + "description": "(function name) Returns ``x`` to the power of ``y``." + }, + "math.pow.summary": { + "message": "Filleann {{x}} chuig cumhacht {{y}}.", + "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": "Uimhir", + "description": "Parameter docs" + }, + "math.pow.param-name.y": { + "message": "y", + "description": "(parameter name) The exponent" + }, + "math.pow.param-doc.y": { + "message": "An léiritheoir", + "description": "Parameter docs" + }, + "math.radians": { + "message": "raidiáin", + "description": "(function name) Convert a degrees to radians." + }, + "math.radians.summary": { + "message": "Tiontaigh céimeanna go raidian.", + "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": "Luach i gcéimeanna", + "description": "Parameter docs" + }, + "math.sin": { + "message": "síneas", + "description": "(function name) Calculate the sine of ``x``." + }, + "math.sin.summary": { + "message": "Ríomh an sín de {{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": "Uimhir", + "description": "Parameter docs" + }, + "math.sqrt": { + "message": "sqrt", + "description": "(function name) Calculate the square root of ``x``." + }, + "math.sqrt.summary": { + "message": "Ríomh an fhréamh chearnach de {{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": "Uimhir", + "description": "Parameter docs" + }, + "math.tan": { + "message": "tan", + "description": "(function name) Calculate the tangent of ``x``." + }, + "math.tan.summary": { + "message": "Ríomh an tadhlaí de {{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": "Uimhir", + "description": "Parameter docs" + }, + "math.trunc": { + "message": "trunc", + "description": "(function name) Round a number towards 0." + }, + "math.trunc.summary": { + "message": "Déan uimhir a shlánú i dtreo 0.", + "description": "Round a number towards 0." + }, + "math.trunc.param-name.x": { + "message": "x", + "description": "(parameter name) A number" + }, + "math.trunc.param-doc.x": { + "message": "Uimhir", + "description": "Parameter docs" + }, + "math.e": { + "message": "e", + "description": "(field name) Base of the natural logarithm" + }, + "math.e.summary": { + "message": "Bunús an logartaim nádúrtha", + "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": "An cóimheas idir imlíne ciorcail agus a thrastomhas", + "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": "Bioráin, íomhánna, fuaimeanna, teocht agus toirt.", + "description": "Pins, images, sounds, temperature and volume." + }, + "microbit.run_every": { + "message": "rith gach", + "description": "(function name) Schedule to run a function at the interval specified by the time arguments **V2 only**." + }, + "microbit.run_every.summary": { + "message": "Sceideal chun feidhm a rith ag an eatramh a shonraítear leis na hargóintí ama **V2 amháin**.", + "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": "Feidhm chun glaoch ag an eatramh a sholáthraítear. Fág ar lár agus é á úsáid mar mhaisitheoir.", + "description": "Parameter docs" + }, + "microbit.run_every.param-name.days": { + "message": "laethanta", + "description": "(parameter name) Sets the day mark for the scheduling." + }, + "microbit.run_every.param-doc.days": { + "message": "Socraíonn sé an marc lae don sceidealú.", + "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": "Socraíonn sé an marc uair an chloig don sceidealú.", + "description": "Parameter docs" + }, + "microbit.run_every.param-name.min": { + "message": "íos", + "description": "(parameter name) Sets the minute mark for the scheduling." + }, + "microbit.run_every.param-doc.min": { + "message": "Socraíonn sé an marc nóiméad don sceidealú.", + "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": "Socraíonn sé an marc milleasoicind don sceidealú.", + "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": "Socraigh an dara marc don sceidealú.", + "description": "Parameter docs" + }, + "microbit.panic": { + "message": "scaoll", + "description": "(function name) Enter a panic mode." + }, + "microbit.panic.summary": { + "message": "Téigh isteach i mód scaoill.", + "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": "Slánuimhir treallach <= 255 chun stádas a léiriú.", + "description": "Parameter docs" + }, + "microbit.reset": { + "message": "athshocrú", + "description": "(function name) Restart the board." + }, + "microbit.reset.summary": { + "message": "Atosaigh an bord.", + "description": "Restart the board." + }, + "microbit.scale-1": { + "message": "scála", + "description": "(function name) Converts a value from a range to an integer range." + }, + "microbit.scale-1.summary": { + "message": "Athraíonn luach ó raon go raon slánuimhir.", + "description": "Converts a value from a range to an integer range." + }, + "microbit.scale-1.param-name.from_": { + "message": "ó", + "description": "(parameter name) A tuple to define the range to convert from." + }, + "microbit.scale-1.param-doc.from_": { + "message": "A tuple a shainmhíniú ar an raon a thiontú ó.", + "description": "Parameter docs" + }, + "microbit.scale-1.param-name.to": { + "message": "chuig", + "description": "(parameter name) A tuple to define the range to convert to." + }, + "microbit.scale-1.param-doc.to": { + "message": "A tuple a shainmhíniú ar an raon a thiontú go.", + "description": "Parameter docs" + }, + "microbit.scale-1.param-name.value": { + "message": "luach", + "description": "(parameter name) A number to convert." + }, + "microbit.scale-1.param-doc.value": { + "message": "Uimhir le tiontú.", + "description": "Parameter docs" + }, + "microbit.scale-2": { + "message": "scála", + "description": "(function name) Converts a value from a range to a floating point range." + }, + "microbit.scale-2.summary": { + "message": "Athraíonn luach ó raon go raon snámhphointe.", + "description": "Converts a value from a range to a floating point range." + }, + "microbit.scale-2.param-name.from_": { + "message": "ó", + "description": "(parameter name) A tuple to define the range to convert from." + }, + "microbit.scale-2.param-doc.from_": { + "message": "Tupla chun an raon le tiontú uaidh a shainiú.", + "description": "Parameter docs" + }, + "microbit.scale-2.param-name.to": { + "message": "chuig", + "description": "(parameter name) A tuple to define the range to convert to." + }, + "microbit.scale-2.param-doc.to": { + "message": "Tupla chun an raon le tiontú chuige a shainiú.", + "description": "Parameter docs" + }, + "microbit.scale-2.param-name.value": { + "message": "luach", + "description": "(parameter name) A number to convert." + }, + "microbit.scale-2.param-doc.value": { + "message": "Uimhir le tiontú.", + "description": "Parameter docs" + }, + "microbit.sleep": { + "message": "codladh", + "description": "(function name) Wait for ``n`` milliseconds." + }, + "microbit.sleep.summary": { + "message": "Fan le haghaidh milleasoicindí {{n}} .", + "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": "Líon na milleasoicindí le fanacht", + "description": "Parameter docs" + }, + "microbit.running_time": { + "message": "am reatha", + "description": "(function name) Get the running time of the board." + }, + "microbit.running_time.summary": { + "message": "Faigh am reatha an bhoird.", + "description": "Get the running time of the board." + }, + "microbit.temperature": { + "message": "teocht", + "description": "(function name) Get the temperature of the micro:bit in degrees Celsius." + }, + "microbit.temperature.summary": { + "message": "Faigh teocht an micro:bit i gcéimeanna Celsius.", + "description": "Get the temperature of the micro:bit in degrees Celsius." + }, + "microbit.set_volume": { + "message": "socraigh an toirt", + "description": "(function name) Sets the volume." + }, + "microbit.set_volume.summary": { + "message": "Socraigh an t-imleabhar.", + "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": "luach idir 0 (íseal) agus 255 (ard).", + "description": "Parameter docs" + }, + "microbit.Button": { + "message": "cnaipe", + "description": "(class name) The class for the buttons ``button_a`` and ``button_b``." + }, + "microbit.Button.summary": { + "message": "An rang do na cnaipí {{button_a}} agus {{button_b}}.", + "description": "The class for the buttons ``button_a`` and ``button_b``." + }, + "microbit.Button.is_pressed": { + "message": "brúite", + "description": "(function name) Check if the button is pressed." + }, + "microbit.Button.is_pressed.summary": { + "message": "Seiceáil an bhfuil an cnaipe brúite.", + "description": "Check if the button is pressed." + }, + "microbit.Button.was_pressed": { + "message": "brúdh", + "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": "Seiceáil ar brúdh an cnaipe ó thosaigh an gléas nó an uair dheireanach a glaodh ar an modh seo.", + "description": "Check if the button was pressed since the device started or the last time this method was called." + }, + "microbit.Button.get_presses": { + "message": "faigh brúiteanna", + "description": "(function name) Get the running total of button presses, and resets this total\nto zero before returning." + }, + "microbit.Button.get_presses.summary": { + "message": "Faigh iomlán reatha na gcnaipí, agus athshocraíonn sé an t-iomlán seo\nnáid sula bhfillfidh tú.", + "description": "Get the running total of button presses, and resets this total\nto zero before returning." + }, + "microbit.button_a": { + "message": "cnaipe a", + "description": "(field name) The left button ``Button`` object." + }, + "microbit.button_a.summary": { + "message": "An cnaipe ar chlé {{Button}} réad.", + "description": "The left button ``Button`` object." + }, + "microbit.button_b": { + "message": "cnaipe b", + "description": "(field name) The right button ``Button`` object." + }, + "microbit.button_b.summary": { + "message": "An cnaipe ceart {{Button}} réad.", + "description": "The right button ``Button`` object." + }, + "microbit.MicroBitDigitalPin": { + "message": "microbitdigitalpin", + "description": "(class name) A digital pin." + }, + "microbit.MicroBitDigitalPin.summary": { + "message": "Biorán digiteach.", + "description": "A digital pin." + }, + "microbit.MicroBitDigitalPin.read_digital": { + "message": "léigh digiteach", + "description": "(function name) Get the digital value of the pin." + }, + "microbit.MicroBitDigitalPin.read_digital.summary": { + "message": "Faigh luach digiteach an bhioráin.", + "description": "Get the digital value of the pin." + }, + "microbit.MicroBitDigitalPin.write_digital": { + "message": "scríobh digiteach", + "description": "(function name) Set the digital value of the pin." + }, + "microbit.MicroBitDigitalPin.write_digital.summary": { + "message": "Socraigh luach digiteach an bhioráin.", + "description": "Set the digital value of the pin." + }, + "microbit.MicroBitDigitalPin.write_digital.param-name.value": { + "message": "luach", + "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 chun an pionna a shocrú ard nó 0 chun an pionna a shocrú íseal", + "description": "Parameter docs" + }, + "microbit.MicroBitDigitalPin.set_pull": { + "message": "tarraingt socraithe", + "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": "Socraigh an staid tarraingthe go ceann de thrí luach féideartha: {{PULL_UP}}, {{PULL_DOWN}} nó {{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": "luach", + "description": "(parameter name) The pull state from the relevant pin, e.g. ``pin0.PULL_UP``." + }, + "microbit.MicroBitDigitalPin.set_pull.param-doc.value": { + "message": "An staid tarraingthe ón bioráin ábhartha, m.sh. {{pin0.PULL_UP}}.", + "description": "Parameter docs" + }, + "microbit.MicroBitDigitalPin.get_pull": { + "message": "faigh socraithe", + "description": "(function name) Get the pull state on a pin." + }, + "microbit.MicroBitDigitalPin.get_pull.summary": { + "message": "Faigh an stát tarraingt ar pionna.", + "description": "Get the pull state on a pin." + }, + "microbit.MicroBitDigitalPin.get_mode": { + "message": "mód faighte", + "description": "(function name) Returns the pin mode." + }, + "microbit.MicroBitDigitalPin.get_mode.summary": { + "message": "Filleann an modh pionna.", + "description": "Returns the pin mode." + }, + "microbit.MicroBitDigitalPin.write_analog": { + "message": "scríobh analógach", + "description": "(function name) Output a PWM signal on the pin, with the duty cycle proportional to ``value``." + }, + "microbit.MicroBitDigitalPin.write_analog.summary": { + "message": "Aschuir comhartha PWM ar an bioráin, agus an timthriall dleachta comhréireach le {{value}}.", + "description": "Output a PWM signal on the pin, with the duty cycle proportional to ``value``." + }, + "microbit.MicroBitDigitalPin.write_analog.param-name.value": { + "message": "luach", + "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": "Slánuimhir nó uimhir snámhphointe idir 0 (0% timthriall dleachta) agus 1023 (dleacht 100%).", + "description": "Parameter docs" + }, + "microbit.MicroBitDigitalPin.set_analog_period": { + "message": "socraigh tréimhse analógach", + "description": "(function name) Set the period of the PWM signal being output to ``period`` in milliseconds." + }, + "microbit.MicroBitDigitalPin.set_analog_period.summary": { + "message": "Socraigh tréimhse an chomhartha PWM atá á haschur go dtí {{period}} ina milleasoicindí.", + "description": "Set the period of the PWM signal being output to ``period`` in milliseconds." + }, + "microbit.MicroBitDigitalPin.set_analog_period.param-name.period": { + "message": "tréimhse", + "description": "(parameter name) The period in milliseconds with a minimum valid value of 1ms." + }, + "microbit.MicroBitDigitalPin.set_analog_period.param-doc.period": { + "message": "An tréimhse ina milleasoicindí le luach bailí íosta de 1ms.", + "description": "Parameter docs" + }, + "microbit.MicroBitDigitalPin.set_analog_period_microseconds": { + "message": "micreasoicindí tréimhse analógacha a shocrú", + "description": "(function name) Set the period of the PWM signal being output to ``period`` in microseconds." + }, + "microbit.MicroBitDigitalPin.set_analog_period_microseconds.summary": { + "message": "Socraigh tréimhse an chomhartha PWM atá á haschur go dtí {{period}} i micrishoicindí.", + "description": "Set the period of the PWM signal being output to ``period`` in microseconds." + }, + "microbit.MicroBitDigitalPin.set_analog_period_microseconds.param-name.period": { + "message": "tréimhse", + "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": "An tréimhse i micrishoicindí le íosluach bailí de 256µs.", + "description": "Parameter docs" + }, + "microbit.MicroBitAnalogDigitalPin": { + "message": "microbitanalogdigitalpin", + "description": "(class name) A pin with analog and digital features." + }, + "microbit.MicroBitAnalogDigitalPin.summary": { + "message": "Bioráin le gnéithe analógacha agus digiteacha.", + "description": "A pin with analog and digital features." + }, + "microbit.MicroBitAnalogDigitalPin.read_analog": { + "message": "léigh analógach", + "description": "(function name) Read the voltage applied to the pin." + }, + "microbit.MicroBitAnalogDigitalPin.read_analog.summary": { + "message": "Léigh an voltas a chuirtear i bhfeidhm ar an biorán.", + "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": "Pionna le gnéithe analógacha, digiteacha agus tadhaill.", + "description": "A pin with analog, digital and touch features." + }, + "microbit.MicroBitTouchPin.is_touched": { + "message": "i dteagmháil", + "description": "(function name) Check if the pin is being touched." + }, + "microbit.MicroBitTouchPin.is_touched.summary": { + "message": "Seiceáil an bhfuil teagmháil á déanamh leis an biorán.", + "description": "Check if the pin is being touched." + }, + "microbit.MicroBitTouchPin.set_touch_mode": { + "message": "socraigh mód tadhaill", + "description": "(function name) Set the touch mode for the pin." + }, + "microbit.MicroBitTouchPin.set_touch_mode.summary": { + "message": "Socraigh an modh tadhaill don pionna.", + "description": "Set the touch mode for the pin." + }, + "microbit.MicroBitTouchPin.set_touch_mode.param-name.value": { + "message": "luach", + "description": "(parameter name) ``CAPACITIVE`` or ``RESISTIVE`` from the relevant pin." + }, + "microbit.MicroBitTouchPin.set_touch_mode.param-doc.value": { + "message": "{{CAPACITIVE}} nó {{RESISTIVE}} ón pionna ábhartha.", + "description": "Parameter docs" + }, + "microbit.pin0": { + "message": "biorán0", + "description": "(field name) Pin with digital, analog and touch features." + }, + "microbit.pin0.summary": { + "message": "Pionna le gnéithe digiteacha, analógacha agus tadhaill.", + "description": "Pin with digital, analog and touch features." + }, + "microbit.pin1": { + "message": "biorán1", + "description": "(field name) Pin with digital, analog and touch features." + }, + "microbit.pin1.summary": { + "message": "Bioráin le gnéithe digiteacha, analógacha agus tadhaill.", + "description": "Pin with digital, analog and touch features." + }, + "microbit.pin2": { + "message": "biorán2", + "description": "(field name) Pin with digital, analog and touch features." + }, + "microbit.pin2.summary": { + "message": "Bioráin le gnéithe digiteacha, analógacha agus tadhaill.", + "description": "Pin with digital, analog and touch features." + }, + "microbit.pin3": { + "message": "biorán3", + "description": "(field name) Pin with digital and analog features." + }, + "microbit.pin3.summary": { + "message": "Bioráin le gnéithe digiteacha agus analógacha.", + "description": "Pin with digital and analog features." + }, + "microbit.pin4": { + "message": "biorán4", + "description": "(field name) Pin with digital and analog features." + }, + "microbit.pin4.summary": { + "message": "Bioráin le gnéithe digiteacha agus analógacha.", + "description": "Pin with digital and analog features." + }, + "microbit.pin5": { + "message": "biorán5", + "description": "(field name) Pin with digital features." + }, + "microbit.pin5.summary": { + "message": "Bioráin le gnéithe digiteacha.", + "description": "Pin with digital features." + }, + "microbit.pin6": { + "message": "biorán6", + "description": "(field name) Pin with digital features." + }, + "microbit.pin6.summary": { + "message": "Bioráin le gnéithe digiteacha.", + "description": "Pin with digital features." + }, + "microbit.pin7": { + "message": "biorán7", + "description": "(field name) Pin with digital features." + }, + "microbit.pin7.summary": { + "message": "Bioráin le gnéithe digiteacha.", + "description": "Pin with digital features." + }, + "microbit.pin8": { + "message": "biorán8", + "description": "(field name) Pin with digital features." + }, + "microbit.pin8.summary": { + "message": "Bioráin le gnéithe digiteacha.", + "description": "Pin with digital features." + }, + "microbit.pin9": { + "message": "biorán9", + "description": "(field name) Pin with digital features." + }, + "microbit.pin9.summary": { + "message": "Bioráin le gnéithe digiteacha.", + "description": "Pin with digital features." + }, + "microbit.pin10": { + "message": "biorán10", + "description": "(field name) Pin with digital and analog features." + }, + "microbit.pin10.summary": { + "message": "Bioráin le gnéithe digiteacha agus analógacha.", + "description": "Pin with digital and analog features." + }, + "microbit.pin11": { + "message": "biorán11", + "description": "(field name) Pin with digital features." + }, + "microbit.pin11.summary": { + "message": "Bioráin le gnéithe digiteacha.", + "description": "Pin with digital features." + }, + "microbit.pin12": { + "message": "biorán12", + "description": "(field name) Pin with digital features." + }, + "microbit.pin12.summary": { + "message": "Bioráin le gnéithe digiteacha.", + "description": "Pin with digital features." + }, + "microbit.pin13": { + "message": "biorán 13", + "description": "(field name) Pin with digital features." + }, + "microbit.pin13.summary": { + "message": "Bioráin le gnéithe digiteacha.", + "description": "Pin with digital features." + }, + "microbit.pin14": { + "message": "biorán14", + "description": "(field name) Pin with digital features." + }, + "microbit.pin14.summary": { + "message": "Bioráin le gnéithe digiteacha.", + "description": "Pin with digital features." + }, + "microbit.pin15": { + "message": "biorán15", + "description": "(field name) Pin with digital features." + }, + "microbit.pin15.summary": { + "message": "Bioráin le gnéithe digiteacha.", + "description": "Pin with digital features." + }, + "microbit.pin16": { + "message": "biorán16", + "description": "(field name) Pin with digital features." + }, + "microbit.pin16.summary": { + "message": "Bioráin le gnéithe digiteacha.", + "description": "Pin with digital features." + }, + "microbit.pin19": { + "message": "biorán19", + "description": "(field name) Pin with digital features." + }, + "microbit.pin19.summary": { + "message": "Bioráin le gnéithe digiteacha.", + "description": "Pin with digital features." + }, + "microbit.pin20": { + "message": "biorán20", + "description": "(field name) Pin with digital features." + }, + "microbit.pin20.summary": { + "message": "Bioráin le gnéithe digiteacha.", + "description": "Pin with digital features." + }, + "microbit.pin_logo": { + "message": "lógó bioráin", + "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": "Biorán lógó íogair do theagmháil ar aghaidh an micro:bit, atá socraithe de réir réamhshocraithe go mód tadhaill toilleasach.", + "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": "cainteoir bioráin", + "description": "(field name) A pin to address the micro:bit speaker." + }, + "microbit.pin_speaker.summary": { + "message": "Biorán chun an cainteoir micro:bit a sheoladh.", + "description": "A pin to address the micro:bit speaker." + }, + "microbit.Image": { + "message": "íomhá", + "description": "(class name) An image to show on the micro:bit LED display." + }, + "microbit.Image.summary": { + "message": "Íomhá le taispeáint ar an taispeáint micro:bit LED.", + "description": "An image to show on the micro:bit LED display." + }, + "microbit.Image.HEART": { + "message": "croí", + "description": "(field name) Heart image." + }, + "microbit.Image.HEART.summary": { + "message": "Íomhá chroí.", + "description": "Heart image." + }, + "microbit.Image.HEART_SMALL": { + "message": "croí beag", + "description": "(field name) Small heart image." + }, + "microbit.Image.HEART_SMALL.summary": { + "message": "Íomhá bheag chroí.", + "description": "Small heart image." + }, + "microbit.Image.HAPPY": { + "message": "sásta", + "description": "(field name) Happy face image." + }, + "microbit.Image.HAPPY.summary": { + "message": "Íomhá aghaidhe sona.", + "description": "Happy face image." + }, + "microbit.Image.SMILE": { + "message": "aoibh gháire", + "description": "(field name) Smiling mouth image." + }, + "microbit.Image.SMILE.summary": { + "message": "Íomhá béil ag gáire.", + "description": "Smiling mouth image." + }, + "microbit.Image.SAD": { + "message": "brónach", + "description": "(field name) Sad face image." + }, + "microbit.Image.SAD.summary": { + "message": "Íomhá aghaidhe brónach.", + "description": "Sad face image." + }, + "microbit.Image.CONFUSED": { + "message": "mearbhall", + "description": "(field name) Confused face image." + }, + "microbit.Image.CONFUSED.summary": { + "message": "Íomhá aghaidhe mearbhall.", + "description": "Confused face image." + }, + "microbit.Image.ANGRY": { + "message": "feargach", + "description": "(field name) Angry face image." + }, + "microbit.Image.ANGRY.summary": { + "message": "Íomhá aghaidh feargach.", + "description": "Angry face image." + }, + "microbit.Image.ASLEEP": { + "message": "ina chodladh", + "description": "(field name) Sleeping face image." + }, + "microbit.Image.ASLEEP.summary": { + "message": "Íomhá aghaidhe codlata.", + "description": "Sleeping face image." + }, + "microbit.Image.SURPRISED": { + "message": "ionadh", + "description": "(field name) Surprised face image." + }, + "microbit.Image.SURPRISED.summary": { + "message": "Íomhá aghaidhe ionadh.", + "description": "Surprised face image." + }, + "microbit.Image.SILLY": { + "message": "amaideach", + "description": "(field name) Silly face image." + }, + "microbit.Image.SILLY.summary": { + "message": "Íomhá aghaidh amaideach.", + "description": "Silly face image." + }, + "microbit.Image.FABULOUS": { + "message": "iontach", + "description": "(field name) Sunglasses face image." + }, + "microbit.Image.FABULOUS.summary": { + "message": "Íomhá aghaidhe spéaclaí gréine.", + "description": "Sunglasses face image." + }, + "microbit.Image.MEH": { + "message": "meh", + "description": "(field name) Unimpressed face image." + }, + "microbit.Image.MEH.summary": { + "message": "Íomhá aghaidhe neamhbhrúite.", + "description": "Unimpressed face image." + }, + "microbit.Image.YES": { + "message": "tá", + "description": "(field name) Tick image." + }, + "microbit.Image.YES.summary": { + "message": "Cuir tic leis an íomhá.", + "description": "Tick image." + }, + "microbit.Image.NO": { + "message": "níl", + "description": "(field name) Cross image." + }, + "microbit.Image.NO.summary": { + "message": "Íomhá croise.", + "description": "Cross image." + }, + "microbit.Image.CLOCK12": { + "message": "clog12", + "description": "(field name) Image with line pointing to 12 o'clock." + }, + "microbit.Image.CLOCK12.summary": { + "message": "Íomhá le líne dírithe ar 12 a chlog.", + "description": "Image with line pointing to 12 o'clock." + }, + "microbit.Image.CLOCK11": { + "message": "clog11", + "description": "(field name) Image with line pointing to 11 o'clock." + }, + "microbit.Image.CLOCK11.summary": { + "message": "Íomhá le líne dírithe ar 11 a chlog.", + "description": "Image with line pointing to 11 o'clock." + }, + "microbit.Image.CLOCK10": { + "message": "clog10", + "description": "(field name) Image with line pointing to 10 o'clock." + }, + "microbit.Image.CLOCK10.summary": { + "message": "Íomhá le líne dírithe ar 10 a chlog.", + "description": "Image with line pointing to 10 o'clock." + }, + "microbit.Image.CLOCK9": { + "message": "clog9", + "description": "(field name) Image with line pointing to 9 o'clock." + }, + "microbit.Image.CLOCK9.summary": { + "message": "Íomhá le líne dírithe go dtí 9 a chlog.", + "description": "Image with line pointing to 9 o'clock." + }, + "microbit.Image.CLOCK8": { + "message": "clog8", + "description": "(field name) Image with line pointing to 8 o'clock." + }, + "microbit.Image.CLOCK8.summary": { + "message": "Íomhá le líne dírithe go dtí 8 a chlog.", + "description": "Image with line pointing to 8 o'clock." + }, + "microbit.Image.CLOCK7": { + "message": "clog7", + "description": "(field name) Image with line pointing to 7 o'clock." + }, + "microbit.Image.CLOCK7.summary": { + "message": "Íomhá le líne dírithe go dtí 7 a chlog.", + "description": "Image with line pointing to 7 o'clock." + }, + "microbit.Image.CLOCK6": { + "message": "clog6", + "description": "(field name) Image with line pointing to 6 o'clock." + }, + "microbit.Image.CLOCK6.summary": { + "message": "Íomhá le líne ag díriú go dtí 6 a chlog.", + "description": "Image with line pointing to 6 o'clock." + }, + "microbit.Image.CLOCK5": { + "message": "clog5", + "description": "(field name) Image with line pointing to 5 o'clock." + }, + "microbit.Image.CLOCK5.summary": { + "message": "Íomhá le líne dírithe go dtí 5 a chlog.", + "description": "Image with line pointing to 5 o'clock." + }, + "microbit.Image.CLOCK4": { + "message": "clog4", + "description": "(field name) Image with line pointing to 4 o'clock." + }, + "microbit.Image.CLOCK4.summary": { + "message": "Íomhá le líne dírithe go dtí 4 a chlog.", + "description": "Image with line pointing to 4 o'clock." + }, + "microbit.Image.CLOCK3": { + "message": "clog3", + "description": "(field name) Image with line pointing to 3 o'clock." + }, + "microbit.Image.CLOCK3.summary": { + "message": "Íomhá le líne dírithe go dtí 3 a chlog.", + "description": "Image with line pointing to 3 o'clock." + }, + "microbit.Image.CLOCK2": { + "message": "clog2", + "description": "(field name) Image with line pointing to 2 o'clock." + }, + "microbit.Image.CLOCK2.summary": { + "message": "Íomhá le líne ag díriú go dtí 2 a chlog.", + "description": "Image with line pointing to 2 o'clock." + }, + "microbit.Image.CLOCK1": { + "message": "clog1", + "description": "(field name) Image with line pointing to 1 o'clock." + }, + "microbit.Image.CLOCK1.summary": { + "message": "Íomhá le líne ag díriú go dtí 1 a chlog.", + "description": "Image with line pointing to 1 o'clock." + }, + "microbit.Image.ARROW_N": { + "message": "saighead n", + "description": "(field name) Image of arrow pointing north." + }, + "microbit.Image.ARROW_N.summary": { + "message": "Íomhá na saigheade dírithe ó thuaidh.", + "description": "Image of arrow pointing north." + }, + "microbit.Image.ARROW_NE": { + "message": "saighead ne", + "description": "(field name) Image of arrow pointing north east." + }, + "microbit.Image.ARROW_NE.summary": { + "message": "Íomhá na saigheade dírithe soir ó thuaidh.", + "description": "Image of arrow pointing north east." + }, + "microbit.Image.ARROW_E": { + "message": "saighead e", + "description": "(field name) Image of arrow pointing east." + }, + "microbit.Image.ARROW_E.summary": { + "message": "Íomhá na saigheade dírithe ar an taobh thoir.", + "description": "Image of arrow pointing east." + }, + "microbit.Image.ARROW_SE": { + "message": "saighead se", + "description": "(field name) Image of arrow pointing south east." + }, + "microbit.Image.ARROW_SE.summary": { + "message": "Íomhá na saigheade dírithe soir ó dheas.", + "description": "Image of arrow pointing south east." + }, + "microbit.Image.ARROW_S": { + "message": "saighead s", + "description": "(field name) Image of arrow pointing south." + }, + "microbit.Image.ARROW_S.summary": { + "message": "Íomhá na saigheade dírithe ó dheas.", + "description": "Image of arrow pointing south." + }, + "microbit.Image.ARROW_SW": { + "message": "saighead sw", + "description": "(field name) Image of arrow pointing south west." + }, + "microbit.Image.ARROW_SW.summary": { + "message": "Íomhá na saigheade dírithe siar ó dheas.", + "description": "Image of arrow pointing south west." + }, + "microbit.Image.ARROW_W": { + "message": "saighead w", + "description": "(field name) Image of arrow pointing west." + }, + "microbit.Image.ARROW_W.summary": { + "message": "Íomhá den tsaighead atá dírithe siar.", + "description": "Image of arrow pointing west." + }, + "microbit.Image.ARROW_NW": { + "message": "saighead nw", + "description": "(field name) Image of arrow pointing north west." + }, + "microbit.Image.ARROW_NW.summary": { + "message": "Íomhá na saigheade dírithe siar ó thuaidh.", + "description": "Image of arrow pointing north west." + }, + "microbit.Image.TRIANGLE": { + "message": "triantán", + "description": "(field name) Image of a triangle pointing up." + }, + "microbit.Image.TRIANGLE.summary": { + "message": "Íomhá de thriantán ag pointeáil suas.", + "description": "Image of a triangle pointing up." + }, + "microbit.Image.TRIANGLE_LEFT": { + "message": "triantán ar chlé", + "description": "(field name) Image of a triangle in the left corner." + }, + "microbit.Image.TRIANGLE_LEFT.summary": { + "message": "Íomhá de thriantán sa chúinne ar chlé.", + "description": "Image of a triangle in the left corner." + }, + "microbit.Image.CHESSBOARD": { + "message": "clár fichille", + "description": "(field name) Alternate LEDs lit in a chessboard pattern." + }, + "microbit.Image.CHESSBOARD.summary": { + "message": "Soilse LEDs malartacha i bpatrún clár fichille.", + "description": "Alternate LEDs lit in a chessboard pattern." + }, + "microbit.Image.DIAMOND": { + "message": "diamant", + "description": "(field name) Diamond image." + }, + "microbit.Image.DIAMOND.summary": { + "message": "Íomhá diamant.", + "description": "Diamond image." + }, + "microbit.Image.DIAMOND_SMALL": { + "message": "diamant beag", + "description": "(field name) Small diamond image." + }, + "microbit.Image.DIAMOND_SMALL.summary": { + "message": "Íomhá diamant beag.", + "description": "Small diamond image." + }, + "microbit.Image.SQUARE": { + "message": "cearnóg", + "description": "(field name) Square image." + }, + "microbit.Image.SQUARE.summary": { + "message": "Íomhá cearnóg.", + "description": "Square image." + }, + "microbit.Image.SQUARE_SMALL": { + "message": "cearnach beag", + "description": "(field name) Small square image." + }, + "microbit.Image.SQUARE_SMALL.summary": { + "message": "Íomhá beag cearnach.", + "description": "Small square image." + }, + "microbit.Image.RABBIT": { + "message": "coinín", + "description": "(field name) Rabbit image." + }, + "microbit.Image.RABBIT.summary": { + "message": "Íomhá coinín.", + "description": "Rabbit image." + }, + "microbit.Image.COW": { + "message": "bó", + "description": "(field name) Cow image." + }, + "microbit.Image.COW.summary": { + "message": "Íomhá bó.", + "description": "Cow image." + }, + "microbit.Image.MUSIC_CROTCHET": { + "message": "croiséad ceoil", + "description": "(field name) Crotchet note image." + }, + "microbit.Image.MUSIC_CROTCHET.summary": { + "message": "Íomhá nóta cróise.", + "description": "Crotchet note image." + }, + "microbit.Image.MUSIC_QUAVER": { + "message": "cuais cheoil", + "description": "(field name) Quaver note image." + }, + "microbit.Image.MUSIC_QUAVER.summary": { + "message": "Creathán nóta íomhá.", + "description": "Quaver note image." + }, + "microbit.Image.MUSIC_QUAVERS": { + "message": "cuacha ceoil", + "description": "(field name) Pair of quavers note image." + }, + "microbit.Image.MUSIC_QUAVERS.summary": { + "message": "Íomhá de nótaí péire ochtú comhartha.", + "description": "Pair of quavers note image." + }, + "microbit.Image.PITCHFORK": { + "message": "forc-pice", + "description": "(field name) Pitchfork image." + }, + "microbit.Image.PITCHFORK.summary": { + "message": "Íomhá forc pice.", + "description": "Pitchfork image." + }, + "microbit.Image.XMAS": { + "message": "nollag", + "description": "(field name) Christmas tree image." + }, + "microbit.Image.XMAS.summary": { + "message": "Íomhá crann Nollag.", + "description": "Christmas tree image." + }, + "microbit.Image.PACMAN": { + "message": "pacman", + "description": "(field name) Pac-Man arcade character image." + }, + "microbit.Image.PACMAN.summary": { + "message": "Íomhá carachtar stuara PAC-Man.", + "description": "Pac-Man arcade character image." + }, + "microbit.Image.TARGET": { + "message": "sprioc", + "description": "(field name) Target image." + }, + "microbit.Image.TARGET.summary": { + "message": "Íomhá sprice.", + "description": "Target image." + }, + "microbit.Image.TSHIRT": { + "message": "léine-t", + "description": "(field name) T-shirt image." + }, + "microbit.Image.TSHIRT.summary": { + "message": "Íomhá T-léine.", + "description": "T-shirt image." + }, + "microbit.Image.ROLLERSKATE": { + "message": "scátáil-rollála", + "description": "(field name) Rollerskate image." + }, + "microbit.Image.ROLLERSKATE.summary": { + "message": "Íomhá scátáil-rollála.", + "description": "Rollerskate image." + }, + "microbit.Image.DUCK": { + "message": "lacha", + "description": "(field name) Duck image." + }, + "microbit.Image.DUCK.summary": { + "message": "Íomhá lacha.", + "description": "Duck image." + }, + "microbit.Image.HOUSE": { + "message": "teach", + "description": "(field name) House image." + }, + "microbit.Image.HOUSE.summary": { + "message": "Íomhá tí.", + "description": "House image." + }, + "microbit.Image.TORTOISE": { + "message": "toirtís", + "description": "(field name) Tortoise image." + }, + "microbit.Image.TORTOISE.summary": { + "message": "Íomhá turtar.", + "description": "Tortoise image." + }, + "microbit.Image.BUTTERFLY": { + "message": "féileacán", + "description": "(field name) Butterfly image." + }, + "microbit.Image.BUTTERFLY.summary": { + "message": "Íomhá féileacán.", + "description": "Butterfly image." + }, + "microbit.Image.STICKFIGURE": { + "message": "figiúr-maide", + "description": "(field name) Stick figure image." + }, + "microbit.Image.STICKFIGURE.summary": { + "message": "Bata íomhá figiúr.", + "description": "Stick figure image." + }, + "microbit.Image.GHOST": { + "message": "taibhse", + "description": "(field name) Ghost image." + }, + "microbit.Image.GHOST.summary": { + "message": "Íomhá taibhse.", + "description": "Ghost image." + }, + "microbit.Image.SWORD": { + "message": "claíomh", + "description": "(field name) Sword image." + }, + "microbit.Image.SWORD.summary": { + "message": "Íomhá chlaíomh.", + "description": "Sword image." + }, + "microbit.Image.GIRAFFE": { + "message": "sioráf", + "description": "(field name) Giraffe image." + }, + "microbit.Image.GIRAFFE.summary": { + "message": "Íomhá sioráf.", + "description": "Giraffe image." + }, + "microbit.Image.SKULL": { + "message": "cloigeann", + "description": "(field name) Skull image." + }, + "microbit.Image.SKULL.summary": { + "message": "Íomhá cloigeann.", + "description": "Skull image." + }, + "microbit.Image.UMBRELLA": { + "message": "scáth fearthainne", + "description": "(field name) Umbrella image." + }, + "microbit.Image.UMBRELLA.summary": { + "message": "Íomhá scáth fearthainne.", + "description": "Umbrella image." + }, + "microbit.Image.SNAKE": { + "message": "nathair", + "description": "(field name) Snake image." + }, + "microbit.Image.SNAKE.summary": { + "message": "Íomhá nathair.", + "description": "Snake image." + }, + "microbit.Image.SCISSORS": { + "message": "siosúr", + "description": "(field name) Scissors image." + }, + "microbit.Image.SCISSORS.summary": { + "message": "Íomhá siosúr.", + "description": "Scissors image." + }, + "microbit.Image.ALL_CLOCKS": { + "message": "gach clog", + "description": "(field name) A list containing all the CLOCK_ images in sequence." + }, + "microbit.Image.ALL_CLOCKS.summary": { + "message": "Liosta ina bhfuil na híomhánna CLOCK_ go léir in ord.", + "description": "A list containing all the CLOCK_ images in sequence." + }, + "microbit.Image.ALL_ARROWS": { + "message": "gach saighead", + "description": "(field name) A list containing all the ARROW_ images in sequence." + }, + "microbit.Image.ALL_ARROWS.summary": { + "message": "Liosta ina bhfuil na híomhánna ARROW_ go léir in ord.", + "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": "Cruthaigh íomhá ó theaghrán ag cur síos ar na soilse atá lasta.", + "description": "Create an image from a string describing which LEDs are lit." + }, + "microbit.Image.__init__-1.param-name.string": { + "message": "teaghrán", + "description": "(parameter name) The string describing the image." + }, + "microbit.Image.__init__-1.param-doc.string": { + "message": "An teaghrán ag cur síos ar an íomhá.", + "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": "Cruthaigh íomhá fholamh le colúin {{width}} agus sraitheanna {{height}} .", + "description": "Create an empty image with ``width`` columns and ``height`` rows." + }, + "microbit.Image.__init__-2.param-name.buffer": { + "message": "maolán", + "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": "Eagar roghnach nó bearta de {{width}}×{{height}} slánuimhreacha i raon 0-9 chun an íomhá a thúsú", + "description": "Parameter docs" + }, + "microbit.Image.__init__-2.param-name.height": { + "message": "airde", + "description": "(parameter name) Optional height of the image" + }, + "microbit.Image.__init__-2.param-doc.height": { + "message": "Airde roghnach na híomhá", + "description": "Parameter docs" + }, + "microbit.Image.__init__-2.param-name.width": { + "message": "leithead", + "description": "(parameter name) Optional width of the image" + }, + "microbit.Image.__init__-2.param-doc.width": { + "message": "Leithead roghnach na híomhá", + "description": "Parameter docs" + }, + "microbit.Image.width": { + "message": "leithead", + "description": "(function name) Get the number of columns." + }, + "microbit.Image.width.summary": { + "message": "Faigh líon na gcolún.", + "description": "Get the number of columns." + }, + "microbit.Image.height": { + "message": "airde", + "description": "(function name) Get the number of rows." + }, + "microbit.Image.height.summary": { + "message": "Faigh líon na sraitheanna.", + "description": "Get the number of rows." + }, + "microbit.Image.set_pixel": { + "message": "socraigh picteilín", + "description": "(function name) Set the brightness of a pixel." + }, + "microbit.Image.set_pixel.summary": { + "message": "Socraigh gile picteilín.", + "description": "Set the brightness of a pixel." + }, + "microbit.Image.set_pixel.param-name.value": { + "message": "luach", + "description": "(parameter name) The brightness as an integer between 0 (dark) and 9 (bright)" + }, + "microbit.Image.set_pixel.param-doc.value": { + "message": "An ghile mar shlánuimhir idir 0 (dorcha) agus 9 (geal)", + "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": "Uimhir an cholúin", + "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": "Uimhir an ró", + "description": "Parameter docs" + }, + "microbit.Image.get_pixel": { + "message": "faigh picteilín", + "description": "(function name) Get the brightness of a pixel." + }, + "microbit.Image.get_pixel.summary": { + "message": "Faigh gile picteilín.", + "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": "Uimhir an cholúin", + "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": "Uimhir na sraithe", + "description": "Parameter docs" + }, + "microbit.Image.shift_left": { + "message": "shift ar chlé", + "description": "(function name) Create a new image by shifting the picture left." + }, + "microbit.Image.shift_left.summary": { + "message": "Cruthaigh íomhá nua tríd an bpictiúr ar chlé a athrú.", + "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": "Líon na gcolún atá le haistriú ag", + "description": "Parameter docs" + }, + "microbit.Image.shift_right": { + "message": "shift ar dheis", + "description": "(function name) Create a new image by shifting the picture right." + }, + "microbit.Image.shift_right.summary": { + "message": "Cruthaigh íomhá nua tríd an bpictiúr a athrú ar dheis.", + "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": "Líon na gcolún le haistriú", + "description": "Parameter docs" + }, + "microbit.Image.shift_up": { + "message": "shift suas", + "description": "(function name) Create a new image by shifting the picture up." + }, + "microbit.Image.shift_up.summary": { + "message": "Cruthaigh íomhá nua tríd an bpictiúr a athrú suas.", + "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": "Líon na rónna le hathrú ag", + "description": "Parameter docs" + }, + "microbit.Image.shift_down": { + "message": "shift síos", + "description": "(function name) Create a new image by shifting the picture down." + }, + "microbit.Image.shift_down.summary": { + "message": "Cruthaigh íomhá nua tríd an bpictiúr a aistriú síos.", + "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": "Líon na rónna le haistriú", + "description": "Parameter docs" + }, + "microbit.Image.crop": { + "message": "barr", + "description": "(function name) Create a new image by cropping the picture." + }, + "microbit.Image.crop.summary": { + "message": "Cruthaigh íomhá nua tríd an bpictiúr a bearradh.", + "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": "An airde barr", + "description": "Parameter docs" + }, + "microbit.Image.crop.param-name.w": { + "message": "w", + "description": "(parameter name) The crop width" + }, + "microbit.Image.crop.param-doc.w": { + "message": "An leithead barr", + "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": "An colún fritháireamh barr", + "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": "An ró fritháireamh barr", + "description": "Parameter docs" + }, + "microbit.Image.copy": { + "message": "cóip", + "description": "(function name) Create an exact copy of the image." + }, + "microbit.Image.copy.summary": { + "message": "Cruthaigh cóip chruinn den íomhá.", + "description": "Create an exact copy of the image." + }, + "microbit.Image.invert": { + "message": "inbhéartaithe", + "description": "(function name) Create a new image by inverting the brightness of the pixels in the\nsource image." + }, + "microbit.Image.invert.summary": { + "message": "Cruthaigh íomhá nua trí ghile na bpicteilíní a inbhéartú sa\níomhá foinseach.", + "description": "Create a new image by inverting the brightness of the pixels in the\nsource image." + }, + "microbit.Image.fill": { + "message": "líon", + "description": "(function name) Set the brightness of all the pixels in the image." + }, + "microbit.Image.fill.summary": { + "message": "Socraigh gile na bpicteilíní go léir san íomhá.", + "description": "Set the brightness of all the pixels in the image." + }, + "microbit.Image.fill.param-name.value": { + "message": "luach", + "description": "(parameter name) The new brightness as a number between 0 (dark) and 9 (bright)." + }, + "microbit.Image.fill.param-doc.value": { + "message": "An gile nua mar uimhir idir 0 (dorcha) agus 9 (geal).", + "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": "Cóipeáil limistéar ó íomhá eile isteach san íomhá seo.", + "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": "Líon na rónna le cóipeáil", + "description": "Parameter docs" + }, + "microbit.Image.blit.param-name.src": { + "message": "src", + "description": "(parameter name) The source image" + }, + "microbit.Image.blit.param-doc.src": { + "message": "An íomhá fhoinseach", + "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": "Líon na gcolún le cóipeáil", + "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": "Fritháireamh an cholúin tosaigh san íomhá fhoinseach", + "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": "Fritháireamh an cholúin le mionathrú san íomhá seo", + "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": "Fritháireamh an ró tosaigh san íomhá foinseach", + "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": "Fritháireamh an ró le mionathrú san íomhá seo", + "description": "Parameter docs" + }, + "microbit.Image.__repr__": { + "message": "repr", + "description": "(function name) Get a compact string representation of the image." + }, + "microbit.Image.__repr__.summary": { + "message": "Faigh léiriú teaghrán dlúth ar an íomhá.", + "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": "Faigh léiriú teaghrán inléite ar an íomhá.", + "description": "Get a readable string representation of the image." + }, + "microbit.Image.__add__": { + "message": "suimigh", + "description": "(function name) Create a new image by adding the brightness values from the two\nimages for each pixel." + }, + "microbit.Image.__add__.summary": { + "message": "Cruthaigh íomhá nua trí na luachanna gile ón dá cheann a chur leis\níomhánna do gach picteilín.", + "description": "Create a new image by adding the brightness values from the two\nimages for each pixel." + }, + "microbit.Image.__add__.param-name.other": { + "message": "eile", + "description": "(parameter name) The image to add." + }, + "microbit.Image.__add__.param-doc.other": { + "message": "An íomhá le cur leis.", + "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": "Cruthaigh íomhá nua trí luachanna gile an\níomhá eile ón íomhá seo.", + "description": "Create a new image by subtracting the brightness values of the\nother image from this image." + }, + "microbit.Image.__sub__.param-name.other": { + "message": "eile", + "description": "(parameter name) The image to subtract." + }, + "microbit.Image.__sub__.param-doc.other": { + "message": "An íomhá a dhealú.", + "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": "Cruthaigh íomhá nua trí ghile gach picteilín a iolrú faoi\n{{n}}.", + "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": "An luach a iolrú faoi.", + "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": "Cruthaigh íomhá nua trí ghile gach picteilín a roinnt ar\n{{n}}.", + "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": "An luach a roinnt ar.", + "description": "Parameter docs" + }, + "microbit.SoundEvent.LOUD": { + "message": "ard", + "description": "(field name) Represents the transition of sound events, from ``quiet`` to ``loud`` like clapping or shouting." + }, + "microbit.SoundEvent.LOUD.summary": { + "message": "Léiríonn sé aistriú imeachtaí fuaime, ó {{quiet}} go {{loud}} cosúil le bualadh nó béicíl.", + "description": "Represents the transition of sound events, from ``quiet`` to ``loud`` like clapping or shouting." + }, + "microbit.SoundEvent.QUIET": { + "message": "ciúin", + "description": "(field name) Represents the transition of sound events, from ``loud`` to ``quiet`` like speaking or background music." + }, + "microbit.SoundEvent.QUIET.summary": { + "message": "Léiríonn sé seo aistriú imeachtaí fuaime, ó {{loud}} go {{quiet}} cosúil le ceol labhartha nó cúlra.", + "description": "Represents the transition of sound events, from ``loud`` to ``quiet`` like speaking or background music." + }, + "microbit.Sound": { + "message": "fuaim", + "description": "(class name) The built-in sounds can be called using ``audio.play(Sound.NAME)``." + }, + "microbit.Sound.summary": { + "message": "Is féidir na fuaimeanna tógtha a ghlaoch ag baint úsáide as {{audio.play(Sound.NAME)}}.", + "description": "The built-in sounds can be called using ``audio.play(Sound.NAME)``." + }, + "microbit.Sound.GIGGLE": { + "message": "scig-gháire", + "description": "(field name) Giggling sound." + }, + "microbit.Sound.GIGGLE.summary": { + "message": "Fuaim scig-gháire.", + "description": "Giggling sound." + }, + "microbit.Sound.HAPPY": { + "message": "sásta", + "description": "(field name) Happy sound." + }, + "microbit.Sound.HAPPY.summary": { + "message": "Fuaim shona.", + "description": "Happy sound." + }, + "microbit.Sound.HELLO": { + "message": "dia duit", + "description": "(field name) Greeting sound." + }, + "microbit.Sound.HELLO.summary": { + "message": "Fuaime beannacht.", + "description": "Greeting sound." + }, + "microbit.Sound.MYSTERIOUS": { + "message": "mistéireach", + "description": "(field name) Mysterious sound." + }, + "microbit.Sound.MYSTERIOUS.summary": { + "message": "Fuaim mhistéireach.", + "description": "Mysterious sound." + }, + "microbit.Sound.SAD": { + "message": "brónach", + "description": "(field name) Sad sound." + }, + "microbit.Sound.SAD.summary": { + "message": "Fuaim bhrónach.", + "description": "Sad sound." + }, + "microbit.Sound.SLIDE": { + "message": "sleamhnán", + "description": "(field name) Sliding sound." + }, + "microbit.Sound.SLIDE.summary": { + "message": "Fuaim sleamhnáin.", + "description": "Sliding sound." + }, + "microbit.Sound.SOARING": { + "message": "téagartha", + "description": "(field name) Soaring sound." + }, + "microbit.Sound.SOARING.summary": { + "message": "Fuaim téagartha.", + "description": "Soaring sound." + }, + "microbit.Sound.SPRING": { + "message": "an t-earrach", + "description": "(field name) Spring sound." + }, + "microbit.Sound.SPRING.summary": { + "message": "Fuaim an earraigh.", + "description": "Spring sound." + }, + "microbit.Sound.TWINKLE": { + "message": "drithligh", + "description": "(field name) Twinkling sound." + }, + "microbit.Sound.TWINKLE.summary": { + "message": "Fuaim drithligh.", + "description": "Twinkling sound." + }, + "microbit.Sound.YAWN": { + "message": "méanfach", + "description": "(field name) Yawning sound." + }, + "microbit.Sound.YAWN.summary": { + "message": "Fuaim méanfach.", + "description": "Yawning sound." + }, + "microbit.accelerometer": { + "message": "luasmhéadar", + "description": "(module name) Measure the acceleration of the micro:bit and recognise gestures." + }, + "microbit.accelerometer.summary": { + "message": "Tomhais luasghéarú an micro:bit agus aithin gothaí.", + "description": "Measure the acceleration of the micro:bit and recognise gestures." + }, + "microbit.accelerometer.get_x": { + "message": "faigh x", + "description": "(function name) Get the acceleration measurement in the ``x`` axis in milli-g." + }, + "microbit.accelerometer.get_x.summary": { + "message": "Faigh an tomhas luasghéaraithe san ais {{x}} i milli-g.", + "description": "Get the acceleration measurement in the ``x`` axis in milli-g." + }, + "microbit.accelerometer.get_y": { + "message": "faigh y", + "description": "(function name) Get the acceleration measurement in the ``y`` axis in milli-g." + }, + "microbit.accelerometer.get_y.summary": { + "message": "Faigh an tomhas luasghéaraithe san ais {{y}} i milli-g.", + "description": "Get the acceleration measurement in the ``y`` axis in milli-g." + }, + "microbit.accelerometer.get_z": { + "message": "faigh z", + "description": "(function name) Get the acceleration measurement in the ``z`` axis in milli-g." + }, + "microbit.accelerometer.get_z.summary": { + "message": "Faigh an tomhas luasghéaraithe san ais {{z}} i milli-g.", + "description": "Get the acceleration measurement in the ``z`` axis in milli-g." + }, + "microbit.accelerometer.get_values": { + "message": "faigh luachanna", + "description": "(function name) Get the acceleration measurements in all axes at once as a tuple." + }, + "microbit.accelerometer.get_values.summary": { + "message": "Faigh na tomhais luasghéaraithe i ngach aiseanna ag an am céanna mar tuple.", + "description": "Get the acceleration measurements in all axes at once as a tuple." + }, + "microbit.accelerometer.get_strength": { + "message": "faigh neart", + "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": "Faigh tomhas luasghéaraithe na n-aiseanna go léir le chéile, mar shlánuimhir dhearfach. Is é seo suim Pythagorean na n-aiseanna X, Y agus 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": { + "message": "gotha ​​reatha", + "description": "(function name) Get the name of the current gesture." + }, + "microbit.accelerometer.current_gesture.summary": { + "message": "Faigh ainm an chomhartha reatha.", + "description": "Get the name of the current gesture." + }, + "microbit.accelerometer.is_gesture": { + "message": "is gotha", + "description": "(function name) Check if the named gesture is currently active." + }, + "microbit.accelerometer.is_gesture.summary": { + "message": "Seiceáil an bhfuil an comhartha ainmnithe gníomhach faoi láthair.", + "description": "Check if the named gesture is currently active." + }, + "microbit.accelerometer.is_gesture.param-name.name": { + "message": "ainm", + "description": "(parameter name) The gesture name." + }, + "microbit.accelerometer.is_gesture.param-doc.name": { + "message": "An t-ainm gotha.", + "description": "Parameter docs" + }, + "microbit.accelerometer.was_gesture": { + "message": "bhí gotha", + "description": "(function name) Check if the named gesture was active since the last call." + }, + "microbit.accelerometer.was_gesture.summary": { + "message": "Seiceáil an raibh an comhartha ainmnithe gníomhach ón nglao deireanach.", + "description": "Check if the named gesture was active since the last call." + }, + "microbit.accelerometer.was_gesture.param-name.name": { + "message": "ainm", + "description": "(parameter name) The gesture name." + }, + "microbit.accelerometer.was_gesture.param-doc.name": { + "message": "Ainm an ghluaiseachta.", + "description": "Parameter docs" + }, + "microbit.accelerometer.get_gestures": { + "message": "faigh gothaí", + "description": "(function name) Return a tuple of the gesture history." + }, + "microbit.accelerometer.get_gestures.summary": { + "message": "Tabhair ar ais tuple de stair na gothaí.", + "description": "Return a tuple of the gesture history." + }, + "microbit.accelerometer.set_range": { + "message": "socraigh raon", + "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": "Socraigh an raon íogaireachta luasmhéadair, i g (domhantarraingt chaighdeánach), go dtí na luachanna is gaire a dtacaíonn na crua-earraí leo, agus mar sin cruinníonn sé le {{2}}, {{4}}, nó {{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": "luach", + "description": "(parameter name) New range for the accelerometer, an integer in ``g``." + }, + "microbit.accelerometer.set_range.param-doc.value": { + "message": "Raon nua don luasmhéadar, slánuimhir i {{g}}.", + "description": "Parameter docs" + }, + "microbit.audio": { + "message": "fuaime", + "description": "(module name) Play sounds using the micro:bit (import ``audio`` for V1 compatibility)." + }, + "microbit.audio.summary": { + "message": "Seinn fuaimeanna ag baint úsáide as an micro:bit (allmhairiú {{audio}} le haghaidh comhoiriúnacht V1).", + "description": "Play sounds using the micro:bit (import ``audio`` for V1 compatibility)." + }, + "microbit.audio.play": { + "message": "seinn", + "description": "(function name) Play a built-in sound, sound effect or custom audio frames." + }, + "microbit.audio.play.summary": { + "message": "Seinn fuaim-tógtha i, éifeacht fuaime nó frámaí fuaime saincheaptha.", + "description": "Play a built-in sound, sound effect or custom audio frames." + }, + "microbit.audio.play.param-name.pin": { + "message": "biorán", + "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": "Is féidir argóint roghnach chun an bioráin aschuir a shonrú a úsáid chun mainneachtain {{pin0}}a shárú. Mura dteastaíonn aon fhuaim uainn is féidir linn {{pin=None}}a úsáid.", + "description": "Parameter docs" + }, + "microbit.audio.play.param-name.return_pin": { + "message": "biorán fillte", + "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": "Sonraíonn bioráin cónascaire imeall difreálach chun ceangal le cainteoir seachtrach in ionad na talún. Déantar neamhaird air seo don athbhreithniú **V2**.", + "description": "Parameter docs" + }, + "microbit.audio.play.param-name.source": { + "message": "foinse", + "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": "{{Sound}} ionsuite amhail {{Sound.GIGGLE}}, {{SoundEffect}} nó sonraí samplacha mar athrá ar réada {{AudioFrame}}.", + "description": "Parameter docs" + }, + "microbit.audio.play.param-name.wait": { + "message": "fan", + "description": "(parameter name) If ``wait`` is ``True``, this function will block until the sound is complete." + }, + "microbit.audio.play.param-doc.wait": { + "message": "Má tá {{wait}} {{True}}, blocálfaidh an fheidhm seo go dtí go mbeidh an fhuaim críochnaithe.", + "description": "Parameter docs" + }, + "microbit.audio.is_playing": { + "message": "ag seinm", + "description": "(function name) Check whether a sound is playing." + }, + "microbit.audio.is_playing.summary": { + "message": "Seiceáil an bhfuil fuaim á seinm.", + "description": "Check whether a sound is playing." + }, + "microbit.audio.stop": { + "message": "stad", + "description": "(function name) Stop all audio playback." + }, + "microbit.audio.stop.summary": { + "message": "Stop gach athsheinm fuaime.", + "description": "Stop all audio playback." + }, + "microbit.audio.SoundEffect": { + "message": "éifeachtfuaime", + "description": "(class name) A sound effect, composed by a set of parameters configured via the constructor or attributes." + }, + "microbit.audio.SoundEffect.summary": { + "message": "Éifeacht fuaime, comhdhéanta ag sraith paraiméadar cumraithe tríd an cruthaitheoir nó tréithe.", + "description": "A sound effect, composed by a set of parameters configured via the constructor or attributes." + }, + "microbit.audio.SoundEffect.WAVEFORM_SINE": { + "message": "tonnchruth síneas", + "description": "(field name) Sine wave option used for the ``waveform`` parameter." + }, + "microbit.audio.SoundEffect.WAVEFORM_SINE.summary": { + "message": "Rogha tonn sine a úsáidtear don pharaiméadar {{waveform}} .", + "description": "Sine wave option used for the ``waveform`` parameter." + }, + "microbit.audio.SoundEffect.WAVEFORM_SAWTOOTH": { + "message": "tonnfhad fiacail sábha", + "description": "(field name) Sawtooth wave option used for the ``waveform`` parameter." + }, + "microbit.audio.SoundEffect.WAVEFORM_SAWTOOTH.summary": { + "message": "Rogha tonn fiacail sábha a úsáidtear don pharaiméadar {{waveform}} .", + "description": "Sawtooth wave option used for the ``waveform`` parameter." + }, + "microbit.audio.SoundEffect.WAVEFORM_TRIANGLE": { + "message": "triantán tonnchrutha", + "description": "(field name) Triangle wave option used for the ``waveform`` parameter." + }, + "microbit.audio.SoundEffect.WAVEFORM_TRIANGLE.summary": { + "message": "Rogha tonn triantáin a úsáidtear don pharaiméadar {{waveform}} .", + "description": "Triangle wave option used for the ``waveform`` parameter." + }, + "microbit.audio.SoundEffect.WAVEFORM_SQUARE": { + "message": "cearnóg tonnfhoirme", + "description": "(field name) Square wave option used for the ``waveform`` parameter." + }, + "microbit.audio.SoundEffect.WAVEFORM_SQUARE.summary": { + "message": "Rogha tonn cearnach a úsáidtear don pharaiméadar {{waveform}} .", + "description": "Square wave option used for the ``waveform`` parameter." + }, + "microbit.audio.SoundEffect.WAVEFORM_NOISE": { + "message": "torann tonnfhoirme", + "description": "(field name) Noise option used for the ``waveform`` parameter." + }, + "microbit.audio.SoundEffect.WAVEFORM_NOISE.summary": { + "message": "Rogha torainn a úsáidtear don pharaiméadar {{waveform}} .", + "description": "Noise option used for the ``waveform`` parameter." + }, + "microbit.audio.SoundEffect.SHAPE_LINEAR": { + "message": "cruth líneach", + "description": "(field name) Linear interpolation option used for the ``shape`` parameter." + }, + "microbit.audio.SoundEffect.SHAPE_LINEAR.summary": { + "message": "Rogha idirshuíomh líneach a úsáidtear don pharaiméadar {{shape}} .", + "description": "Linear interpolation option used for the ``shape`` parameter." + }, + "microbit.audio.SoundEffect.SHAPE_CURVE": { + "message": "cruth cuar", + "description": "(field name) Curve interpolation option used for the ``shape`` parameter." + }, + "microbit.audio.SoundEffect.SHAPE_CURVE.summary": { + "message": "Rogha idirshuíomh cuar a úsáidtear don pharaiméadar {{shape}} .", + "description": "Curve interpolation option used for the ``shape`` parameter." + }, + "microbit.audio.SoundEffect.SHAPE_LOG": { + "message": "log cruth", + "description": "(field name) Logarithmic interpolation option used for the ``shape`` parameter." + }, + "microbit.audio.SoundEffect.SHAPE_LOG.summary": { + "message": "Rogha idirshuíomh logartamach a úsáidtear don pharaiméadar {{shape}} .", + "description": "Logarithmic interpolation option used for the ``shape`` parameter." + }, + "microbit.audio.SoundEffect.FX_NONE": { + "message": "fx aon cheann", + "description": "(field name) No effect option used for the ``fx`` parameter." + }, + "microbit.audio.SoundEffect.FX_NONE.summary": { + "message": "Níl aon rogha éifeachta in úsáid don pharaiméadar {{fx}} .", + "description": "No effect option used for the ``fx`` parameter." + }, + "microbit.audio.SoundEffect.FX_TREMOLO": { + "message": "tremolo fx", + "description": "(field name) Tremolo effect option used for the ``fx`` parameter." + }, + "microbit.audio.SoundEffect.FX_TREMOLO.summary": { + "message": "Rogha éifeachta Tremolo a úsáidtear don pharaiméadar {{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": "Rogha éifeachta Vibrato a úsáidtear don pharaiméadar {{fx}} .", + "description": "Vibrato effect option used for the ``fx`` parameter." + }, + "microbit.audio.SoundEffect.FX_WARBLE": { + "message": "fx warble", + "description": "(field name) Warble effect option used for the ``fx`` parameter." + }, + "microbit.audio.SoundEffect.FX_WARBLE.summary": { + "message": "Rogha éifeacht warble a úsáidtear le haghaidh an paraiméadar {{fx}} .", + "description": "Warble effect option used for the ``fx`` parameter." + }, + "microbit.audio.SoundEffect.freq_start": { + "message": "tús minicíochta", + "description": "(field name) Start frequency in Hertz (Hz), a number between ``0`` and ``9999``" + }, + "microbit.audio.SoundEffect.freq_start.summary": { + "message": "Tosaigh minicíocht i Hertz (Hz), uimhir idir {{0}} agus {{9999}}", + "description": "Start frequency in Hertz (Hz), a number between ``0`` and ``9999``" + }, + "microbit.audio.SoundEffect.freq_end": { + "message": "deireadh freq", + "description": "(field name) End frequency in Hertz (Hz), a number between ``0`` and ``9999``" + }, + "microbit.audio.SoundEffect.freq_end.summary": { + "message": "Minicíocht deiridh i Heirts (Hz), uimhir idir {{0}} agus {{9999}}", + "description": "End frequency in Hertz (Hz), a number between ``0`` and ``9999``" + }, + "microbit.audio.SoundEffect.duration": { + "message": "fad", + "description": "(field name) Duration of the sound in milliseconds, a number between ``0`` and ``9999``" + }, + "microbit.audio.SoundEffect.duration.summary": { + "message": "Fad na fuaime i milleasoicindí, uimhir idir {{0}} agus {{9999}}", + "description": "Duration of the sound in milliseconds, a number between ``0`` and ``9999``" + }, + "microbit.audio.SoundEffect.vol_start": { + "message": "tús vol", + "description": "(field name) Start volume value, a number between ``0`` and ``255``" + }, + "microbit.audio.SoundEffect.vol_start.summary": { + "message": "Tosaigh luach toirte, uimhir idir {{0}} agus {{255}}", + "description": "Start volume value, a number between ``0`` and ``255``" + }, + "microbit.audio.SoundEffect.vol_end": { + "message": "deireadh imleabhair", + "description": "(field name) End volume value, a number between ``0`` and ``255``" + }, + "microbit.audio.SoundEffect.vol_end.summary": { + "message": "Luach toirte deiridh, uimhir idir {{0}} agus {{255}}", + "description": "End volume value, a number between ``0`` and ``255``" + }, + "microbit.audio.SoundEffect.waveform": { + "message": "tonnchruth", + "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": "Cineál cruth waveform, ceann de na luachanna seo: {{WAVEFORM_SINE}}, {{WAVEFORM_SAWTOOTH}}, {{WAVEFORM_TRIANGLE}}, {{WAVEFORM_SQUARE}}, {{WAVEFORM_NOISE}} (torann a ghintear go randamach)", + "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": "Éifeacht le cur leis an bhfuaim, ceann amháin de na luachanna seo a leanas: {{FX_TREMOLO}}, {{FX_VIBRATO}}, {{FX_WARBLE}}, nó {{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": "cruth", + "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": "An cineál cuar idirshuíomh idir na minicíochtaí tosaigh agus deiridh, tá cruthanna tonn éagsúla rátaí éagsúla athraithe i minicíocht. Ceann de na luachanna seo a leanas: {{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": "Cruthaigh éifeacht fuaime nua.", + "description": "Create a new sound effect." + }, + "microbit.audio.SoundEffect.__init__.param-name.duration": { + "message": "fad", + "description": "(parameter name) Duration of the sound in milliseconds, a number between ``0`` and ``9999``." + }, + "microbit.audio.SoundEffect.__init__.param-doc.duration": { + "message": "Fad na fuaime i milleasoicindí, uimhir idir {{0}} agus {{9999}}.", + "description": "Parameter docs" + }, + "microbit.audio.SoundEffect.__init__.param-name.freq_end": { + "message": "deireadh minicíochta", + "description": "(parameter name) End frequency in Hertz (Hz), a number between ``0`` and ``9999``." + }, + "microbit.audio.SoundEffect.__init__.param-doc.freq_end": { + "message": "Minicíocht deiridh i Hertz (Hz), uimhir idir {{0}} agus {{9999}}.", + "description": "Parameter docs" + }, + "microbit.audio.SoundEffect.__init__.param-name.freq_start": { + "message": "tús minicíochta", + "description": "(parameter name) Start frequency in Hertz (Hz), a number between ``0`` and ``9999``." + }, + "microbit.audio.SoundEffect.__init__.param-doc.freq_start": { + "message": "Tosaigh minicíocht i Hertz (Hz), uimhir idir {{0}} agus {{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": "Éifeacht le cur leis an bhfuaim, ceann amháin de na luachanna seo a leanas: {{FX_TREMOLO}}, {{FX_VIBRATO}}, {{FX_WARBLE}}, nó {{FX_NONE}}.", + "description": "Parameter docs" + }, + "microbit.audio.SoundEffect.__init__.param-name.shape": { + "message": "cruth", + "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": "An cineál cuar idirshuíomh idir na minicíochtaí tosaigh agus deiridh, tá cruthanna tonn éagsúla rátaí éagsúla athraithe i minicíocht. Ceann de na luachanna seo a leanas: {{SHAPE_LINEAR}}, {{SHAPE_CURVE}}, {{SHAPE_LOG}}.", + "description": "Parameter docs" + }, + "microbit.audio.SoundEffect.__init__.param-name.vol_end": { + "message": "deireadh an toirte", + "description": "(parameter name) End volume value, a number between ``0`` and ``255``." + }, + "microbit.audio.SoundEffect.__init__.param-doc.vol_end": { + "message": "Luach deiridh an toirte, uimhir idir {{0}} agus {{255}}.", + "description": "Parameter docs" + }, + "microbit.audio.SoundEffect.__init__.param-name.vol_start": { + "message": "tús toirte", + "description": "(parameter name) Start volume value, a number between ``0`` and ``255``." + }, + "microbit.audio.SoundEffect.__init__.param-doc.vol_start": { + "message": "Tosaigh luach toirte, uimhir idir {{0}} agus {{255}}.", + "description": "Parameter docs" + }, + "microbit.audio.SoundEffect.__init__.param-name.waveform": { + "message": "tonnfhoirm", + "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": "Cineál cruth waveform, ceann de na luachanna seo: {{WAVEFORM_SINE}}, {{WAVEFORM_SAWTOOTH}}, {{WAVEFORM_TRIANGLE}}, {{WAVEFORM_SQUARE}}, {{WAVEFORM_NOISE}} (torann a ghintear go randamach).", + "description": "Parameter docs" + }, + "microbit.audio.SoundEffect.copy": { + "message": "cóip", + "description": "(function name) Create a copy of this ``SoundEffect``." + }, + "microbit.audio.SoundEffect.copy.summary": { + "message": "Cruthaigh cóip den {{SoundEffect}}seo.", + "description": "Create a copy of this ``SoundEffect``." + }, + "microbit.audio.AudioFrame": { + "message": "fráma fuaime", + "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": "Is éard is réad {{AudioFrame}} ann ná liosta de 32 sampla ar beart gan síniú gach ceann acu\n(slánuimhir idir 0 agus 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": "cóipeáil ó", + "description": "(function name) Overwrite the data in this ``AudioFrame`` with the data from another ``AudioFrame`` instance." + }, + "microbit.audio.AudioFrame.copyfrom.summary": { + "message": "Forscríobh na sonraí sa {{AudioFrame}} seo leis na sonraí ó shampla {{AudioFrame}} eile.", + "description": "Overwrite the data in this ``AudioFrame`` with the data from another ``AudioFrame`` instance." + }, + "microbit.audio.AudioFrame.copyfrom.param-name.other": { + "message": "eile", + "description": "(parameter name) ``AudioFrame`` instance from which to copy the data." + }, + "microbit.audio.AudioFrame.copyfrom.param-doc.other": { + "message": "{{AudioFrame}} ásc as ar féidir na sonraí a chóipeáil.", + "description": "Parameter docs" + }, + "microbit.compass": { + "message": "compás", + "description": "(module name) Use the built-in compass." + }, + "microbit.compass.summary": { + "message": "Bain úsáid as an compás tógtha.", + "description": "Use the built-in compass." + }, + "microbit.compass.calibrate": { + "message": "calabrú", + "description": "(function name) Starts the calibration process." + }, + "microbit.compass.calibrate.summary": { + "message": "Tosaíonn seo an próiseas calabrúcháin.", + "description": "Starts the calibration process." + }, + "microbit.compass.is_calibrated": { + "message": "atá calabraithe", + "description": "(function name) Check is the compass is calibrated." + }, + "microbit.compass.is_calibrated.summary": { + "message": "Seiceáil go bhfuil an compás calabraithe.", + "description": "Check is the compass is calibrated." + }, + "microbit.compass.clear_calibration": { + "message": "calabrú soiléir", + "description": "(function name) Undoes the calibration, making the compass uncalibrated again." + }, + "microbit.compass.clear_calibration.summary": { + "message": "Cealaigh an calabrú, rud a fhágann go bhfuil an compás neamhráite arís.", + "description": "Undoes the calibration, making the compass uncalibrated again." + }, + "microbit.compass.get_x": { + "message": "faigh x", + "description": "(function name) Get the magnetic field strength on the ``x`` axis." + }, + "microbit.compass.get_x.summary": { + "message": "Faigh neart an réimse mhaighnéadaigh ar an ais {{x}} .", + "description": "Get the magnetic field strength on the ``x`` axis." + }, + "microbit.compass.get_y": { + "message": "faigh y", + "description": "(function name) Get the magnetic field strength on the ``y`` axis." + }, + "microbit.compass.get_y.summary": { + "message": "Faigh neart an réimse mhaighnéadaigh ar an ais {{y}} .", + "description": "Get the magnetic field strength on the ``y`` axis." + }, + "microbit.compass.get_z": { + "message": "faigh z", + "description": "(function name) Get the magnetic field strength on the ``z`` axis." + }, + "microbit.compass.get_z.summary": { + "message": "Faigh neart an réimse mhaighnéadaigh ar an ais {{z}} .", + "description": "Get the magnetic field strength on the ``z`` axis." + }, + "microbit.compass.heading": { + "message": "ceannteideal", + "description": "(function name) Get the compass heading." + }, + "microbit.compass.heading.summary": { + "message": "Faigh ceannteideal an chompáis.", + "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": "Faigh méid an réimse maighnéadach timpeall an ghléis.", + "description": "Get the magnitude of the magnetic field around the device." + }, + "microbit.display": { + "message": "taispeáint", + "description": "(module name) Show text, images and animations on the 5×5 LED display." + }, + "microbit.display.summary": { + "message": "Taispeáin téacs, íomhánna agus beochan ar an taispeáint LED 5×5.", + "description": "Show text, images and animations on the 5×5 LED display." + }, + "microbit.display.get_pixel": { + "message": "faigh picteilín", + "description": "(function name) Get the brightness of the LED at column ``x`` and row ``y``." + }, + "microbit.display.get_pixel.summary": { + "message": "Faigh gile an LED ag colún {{x}} agus as a chéile {{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": "An colún taispeána (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": "An tsraith taispeána (0..4)", + "description": "Parameter docs" + }, + "microbit.display.set_pixel": { + "message": "socraigh picteilín", + "description": "(function name) Set the brightness of the LED at column ``x`` and row ``y``." + }, + "microbit.display.set_pixel.summary": { + "message": "Socraigh gile an LED ag colún {{x}} agus as a chéile {{y}}.", + "description": "Set the brightness of the LED at column ``x`` and row ``y``." + }, + "microbit.display.set_pixel.param-name.value": { + "message": "luach", + "description": "(parameter name) The brightness between 0 (off) and 9 (bright)" + }, + "microbit.display.set_pixel.param-doc.value": { + "message": "An ghile idir 0 (as) agus 9 (geal)", + "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": "An colún taispeána (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": "An tsraith taispeána (0..4)", + "description": "Parameter docs" + }, + "microbit.display.clear": { + "message": "soiléir", + "description": "(function name) Set the brightness of all LEDs to 0 (off)." + }, + "microbit.display.clear.summary": { + "message": "Socraigh gile na soilse go léir go 0 (as).", + "description": "Set the brightness of all LEDs to 0 (off)." + }, + "microbit.display.show": { + "message": "taispeáin", + "description": "(function name) Shows images, letters or digits on the LED display." + }, + "microbit.display.show.summary": { + "message": "Taispeáin íomhánna, litreacha nó digití ar an taispeáint LED.", + "description": "Shows images, letters or digits on the LED display." + }, + "microbit.display.show.param-name.clear": { + "message": "soiléir", + "description": "(parameter name) If ``clear`` is ``True``, the display will be cleared after the sequence has finished." + }, + "microbit.display.show.param-doc.clear": { + "message": "Más ionann {{clear}} agus {{True}}, glanfar an taispeáint tar éis don seicheamh a bheith críochnaithe.", + "description": "Parameter docs" + }, + "microbit.display.show.param-name.delay": { + "message": "moill", + "description": "(parameter name) Each letter, digit or image is shown with ``delay`` milliseconds between them." + }, + "microbit.display.show.param-doc.delay": { + "message": "Taispeántar gach litir, digit nó íomhá le milleasoicindí {{delay}} eatarthu.", + "description": "Parameter docs" + }, + "microbit.display.show.param-name.image": { + "message": "íomhá", + "description": "(parameter name) A string, number, image or list of images to show." + }, + "microbit.display.show.param-doc.image": { + "message": "Teaghrán, uimhir, íomhá nó liosta íomhánna le taispeáint.", + "description": "Parameter docs" + }, + "microbit.display.show.param-name.loop": { + "message": "lúb", + "description": "(parameter name) If ``loop`` is ``True``, the animation will repeat forever." + }, + "microbit.display.show.param-doc.loop": { + "message": "Má tá {{loop}} {{True}}, déanfaidh an beochan arís go deo.", + "description": "Parameter docs" + }, + "microbit.display.show.param-name.wait": { + "message": "fan", + "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": "Más {{wait}} é {{True}}, cuirfear bac ar an bhfeidhm seo go dtí go mbeidh an bheochan críochnaithe, nó tarlóidh an bheochan sa chúlra.", + "description": "Parameter docs" + }, + "microbit.display.scroll": { + "message": "scrollaigh", + "description": "(function name) Scrolls a number or text on the LED display." + }, + "microbit.display.scroll.summary": { + "message": "Scrollaigh uimhir nó téacs ar an taispeáint LED.", + "description": "Scrolls a number or text on the LED display." + }, + "microbit.display.scroll.param-name.delay": { + "message": "moill", + "description": "(parameter name) The ``delay`` parameter controls how fast the text is scrolling." + }, + "microbit.display.scroll.param-doc.delay": { + "message": "Rialaíonn an paraiméadar {{delay}} cé chomh tapa is atá an téacs ag scrollú.", + "description": "Parameter docs" + }, + "microbit.display.scroll.param-name.loop": { + "message": "lúb", + "description": "(parameter name) If ``loop`` is ``True``, the animation will repeat forever." + }, + "microbit.display.scroll.param-doc.loop": { + "message": "Má tá {{loop}} {{True}}, déanfaidh an beochan arís go deo.", + "description": "Parameter docs" + }, + "microbit.display.scroll.param-name.monospace": { + "message": "monaspás", + "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": "Más {{monospace}} é {{True}}, tógfaidh na carachtair go léir suas le 5 cholún picteilín ar leithead, nó mura mbeidh go díreach 1 cholún bán picteilín idir gach carachtar agus iad ag scrollú.", + "description": "Parameter docs" + }, + "microbit.display.scroll.param-name.text": { + "message": "téacs", + "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": "An teaghrán le scrollú. Más slánuimhir nó snámhphointe é {{text}} tiontaítear é ar dtús go teaghrán ag baint úsáide as {{str()}}.", + "description": "Parameter docs" + }, + "microbit.display.scroll.param-name.wait": { + "message": "fan", + "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": "Má tá {{wait}} {{True}}, blocálfaidh an fheidhm seo go dtí go mbeidh an beochan críochnaithe, nó tarlóidh an beochan sa chúlra.", + "description": "Parameter docs" + }, + "microbit.display.on": { + "message": "ar", + "description": "(function name) Turn on the LED display." + }, + "microbit.display.on.summary": { + "message": "Cas ar an taispeáint LED.", + "description": "Turn on the LED display." + }, + "microbit.display.off": { + "message": "as", + "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": "Múch an taispeáint LED (ceadaíonn an taispeáint a dhíchumasú duit na bioráin GPIO a athúsáid chun críocha eile).", + "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": "atá ar", + "description": "(function name) Check whether the LED display is enabled." + }, + "microbit.display.is_on.summary": { + "message": "Seiceáil an bhfuil an taispeáint LED cumasaithe.", + "description": "Check whether the LED display is enabled." + }, + "microbit.display.read_light_level": { + "message": "léigh leibhéal an tsolais", + "description": "(function name) Read the light level." + }, + "microbit.display.read_light_level.summary": { + "message": "Léigh leibhéal an tsolais.", + "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": "Cumarsáid a dhéanamh le gléasanna ag baint úsáide as prótacal bus I²C.", + "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": "Ath-thúsaigh forimeallach.", + "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": "minicíocht cloig", + "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": "biorán {{scl}} (réamhshocrú 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": "biorán {{sda}} (réamhshocrú 20)", + "description": "Parameter docs" + }, + "microbit.i2c.scan": { + "message": "scanadh", + "description": "(function name) Scan the bus for devices." + }, + "microbit.i2c.scan.summary": { + "message": "Scan an bus le haghaidh gléasanna.", + "description": "Scan the bus for devices." + }, + "microbit.i2c.read": { + "message": "léigh", + "description": "(function name) Read bytes from a device." + }, + "microbit.i2c.read.summary": { + "message": "Léigh bearta ó ghléas.", + "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": "Seoladh 7 ngiotán an ghléis", + "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": "Líon na mbeart atá le léamh", + "description": "Parameter docs" + }, + "microbit.i2c.read.param-name.repeat": { + "message": "athdhéanamh", + "description": "(parameter name) If ``True``, no stop bit will be sent" + }, + "microbit.i2c.read.param-doc.repeat": { + "message": "Má {{True}}, ní sheolfar aon ghiotán stad", + "description": "Parameter docs" + }, + "microbit.i2c.write": { + "message": "scríobh", + "description": "(function name) Write bytes to a device." + }, + "microbit.i2c.write.summary": { + "message": "Scríobh bearta chuig gléas.", + "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": "Seoladh 7 ngiotán an ghléis", + "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": "Maolán ina bhfuil na bearta le scríobh", + "description": "Parameter docs" + }, + "microbit.i2c.write.param-name.repeat": { + "message": "athdhéanamh", + "description": "(parameter name) If ``True``, no stop bit will be sent" + }, + "microbit.i2c.write.param-doc.repeat": { + "message": "Má {{True}}, ní sheolfar aon ghiotán stad", + "description": "Parameter docs" + }, + "microbit.microphone": { + "message": "micreafón", + "description": "(module name) Respond to sound using the built-in microphone (V2 only)." + }, + "microbit.microphone.summary": { + "message": "Freagair fuaim ag baint úsáide as an micreafón tógtha (V2 amháin).", + "description": "Respond to sound using the built-in microphone (V2 only)." + }, + "microbit.microphone.current_event": { + "message": "imeacht reatha", + "description": "(function name) Get the last recorded sound event" + }, + "microbit.microphone.current_event.summary": { + "message": "Faigh an teagmhas fuaime taifeadta is déanaí", + "description": "Get the last recorded sound event" + }, + "microbit.microphone.was_event": { + "message": "ba imeacht é", + "description": "(function name) Check if a sound was heard at least once since the last call." + }, + "microbit.microphone.was_event.summary": { + "message": "Seiceáil ar chualathas fuaim uair amháin ar a laghad ón nglao deireanach.", + "description": "Check if a sound was heard at least once since the last call." + }, + "microbit.microphone.was_event.param-name.event": { + "message": "imeacht", + "description": "(parameter name) The event to check for, such as ``SoundEvent.LOUD`` or ``SoundEvent.QUIET``" + }, + "microbit.microphone.was_event.param-doc.event": { + "message": "An ócáid le seiceáil, mar shampla {{SoundEvent.LOUD}} nó {{SoundEvent.QUIET}}", + "description": "Parameter docs" + }, + "microbit.microphone.is_event": { + "message": "imeacht", + "description": "(function name) Check the most recent sound event detected." + }, + "microbit.microphone.is_event.summary": { + "message": "Seiceáil an teagmhas fuaime is déanaí a braitheadh.", + "description": "Check the most recent sound event detected." + }, + "microbit.microphone.is_event.param-name.event": { + "message": "imeacht", + "description": "(parameter name) The event to check for, such as ``SoundEvent.LOUD`` or ``SoundEvent.QUIET``" + }, + "microbit.microphone.is_event.param-doc.event": { + "message": "An ócáid le seiceáil, mar shampla {{SoundEvent.LOUD}} nó {{SoundEvent.QUIET}}", + "description": "Parameter docs" + }, + "microbit.microphone.get_events": { + "message": "faigh imeachtaí", + "description": "(function name) Get the sound event history as a tuple." + }, + "microbit.microphone.get_events.summary": { + "message": "Faigh stair na hócáide fuaime mar thuple.", + "description": "Get the sound event history as a tuple." + }, + "microbit.microphone.set_threshold": { + "message": "tairseach shocraithe", + "description": "(function name) Set the threshold for a sound event." + }, + "microbit.microphone.set_threshold.summary": { + "message": "Socraigh an tairseach le haghaidh teagmhas fuaime.", + "description": "Set the threshold for a sound event." + }, + "microbit.microphone.set_threshold.param-name.event": { + "message": "imeacht", + "description": "(parameter name) A sound event, such as ``SoundEvent.LOUD`` or ``SoundEvent.QUIET``." + }, + "microbit.microphone.set_threshold.param-doc.event": { + "message": "Imeacht fuaime, mar shampla {{SoundEvent.LOUD}} nó {{SoundEvent.QUIET}}.", + "description": "Parameter docs" + }, + "microbit.microphone.set_threshold.param-name.value": { + "message": "luach", + "description": "(parameter name) The threshold level in the range 0-255." + }, + "microbit.microphone.set_threshold.param-doc.value": { + "message": "An leibhéal tairsí sa raon 0-255.", + "description": "Parameter docs" + }, + "microbit.microphone.sound_level": { + "message": "leibhéal fuaime", + "description": "(function name) Get the sound pressure level." + }, + "microbit.microphone.sound_level.summary": { + "message": "Faigh an leibhéal brú fuaime.", + "description": "Get the sound pressure level." + }, + "microbit.speaker": { + "message": "cainteoir", + "description": "(module name) Control the built-in speaker (V2 only)." + }, + "microbit.speaker.summary": { + "message": "Rialú an cainteoir tógtha i (V2 amháin).", + "description": "Control the built-in speaker (V2 only)." + }, + "microbit.speaker.off": { + "message": "as", + "description": "(function name) Turn the speaker off." + }, + "microbit.speaker.off.summary": { + "message": "Múch an cainteoir.", + "description": "Turn the speaker off." + }, + "microbit.speaker.on": { + "message": "ar", + "description": "(function name) Turn the speaker on." + }, + "microbit.speaker.on.summary": { + "message": "Cas an cainteoir air.", + "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": "Cumarsáid a dhéanamh le gléasanna ag baint úsáide as an gcomhéadan forimeallach sraitheach (SPI) bus.", + "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": "Túsaigh cumarsáid SPI.", + "description": "Initialize SPI communication." + }, + "microbit.spi.init.param-name.baudrate": { + "message": "ráta baud", + "description": "(parameter name) The speed of communication." + }, + "microbit.spi.init.param-doc.baudrate": { + "message": "Luas na cumarsáide.", + "description": "Parameter docs" + }, + "microbit.spi.init.param-name.bits": { + "message": "giotáin", + "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": "An leithead i giotán de gach aistriú. Faoi láthair ní thacaítear ach le {{bits=8}} . Mar sin féin, d'fhéadfadh sé seo athrú amach anseo.", + "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": "biorán miso (réamhshocraithe 14)", + "description": "Parameter docs" + }, + "microbit.spi.init.param-name.mode": { + "message": "mód", + "description": "(parameter name) Determines the combination of clock polarity and phase - `see online table `_." + }, + "microbit.spi.init.param-doc.mode": { + "message": "Cinneann sé an meascán de polaraíocht clog agus céim - 'féach tábla ar líne '_.", + "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": "bioráin mosi (réamhshocrú 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": "bioráin sclk (réamhshocrú 13)", + "description": "Parameter docs" + }, + "microbit.spi.read": { + "message": "léamh", + "description": "(function name) Read at most ``nbytes`` while continuously writing the single byte given by ``out``." + }, + "microbit.spi.read.summary": { + "message": "Léigh ar a mhéad {{nbytes}} agus an beart aonair a thugann {{out}}á scríobh go leanúnach.", + "description": "Read at most ``nbytes`` while continuously writing the single byte given by ``out``." + }, + "microbit.spi.read.param-name.nbytes": { + "message": "nbeart", + "description": "(parameter name) Maximum number of bytes to read." + }, + "microbit.spi.read.param-doc.nbytes": { + "message": "Líon uasta na mbeart le léamh.", + "description": "Parameter docs" + }, + "microbit.spi.read.param-name.out": { + "message": "amach", + "description": "(parameter name) The byte value to write (default 0)." + }, + "microbit.spi.read.param-doc.out": { + "message": "An luach beart le scríobh (réamhshocrú 0).", + "description": "Parameter docs" + }, + "microbit.spi.write": { + "message": "scríobh", + "description": "(function name) Write bytes to the bus." + }, + "microbit.spi.write.summary": { + "message": "Scríobh bearta chuig an mbus.", + "description": "Write bytes to the bus." + }, + "microbit.spi.write.param-name.buffer": { + "message": "maolán", + "description": "(parameter name) A buffer to read data from." + }, + "microbit.spi.write.param-doc.buffer": { + "message": "Maolán chun sonraí a léamh as.", + "description": "Parameter docs" + }, + "microbit.spi.write_readinto": { + "message": "scríobh 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": "Scríobh an maolán {{out}} chuig an mbus agus léigh aon fhreagra isteach sa mhaolán {{in_}} .", + "description": "Write the ``out`` buffer to the bus and read any response into the ``in_`` buffer." + }, + "microbit.spi.write_readinto.param-name.in_": { + "message": "i", + "description": "(parameter name) The buffer to read data from." + }, + "microbit.spi.write_readinto.param-doc.in_": { + "message": "An maolán chun sonraí a léamh as.", + "description": "Parameter docs" + }, + "microbit.spi.write_readinto.param-name.out": { + "message": "amach", + "description": "(parameter name) The buffer to write any response to." + }, + "microbit.spi.write_readinto.param-doc.out": { + "message": "An maolán chun aon fhreagra a scríobh.", + "description": "Parameter docs" + }, + "microbit.uart": { + "message": "uart", + "description": "(module name) Communicate with a device using a serial interface." + }, + "microbit.uart.summary": { + "message": "Cumarsáid a dhéanamh le gléas ag baint úsáide as comhéadan sraitheach.", + "description": "Communicate with a device using a serial interface." + }, + "microbit.uart.ODD": { + "message": "corr", + "description": "(field name) Odd parity" + }, + "microbit.uart.ODD.summary": { + "message": "Paireacht chorr", + "description": "Odd parity" + }, + "microbit.uart.EVEN": { + "message": "fiú amháin", + "description": "(field name) Even parity" + }, + "microbit.uart.EVEN.summary": { + "message": "Paireacht fiú", + "description": "Even parity" + }, + "microbit.uart.init": { + "message": "init", + "description": "(function name) Initialize serial communication." + }, + "microbit.uart.init.summary": { + "message": "Túsaigh cumarsáid sraitheach.", + "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": "Luas na cumarsáide.", + "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": "Méid na mbeart atá á dtarchur. micro:bit: ní thacaíonn giotán ach le 8.", + "description": "Parameter docs" + }, + "microbit.uart.init.param-name.parity": { + "message": "paireacht", + "description": "(parameter name) How parity is checked, ``None``, ``uart.ODD`` or ``uart.EVEN``." + }, + "microbit.uart.init.param-doc.parity": { + "message": "Conas a dhéantar paireacht a sheiceáil, {{None}}, {{uart.ODD}} nó {{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": "Biorán glactha.", + "description": "Parameter docs" + }, + "microbit.uart.init.param-name.stop": { + "message": "stad", + "description": "(parameter name) The number of stop bits, has to be 1 for micro:bit." + }, + "microbit.uart.init.param-doc.stop": { + "message": "Líon na ngiotán stad, caithfidh sé a bheith 1 le haghaidh micro:bit.", + "description": "Parameter docs" + }, + "microbit.uart.init.param-name.tx": { + "message": "tx", + "description": "(parameter name) Transmitting pin." + }, + "microbit.uart.init.param-doc.tx": { + "message": "Bioráin a tharchur.", + "description": "Parameter docs" + }, + "microbit.uart.any": { + "message": "aon", + "description": "(function name) Check if any data is waiting." + }, + "microbit.uart.any.summary": { + "message": "Seiceáil an bhfuil aon sonraí ag fanacht.", + "description": "Check if any data is waiting." + }, + "microbit.uart.read": { + "message": "léamh", + "description": "(function name) Read bytes." + }, + "microbit.uart.read.summary": { + "message": "Léigh bearta.", + "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": "Má tá {{nbytes}} sonraithe ansin léigh ar a mhéad go leor beart, nó léigh an oiread beart agus is féidir", + "description": "Parameter docs" + }, + "microbit.uart.readinto": { + "message": "readinto", + "description": "(function name) Read bytes into the ``buf``." + }, + "microbit.uart.readinto.summary": { + "message": "Léigh bearta isteach sa {{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": "An maolán le scríobh chuige.", + "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": "Má tá {{nbytes}} sonraithe ansin léigh ar a mhéad go leor bearta, ar shlí eile a léamh {{len(buf)}} bearta.", + "description": "Parameter docs" + }, + "microbit.uart.readline": { + "message": "readline", + "description": "(function name) Read a line, ending in a newline character." + }, + "microbit.uart.readline.summary": { + "message": "Léigh líne, ag críochnú i gcarachtar líne nua.", + "description": "Read a line, ending in a newline character." + }, + "microbit.uart.write": { + "message": "scríobh", + "description": "(function name) Write a buffer to the bus." + }, + "microbit.uart.write.summary": { + "message": "Scríobh maolán ar an mbus.", + "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": "Réad beart nó teaghrán.", + "description": "Parameter docs" + }, + "micropython": { + "message": "micropython", + "description": "(module name) MicroPython internals." + }, + "micropython.summary": { + "message": "Gnéithe inmheánacha MicroPython.", + "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": "Úsáidtear é chun a dhearbhú go bhfuil an slonn tairiseach ionas gur féidir leis an tiomsaitheoir\nan leas is fearr is féidir a bhaint as.", + "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": "Léiriú tairiseach.", + "description": "Parameter docs" + }, + "micropython.opt_level-1": { + "message": "leibhéal roghnaithe", + "description": "(function name) Get the current optimisation level for the compilation of scripts." + }, + "micropython.opt_level-1.summary": { + "message": "Faigh an leibhéal optamaithe reatha chun scripteanna a thiomsú.", + "description": "Get the current optimisation level for the compilation of scripts." + }, + "micropython.opt_level-2": { + "message": "leibhéal rogha", + "description": "(function name) Sets the optimisation level for subsequent compilation of scripts." + }, + "micropython.opt_level-2.summary": { + "message": "Socraigh an leibhéal optamaithe le haghaidh tiomsú scripteanna ina dhiaidh sin.", + "description": "Sets the optimisation level for subsequent compilation of scripts." + }, + "micropython.opt_level-2.param-name.level": { + "message": "leibhéal", + "description": "(parameter name) An integer optimisation level." + }, + "micropython.opt_level-2.param-doc.level": { + "message": "Leibhéal optamaithe slánuimhir.", + "description": "Parameter docs" + }, + "micropython.mem_info": { + "message": "eolas cuimhne", + "description": "(function name) Print information about currently used memory." + }, + "micropython.mem_info.summary": { + "message": "Priontáil faisnéis faoin gcuimhne atá in úsáid faoi láthair.", + "description": "Print information about currently used memory." + }, + "micropython.mem_info.param-name.verbose": { + "message": "foclach", + "description": "(parameter name) If the ``verbose`` argument is given then extra information is printed." + }, + "micropython.mem_info.param-doc.verbose": { + "message": "Má thugtar an argóint {{verbose}}, clóitear faisnéis bhreise.", + "description": "Parameter docs" + }, + "micropython.qstr_info": { + "message": "eolas qstr", + "description": "(function name) Print information about currently interned strings." + }, + "micropython.qstr_info.summary": { + "message": "Priontáil eolas faoi théada atá imtheorannaithe faoi láthair.", + "description": "Print information about currently interned strings." + }, + "micropython.qstr_info.param-name.verbose": { + "message": "foclach", + "description": "(parameter name) If the ``verbose`` argument is given then extra information is printed." + }, + "micropython.qstr_info.param-doc.verbose": { + "message": "Má thugtar an argóint {{verbose}}, clóitear faisnéis bhreise.", + "description": "Parameter docs" + }, + "micropython.stack_use": { + "message": "úsáid cruach", + "description": "(function name) Return an integer representing the current amount of stack that is being\nused." + }, + "micropython.stack_use.summary": { + "message": "Tabhair slánuimhir ar ais a léiríonn an méid reatha cruach atá á\na úsáidtear.", + "description": "Return an integer representing the current amount of stack that is being\nused." + }, + "micropython.heap_lock": { + "message": "glas carn", + "description": "(function name) Lock the heap." + }, + "micropython.heap_lock.summary": { + "message": "Glasáil an carn.", + "description": "Lock the heap." + }, + "micropython.heap_unlock": { + "message": "díghlasáil carn", + "description": "(function name) Unlock the heap." + }, + "micropython.heap_unlock.summary": { + "message": "Díghlasáil an carn.", + "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": "Socraigh an carachtar a ardóidh eisceacht {{KeyboardInterrupt}} .", + "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": "Cód carachtar chun an t-idirbhriseadh nó -1 a ardú chun gabháil Ctrl-C a dhíchumasú.", + "description": "Parameter docs" + }, + "music": { + "message": "ceol", + "description": "(module name) Create and play melodies." + }, + "music.summary": { + "message": "Cruthaigh agus seinn séiseanna.", + "description": "Create and play melodies." + }, + "music.DADADADUM": { + "message": "dadadadum", + "description": "(field name) Melody: the opening to Beethoven’s 5th Symphony in C minor." + }, + "music.DADADADUM.summary": { + "message": "Fonn: oscailt 5ú Siansa Beethoven i C mion.", + "description": "Melody: the opening to Beethoven’s 5th Symphony in C minor." + }, + "music.ENTERTAINER": { + "message": "siamsóir", + "description": "(field name) Melody: the opening fragment of Scott Joplin’s Ragtime classic “The Entertainer”." + }, + "music.ENTERTAINER.summary": { + "message": "Fonn: an blúire oscailte de chlasaic Ragtime Scott Joplin \"The Entertainer\".", + "description": "Melody: the opening fragment of Scott Joplin’s Ragtime classic “The Entertainer”." + }, + "music.PRELUDE": { + "message": "réamhrá", + "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": "Fonn: oscailt an chéad Réamhrá i C Major de 48 Réamhráite agus Fugues 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": "Fonn: an téama \"Ode to Joy\" ó 9ú Siansa Beethoven in D minor.", + "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": "Fonn: téama Nyan Cat (http://www.nyan.cat/).", + "description": "Melody: the Nyan Cat theme (http://www.nyan.cat/)." + }, + "music.RINGTONE": { + "message": "clingthon", + "description": "(field name) Melody: something that sounds like a mobile phone ringtone." + }, + "music.RINGTONE.summary": { + "message": "Fonn: rud a fhuaimníonn cosúil le clingthon fón póca.", + "description": "Melody: something that sounds like a mobile phone ringtone." + }, + "music.FUNK": { + "message": "func", + "description": "(field name) Melody: a funky bass line for secret agents and criminal masterminds." + }, + "music.FUNK.summary": { + "message": "Fonn: líne dord spraíúil do ghníomhairí rúnda agus do mháistir-intinn choiriúla.", + "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": "Fonn: a boogie-woogie 12-bar blues ag siúl Bass.", + "description": "Melody: a boogie-woogie 12-bar blues walking bass." + }, + "music.BIRTHDAY": { + "message": "lá breithe", + "description": "(field name) Melody: “Happy Birthday to You…”" + }, + "music.BIRTHDAY.summary": { + "message": "Fonn: \"Breithlá sona duit...\"", + "description": "Melody: “Happy Birthday to You…”" + }, + "music.WEDDING": { + "message": "pósadh", + "description": "(field name) Melody: the bridal chorus from Wagner’s opera “Lohengrin”." + }, + "music.WEDDING.summary": { + "message": "Fonn: an curfá bridal ó cheoldráma Wagner \"Lohengrin\".", + "description": "Melody: the bridal chorus from Wagner’s opera “Lohengrin”." + }, + "music.FUNERAL": { + "message": "sochraid", + "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": "Fonn : an “máirseáil sochraide” ar a dtugtar freisin Sonáid Phianó Uimh. 2 i B♭ beag, Op. 35 le Frédéric Chopin.", + "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": "Fonn: tá blúire spraoi a léiríonn magadh déanta.", + "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": "Fonn: Máirseáil John Philip Sousa “Liberty Bell” ar a dtugtar téama “Monty Python’s Flying Circus” (ar a dtugtar an teanga ríomhchlárúcháin Python ina diaidh).", + "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": "drochdhuine", + "description": "(field name) Melody: silent movie era entrance of a baddy." + }, + "music.BADDY.summary": { + "message": "Fonn: bealach isteach ré an scannáin chiúin de drochdhuine.", + "description": "Melody: silent movie era entrance of a baddy." + }, + "music.CHASE": { + "message": "ruaig", + "description": "(field name) Melody: silent movie era chase scene." + }, + "music.CHASE.summary": { + "message": "Fonn: radharc ruaig ré scannán ciúin.", + "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": "Fonn: comhartha gearr chun a chur in iúl gur tharla rud éigin.", + "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": "Fonn: trombón an-bhrónach.", + "description": "Melody: a very sad trombone." + }, + "music.JUMP_UP": { + "message": "léim suas", + "description": "(field name) Melody: for use in a game, indicating upward movement." + }, + "music.JUMP_UP.summary": { + "message": "Fonn: le húsáid i gcluiche, rud a léiríonn gluaiseacht aníos.", + "description": "Melody: for use in a game, indicating upward movement." + }, + "music.JUMP_DOWN": { + "message": "léim síos", + "description": "(field name) Melody: for use in a game, indicating downward movement." + }, + "music.JUMP_DOWN.summary": { + "message": "Séis: le húsáid i gcluiche, rud a léiríonn gluaiseacht anuas.", + "description": "Melody: for use in a game, indicating downward movement." + }, + "music.POWER_UP": { + "message": "cumhacht suas", + "description": "(field name) Melody: a fanfare to indicate an achievement unlocked." + }, + "music.POWER_UP.summary": { + "message": "Fonn: fonnfóir chun éacht a dhíghlasáil a léiriú.", + "description": "Melody: a fanfare to indicate an achievement unlocked." + }, + "music.POWER_DOWN": { + "message": "cumhacht síos", + "description": "(field name) Melody: a sad fanfare to indicate an achievement lost." + }, + "music.POWER_DOWN.summary": { + "message": "Fonn: faitíos brónach chun éacht a cailleadh a léiriú.", + "description": "Melody: a sad fanfare to indicate an achievement lost." + }, + "music.set_tempo": { + "message": "socraigh tempo", + "description": "(function name) Sets the approximate tempo for playback." + }, + "music.set_tempo.summary": { + "message": "Socraigh an luas garbh le haghaidh athsheinm.", + "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": "Slánuimhir a chinneann cé mhéad buille in aghaidh an nóiméid.", + "description": "Parameter docs" + }, + "music.set_tempo.param-name.ticks": { + "message": "sceartáin", + "description": "(parameter name) The number of ticks constituting a beat." + }, + "music.set_tempo.param-doc.ticks": { + "message": "Líon na sceartán ar buille iad.", + "description": "Parameter docs" + }, + "music.get_tempo": { + "message": "faigh tempo", + "description": "(function name) Gets the current tempo as a tuple of integers: ``(ticks, bpm)``." + }, + "music.get_tempo.summary": { + "message": "Faigheann an luas reatha mar tupla slánuimhreacha: {{(ticks, bpm)}}.", + "description": "Gets the current tempo as a tuple of integers: ``(ticks, bpm)``." + }, + "music.play": { + "message": "seinn", + "description": "(function name) Plays music." + }, + "music.play.summary": { + "message": "Seinneann sé ceol.", + "description": "Plays music." + }, + "music.play.param-name.loop": { + "message": "lúb", + "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": "Má tá {{loop}} socraithe go {{True}}, athrá ar an tiún go dtí go dtugtar {{stop}} nó go gcuirtear isteach ar an nglao blocála.", + "description": "Parameter docs" + }, + "music.play.param-name.music": { + "message": "ceol", + "description": "(parameter name) music specified in `a special notation `_" + }, + "music.play.param-doc.music": { + "message": "ceol a shonraítear in 'nodaireacht speisialta '_", + "description": "Parameter docs" + }, + "music.play.param-name.pin": { + "message": "biorán", + "description": "(parameter name) the output pin for use with an external speaker (default ``pin0``), ``None`` for no sound." + }, + "music.play.param-doc.pin": { + "message": "an bioráin aschuir le húsáid le cainteoir seachtrach (réamhshocraithe {{pin0}}), {{None}} gan aon fhuaim.", + "description": "Parameter docs" + }, + "music.play.param-name.wait": { + "message": "fan", + "description": "(parameter name) If ``wait`` is set to ``True``, this function is blocking." + }, + "music.play.param-doc.wait": { + "message": "Má tá {{wait}} socraithe go {{True}}, tá an fheidhm seo ag blocáil.", + "description": "Parameter docs" + }, + "music.pitch": { + "message": "páirc", + "description": "(function name) Play a note." + }, + "music.pitch.summary": { + "message": "Seinn nóta.", + "description": "Play a note." + }, + "music.pitch.param-name.duration": { + "message": "fad", + "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": "Fad milleasoicind. Má tá fuaim dhiúltach ansin leanúnach go dtí an chéad ghlao eile nó glao ar {{stop}}.", + "description": "Parameter docs" + }, + "music.pitch.param-name.frequency": { + "message": "minicíocht", + "description": "(parameter name) An integer frequency" + }, + "music.pitch.param-doc.frequency": { + "message": "Minicíocht slánuimhir", + "description": "Parameter docs" + }, + "music.pitch.param-name.pin": { + "message": "biorán", + "description": "(parameter name) Optional output pin (default ``pin0``)." + }, + "music.pitch.param-doc.pin": { + "message": "Bioráin aschuir roghnach (réamhshocraithe {{pin0}}).", + "description": "Parameter docs" + }, + "music.pitch.param-name.wait": { + "message": "fan", + "description": "(parameter name) If ``wait`` is set to ``True``, this function is blocking." + }, + "music.pitch.param-doc.wait": { + "message": "Má tá {{wait}} socraithe go {{True}}, tá an fheidhm seo ag blocáil.", + "description": "Parameter docs" + }, + "music.stop": { + "message": "stad", + "description": "(function name) Stops all music playback on the built-in speaker and any pin outputting sound." + }, + "music.stop.summary": { + "message": "Stopann sé gach athsheinm ceoil ar an gcainteoir tógtha isteach agus aon fhuaim aschur bioráin.", + "description": "Stops all music playback on the built-in speaker and any pin outputting sound." + }, + "music.stop.param-name.pin": { + "message": "pionna", + "description": "(parameter name) An optional argument can be provided to specify a pin, e.g. ``music.stop(pin1)``." + }, + "music.stop.param-doc.pin": { + "message": "Is féidir argóint roghnach a chur ar fáil chun biorán a shonrú, m.sh. {{music.stop(pin1)}}.", + "description": "Parameter docs" + }, + "music.reset": { + "message": "athshocrú", + "description": "(function name) Resets ticks, bpm, duration and octave to their default values." + }, + "music.reset.summary": { + "message": "Athshocraigh sceartáin, bpm, fad agus ochtach chuig a luachanna réamhshocraithe.", + "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": "Stiallacha RGB agus RGBW LED atá inseolta ina n-aonar.", + "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": "Túsaigh stiall nua de soilse neopicsel a rialaítear trí bhiorán.", + "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": "Bearta in aghaidh an phicteilín. Maidir le tacaíocht neopicsel RGBW, pas 4 seachas mainneachtain 3 do RGB agus GRB.", + "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": "Líon na neopicsel sa stiall.", + "description": "Parameter docs" + }, + "neopixel.NeoPixel.__init__.param-name.pin": { + "message": "biorán", + "description": "(parameter name) The pin controlling the neopixel strip." + }, + "neopixel.NeoPixel.__init__.param-doc.pin": { + "message": "An biorán a rialaíonn an stiall neopicsel.", + "description": "Parameter docs" + }, + "neopixel.NeoPixel.clear": { + "message": "soiléir", + "description": "(function name) Clear all the pixels." + }, + "neopixel.NeoPixel.clear.summary": { + "message": "Glan na picteilíní go léir.", + "description": "Clear all the pixels." + }, + "neopixel.NeoPixel.show": { + "message": "taispeáin", + "description": "(function name) Show the pixels." + }, + "neopixel.NeoPixel.show.summary": { + "message": "Taispeáin na picteilíní.", + "description": "Show the pixels." + }, + "neopixel.NeoPixel.write": { + "message": "scríobh", + "description": "(function name) Show the pixels (micro:bit V2 only)." + }, + "neopixel.NeoPixel.write.summary": { + "message": "Taispeáin na picteilíní (micro:bit V2 amháin).", + "description": "Show the pixels (micro:bit V2 only)." + }, + "neopixel.NeoPixel.fill": { + "message": "líonadh", + "description": "(function name) Colour all pixels a given RGB/RGBW value (micro:bit V2 only)." + }, + "neopixel.NeoPixel.fill.summary": { + "message": "Dathaigh gach picteilín luach RGB / RGBW ar leith (micro:bit V2 amháin).", + "description": "Colour all pixels a given RGB/RGBW value (micro:bit V2 only)." + }, + "neopixel.NeoPixel.fill.param-name.colour": { + "message": "dath", + "description": "(parameter name) A tuple of the same length as the number of bytes per pixel (bpp)." + }, + "neopixel.NeoPixel.fill.param-doc.colour": { + "message": "Tupla den fhad céanna le líon na mbeart in aghaidh an phicteilín (bpp).", + "description": "Parameter docs" + }, + "neopixel.NeoPixel.__setitem__": { + "message": "socraigh mír", + "description": "(function name) Set a pixel colour." + }, + "neopixel.NeoPixel.__setitem__.summary": { + "message": "Socraigh dath picteilín.", + "description": "Set a pixel colour." + }, + "neopixel.NeoPixel.__setitem__.param-name.key": { + "message": "eochair", + "description": "(parameter name) The pixel number." + }, + "neopixel.NeoPixel.__setitem__.param-doc.key": { + "message": "Uimhir an phicteilín.", + "description": "Parameter docs" + }, + "neopixel.NeoPixel.__setitem__.param-name.value": { + "message": "luach", + "description": "(parameter name) The colour." + }, + "neopixel.NeoPixel.__setitem__.param-doc.value": { + "message": "An dath.", + "description": "Parameter docs" + }, + "neopixel.NeoPixel.__getitem__": { + "message": "faigh mír", + "description": "(function name) Get a pixel colour." + }, + "neopixel.NeoPixel.__getitem__.summary": { + "message": "Faigh dath picteilín.", + "description": "Get a pixel colour." + }, + "neopixel.NeoPixel.__getitem__.param-name.key": { + "message": "eochair", + "description": "(parameter name) The pixel number." + }, + "neopixel.NeoPixel.__getitem__.param-doc.key": { + "message": "Uimhir an phicteilín.", + "description": "Parameter docs" + }, + "neopixel.NeoPixel.__len__": { + "message": "len", + "description": "(function name) Get length of this pixel strip." + }, + "neopixel.NeoPixel.__len__.summary": { + "message": "Faigh fad an stiall picteilín seo.", + "description": "Get length of this pixel strip." + }, + "os": { + "message": "os", + "description": "(module name) Access the file system." + }, + "os.summary": { + "message": "Rochtain a fháil ar an gcóras comhad.", + "description": "Access the file system." + }, + "os.listdir": { + "message": "listdir", + "description": "(function name) List files." + }, + "os.listdir.summary": { + "message": "Liostaigh comhaid.", + "description": "List files." + }, + "os.remove": { + "message": "bain", + "description": "(function name) Remove (delete) a file." + }, + "os.remove.summary": { + "message": "Bain (scrios) comhad.", + "description": "Remove (delete) a file." + }, + "os.remove.param-name.filename": { + "message": "ainm comhaid", + "description": "(parameter name) The file to delete." + }, + "os.remove.param-doc.filename": { + "message": "An comhad le scriosadh.", + "description": "Parameter docs" + }, + "os.size": { + "message": "méid", + "description": "(function name) Returns the size of a file." + }, + "os.size.summary": { + "message": "Tuairisceáin méid comhaid.", + "description": "Returns the size of a file." + }, + "os.size.param-name.filename": { + "message": "ainm comhaid", + "description": "(parameter name) The file" + }, + "os.size.param-doc.filename": { + "message": "An comhad", + "description": "Parameter docs" + }, + "os.uname_result": { + "message": "toradh uname", + "description": "(class name) Result of ``os.uname()``" + }, + "os.uname_result.summary": { + "message": "Toradh de {{os.uname()}}", + "description": "Result of ``os.uname()``" + }, + "os.uname_result.sysname": { + "message": "ainm an chórais", + "description": "(field name) Operating system name." + }, + "os.uname_result.sysname.summary": { + "message": "Ainm an chórais oibriúcháin.", + "description": "Operating system name." + }, + "os.uname_result.nodename": { + "message": "ainm nóid", + "description": "(field name) Name of machine on network (implementation-defined)." + }, + "os.uname_result.nodename.summary": { + "message": "Ainm an mheaisín ar an líonra (cur i bhfeidhm sainithe).", + "description": "Name of machine on network (implementation-defined)." + }, + "os.uname_result.release": { + "message": "scaoileadh", + "description": "(field name) Operating system release." + }, + "os.uname_result.release.summary": { + "message": "Scaoileadh an chórais oibriúcháin.", + "description": "Operating system release." + }, + "os.uname_result.version": { + "message": "leagan", + "description": "(field name) Operating system version." + }, + "os.uname_result.version.summary": { + "message": "Leagan an chórais oibriúcháin.", + "description": "Operating system version." + }, + "os.uname_result.machine": { + "message": "meaisín", + "description": "(field name) Hardware identifier." + }, + "os.uname_result.machine.summary": { + "message": "Aitheantóir crua-earraí.", + "description": "Hardware identifier." + }, + "os.uname": { + "message": "uname", + "description": "(function name) Returns information identifying the current operating system." + }, + "os.uname.summary": { + "message": "Tuairisceáin faisnéis a aithníonn an córas oibriúcháin reatha.", + "description": "Returns information identifying the current operating system." + }, + "radio": { + "message": "raidió", + "description": "(module name) Communicate between micro:bits with the built-in radio." + }, + "radio.summary": { + "message": "Cumarsáid a dhéanamh idir micro:bit leis an raidió tógtha.", + "description": "Communicate between micro:bits with the built-in radio." + }, + "radio.RATE_1MBIT": { + "message": "ráta 1mbit", + "description": "(field name) Constant used to indicate a throughput of 1 MBit a second." + }, + "radio.RATE_1MBIT.summary": { + "message": "Tairiseach a úsáidtear chun tréchur 1 MBit an dara ceann a léiriú.", + "description": "Constant used to indicate a throughput of 1 MBit a second." + }, + "radio.RATE_2MBIT": { + "message": "ráta 2mbit", + "description": "(field name) Constant used to indicate a throughput of 2 MBit a second." + }, + "radio.RATE_2MBIT.summary": { + "message": "Tairiseach a úsáidtear chun tréchur 2 MBit an dara ceann a léiriú.", + "description": "Constant used to indicate a throughput of 2 MBit a second." + }, + "radio.on": { + "message": "ar", + "description": "(function name) Turns the radio on." + }, + "radio.on.summary": { + "message": "Casann sé an raidió air.", + "description": "Turns the radio on." + }, + "radio.off": { + "message": "as", + "description": "(function name) Turns off the radio, saving power and memory." + }, + "radio.off.summary": { + "message": "Múchann sé an raidió, ag sábháil cumhachta agus cuimhne.", + "description": "Turns off the radio, saving power and memory." + }, + "radio.config": { + "message": "cumraíocht", + "description": "(function name) Configures the radio." + }, + "radio.config.summary": { + "message": "Cumraigh an raidió.", + "description": "Configures the radio." + }, + "radio.config.param-name.address": { + "message": "seoladh", + "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) ainm treallach, arna shloinneadh mar sheoladh 32-giotán, a úsáidtear chun paicéid atá ag teacht isteach a scagadh ag leibhéal na crua-earraí, gan ach iad siúd a mheaitseáil leis an seoladh a shocraigh tú a choinneáil.\nIs é an réamhshocrú a úsáideann ardáin eile a bhaineann le micro:bit an socrú réamhshocraithe a úsáidtear anseo.", + "description": "Parameter docs" + }, + "radio.config.param-name.channel": { + "message": "cainéal", + "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": "(réamhshocrú = 7) slánuimhir luach ó 0 go 83 (san áireamh) a shainmhíníonn \"cainéal\" treallach a bhfuil an raidió tiúnta leis.\nSeolfar teachtaireachtaí tríd an gcainéal seo agus ní chuirfear ach teachtaireachtaí a fhaightear tríd an gcainéal seo ar an scuaine teachtaireachtaí atá ag teacht isteach. Tá gach céim 1MHz ar leithead, bunaithe ar 2400MHz.", + "description": "Parameter docs" + }, + "radio.config.param-name.data_rate": { + "message": "ráta sonraí", + "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": "(réamhshocrú={{radio.RATE_1MBIT}}) an luas ag a dtarlaíonn tréchur sonraí.\nIs féidir a bheith ar cheann de na tairisigh seo a leanas a shainmhínítear sa mhodúl {{radio}} : {{RATE_250KBIT}}, {{RATE_1MBIT}} nó {{RATE_2MBIT}}.", + "description": "Parameter docs" + }, + "radio.config.param-name.group": { + "message": "grúpa", + "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) luach 8-giotán (0-255) a úsáidtear leis an {{address}} agus teachtaireachtaí á scagadh.\nGo coincheapúil, tá \"seoladh\" cosúil le seoladh tí / oifige agus tá \"grúpa\" cosúil leis an duine ag an seoladh sin ar mian leat do theachtaireacht a sheoladh chuige.", + "description": "Parameter docs" + }, + "radio.config.param-name.length": { + "message": "fad", + "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": "Sainmhíníonn (réamhshocrú=32) an fad uasta, i mbéiteanna, de theachtaireacht a sheoltar tríd an raidió.\nFéadfaidh sé a bheith suas le 251 beart ar fhad (254 - 3 beart do réamhrá S0, FAD agus S1).", + "description": "Parameter docs" + }, + "radio.config.param-name.power": { + "message": "cumhacht", + "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": "(réamhshocrú = 6) Is luach slánuimhir ó 0 go 7 (san áireamh) a chur in iúl ar an neart comhartha a úsáidtear nuair a chraoladh teachtaireacht.\nDá airde an luach is ea is láidre an comhartha, ach is é an gléas is mó a chaitheann an chumhacht. Aistríonn an t-uimhriú go poist sa liosta seo a leanas de luachanna dBm (decibel milliwatt): -30, -20, -16, -12, -8, -4, 0, 4.", + "description": "Parameter docs" + }, + "radio.config.param-name.queue": { + "message": "scuaine", + "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": "(réamhshocrú = 3) sonraítear líon na dteachtaireachtaí is féidir a stóráil ar an scuaine teachtaireachta isteach.\nMura bhfuil aon spásanna fágtha ar an scuaine le haghaidh teachtaireachtaí isteach, ansin tá an teachtaireacht ag teacht isteach thit.", + "description": "Parameter docs" + }, + "radio.reset": { + "message": "athshocrú", + "description": "(function name) Reset the settings to their default values." + }, + "radio.reset.summary": { + "message": "Athshocraigh na socruithe dá luachanna réamhshocraithe.", + "description": "Reset the settings to their default values." + }, + "radio.send_bytes": { + "message": "seol bearta", + "description": "(function name) Sends a message containing bytes." + }, + "radio.send_bytes.summary": { + "message": "Seolann seo teachtaireacht ina bhfuil bearta.", + "description": "Sends a message containing bytes." + }, + "radio.send_bytes.param-name.message": { + "message": "teachtaireacht", + "description": "(parameter name) The bytes to send." + }, + "radio.send_bytes.param-doc.message": { + "message": "Na bearta le seoladh.", + "description": "Parameter docs" + }, + "radio.receive_bytes": { + "message": "bearta a fháil", + "description": "(function name) Receive the next incoming message on the message queue." + }, + "radio.receive_bytes.summary": { + "message": "Faigh an chéad teachtaireacht eile isteach ar an scuaine teachtaireachtaí.", + "description": "Receive the next incoming message on the message queue." + }, + "radio.receive_bytes_into": { + "message": "bearta a fháil isteach i", + "description": "(function name) Copy the next incoming message on the message queue into a buffer." + }, + "radio.receive_bytes_into.summary": { + "message": "Cóipeáil an chéad teachtaireacht isteach eile ar an scuaine teachtaireachta isteach i maolán.", + "description": "Copy the next incoming message on the message queue into a buffer." + }, + "radio.receive_bytes_into.param-name.buffer": { + "message": "maolán", + "description": "(parameter name) The target buffer. The message is truncated if larger than the buffer." + }, + "radio.receive_bytes_into.param-doc.buffer": { + "message": "An maolán sprice. Tá an teachtaireacht teasctha má tá sé níos mó ná an maolán.", + "description": "Parameter docs" + }, + "radio.send": { + "message": "seol", + "description": "(function name) Sends a message string." + }, + "radio.send.summary": { + "message": "Seolann seo teaghrán teachtaireachta.", + "description": "Sends a message string." + }, + "radio.send.param-name.message": { + "message": "teachtaireacht", + "description": "(parameter name) The string to send." + }, + "radio.send.param-doc.message": { + "message": "An sreangán le seoladh.", + "description": "Parameter docs" + }, + "radio.receive": { + "message": "faigh", + "description": "(function name) Works in exactly the same way as ``receive_bytes`` but returns whatever was sent." + }, + "radio.receive.summary": { + "message": "Oibríonn sé ar an mbealach céanna le {{receive_bytes}} ach filleann sé cibé rud a seoladh.", + "description": "Works in exactly the same way as ``receive_bytes`` but returns whatever was sent." + }, + "radio.receive_full": { + "message": "faigh iomlán", + "description": "(function name) Returns a tuple containing three values representing the next incoming message on the message queue." + }, + "radio.receive_full.summary": { + "message": "Tuairisceáin tupla ina bhfuil trí luach a léiríonn an chéad teachtaireacht eile ag teacht isteach ar an scuaine teachtaireacht.", + "description": "Returns a tuple containing three values representing the next incoming message on the message queue." + }, + "random": { + "message": "randamach", + "description": "(module name) Generate random numbers." + }, + "random.summary": { + "message": "Gin uimhreacha randamacha.", + "description": "Generate random numbers." + }, + "random.getrandbits": { + "message": "getrandbits", + "description": "(function name) Generate an integer with ``n`` random bits." + }, + "random.getrandbits.summary": { + "message": "Gin slánuimhir le {{n}} giotán randamach.", + "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": "Luach idir 1-30 (san áireamh).", + "description": "Parameter docs" + }, + "random.seed": { + "message": "síol", + "description": "(function name) Initialize the random number generator." + }, + "random.seed.summary": { + "message": "Túsaigh an gineadóir uimhreacha randamacha.", + "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": "An síol slánuimhir", + "description": "Parameter docs" + }, + "random.randint": { + "message": "randint", + "description": "(function name) Choose a random integer between ``a`` and ``b`` inclusive." + }, + "random.randint.summary": { + "message": "Roghnaigh slánuimhir randamach idir {{a}} agus {{b}} san áireamh.", + "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": "Luach tosaigh don raon (san áireamh)", + "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": "Luach deiridh don raon (san áireamh)", + "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": "Roghnaigh slánuimhir a roghnaíodh go randamach idir nialas agus suas le (ach ní\nlena n-áirítear) {{stop}}.", + "description": "Choose a randomly selected integer between zero and up to (but not\nincluding) ``stop``." + }, + "random.randrange-1.param-name.stop": { + "message": "stad", + "description": "(parameter name) End value for the range (exclusive)" + }, + "random.randrange-1.param-doc.stop": { + "message": "Luach deiridh don raon (eisiach)", + "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": "Roghnaigh eilimint a roghnaíodh go randamach ó {{range(start, stop, step)}}.", + "description": "Choose a randomly selected element from ``range(start, stop, step)``." + }, + "random.randrange-2.param-name.start": { + "message": "tús", + "description": "(parameter name) The start of the range (inclusive)" + }, + "random.randrange-2.param-doc.start": { + "message": "Tús an raoin (san áireamh)", + "description": "Parameter docs" + }, + "random.randrange-2.param-name.step": { + "message": "céim", + "description": "(parameter name) The step." + }, + "random.randrange-2.param-doc.step": { + "message": "An chéim.", + "description": "Parameter docs" + }, + "random.randrange-2.param-name.stop": { + "message": "stad", + "description": "(parameter name) The end of the range (exclusive)" + }, + "random.randrange-2.param-doc.stop": { + "message": "Deireadh an raoin (eisiach)", + "description": "Parameter docs" + }, + "random.choice": { + "message": "rogha", + "description": "(function name) Choose a random element from the non-empty sequence ``seq``." + }, + "random.choice.summary": { + "message": "Roghnaigh eilimint randamach ón seicheamh neamhfholamh {{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": "Seicheamh.", + "description": "Parameter docs" + }, + "random.random": { + "message": "randamach", + "description": "(function name) Generate a random floating point number in the range [0.0, 1.0)." + }, + "random.random.summary": { + "message": "Gin uimhir randamach snámhphointe sa raon [0.0, 1.0).", + "description": "Generate a random floating point number in the range [0.0, 1.0)." + }, + "random.uniform": { + "message": "éide", + "description": "(function name) Return a random floating point number between ``a`` and ``b`` inclusive." + }, + "random.uniform.summary": { + "message": "Seol uimhir randamach snámhphointe ar ais idir {{a}} agus {{b}} san áireamh.", + "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": "Luach tosaigh don raon (san áireamh)", + "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": "Luach deiridh don raon (san áireamh)", + "description": "Parameter docs" + }, + "speech": { + "message": "óráid", + "description": "(module name) Make the micro:bit talk, sing and make other speech like sounds." + }, + "speech.summary": { + "message": "Cuir an micro:bit ag caint, ag canadh agus ag déanamh fuaimeanna eile cosúil le cainte.", + "description": "Make the micro:bit talk, sing and make other speech like sounds." + }, + "speech.translate": { + "message": "aistrigh", + "description": "(function name) Translate English words to phonemes." + }, + "speech.translate.summary": { + "message": "Aistrigh focail Bhéarla go fóinéimí.", + "description": "Translate English words to phonemes." + }, + "speech.translate.param-name.words": { + "message": "focail", + "description": "(parameter name) A string of English words." + }, + "speech.translate.param-doc.words": { + "message": "Teaghrán focal Béarla.", + "description": "Parameter docs" + }, + "speech.pronounce": { + "message": "fuaimniú", + "description": "(function name) Pronounce phonemes." + }, + "speech.pronounce.summary": { + "message": "Fóinéimí a fhuaimniú.", + "description": "Pronounce phonemes." + }, + "speech.pronounce.param-name.mouth": { + "message": "béal", + "description": "(parameter name) A number representing the mouth of the voice" + }, + "speech.pronounce.param-doc.mouth": { + "message": "Uimhir a sheasann do bhéal an ghutha", + "description": "Parameter docs" + }, + "speech.pronounce.param-name.phonemes": { + "message": "fóinéimí", + "description": "(parameter name) The string of phonemes to pronounce" + }, + "speech.pronounce.param-doc.phonemes": { + "message": "An teaghrán fóinéimí a fhuaimniú", + "description": "Parameter docs" + }, + "speech.pronounce.param-name.pin": { + "message": "biorán", + "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": "Is féidir argóint roghnach chun an bioráin aschuir a shonrú a úsáid chun mainneachtain {{pin0}}a shárú.\nMura dteastaíonn uainn aon fhuaim a sheinm as na bioráin is féidir {{pin=None}}a úsáid. micro:bit V2 amháin.", + "description": "Parameter docs" + }, + "speech.pronounce.param-name.pitch": { + "message": "airde", + "description": "(parameter name) A number representing the pitch of the voice" + }, + "speech.pronounce.param-doc.pitch": { + "message": "Uimhir a sheasann do pháirc an ghutha", + "description": "Parameter docs" + }, + "speech.pronounce.param-name.speed": { + "message": "luas", + "description": "(parameter name) A number representing the speed of the voice" + }, + "speech.pronounce.param-doc.speed": { + "message": "Uimhir a léiríonn luas an ghutha", + "description": "Parameter docs" + }, + "speech.pronounce.param-name.throat": { + "message": "scornach", + "description": "(parameter name) A number representing the throat of the voice" + }, + "speech.pronounce.param-doc.throat": { + "message": "Uimhir a sheasann do scornach an ghutha", + "description": "Parameter docs" + }, + "speech.say": { + "message": "abair", + "description": "(function name) Say English words." + }, + "speech.say.summary": { + "message": "Abair focail Bhéarla.", + "description": "Say English words." + }, + "speech.say.param-name.mouth": { + "message": "béal", + "description": "(parameter name) A number representing the mouth of the voice" + }, + "speech.say.param-doc.mouth": { + "message": "Uimhir a sheasann do bhéal an ghutha", + "description": "Parameter docs" + }, + "speech.say.param-name.pin": { + "message": "biorán", + "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": "Is féidir argóint roghnach a úsáid chun an biorán aschuir a shonrú chun an réamhshocrú {{pin0}} a shárú.\nMura dteastaíonn uainn go seinnfí aon fhuaim as na bioráin is féidir {{pin=None}} a úsáid. micro:bit V2 amháin.", + "description": "Parameter docs" + }, + "speech.say.param-name.pitch": { + "message": "airde", + "description": "(parameter name) A number representing the pitch of the voice" + }, + "speech.say.param-doc.pitch": { + "message": "Uimhir a léiríonn airde an ghutha", + "description": "Parameter docs" + }, + "speech.say.param-name.speed": { + "message": "luas", + "description": "(parameter name) A number representing the speed of the voice" + }, + "speech.say.param-doc.speed": { + "message": "Uimhir a léiríonn luas an ghlór", + "description": "Parameter docs" + }, + "speech.say.param-name.throat": { + "message": "scornach", + "description": "(parameter name) A number representing the throat of the voice" + }, + "speech.say.param-doc.throat": { + "message": "Uimhir a sheasann do scornach an ghutha", + "description": "Parameter docs" + }, + "speech.say.param-name.words": { + "message": "focail", + "description": "(parameter name) The string of words to say." + }, + "speech.say.param-doc.words": { + "message": "An teaghrán focal le rá.", + "description": "Parameter docs" + }, + "speech.sing": { + "message": "canadh", + "description": "(function name) Sing phonemes." + }, + "speech.sing.summary": { + "message": "Can fóinéimí.", + "description": "Sing phonemes." + }, + "speech.sing.param-name.mouth": { + "message": "béal", + "description": "(parameter name) A number representing the mouth of the voice" + }, + "speech.sing.param-doc.mouth": { + "message": "Uimhir a sheasann do bhéal an ghutha", + "description": "Parameter docs" + }, + "speech.sing.param-name.phonemes": { + "message": "fóinéimí", + "description": "(parameter name) The string of words to sing." + }, + "speech.sing.param-doc.phonemes": { + "message": "An teaghrán focal le canadh.", + "description": "Parameter docs" + }, + "speech.sing.param-name.pin": { + "message": "biorán", + "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": "Is féidir argóint roghnach chun an bioráin aschuir a shonrú a úsáid chun mainneachtain {{pin0}}a shárú.\nMura dteastaíonn uainn aon fhuaim a sheinm as na bioráin is féidir {{pin=None}}a úsáid. micro:bit V2 amháin.", + "description": "Parameter docs" + }, + "speech.sing.param-name.pitch": { + "message": "airde", + "description": "(parameter name) A number representing the pitch of the voice" + }, + "speech.sing.param-doc.pitch": { + "message": "Uimhir a léiríonn airde an ghutha", + "description": "Parameter docs" + }, + "speech.sing.param-name.speed": { + "message": "luas", + "description": "(parameter name) A number representing the speed of the voice" + }, + "speech.sing.param-doc.speed": { + "message": "Uimhir a léiríonn luas an ghlór", + "description": "Parameter docs" + }, + "speech.sing.param-name.throat": { + "message": "scornach", + "description": "(parameter name) A number representing the throat of the voice" + }, + "speech.sing.param-doc.throat": { + "message": "Uimhir a sheasann do scornach an ghutha", + "description": "Parameter docs" + }, + "struct": { + "message": "struct", + "description": "(module name) Pack and unpack primitive data types." + }, + "struct.summary": { + "message": "Pacáistiú agus díphacáil cineálacha sonraí bunúsach.", + "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": "Faigh líon na mbeart a theastaíonn chun an {{fmt}} tugtha a stóráil.", + "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": "Teaghrán formáide.", + "description": "Parameter docs" + }, + "struct.pack": { + "message": "pacáiste", + "description": "(function name) Pack values according to a format string." + }, + "struct.pack.summary": { + "message": "Pacáil luachanna de réir teaghrán formáide.", + "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": "Na luachanna atá fágtha.", + "description": "Parameter docs" + }, + "struct.pack.param-name.fmt": { + "message": "fmt", + "description": "(parameter name) The format string." + }, + "struct.pack.param-doc.fmt": { + "message": "An teaghrán formáide.", + "description": "Parameter docs" + }, + "struct.pack.param-name.v1": { + "message": "v1", + "description": "(parameter name) The first value." + }, + "struct.pack.param-doc.v1": { + "message": "An chéad luach.", + "description": "Parameter docs" + }, + "struct.pack_into": { + "message": "pacáil isteach i", + "description": "(function name) Pack values according to a format string." + }, + "struct.pack_into.summary": { + "message": "Pacáil luachanna de réir teaghrán formáide.", + "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": "Na luachanna atá fágtha.", + "description": "Parameter docs" + }, + "struct.pack_into.param-name.buffer": { + "message": "maolán", + "description": "(parameter name) The target buffer to write into." + }, + "struct.pack_into.param-doc.buffer": { + "message": "An maolán sprice le scríobh isteach.", + "description": "Parameter docs" + }, + "struct.pack_into.param-name.fmt": { + "message": "fmt", + "description": "(parameter name) The format string." + }, + "struct.pack_into.param-doc.fmt": { + "message": "An teaghrán formáide.", + "description": "Parameter docs" + }, + "struct.pack_into.param-name.offset": { + "message": "fritháireamh", + "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": "An fritháireamh isteach sa mhaolán. D'fhéadfadh sé a bheith diúltach le comhaireamh ó dheireadh an mhaoláin.", + "description": "Parameter docs" + }, + "struct.pack_into.param-name.v1": { + "message": "v1", + "description": "(parameter name) The first value." + }, + "struct.pack_into.param-doc.v1": { + "message": "An chéad luach.", + "description": "Parameter docs" + }, + "struct.unpack": { + "message": "díphacáil", + "description": "(function name) Unpack data according to a format string." + }, + "struct.unpack.summary": { + "message": "Díphacáil sonraí de réir teaghrán formáide.", + "description": "Unpack data according to a format string." + }, + "struct.unpack.param-name.data": { + "message": "sonraí", + "description": "(parameter name) The data." + }, + "struct.unpack.param-doc.data": { + "message": "Na sonraí.", + "description": "Parameter docs" + }, + "struct.unpack.param-name.fmt": { + "message": "fmt", + "description": "(parameter name) The format string." + }, + "struct.unpack.param-doc.fmt": { + "message": "An teaghrán formáide.", + "description": "Parameter docs" + }, + "struct.unpack_from": { + "message": "díphacáil ó", + "description": "(function name) Unpack data from a buffer according to a format string." + }, + "struct.unpack_from.summary": { + "message": "Díphacáil sonraí ó mhaolán de réir teaghrán formáide.", + "description": "Unpack data from a buffer according to a format string." + }, + "struct.unpack_from.param-name.buffer": { + "message": "maolán", + "description": "(parameter name) The source buffer to read from." + }, + "struct.unpack_from.param-doc.buffer": { + "message": "An maolán foinseach le léamh as.", + "description": "Parameter docs" + }, + "struct.unpack_from.param-name.fmt": { + "message": "fmt", + "description": "(parameter name) The format string." + }, + "struct.unpack_from.param-doc.fmt": { + "message": "An teaghrán formáide.", + "description": "Parameter docs" + }, + "struct.unpack_from.param-name.offset": { + "message": "fritháireamh", + "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": "An fritháireamh isteach sa mhaolán. D'fhéadfadh sé a bheith diúltach le comhaireamh ó dheireadh an mhaoláin.", + "description": "Parameter docs" + }, + "sys": { + "message": "sys", + "description": "(module name) System specific functions" + }, + "sys.summary": { + "message": "Feidhmeanna a bhaineann go sonrach leis an gcóras", + "description": "System specific functions" + }, + "sys.exit": { + "message": "scoir", + "description": "(function name) Terminate current program with a given exit code." + }, + "sys.exit.summary": { + "message": "Cuir deireadh leis an ríomhchlár reatha le cód scoir ar leith.", + "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": "An cód scoir nó an teachtaireacht.", + "description": "Parameter docs" + }, + "sys.print_exception": { + "message": "eisceacht priontála", + "description": "(function name) Print an exception with a traceback." + }, + "sys.print_exception.summary": { + "message": "Priontáil eisceacht le rianú siar.", + "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": "An eisceacht maidir le priontáil", + "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": "Liosta inathraithe d'argóintí a cuireadh tús leis an gclár reatha leo.", + "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": "Ord beart an chórais ({{\"little\"}} nó {{\"big\"}}).", + "description": "The byte order of the system (``\"little\"`` or ``\"big\"``)." + }, + "sys.implementation": { + "message": "cur i bhfeidhm", + "description": "(field name) Object with information about the current Python implementation." + }, + "sys.implementation.summary": { + "message": "Cuspóir le faisnéis faoi chur i bhfeidhm reatha Python.", + "description": "Object with information about the current Python implementation." + }, + "sys.maxsize": { + "message": "uasmhéid", + "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": "\nUasluach is féidir le cineál slánuimhir dhúchasach a shealbhú ar an ardán reatha,\nnó an luach uasta is féidir a léiriú le cineál slánuimhir MicroPython, má tá sé níos lú\nná uasluach ardáin (is é sin an cás i gcás calafoirt MicroPython gan\ntacaíocht int fada).", + "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": "modúil", + "description": "(field name) Dictionary of loaded modules. " + }, + "sys.modules.summary": { + "message": "Foclóir modúil luchtaithe. ", + "description": "Dictionary of loaded modules. " + }, + "sys.path": { + "message": "cosán", + "description": "(field name) A mutable list of directories to search for imported modules." + }, + "sys.path.summary": { + "message": "Liosta inathraithe d’eolairí le cuardach a dhéanamh ar mhodúil allmhairithe.", + "description": "A mutable list of directories to search for imported modules." + }, + "sys.platform": { + "message": "ardán", + "description": "(field name) The platform that MicroPython is running on. " + }, + "sys.platform.summary": { + "message": "An t-ardán a bhfuil MicroPython ag rith air. ", + "description": "The platform that MicroPython is running on. " + }, + "sys.version": { + "message": "leagan", + "description": "(field name) Python language version that this implementation conforms to, as a string." + }, + "sys.version.summary": { + "message": "Leagan teanga Python a chloíonn leis an gcur i bhfeidhm seo, mar theaghrán.", + "description": "Python language version that this implementation conforms to, as a string." + }, + "sys.version_info": { + "message": "eolas faoin leagan", + "description": "(field name) Python language version that this implementation conforms to, as a tuple of ints." + }, + "sys.version_info.summary": { + "message": "Leagan teanga Python a gcomhlíonann an cur i bhfeidhm seo, mar thupla de shláintiúirí.", + "description": "Python language version that this implementation conforms to, as a tuple of ints." + }, + "time": { + "message": "am", + "description": "(module name) Measure time and add delays to programs." + }, + "time.summary": { + "message": "Tomhais am agus cuir moilleanna le ríomhchláir.", + "description": "Measure time and add delays to programs." + }, + "time.sleep": { + "message": "codladh", + "description": "(function name) Delay a number of seconds." + }, + "time.sleep.summary": { + "message": "Moill a chur ar roinnt soicindí.", + "description": "Delay a number of seconds." + }, + "time.sleep.param-name.seconds": { + "message": "soicindí", + "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": "Líon na soicindí le codladh.\nBain úsáid as uimhir snámhphointe chun codladh ar feadh uimhir chodánach soicind.", + "description": "Parameter docs" + }, + "time.sleep_ms": { + "message": "codladh ms", + "description": "(function name) Delay for given number of milliseconds." + }, + "time.sleep_ms.summary": { + "message": "Moill ar líon áirithe milleasoicindí.", + "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": "Líon na milleasoicindí moill (>= 0).", + "description": "Parameter docs" + }, + "time.sleep_us": { + "message": "codladh linn", + "description": "(function name) Delay for given number of microseconds." + }, + "time.sleep_us.summary": { + "message": "Moill ar líon áirithe micreasoicindí.", + "description": "Delay for given number of microseconds." + }, + "time.sleep_us.param-name.us": { + "message": "linn", + "description": "(parameter name) The number of microseconds delay (>= 0)." + }, + "time.sleep_us.param-doc.us": { + "message": "Líon na micreasoicindí moill (>= 0).", + "description": "Parameter docs" + }, + "time.ticks_ms": { + "message": "sceartáin 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": "Faigh cuntar milleasoicind atá ag dul i méid le pointe tagartha treallach,\na chlúdaíonn thart tar éis luach éigin.", + "description": "Get an increasing, millisecond counter with an arbitrary reference point,\nthat wraps around after some value." + }, + "time.ticks_us": { + "message": "tic a chur orainn", + "description": "(function name) Get an increasing, microsecond counter with an arbitrary reference point,\nthat wraps around after some value." + }, + "time.ticks_us.summary": { + "message": "Faigh cuntar méadaitheach micreasoicind le pointe tagartha treallach,\na chlúdaíonn thart tar éis luach éigin.", + "description": "Get an increasing, microsecond counter with an arbitrary reference point,\nthat wraps around after some value." + }, + "time.ticks_add": { + "message": "cuir sceartáin", + "description": "(function name) Offset ticks value by a given number, which can be either positive or\nnegative." + }, + "time.ticks_add.summary": { + "message": "Fritháireamh luach ticeanna de réir uimhir ar leith, a d'fhéadfadh a bheith dearfach nó\ndiúltach.", + "description": "Offset ticks value by a given number, which can be either positive or\nnegative." + }, + "time.ticks_add.param-name.delta": { + "message": "deilte", + "description": "(parameter name) An integer offset" + }, + "time.ticks_add.param-doc.delta": { + "message": "Fritháireamh slánuimhir", + "description": "Parameter docs" + }, + "time.ticks_add.param-name.ticks": { + "message": "sceartáin", + "description": "(parameter name) A ticks value" + }, + "time.ticks_add.param-doc.ticks": { + "message": "Luach ticeanna", + "description": "Parameter docs" + }, + "time.ticks_diff": { + "message": "ticeanna difr", + "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": "Tomhais an difríocht idir luachanna a chuirtear ar ais ó\n{{time.ticks_ms()}} nó {{ticks_us()}}, mar luach sínithe\na d'fhéadfadh timfhilleadh timpeall.", + "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": "ticeanna1", + "description": "(parameter name) The value to subtract from" + }, + "time.ticks_diff.param-doc.ticks1": { + "message": "An luach a dhealú ó", + "description": "Parameter docs" + }, + "time.ticks_diff.param-name.ticks2": { + "message": "ticeanna2", + "description": "(parameter name) The value to subtract" + }, + "time.ticks_diff.param-doc.ticks2": { + "message": "An luach a dhealú", + "description": "Parameter docs" + } +} \ No newline at end of file diff --git a/lang/ga-ie/typeshed/stdlib/VERSIONS b/lang/ga-ie/typeshed/stdlib/VERSIONS new file mode 100644 index 0000000..67b710f --- /dev/null +++ b/lang/ga-ie/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/ga-ie/typeshed/stdlib/_typeshed/__init__.pyi b/lang/ga-ie/typeshed/stdlib/_typeshed/__init__.pyi new file mode 100644 index 0000000..7bf6e72 --- /dev/null +++ b/lang/ga-ie/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/ga-ie/typeshed/stdlib/abc.pyi b/lang/ga-ie/typeshed/stdlib/abc.pyi new file mode 100644 index 0000000..18bb090 --- /dev/null +++ b/lang/ga-ie/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/ga-ie/typeshed/stdlib/antigravity.pyi b/lang/ga-ie/typeshed/stdlib/antigravity.pyi new file mode 100644 index 0000000..e69de29 diff --git a/lang/ga-ie/typeshed/stdlib/array.pyi b/lang/ga-ie/typeshed/stdlib/array.pyi new file mode 100644 index 0000000..1e4e630 --- /dev/null +++ b/lang/ga-ie/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/ga-ie/typeshed/stdlib/audio.pyi b/lang/ga-ie/typeshed/stdlib/audio.pyi new file mode 100644 index 0000000..b1d39c7 --- /dev/null +++ b/lang/ga-ie/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/ga-ie/typeshed/stdlib/builtins.pyi b/lang/ga-ie/typeshed/stdlib/builtins.pyi new file mode 100644 index 0000000..8b7dfb9 --- /dev/null +++ b/lang/ga-ie/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/ga-ie/typeshed/stdlib/collections/__init__.pyi b/lang/ga-ie/typeshed/stdlib/collections/__init__.pyi new file mode 100644 index 0000000..8815a4b --- /dev/null +++ b/lang/ga-ie/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/ga-ie/typeshed/stdlib/errno.pyi b/lang/ga-ie/typeshed/stdlib/errno.pyi new file mode 100644 index 0000000..6ff1c70 --- /dev/null +++ b/lang/ga-ie/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/ga-ie/typeshed/stdlib/gc.pyi b/lang/ga-ie/typeshed/stdlib/gc.pyi new file mode 100644 index 0000000..1fd3bd4 --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/gc.pyi @@ -0,0 +1,68 @@ +"""Rialú ar an bailitheoir truflais""" +from typing import overload + +def enable() -> None: + """Cumasaigh bailiú truflais uathoibríoch. (chumasú)""" + ... + +def disable() -> None: + """Díchumasaigh bailiú truflais uathoibríoch. (dhíchumasú) + +Heap memory can still be allocated, +and garbage collection can still be initiated manually using ``gc.collect``.""" + +def collect() -> None: + """Rith bailiúchán truflais. (bhailiú)""" + ... + +def mem_alloc() -> int: + """Faigh líon na mbeart de RAM carn atá leithdháilte. + +:return: The number of bytes allocated. + +This function is MicroPython extension.""" + ... + +def mem_free() -> int: + """Faigh líon na mbeart de RAM gcarn atá ar fáil, nó -1 mura bhfuil an méid seo ar eolas. (cuimhne saor) + +:return: The number of bytes free. + +This function is MicroPython extension.""" + ... + +@overload +def threshold() -> int: + """Ceistigh an tairseach leithdháilte GC bhreise. (tairseach) + +: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: + """Socraigh an tairseach leithdháilte GC breise. (tairseach) + +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: (méid) Líon na mbeart ina dhiaidh sin ba cheart bailiúchán truflais a spreagadh.""" + ... \ No newline at end of file diff --git a/lang/ga-ie/typeshed/stdlib/log.pyi b/lang/ga-ie/typeshed/stdlib/log.pyi new file mode 100644 index 0000000..af6760f --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/log.pyi @@ -0,0 +1,89 @@ +"""Logáil sonraí chuig do micro:bit V2. (loga)""" +from typing import Literal, Mapping, Optional, Union, overload +MILLISECONDS = 1 +"""Formáid stampa ama milleasoicindí. (milleasoicindí)""" +SECONDS = 10 +"""Formáid stampa ama soicindí. (soicindí)""" +MINUTES = 600 +"""Formáid stampa ama nóiméad. (nóiméad)""" +HOURS = 36000 +"""Formáid stampa ama uaireanta. (uair an chloig)""" +DAYS = 864000 +"""Formáid stampa ama na laethanta. (laethanta)""" + +def set_labels(*labels: str, timestamp: Optional[Literal[1, 10, 36000, 864000]]=SECONDS) -> None: + """Socraigh ceanntásc an chomhaid logála. (lipéid a shocrú) + +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: (*lipéid) Aon líon argóintí suímh, gach ceann ag freagairt d'iontráil sa cheanntásc loga. +:param timestamp: (stampa ama) Roghnaigh an t-aonad stampa ama a chuirfear leis go huathoibríoch mar an chéad cholún i ngach ró. Is féidir le luachanna stampa ama a bheith mar cheann de ``log.MILLISECONDS``, ``log.SECONDS``, ``log.MINUTES``, ``log.HOURS``, ``log.DAYS`` nó ``None`` chun an stampa ama a dhíchumasú. Is é ``log.SECONDS`` an luach réamhshocraithe.""" + ... + +@overload +def add(data_dictionary: Optional[Mapping[str, Union[str, int, float]]]) -> None: + """Cuir ró sonraí leis an loga trí fhoclóir ceanntásca agus luachanna a rith. (cuir leis) + +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: (foclóir sonraí) Na sonraí le logáil mar fhoclóir le heochair do gach ceanntásc.""" + ... + +@overload +def add(**kwargs: Union[str, int, float]) -> None: + """Cuir ró sonraí leis an logáil ag baint úsáide as argóintí eochairfhocail. (suimigh) + +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): + """Scrios inneachar an loga, lena n-áirítear ceanntásca. (scrios) + +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: (iomlán) Roghnaíonn ``True`` scriosadh “lán” agus roghnaíonn ``False`` an modh scriosta “tapa”.""" + ... + +def set_mirroring(serial: bool): + """Cumraigh scáthánú na gníomhaíochta logála sonraí chuig an aschur sraitheach. (scáthánú socraithe) + +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: (sraitheach) Cumasaíonn ``True`` sonraí a scáthánú leis an aschur sraitheach.""" + ... \ No newline at end of file diff --git a/lang/ga-ie/typeshed/stdlib/love.pyi b/lang/ga-ie/typeshed/stdlib/love.pyi new file mode 100644 index 0000000..9018624 --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/love.pyi @@ -0,0 +1 @@ +def badaboom() -> None: ... diff --git a/lang/ga-ie/typeshed/stdlib/machine.pyi b/lang/ga-ie/typeshed/stdlib/machine.pyi new file mode 100644 index 0000000..937ae79 --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/machine.pyi @@ -0,0 +1,84 @@ +"""Fóntais leibhéal íseal. (meaisín)""" +from typing import Any +from .microbit import MicroBitDigitalPin + +def unique_id() -> bytes: + """Faigh beart teaghrán le haitheantóir uathúil cláir. (id uathúil) + +Example: ``machine.unique_id()`` + +:return: An identifier that varies from one board instance to another.""" + ... + +def reset() -> None: + """Athshocraigh an gléas ar bhealach cosúil le brúigh an cnaipe ATHSHOCRAITHE seachtrach. (athshocrú) + +Example: ``machine.reset()``""" + ... + +def freq() -> int: + """Faigh an minicíocht LAP i hertz. (minicíocht) + +Example: ``machine.freq()`` + +:return: The CPU frequency.""" + ... + +def disable_irq() -> Any: + """Díchumasaigh iarratais idirbhriste. (díchumasaigh irq) + +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: + """Athchumasaigh iarratais idirbhriste. (cumasaigh irq) + +Example: ``machine.enable_irq(interrupt_state)`` + +:param state: (stát) An luach a cuireadh ar ais ón nglao is déanaí chuig an bhfeidhm ``disable_irq``.""" + ... + +def time_pulse_us(pin: MicroBitDigitalPin, pulse_level: int, timeout_us: int=1000000) -> int: + """Am buille ar bhioráin. (cuisle ama 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: (bioráin) An biorán le húsáid +:param pulse_level: (leibhéal cuisle) 0 go ham cuisle íseal nó 1 go ham cuisle ard +:param timeout_us: (am istigh linn) Teorainn ama micrea soicind +: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: + """An rang le haghaidh radharcanna cuimhne ``mem8``, ``mem16`` agus ``mem32``. (cuimhne)""" + + def __getitem__(self, address: int) -> int: + """Faigh luach ó chuimhne. (faigh-mír) + +:param address: (seoladh) An seoladh cuimhne. +:return: The value at that address as an integer.""" + ... + + def __setitem__(self, address: int, value: int) -> None: + """Socraigh luach ag an seoladh a thugtar. (socraigh-mír) + +:param address: (seoladh) An seoladh cuimhne. +:param value: (luach) An luach slánuimhir a shocrú.""" + ... +mem8: mem +"""Amharc 8-giotán (beart) ar chuimhne. (cuimhne8)""" +mem16: mem +"""Radharc 16-giotán ar chuimhne. (cuimhne16)""" +mem32: mem +"""Amharc 32-giotán ar chuimhne. (cuimhne32)""" \ No newline at end of file diff --git a/lang/ga-ie/typeshed/stdlib/math.pyi b/lang/ga-ie/typeshed/stdlib/math.pyi new file mode 100644 index 0000000..34672df --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/math.pyi @@ -0,0 +1,246 @@ +"""Feidhmeanna matamaiticiúla. (mata)""" +from typing import Tuple + +def acos(x: float) -> float: + """Ríomh an cosine inbhéartach. + +Example: ``math.acos(1)`` + +:param x: Uimhir +:return: The inverse cosine of ``x``""" + ... + +def asin(x: float) -> float: + """Ríomh an sine inbhéartach. + +Example: ``math.asin(0)`` + +:param x: Uimhir +:return: The inverse sine of ``x``""" + ... + +def atan(x: float) -> float: + """Ríomh an tadhlaí inbhéartach. + +Example: ``math.atan(0)`` + +:param x: Uimhir +:return: The inverse tangent of ``x``""" + ... + +def atan2(y: float, x: float) -> float: + """Ríomh príomhluach an tadhlaí inbhéartach de ``y/x``. + +Example: ``math.atan2(0, -1)`` + +:param y: Uimhir +:param x: Uimhir +:return: The principal value of the inverse tangent of ``y/x``""" + ... + +def ceil(x: float) -> float: + """Déan roinnt a shlánú i dtreo éigríochta dearfach. (síleáil) + +Example: ``math.ceil(0.1)`` + +:param x: Uimhir +:return: ``x`` rounded towards positive infinity.""" + ... + +def copysign(x: float, y: float) -> float: + """Ríomh ``x`` le comhartha ``y``. (cóipchomhartha) + +Example: ``math.copysign(1, -1)`` + +:param x: Uimhir +:param y: Foinse an chomhartha don luach fillte +:return: ``x`` with the sign of ``y``""" + ... + +def cos(x: float) -> float: + """Ríomh an comhshíneas de ``x``. + +Example: ``math.cos(0)`` + +:param x: Uimhir +:return: The cosine of ``x``""" + ... + +def degrees(x: float) -> float: + """Raidian Tiontaigh go céimeanna. (céimeanna) + +Example: ``math.degrees(2 * math.pi)`` + +:param x: Luach i radaíní +:return: The value converted to degrees""" + ... + +def exp(x: float) -> float: + """Ríomh easpónantúil ``x``. + +Example: ``math.exp(1)`` + +:param x: Uimhir +:return: The exponential of ``x``.""" + ... + +def fabs(x: float) -> float: + """Tabhair luach absalóideach ``x``ar ais. + +Example: ``math.fabs(-0.1)`` + +:param x: Uimhir +:return: The absolute value of ``x``""" + ... + +def floor(x: float) -> int: + """Babhtaigh uimhir i dtreo éigríoch diúltach. (urlár) + +Example: ``math.floor(0.9)`` + +:param x: Uimhir +:return: ``x`` rounded towards negative infinity.""" + ... + +def fmod(x: float, y: float) -> float: + """Ríomh an chuid eile de ``x/y``. + +Example: ``math.fmod(10, 3)`` + +:param x: An t-uimhreoir +:param y: An t-ainmneoir""" + ... + +def frexp(x: float) -> Tuple[float, int]: + """Díscaoileann sé uimhir snámhphointe isteach ina mantissa agus ina easpónant. + +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: Uimhir snámhphointe +:return: A tuple of length two containing its mantissa then exponent""" + ... + +def isfinite(x: float) -> bool: + """Seiceáil an bhfuil luach críochta. (isfinideach) + +Example: ``math.isfinite(float('inf'))`` + +:param x: Uimhir. +:return: ``True`` if ``x`` is finite, ``False`` otherwise.""" + ... + +def isinf(x: float) -> bool: + """Seiceáil an bhfuil luach gan teorainn. + +Example: ``math.isinf(float('-inf'))`` + +:param x: Uimhir +:return: ``True`` if ``x`` is infinite, ``False`` otherwise.""" + ... + +def isnan(x: float) -> bool: + """Seiceáil an luach nach uimhir é (NaN). + +Example: ``math.isnan(float('nan'))`` + +:param x: Uimhir +:return: ``True`` if ``x`` is not-a-number (NaN), ``False`` otherwise.""" + ... + +def ldexp(x: float, exp: int) -> float: + """Ríomh ``x * (2**exp)``. + +Example: ``math.ldexp(0.5, 2)`` + +:param x: Uimhir +:param exp: Easpónant slánuimhir +:return: ``x * (2**exp)``""" + ... + +def log(x: float, base: float=e) -> float: + """Ríomh logarithm ``x`` go dtí an bonn tugtha (réamhshocraithe don logarithm nádúrtha). (loga) + +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: Uimhir +:param base: (bonn) An bonn le húsáid +:return: The natural logarithm of ``x``""" + ... + +def modf(x: float) -> Tuple[float, float]: + """Ríomh na codanna codánacha agus lárnacha de ``x``. + +Example: ``fractional, integral = math.modf(1.5)`` + +:param x: Uimhir +: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: + """Filleann ``x`` chuig cumhacht ``y``. + +Example: ``math.pow(4, 0.5)`` + +:param x: Uimhir +:param y: An léiritheoir +:return: ``x`` to the power of ``y``""" + ... + +def radians(x: float) -> float: + """Tiontaigh céimeanna go raidian. (raidiáin) + +Example: ``math.radians(360)`` + +:param x: Luach i gcéimeanna +:return: The value converted to radians""" + ... + +def sin(x: float) -> float: + """Ríomh an sín de ``x``. (síneas) + +Example: ``math.sin(math.pi/2)`` + +:param x: Uimhir +:return: The sine of ``x``""" + ... + +def sqrt(x: float) -> float: + """Ríomh an fhréamh chearnach de ``x``. + +Example: ``math.sqrt(4)`` + +:param x: Uimhir +:return: The square root of ``x``""" + ... + +def tan(x: float) -> float: + """Ríomh an tadhlaí de ``x``. + +Example: ``math.tan(0)`` + +:param x: Uimhir +:return: The tangent of ``x``.""" + ... + +def trunc(x: float) -> int: + """Déan uimhir a shlánú i dtreo 0. + +Example: ``math.trunc(-0.9)`` + +:param x: Uimhir +:return: ``x`` rounded towards zero.""" + ... +e: float +"""Bunús an logartaim nádúrtha""" +pi: float +"""An cóimheas idir imlíne ciorcail agus a thrastomhas""" \ No newline at end of file diff --git a/lang/ga-ie/typeshed/stdlib/microbit/__init__.pyi b/lang/ga-ie/typeshed/stdlib/microbit/__init__.pyi new file mode 100644 index 0000000..61ad6a5 --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/microbit/__init__.pyi @@ -0,0 +1,712 @@ +"""Bioráin, íomhánna, fuaimeanna, teocht agus toirt.""" +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]]: + """Sceideal chun feidhm a rith ag an eatramh a shonraítear leis na hargóintí ama **V2 amháin**. (rith gach) + +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: Feidhm chun glaoch ag an eatramh a sholáthraítear. Fág ar lár agus é á úsáid mar mhaisitheoir. +:param days: (laethanta) Socraíonn sé an marc lae don sceidealú. +:param h: Socraíonn sé an marc uair an chloig don sceidealú. +:param min: (íos) Socraíonn sé an marc nóiméad don sceidealú. +:param s: Socraigh an dara marc don sceidealú. +:param ms: Socraíonn sé an marc milleasoicind don sceidealú.""" + +def panic(n: int) -> None: + """Téigh isteach i mód scaoill. (scaoll) + +Example: ``panic(127)`` + +:param n: Slánuimhir treallach <= 255 chun stádas a léiriú. + +Requires restart.""" + +def reset() -> None: + """Atosaigh an bord. (athshocrú)""" + +@overload +def scale(value: float, from_: Tuple[float, float], to: Tuple[int, int]) -> int: + """Athraíonn luach ó raon go raon slánuimhir. (scála) + +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: (luach) Uimhir le tiontú. +:param from_: (ó) A tuple a shainmhíniú ar an raon a thiontú ó. +:param to: (chuig) A tuple a shainmhíniú ar an raon a thiontú go. +:return: The ``value`` converted to the ``to`` range.""" + +@overload +def scale(value: float, from_: Tuple[float, float], to: Tuple[float, float]) -> float: + """Athraíonn luach ó raon go raon snámhphointe. (scála) + +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: (luach) Uimhir le tiontú. +:param from_: (ó) Tupla chun an raon le tiontú uaidh a shainiú. +:param to: (chuig) Tupla chun an raon le tiontú chuige a shainiú. +:return: The ``value`` converted to the ``to`` range.""" + +def sleep(n: float) -> None: + """Fan le haghaidh milleasoicindí ``n`` . (codladh) + +Example: ``sleep(1000)`` + +:param n: Líon na milleasoicindí le fanacht + +One second is 1000 milliseconds, so:: + + microbit.sleep(1000) + +will pause the execution for one second.""" + +def running_time() -> int: + """Faigh am reatha an bhoird. (am reatha) + +:return: The number of milliseconds since the board was switched on or restarted.""" + +def temperature() -> int: + """Faigh teocht an micro:bit i gcéimeanna Celsius. (teocht)""" + +def set_volume(v: int) -> None: + """Socraigh an t-imleabhar. (socraigh an toirt) + +Example: ``set_volume(127)`` + +:param v: luach idir 0 (íseal) agus 255 (ard). + +Out of range values will be clamped to 0 or 255. + +**V2** only.""" + ... + +class Button: + """An rang do na cnaipí ``button_a`` agus ``button_b``. (cnaipe)""" + + def is_pressed(self) -> bool: + """Seiceáil an bhfuil an cnaipe brúite. (brúite) + +:return: ``True`` if the specified button ``button`` is pressed, and ``False`` otherwise.""" + ... + + def was_pressed(self) -> bool: + """Seiceáil ar brúdh an cnaipe ó thosaigh an gléas nó an uair dheireanach a glaodh ar an modh seo. (brúdh) + +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: + """Faigh iomlán reatha na gcnaipí, agus athshocraíonn sé an t-iomlán seo +náid sula bhfillfidh tú. (faigh brúiteanna) + +:return: The number of presses since the device started or the last time this method was called""" + ... +button_a: Button +"""An cnaipe ar chlé ``Button`` réad. (cnaipe a)""" +button_b: Button +"""An cnaipe ceart ``Button`` réad. (cnaipe b)""" + +class MicroBitDigitalPin: + """Biorán digiteach. + +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: + """Faigh luach digiteach an bhioráin. (léigh digiteach) + +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: + """Socraigh luach digiteach an bhioráin. (scríobh digiteach) + +Example: ``pin0.write_digital(1)`` + +:param value: (luach) 1 chun an pionna a shocrú ard nó 0 chun an pionna a shocrú íseal""" + ... + + def set_pull(self, value: int) -> None: + """Socraigh an staid tarraingthe go ceann de thrí luach féideartha: ``PULL_UP``, ``PULL_DOWN`` nó ``NO_PULL``. (tarraingt socraithe) + +Example: ``pin0.set_pull(pin0.PULL_UP)`` + +:param value: (luach) An staid tarraingthe ón bioráin ábhartha, m.sh. ``pin0.PULL_UP``.""" + ... + + def get_pull(self) -> int: + """Faigh an stát tarraingt ar pionna. (faigh socraithe) + +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: + """Filleann an modh pionna. (mód faighte) + +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: + """Aschuir comhartha PWM ar an bioráin, agus an timthriall dleachta comhréireach le ``value``. (scríobh analógach) + +Example: ``pin0.write_analog(254)`` + +:param value: (luach) Slánuimhir nó uimhir snámhphointe idir 0 (0% timthriall dleachta) agus 1023 (dleacht 100%).""" + + def set_analog_period(self, period: int) -> None: + """Socraigh tréimhse an chomhartha PWM atá á haschur go dtí ``period`` ina milleasoicindí. (socraigh tréimhse analógach) + +Example: ``pin0.set_analog_period(10)`` + +:param period: (tréimhse) An tréimhse ina milleasoicindí le luach bailí íosta de 1ms.""" + + def set_analog_period_microseconds(self, period: int) -> None: + """Socraigh tréimhse an chomhartha PWM atá á haschur go dtí ``period`` i micrishoicindí. (micreasoicindí tréimhse analógacha a shocrú) + +Example: ``pin0.set_analog_period_microseconds(512)`` + +:param period: (tréimhse) An tréimhse i micrishoicindí le íosluach bailí de 256µs.""" + +class MicroBitAnalogDigitalPin(MicroBitDigitalPin): + """Bioráin le gnéithe analógacha agus digiteacha.""" + + def read_analog(self) -> int: + """Léigh an voltas a chuirtear i bhfeidhm ar an biorán. (léigh analógach) + +Example: ``pin0.read_analog()`` + +:return: An integer between 0 (meaning 0V) and 1023 (meaning 3.3V).""" + +class MicroBitTouchPin(MicroBitAnalogDigitalPin): + """Pionna le gnéithe analógacha, digiteacha agus tadhaill.""" + CAPACITIVE: int + RESISTIVE: int + + def is_touched(self) -> bool: + """Seiceáil an bhfuil teagmháil á déanamh leis an biorán. (i dteagmháil) + +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: + """Socraigh an modh tadhaill don pionna. (socraigh mód tadhaill) + +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: (luach) ``CAPACITIVE`` nó ``RESISTIVE`` ón pionna ábhartha.""" + ... +pin0: MicroBitTouchPin +"""Pionna le gnéithe digiteacha, analógacha agus tadhaill. (biorán0)""" +pin1: MicroBitTouchPin +"""Bioráin le gnéithe digiteacha, analógacha agus tadhaill. (biorán1)""" +pin2: MicroBitTouchPin +"""Bioráin le gnéithe digiteacha, analógacha agus tadhaill. (biorán2)""" +pin3: MicroBitAnalogDigitalPin +"""Bioráin le gnéithe digiteacha agus analógacha. (biorán3)""" +pin4: MicroBitAnalogDigitalPin +"""Bioráin le gnéithe digiteacha agus analógacha. (biorán4)""" +pin5: MicroBitDigitalPin +"""Bioráin le gnéithe digiteacha. (biorán5)""" +pin6: MicroBitDigitalPin +"""Bioráin le gnéithe digiteacha. (biorán6)""" +pin7: MicroBitDigitalPin +"""Bioráin le gnéithe digiteacha. (biorán7)""" +pin8: MicroBitDigitalPin +"""Bioráin le gnéithe digiteacha. (biorán8)""" +pin9: MicroBitDigitalPin +"""Bioráin le gnéithe digiteacha. (biorán9)""" +pin10: MicroBitAnalogDigitalPin +"""Bioráin le gnéithe digiteacha agus analógacha. (biorán10)""" +pin11: MicroBitDigitalPin +"""Bioráin le gnéithe digiteacha. (biorán11)""" +pin12: MicroBitDigitalPin +"""Bioráin le gnéithe digiteacha. (biorán12)""" +pin13: MicroBitDigitalPin +"""Bioráin le gnéithe digiteacha. (biorán 13)""" +pin14: MicroBitDigitalPin +"""Bioráin le gnéithe digiteacha. (biorán14)""" +pin15: MicroBitDigitalPin +"""Bioráin le gnéithe digiteacha. (biorán15)""" +pin16: MicroBitDigitalPin +"""Bioráin le gnéithe digiteacha. (biorán16)""" +pin19: MicroBitDigitalPin +"""Bioráin le gnéithe digiteacha. (biorán19)""" +pin20: MicroBitDigitalPin +"""Bioráin le gnéithe digiteacha. (biorán20)""" +pin_logo: MicroBitTouchPin +"""Biorán lógó íogair do theagmháil ar aghaidh an micro:bit, atá socraithe de réir réamhshocraithe go mód tadhaill toilleasach. (lógó bioráin)""" +pin_speaker: MicroBitAnalogDigitalPin +"""Biorán chun an cainteoir micro:bit a sheoladh. (cainteoir bioráin) + +This API is intended only for use in Pulse-Width Modulation pin operations e.g. pin_speaker.write_analog(128). +""" + +class Image: + """Íomhá le taispeáint ar an taispeáint micro:bit LED. (íomhá) + +Given an image object it's possible to display it via the ``display`` API:: + + display.show(Image.HAPPY)""" + HEART: Image + """Íomhá chroí. (croí)""" + HEART_SMALL: Image + """Íomhá bheag chroí. (croí beag)""" + HAPPY: Image + """Íomhá aghaidhe sona. (sásta)""" + SMILE: Image + """Íomhá béil ag gáire. (aoibh gháire)""" + SAD: Image + """Íomhá aghaidhe brónach. (brónach)""" + CONFUSED: Image + """Íomhá aghaidhe mearbhall. (mearbhall)""" + ANGRY: Image + """Íomhá aghaidh feargach. (feargach)""" + ASLEEP: Image + """Íomhá aghaidhe codlata. (ina chodladh)""" + SURPRISED: Image + """Íomhá aghaidhe ionadh. (ionadh)""" + SILLY: Image + """Íomhá aghaidh amaideach. (amaideach)""" + FABULOUS: Image + """Íomhá aghaidhe spéaclaí gréine. (iontach)""" + MEH: Image + """Íomhá aghaidhe neamhbhrúite.""" + YES: Image + """Cuir tic leis an íomhá. (tá)""" + NO: Image + """Íomhá croise. (níl)""" + CLOCK12: Image + """Íomhá le líne dírithe ar 12 a chlog. (clog12)""" + CLOCK11: Image + """Íomhá le líne dírithe ar 11 a chlog. (clog11)""" + CLOCK10: Image + """Íomhá le líne dírithe ar 10 a chlog. (clog10)""" + CLOCK9: Image + """Íomhá le líne dírithe go dtí 9 a chlog. (clog9)""" + CLOCK8: Image + """Íomhá le líne dírithe go dtí 8 a chlog. (clog8)""" + CLOCK7: Image + """Íomhá le líne dírithe go dtí 7 a chlog. (clog7)""" + CLOCK6: Image + """Íomhá le líne ag díriú go dtí 6 a chlog. (clog6)""" + CLOCK5: Image + """Íomhá le líne dírithe go dtí 5 a chlog. (clog5)""" + CLOCK4: Image + """Íomhá le líne dírithe go dtí 4 a chlog. (clog4)""" + CLOCK3: Image + """Íomhá le líne dírithe go dtí 3 a chlog. (clog3)""" + CLOCK2: Image + """Íomhá le líne ag díriú go dtí 2 a chlog. (clog2)""" + CLOCK1: Image + """Íomhá le líne ag díriú go dtí 1 a chlog. (clog1)""" + ARROW_N: Image + """Íomhá na saigheade dírithe ó thuaidh. (saighead n)""" + ARROW_NE: Image + """Íomhá na saigheade dírithe soir ó thuaidh. (saighead ne)""" + ARROW_E: Image + """Íomhá na saigheade dírithe ar an taobh thoir. (saighead e)""" + ARROW_SE: Image + """Íomhá na saigheade dírithe soir ó dheas. (saighead se)""" + ARROW_S: Image + """Íomhá na saigheade dírithe ó dheas. (saighead s)""" + ARROW_SW: Image + """Íomhá na saigheade dírithe siar ó dheas. (saighead sw)""" + ARROW_W: Image + """Íomhá den tsaighead atá dírithe siar. (saighead w)""" + ARROW_NW: Image + """Íomhá na saigheade dírithe siar ó thuaidh. (saighead nw)""" + TRIANGLE: Image + """Íomhá de thriantán ag pointeáil suas. (triantán)""" + TRIANGLE_LEFT: Image + """Íomhá de thriantán sa chúinne ar chlé. (triantán ar chlé)""" + CHESSBOARD: Image + """Soilse LEDs malartacha i bpatrún clár fichille. (clár fichille)""" + DIAMOND: Image + """Íomhá diamant. (diamant)""" + DIAMOND_SMALL: Image + """Íomhá diamant beag. (diamant beag)""" + SQUARE: Image + """Íomhá cearnóg. (cearnóg)""" + SQUARE_SMALL: Image + """Íomhá beag cearnach. (cearnach beag)""" + RABBIT: Image + """Íomhá coinín. (coinín)""" + COW: Image + """Íomhá bó. (bó)""" + MUSIC_CROTCHET: Image + """Íomhá nóta cróise. (croiséad ceoil)""" + MUSIC_QUAVER: Image + """Creathán nóta íomhá. (cuais cheoil)""" + MUSIC_QUAVERS: Image + """Íomhá de nótaí péire ochtú comhartha. (cuacha ceoil)""" + PITCHFORK: Image + """Íomhá forc pice. (forc-pice)""" + XMAS: Image + """Íomhá crann Nollag. (nollag)""" + PACMAN: Image + """Íomhá carachtar stuara PAC-Man.""" + TARGET: Image + """Íomhá sprice. (sprioc)""" + TSHIRT: Image + """Íomhá T-léine. (léine-t)""" + ROLLERSKATE: Image + """Íomhá scátáil-rollála. (scátáil-rollála)""" + DUCK: Image + """Íomhá lacha. (lacha)""" + HOUSE: Image + """Íomhá tí. (teach)""" + TORTOISE: Image + """Íomhá turtar. (toirtís)""" + BUTTERFLY: Image + """Íomhá féileacán. (féileacán)""" + STICKFIGURE: Image + """Bata íomhá figiúr. (figiúr-maide)""" + GHOST: Image + """Íomhá taibhse. (taibhse)""" + SWORD: Image + """Íomhá chlaíomh. (claíomh)""" + GIRAFFE: Image + """Íomhá sioráf. (sioráf)""" + SKULL: Image + """Íomhá cloigeann. (cloigeann)""" + UMBRELLA: Image + """Íomhá scáth fearthainne. (scáth fearthainne)""" + SNAKE: Image + """Íomhá nathair. (nathair)""" + SCISSORS: Image + """Íomhá siosúr. (siosúr)""" + ALL_CLOCKS: List[Image] + """Liosta ina bhfuil na híomhánna CLOCK_ go léir in ord. (gach clog)""" + ALL_ARROWS: List[Image] + """Liosta ina bhfuil na híomhánna ARROW_ go léir in ord. (gach saighead)""" + + @overload + def __init__(self, string: str) -> None: + """Cruthaigh íomhá ó theaghrán ag cur síos ar na soilse atá lasta. + +``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: (teaghrán) An teaghrán ag cur síos ar an íomhá.""" + ... + + @overload + def __init__(self, width: int=5, height: int=5, buffer: ReadableBuffer=None) -> None: + """Cruthaigh íomhá fholamh le colúin ``width`` agus sraitheanna ``height`` . + +:param width: (leithead) Leithead roghnach na híomhá +:param height: (airde) Airde roghnach na híomhá +:param buffer: (maolán) Eagar roghnach nó bearta de ``width``×``height`` slánuimhreacha i raon 0-9 chun an íomhá a thúsú + +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: + """Faigh líon na gcolún. (leithead) + +:return: The number of columns in the image""" + ... + + def height(self) -> int: + """Faigh líon na sraitheanna. (airde) + +:return: The number of rows in the image""" + ... + + def set_pixel(self, x: int, y: int, value: int) -> None: + """Socraigh gile picteilín. (socraigh picteilín) + +Example: ``my_image.set_pixel(0, 0, 9)`` + +:param x: Uimhir an cholúin +:param y: Uimhir an ró +:param value: (luach) An ghile mar shlánuimhir idir 0 (dorcha) agus 9 (geal) + +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: + """Faigh gile picteilín. (faigh picteilín) + +Example: ``my_image.get_pixel(0, 0)`` + +:param x: Uimhir an cholúin +:param y: Uimhir na sraithe +:return: The brightness as an integer between 0 and 9.""" + ... + + def shift_left(self, n: int) -> Image: + """Cruthaigh íomhá nua tríd an bpictiúr ar chlé a athrú. (shift ar chlé) + +Example: ``Image.HEART_SMALL.shift_left(1)`` + +:param n: Líon na gcolún atá le haistriú ag +:return: The shifted image""" + ... + + def shift_right(self, n: int) -> Image: + """Cruthaigh íomhá nua tríd an bpictiúr a athrú ar dheis. (shift ar dheis) + +Example: ``Image.HEART_SMALL.shift_right(1)`` + +:param n: Líon na gcolún le haistriú +:return: The shifted image""" + ... + + def shift_up(self, n: int) -> Image: + """Cruthaigh íomhá nua tríd an bpictiúr a athrú suas. (shift suas) + +Example: ``Image.HEART_SMALL.shift_up(1)`` + +:param n: Líon na rónna le hathrú ag +:return: The shifted image""" + ... + + def shift_down(self, n: int) -> Image: + """Cruthaigh íomhá nua tríd an bpictiúr a aistriú síos. (shift síos) + +Example: ``Image.HEART_SMALL.shift_down(1)`` + +:param n: Líon na rónna le haistriú +:return: The shifted image""" + ... + + def crop(self, x: int, y: int, w: int, h: int) -> Image: + """Cruthaigh íomhá nua tríd an bpictiúr a bearradh. (barr) + +Example: ``Image.HEART.crop(1, 1, 3, 3)`` + +:param x: An colún fritháireamh barr +:param y: An ró fritháireamh barr +:param w: An leithead barr +:param h: An airde barr +:return: The new image""" + ... + + def copy(self) -> Image: + """Cruthaigh cóip chruinn den íomhá. (cóip) + +Example: ``Image.HEART.copy()`` + +:return: The new image""" + ... + + def invert(self) -> Image: + """Cruthaigh íomhá nua trí ghile na bpicteilíní a inbhéartú sa +íomhá foinseach. (inbhéartaithe) + +Example: ``Image.SMALL_HEART.invert()`` + +:return: The new image.""" + ... + + def fill(self, value: int) -> None: + """Socraigh gile na bpicteilíní go léir san íomhá. (líon) + +Example: ``my_image.fill(5)`` + +:param value: (luach) An gile nua mar uimhir idir 0 (dorcha) agus 9 (geal). + +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: + """Cóipeáil limistéar ó íomhá eile isteach san íomhá seo. + +Example: ``my_image.blit(Image.HEART, 1, 1, 3, 3, 1, 1)`` + +:param src: An íomhá fhoinseach +:param x: Fritháireamh an cholúin tosaigh san íomhá fhoinseach +:param y: Fritháireamh an ró tosaigh san íomhá foinseach +:param w: Líon na gcolún le cóipeáil +:param h: Líon na rónna le cóipeáil +:param xdest: Fritháireamh an cholúin le mionathrú san íomhá seo +:param ydest: Fritháireamh an ró le mionathrú san íomhá seo + +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: + """Faigh léiriú teaghrán dlúth ar an íomhá.""" + ... + + def __str__(self) -> str: + """Faigh léiriú teaghrán inléite ar an íomhá.""" + ... + + def __add__(self, other: Image) -> Image: + """Cruthaigh íomhá nua trí na luachanna gile ón dá cheann a chur leis +íomhánna do gach picteilín. (suimigh) + +Example: ``Image.HEART + Image.HAPPY`` + +:param other: (eile) An íomhá le cur leis.""" + ... + + def __sub__(self, other: Image) -> Image: + """Cruthaigh íomhá nua trí luachanna gile an +íomhá eile ón íomhá seo. + +Example: ``Image.HEART - Image.HEART_SMALL`` + +:param other: (eile) An íomhá a dhealú.""" + ... + + def __mul__(self, n: float) -> Image: + """Cruthaigh íomhá nua trí ghile gach picteilín a iolrú faoi +``n``. + +Example: ``Image.HEART * 0.5`` + +:param n: An luach a iolrú faoi.""" + ... + + def __truediv__(self, n: float) -> Image: + """Cruthaigh íomhá nua trí ghile gach picteilín a roinnt ar +``n``. + +Example: ``Image.HEART / 2`` + +:param n: An luach a roinnt ar.""" + ... + +class SoundEvent: + LOUD: SoundEvent + """Léiríonn sé aistriú imeachtaí fuaime, ó ``quiet`` go ``loud`` cosúil le bualadh nó béicíl. (ard)""" + QUIET: SoundEvent + """Léiríonn sé seo aistriú imeachtaí fuaime, ó ``loud`` go ``quiet`` cosúil le ceol labhartha nó cúlra. (ciúin)""" + +class Sound: + """Is féidir na fuaimeanna tógtha a ghlaoch ag baint úsáide as ``audio.play(Sound.NAME)``. (fuaim)""" + GIGGLE: Sound + """Fuaim scig-gháire. (scig-gháire)""" + HAPPY: Sound + """Fuaim shona. (sásta)""" + HELLO: Sound + """Fuaime beannacht. (dia duit)""" + MYSTERIOUS: Sound + """Fuaim mhistéireach. (mistéireach)""" + SAD: Sound + """Fuaim bhrónach. (brónach)""" + SLIDE: Sound + """Fuaim sleamhnáin. (sleamhnán)""" + SOARING: Sound + """Fuaim téagartha. (téagartha)""" + SPRING: Sound + """Fuaim an earraigh. (an t-earrach)""" + TWINKLE: Sound + """Fuaim drithligh. (drithligh)""" + YAWN: Sound + """Fuaim méanfach. (méanfach)""" \ No newline at end of file diff --git a/lang/ga-ie/typeshed/stdlib/microbit/accelerometer.pyi b/lang/ga-ie/typeshed/stdlib/microbit/accelerometer.pyi new file mode 100644 index 0000000..f2fb4a1 --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/microbit/accelerometer.pyi @@ -0,0 +1,103 @@ +"""Tomhais luasghéarú an micro:bit agus aithin gothaí. (luasmhéadar)""" +from typing import Tuple + +def get_x() -> int: + """Faigh an tomhas luasghéaraithe san ais ``x`` i milli-g. (faigh x) + +Example: ``accelerometer.get_x()`` + +:return: A positive or negative integer depending on direction in the range +/- 2000mg.""" + ... + +def get_y() -> int: + """Faigh an tomhas luasghéaraithe san ais ``y`` i milli-g. (faigh y) + +Example: ``accelerometer.get_y()`` + +:return: A positive or negative integer depending on direction in the range +/- 2000mg.""" + ... + +def get_z() -> int: + """Faigh an tomhas luasghéaraithe san ais ``z`` i milli-g. (faigh 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]: + """Faigh na tomhais luasghéaraithe i ngach aiseanna ag an am céanna mar tuple. (faigh luachanna) + +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: + """Faigh tomhas luasghéaraithe na n-aiseanna go léir le chéile, mar shlánuimhir dhearfach. Is é seo suim Pythagorean na n-aiseanna X, Y agus Z. (faigh neart) + +Example: ``accelerometer.get_strength()`` + +:return: The combined acceleration strength of all the axes, in milli-g.""" + ... + +def current_gesture() -> str: + """Faigh ainm an chomhartha reatha. (gotha \u200b\u200breatha) + +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: + """Seiceáil an bhfuil an comhartha ainmnithe gníomhach faoi láthair. (is gotha) + +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: (ainm) An t-ainm gotha. +:return: ``True`` if the gesture is active, ``False`` otherwise.""" + ... + +def was_gesture(name: str) -> bool: + """Seiceáil an raibh an comhartha ainmnithe gníomhach ón nglao deireanach. (bhí gotha) + +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: (ainm) Ainm an ghluaiseachta. +:return: ``True`` if the gesture was active since the last call, ``False`` otherwise.""" + +def get_gestures() -> Tuple[str, ...]: + """Tabhair ar ais tuple de stair na gothaí. (faigh gothaí) + +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: + """Socraigh an raon íogaireachta luasmhéadair, i g (domhantarraingt chaighdeánach), go dtí na luachanna is gaire a dtacaíonn na crua-earraí leo, agus mar sin cruinníonn sé le ``2``, ``4``, nó ``8`` g. (socraigh raon) + +Example: ``accelerometer.set_range(8)`` + +:param value: (luach) Raon nua don luasmhéadar, slánuimhir i ``g``.""" \ No newline at end of file diff --git a/lang/ga-ie/typeshed/stdlib/microbit/audio.pyi b/lang/ga-ie/typeshed/stdlib/microbit/audio.pyi new file mode 100644 index 0000000..6fe096a --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/microbit/audio.pyi @@ -0,0 +1,124 @@ +"""Seinn fuaimeanna ag baint úsáide as an micro:bit (allmhairiú ``audio`` le haghaidh comhoiriúnacht V1). (fuaime)""" +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: + """Seinn fuaim-tógtha i, éifeacht fuaime nó frámaí fuaime saincheaptha. (seinn) + +Example: ``audio.play(Sound.GIGGLE)`` + +:param source: (foinse) ``Sound`` ionsuite amhail ``Sound.GIGGLE``, ``SoundEffect`` nó sonraí samplacha mar athrá ar réada ``AudioFrame``. +:param wait: (fan) Má tá ``wait`` ``True``, blocálfaidh an fheidhm seo go dtí go mbeidh an fhuaim críochnaithe. +:param pin: (biorán) Is féidir argóint roghnach chun an bioráin aschuir a shonrú a úsáid chun mainneachtain ``pin0``a shárú. Mura dteastaíonn aon fhuaim uainn is féidir linn ``pin=None``a úsáid. +:param return_pin: (biorán fillte) Sonraíonn bioráin cónascaire imeall difreálach chun ceangal le cainteoir seachtrach in ionad na talún. Déantar neamhaird air seo don athbhreithniú **V2**.""" + +def is_playing() -> bool: + """Seiceáil an bhfuil fuaim á seinm. (ag seinm) + +Example: ``audio.is_playing()`` + +:return: ``True`` if audio is playing, otherwise ``False``.""" + ... + +def stop() -> None: + """Stop gach athsheinm fuaime. (stad) + +Example: ``audio.stop()``""" + ... + +class SoundEffect: + """Éifeacht fuaime, comhdhéanta ag sraith paraiméadar cumraithe tríd an cruthaitheoir nó tréithe. (éifeachtfuaime)""" + WAVEFORM_SINE: ClassVar[int] + """Rogha tonn sine a úsáidtear don pharaiméadar ``waveform`` . (tonnchruth síneas)""" + WAVEFORM_SAWTOOTH: ClassVar[int] + """Rogha tonn fiacail sábha a úsáidtear don pharaiméadar ``waveform`` . (tonnfhad fiacail sábha)""" + WAVEFORM_TRIANGLE: ClassVar[int] + """Rogha tonn triantáin a úsáidtear don pharaiméadar ``waveform`` . (triantán tonnchrutha)""" + WAVEFORM_SQUARE: ClassVar[int] + """Rogha tonn cearnach a úsáidtear don pharaiméadar ``waveform`` . (cearnóg tonnfhoirme)""" + WAVEFORM_NOISE: ClassVar[int] + """Rogha torainn a úsáidtear don pharaiméadar ``waveform`` . (torann tonnfhoirme)""" + SHAPE_LINEAR: ClassVar[int] + """Rogha idirshuíomh líneach a úsáidtear don pharaiméadar ``shape`` . (cruth líneach)""" + SHAPE_CURVE: ClassVar[int] + """Rogha idirshuíomh cuar a úsáidtear don pharaiméadar ``shape`` . (cruth cuar)""" + SHAPE_LOG: ClassVar[int] + """Rogha idirshuíomh logartamach a úsáidtear don pharaiméadar ``shape`` . (log cruth)""" + FX_NONE: ClassVar[int] + """Níl aon rogha éifeachta in úsáid don pharaiméadar ``fx`` . (fx aon cheann)""" + FX_TREMOLO: ClassVar[int] + """Rogha éifeachta Tremolo a úsáidtear don pharaiméadar ``fx`` . (tremolo fx)""" + FX_VIBRATO: ClassVar[int] + """Rogha éifeachta Vibrato a úsáidtear don pharaiméadar ``fx`` .""" + FX_WARBLE: ClassVar[int] + """Rogha éifeacht warble a úsáidtear le haghaidh an paraiméadar ``fx`` .""" + freq_start: int + """Tosaigh minicíocht i Hertz (Hz), uimhir idir ``0`` agus ``9999`` (tús minicíochta)""" + freq_end: int + """Minicíocht deiridh i Heirts (Hz), uimhir idir ``0`` agus ``9999`` (deireadh freq)""" + duration: int + """Fad na fuaime i milleasoicindí, uimhir idir ``0`` agus ``9999`` (fad)""" + vol_start: int + """Tosaigh luach toirte, uimhir idir ``0`` agus ``255`` (tús vol)""" + vol_end: int + """Luach toirte deiridh, uimhir idir ``0`` agus ``255`` (deireadh imleabhair)""" + waveform: int + """Cineál cruth waveform, ceann de na luachanna seo: ``WAVEFORM_SINE``, ``WAVEFORM_SAWTOOTH``, ``WAVEFORM_TRIANGLE``, ``WAVEFORM_SQUARE``, ``WAVEFORM_NOISE`` (torann a ghintear go randamach) (tonnchruth)""" + fx: int + """Éifeacht le cur leis an bhfuaim, ceann amháin de na luachanna seo a leanas: ``FX_TREMOLO``, ``FX_VIBRATO``, ``FX_WARBLE``, nó ``FX_NONE``""" + shape: int + """An cineál cuar idirshuíomh idir na minicíochtaí tosaigh agus deiridh, tá cruthanna tonn éagsúla rátaí éagsúla athraithe i minicíocht. Ceann de na luachanna seo a leanas: ``SHAPE_LINEAR``, ``SHAPE_CURVE``, ``SHAPE_LOG`` (cruth)""" + + 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): + """Cruthaigh éifeacht fuaime nua. + +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: (tús minicíochta) Tosaigh minicíocht i Hertz (Hz), uimhir idir ``0`` agus ``9999``. +:param freq_end: (deireadh minicíochta) Minicíocht deiridh i Hertz (Hz), uimhir idir ``0`` agus ``9999``. +:param duration: (fad) Fad na fuaime i milleasoicindí, uimhir idir ``0`` agus ``9999``. +:param vol_start: (tús toirte) Tosaigh luach toirte, uimhir idir ``0`` agus ``255``. +:param vol_end: (deireadh an toirte) Luach deiridh an toirte, uimhir idir ``0`` agus ``255``. +:param waveform: (tonnfhoirm) Cineál cruth waveform, ceann de na luachanna seo: ``WAVEFORM_SINE``, ``WAVEFORM_SAWTOOTH``, ``WAVEFORM_TRIANGLE``, ``WAVEFORM_SQUARE``, ``WAVEFORM_NOISE`` (torann a ghintear go randamach). +:param fx: Éifeacht le cur leis an bhfuaim, ceann amháin de na luachanna seo a leanas: ``FX_TREMOLO``, ``FX_VIBRATO``, ``FX_WARBLE``, nó ``FX_NONE``. +:param shape: (cruth) An cineál cuar idirshuíomh idir na minicíochtaí tosaigh agus deiridh, tá cruthanna tonn éagsúla rátaí éagsúla athraithe i minicíocht. Ceann de na luachanna seo a leanas: ``SHAPE_LINEAR``, ``SHAPE_CURVE``, ``SHAPE_LOG``.""" + + def copy(self) -> SoundEffect: + """Cruthaigh cóip den ``SoundEffect``seo. (cóip) + +Example: ``sound_2 = sound_1.copy()`` + +:return: A copy of the SoundEffect.""" + +class AudioFrame: + """Is éard is réad ``AudioFrame`` ann ná liosta de 32 sampla ar beart gan síniú gach ceann acu +(slánuimhir idir 0 agus 255). (fráma fuaime) + +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: + """Forscríobh na sonraí sa ``AudioFrame`` seo leis na sonraí ó shampla ``AudioFrame`` eile. (cóipeáil ó) + +Example: ``my_frame.copyfrom(source_frame)`` + +:param other: (eile) ``AudioFrame`` ásc as ar féidir na sonraí a chóipeáil.""" + + 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/ga-ie/typeshed/stdlib/microbit/compass.pyi b/lang/ga-ie/typeshed/stdlib/microbit/compass.pyi new file mode 100644 index 0000000..573ef4d --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/microbit/compass.pyi @@ -0,0 +1,70 @@ +"""Bain úsáid as an compás tógtha. (compás)""" + +def calibrate() -> None: + """Tosaíonn seo an próiseas calabrúcháin. (calabrú) + +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: + """Seiceáil go bhfuil an compás calabraithe. (atá calabraithe) + +Example: ``compass.is_calibrated()`` + +:return: ``True`` if the compass has been successfully calibrated, ``False`` otherwise.""" + ... + +def clear_calibration() -> None: + """Cealaigh an calabrú, rud a fhágann go bhfuil an compás neamhráite arís. (calabrú soiléir) + +Example: ``compass.clear_calibration()``""" + ... + +def get_x() -> int: + """Faigh neart an réimse mhaighnéadaigh ar an ais ``x`` . (faigh 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: + """Faigh neart an réimse mhaighnéadaigh ar an ais ``y`` . (faigh 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: + """Faigh neart an réimse mhaighnéadaigh ar an ais ``z`` . (faigh 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: + """Faigh ceannteideal an chompáis. (ceannteideal) + +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: + """Faigh méid an réimse maighnéadach timpeall an ghléis. + +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/ga-ie/typeshed/stdlib/microbit/display.pyi b/lang/ga-ie/typeshed/stdlib/microbit/display.pyi new file mode 100644 index 0000000..ae8c82a --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/microbit/display.pyi @@ -0,0 +1,92 @@ +"""Taispeáin téacs, íomhánna agus beochan ar an taispeáint LED 5×5. (taispeáint)""" +from ..microbit import Image +from typing import Union, overload, Iterable + +def get_pixel(x: int, y: int) -> int: + """Faigh gile an LED ag colún ``x`` agus as a chéile ``y``. (faigh picteilín) + +Example: ``display.get_pixel(0, 0)`` + +:param x: An colún taispeána (0..4) +:param y: An tsraith taispeána (0..4) +:return: A number between 0 (off) and 9 (bright)""" + ... + +def set_pixel(x: int, y: int, value: int) -> None: + """Socraigh gile an LED ag colún ``x`` agus as a chéile ``y``. (socraigh picteilín) + +Example: ``display.set_pixel(0, 0, 9)`` + +:param x: An colún taispeána (0..4) +:param y: An tsraith taispeána (0..4) +:param value: (luach) An ghile idir 0 (as) agus 9 (geal)""" + ... + +def clear() -> None: + """Socraigh gile na soilse go léir go 0 (as). (soiléir) + +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: + """Taispeáin íomhánna, litreacha nó digití ar an taispeáint LED. (taispeáin) + +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: (íomhá) Teaghrán, uimhir, íomhá nó liosta íomhánna le taispeáint. +:param delay: (moill) Taispeántar gach litir, digit nó íomhá le milleasoicindí ``delay`` eatarthu. +:param wait: (fan) Más ``wait`` é ``True``, cuirfear bac ar an bhfeidhm seo go dtí go mbeidh an bheochan críochnaithe, nó tarlóidh an bheochan sa chúlra. +:param loop: (lúb) Má tá ``loop`` ``True``, déanfaidh an beochan arís go deo. +:param clear: (soiléir) Más ionann ``clear`` agus ``True``, glanfar an taispeáint tar éis don seicheamh a bheith críochnaithe. + +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: + """Scrollaigh uimhir nó téacs ar an taispeáint LED. (scrollaigh) + +Example: ``display.scroll('micro:bit')`` + +:param text: (téacs) An teaghrán le scrollú. Más slánuimhir nó snámhphointe é ``text`` tiontaítear é ar dtús go teaghrán ag baint úsáide as ``str()``. +:param delay: (moill) Rialaíonn an paraiméadar ``delay`` cé chomh tapa is atá an téacs ag scrollú. +:param wait: (fan) Má tá ``wait`` ``True``, blocálfaidh an fheidhm seo go dtí go mbeidh an beochan críochnaithe, nó tarlóidh an beochan sa chúlra. +:param loop: (lúb) Má tá ``loop`` ``True``, déanfaidh an beochan arís go deo. +:param monospace: (monaspás) Más ``monospace`` é ``True``, tógfaidh na carachtair go léir suas le 5 cholún picteilín ar leithead, nó mura mbeidh go díreach 1 cholún bán picteilín idir gach carachtar agus iad ag scrollú. + +The ``wait``, ``loop`` and ``monospace`` arguments must be specified +using their keyword.""" + ... + +def on() -> None: + """Cas ar an taispeáint LED. (ar) + +Example: ``display.on()``""" + ... + +def off() -> None: + """Múch an taispeáint LED (ceadaíonn an taispeáint a dhíchumasú duit na bioráin GPIO a athúsáid chun críocha eile). (as) + +Example: ``display.off()``""" + ... + +def is_on() -> bool: + """Seiceáil an bhfuil an taispeáint LED cumasaithe. (atá ar) + +Example: ``display.is_on()`` + +:return: ``True`` if the display is on, otherwise returns ``False``.""" + ... + +def read_light_level() -> int: + """Léigh leibhéal an tsolais. (léigh leibhéal an tsolais) + +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/ga-ie/typeshed/stdlib/microbit/i2c.pyi b/lang/ga-ie/typeshed/stdlib/microbit/i2c.pyi new file mode 100644 index 0000000..d9c610c --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/microbit/i2c.pyi @@ -0,0 +1,49 @@ +"""Cumarsáid a dhéanamh le gléasanna ag baint úsáide as prótacal bus I²C.""" +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: + """Ath-thúsaigh forimeallach. + +Example: ``i2c.init()`` + +:param freq: minicíocht cloig +:param sda: biorán ``sda`` (réamhshocrú 20) +:param scl: biorán ``scl`` (réamhshocrú 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]: + """Scan an bus le haghaidh gléasanna. (scanadh) + +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: + """Léigh bearta ó ghléas. (léigh) + +Example: ``i2c.read(0x50, 64)`` + +:param addr: Seoladh 7 ngiotán an ghléis +:param n: Líon na mbeart atá le léamh +:param repeat: (athdhéanamh) Má ``True``, ní sheolfar aon ghiotán stad +:return: The bytes read""" + ... + +def write(addr: int, buf: ReadableBuffer, repeat: bool=False) -> None: + """Scríobh bearta chuig gléas. (scríobh) + +Example: ``i2c.write(0x50, bytes([1, 2, 3]))`` + +:param addr: Seoladh 7 ngiotán an ghléis +:param buf: Maolán ina bhfuil na bearta le scríobh +:param repeat: (athdhéanamh) Má ``True``, ní sheolfar aon ghiotán stad""" + ... \ No newline at end of file diff --git a/lang/ga-ie/typeshed/stdlib/microbit/microphone.pyi b/lang/ga-ie/typeshed/stdlib/microbit/microphone.pyi new file mode 100644 index 0000000..213ba41 --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/microbit/microphone.pyi @@ -0,0 +1,62 @@ +"""Freagair fuaim ag baint úsáide as an micreafón tógtha (V2 amháin). (micreafón)""" +from typing import Optional, Tuple +from ..microbit import SoundEvent + +def current_event() -> Optional[SoundEvent]: + """Faigh an teagmhas fuaime taifeadta is déanaí (imeacht reatha) + +Example: ``microphone.current_event()`` + +:return: The event, ``SoundEvent('loud')`` or ``SoundEvent('quiet')``.""" + ... + +def was_event(event: SoundEvent) -> bool: + """Seiceáil ar chualathas fuaim uair amháin ar a laghad ón nglao deireanach. (ba imeacht é) + +Example: ``microphone.was_event(SoundEvent.LOUD)`` + +This call clears the sound history before returning. + +:param event: (imeacht) An ócáid le seiceáil, mar shampla ``SoundEvent.LOUD`` nó ``SoundEvent.QUIET`` +:return: ``True`` if sound was heard at least once since the last call, otherwise ``False``.""" + ... + +def is_event(event: SoundEvent) -> bool: + """Seiceáil an teagmhas fuaime is déanaí a braitheadh. (imeacht) + +Example: ``microphone.is_event(SoundEvent.LOUD)`` + +This call does not clear the sound event history. + +:param event: (imeacht) An ócáid le seiceáil, mar shampla ``SoundEvent.LOUD`` nó ``SoundEvent.QUIET`` +:return: ``True`` if sound was the most recent heard, ``False`` otherwise.""" + ... + +def get_events() -> Tuple[SoundEvent, ...]: + """Faigh stair na hócáide fuaime mar thuple. (faigh imeachtaí) + +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: + """Socraigh an tairseach le haghaidh teagmhas fuaime. (tairseach shocraithe) + +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: (imeacht) Imeacht fuaime, mar shampla ``SoundEvent.LOUD`` nó ``SoundEvent.QUIET``. +:param value: (luach) An leibhéal tairsí sa raon 0-255.""" + ... + +def sound_level() -> int: + """Faigh an leibhéal brú fuaime. (leibhéal fuaime) + +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/ga-ie/typeshed/stdlib/microbit/speaker.pyi b/lang/ga-ie/typeshed/stdlib/microbit/speaker.pyi new file mode 100644 index 0000000..06d3176 --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/microbit/speaker.pyi @@ -0,0 +1,15 @@ +"""Rialú an cainteoir tógtha i (V2 amháin). (cainteoir)""" + +def off() -> None: + """Múch an cainteoir. (as) + +Example: ``speaker.off()`` + +This does not disable sound output to an edge connector pin.""" + ... + +def on() -> None: + """Cas an cainteoir air. (ar) + +Example: ``speaker.on()``""" + ... \ No newline at end of file diff --git a/lang/ga-ie/typeshed/stdlib/microbit/spi.pyi b/lang/ga-ie/typeshed/stdlib/microbit/spi.pyi new file mode 100644 index 0000000..0db7a3f --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/microbit/spi.pyi @@ -0,0 +1,47 @@ +"""Cumarsáid a dhéanamh le gléasanna ag baint úsáide as an gcomhéadan forimeallach sraitheach (SPI) bus.""" +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: + """Túsaigh cumarsáid SPI. + +Example: ``spi.init()`` + +For correct communication, the parameters have to be the same on both communicating devices. + +:param baudrate: (ráta baud) Luas na cumarsáide. +:param bits: (giotáin) An leithead i giotán de gach aistriú. Faoi láthair ní thacaítear ach le ``bits=8`` . Mar sin féin, d'fhéadfadh sé seo athrú amach anseo. +:param mode: (mód) Cinneann sé an meascán de polaraíocht clog agus céim - 'féach tábla ar líne '_. +:param sclk: bioráin sclk (réamhshocrú 13) +:param mosi: bioráin mosi (réamhshocrú 15) +:param miso: biorán miso (réamhshocraithe 14)""" + ... + +def read(nbytes: int, out: int=0) -> bytes: + """Léigh ar a mhéad ``nbytes`` agus an beart aonair a thugann ``out``á scríobh go leanúnach. (léamh) + +Example: ``spi.read(64)`` + +:param nbytes: (nbeart) Líon uasta na mbeart le léamh. +:param out: (amach) An luach beart le scríobh (réamhshocrú 0). +:return: The bytes read.""" + ... + +def write(buffer: ReadableBuffer) -> None: + """Scríobh bearta chuig an mbus. (scríobh) + +Example: ``spi.write(bytes([1, 2, 3]))`` + +:param buffer: (maolán) Maolán chun sonraí a léamh as.""" + ... + +def write_readinto(out: WriteableBuffer, in_: ReadableBuffer) -> None: + """Scríobh an maolán ``out`` chuig an mbus agus léigh aon fhreagra isteach sa mhaolán ``in_`` . (scríobh readinto) + +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: (amach) An maolán chun aon fhreagra a scríobh. +:param in_: (i) An maolán chun sonraí a léamh as.""" + ... \ No newline at end of file diff --git a/lang/ga-ie/typeshed/stdlib/microbit/uart.pyi b/lang/ga-ie/typeshed/stdlib/microbit/uart.pyi new file mode 100644 index 0000000..a5f52c3 --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/microbit/uart.pyi @@ -0,0 +1,79 @@ +"""Cumarsáid a dhéanamh le gléas ag baint úsáide as comhéadan sraitheach.""" +from _typeshed import WriteableBuffer +from ..microbit import MicroBitDigitalPin +from typing import Optional, Union +ODD: int +"""Paireacht chorr (corr)""" +EVEN: int +"""Paireacht fiú (fiú amháin)""" + +def init(baudrate: int=9600, bits: int=8, parity: Optional[int]=None, stop: int=1, tx: Optional[MicroBitDigitalPin]=None, rx: Optional[MicroBitDigitalPin]=None) -> None: + """Túsaigh cumarsáid sraitheach. + +Example: ``uart.init(115200, tx=pin0, rx=pin1)`` + +:param baudrate: Luas na cumarsáide. +:param bits: Méid na mbeart atá á dtarchur. micro:bit: ní thacaíonn giotán ach le 8. +:param parity: (paireacht) Conas a dhéantar paireacht a sheiceáil, ``None``, ``uart.ODD`` nó ``uart.EVEN``. +:param stop: (stad) Líon na ngiotán stad, caithfidh sé a bheith 1 le haghaidh micro:bit. +:param tx: Bioráin a tharchur. +:param rx: Biorán glactha. + +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: + """Seiceáil an bhfuil aon sonraí ag fanacht. (aon) + +Example: ``uart.any()`` + +:return: ``True`` if any data is waiting, else ``False``.""" + ... + +def read(nbytes: Optional[int]=None) -> Optional[bytes]: + """Léigh bearta. (léamh) + +Example: ``uart.read()`` + +:param nbytes: Má tá ``nbytes`` sonraithe ansin léigh ar a mhéad go leor beart, nó léigh an oiread beart agus is féidir +:return: A bytes object or ``None`` on timeout""" + ... + +def readinto(buf: WriteableBuffer, nbytes: Optional[int]=None) -> Optional[int]: + """Léigh bearta isteach sa ``buf``. + +Example: ``uart.readinto(input_buffer)`` + +:param buf: An maolán le scríobh chuige. +:param nbytes: Má tá ``nbytes`` sonraithe ansin léigh ar a mhéad go leor bearta, ar shlí eile a léamh ``len(buf)`` bearta. +:return: number of bytes read and stored into ``buf`` or ``None`` on timeout.""" + ... + +def readline() -> Optional[bytes]: + """Léigh líne, ag críochnú i gcarachtar líne nua. + +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]: + """Scríobh maolán ar an mbus. (scríobh) + +Example: ``uart.write('hello world')`` + +:param buf: Réad beart nó teaghrán. +: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/ga-ie/typeshed/stdlib/micropython.pyi b/lang/ga-ie/typeshed/stdlib/micropython.pyi new file mode 100644 index 0000000..c486b3a --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/micropython.pyi @@ -0,0 +1,133 @@ +"""Gnéithe inmheánacha MicroPython.""" +from typing import Any, TypeVar, overload +_T = TypeVar('_T') + +def const(expr: _T) -> _T: + """Úsáidtear é chun a dhearbhú go bhfuil an slonn tairiseach ionas gur féidir leis an tiomsaitheoir +an leas is fearr is féidir a bhaint as. + +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: Léiriú tairiseach.""" + ... + +@overload +def opt_level() -> int: + """Faigh an leibhéal optamaithe reatha chun scripteanna a thiomsú. (leibhéal roghnaithe) + +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: + """Socraigh an leibhéal optamaithe le haghaidh tiomsú scripteanna ina dhiaidh sin. (leibhéal rogha) + +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: (leibhéal) Leibhéal optamaithe slánuimhir.""" + ... + +def mem_info(verbose: Any=None) -> None: + """Priontáil faisnéis faoin gcuimhne atá in úsáid faoi láthair. (eolas cuimhne) + +Example: ``micropython.mem_info()`` + +:param verbose: (foclach) Má thugtar an argóint ``verbose``, clóitear faisnéis bhreise.""" + ... + +def qstr_info(verbose: Any=None) -> None: + """Priontáil eolas faoi théada atá imtheorannaithe faoi láthair. (eolas qstr) + +Example: ``micropython.qstr_info()`` + +:param verbose: (foclach) Má thugtar an argóint ``verbose``, clóitear faisnéis bhreise. + +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: + """Tabhair slánuimhir ar ais a léiríonn an méid reatha cruach atá á +a úsáidtear. (úsáid cruach) + +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: + """Glasáil an carn. (glas carn) + +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: + """Díghlasáil an carn. (díghlasáil carn) + +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: + """Socraigh an carachtar a ardóidh eisceacht ``KeyboardInterrupt`` . + +Example: ``micropython.kbd_intr(-1)`` + +:param chr: Cód carachtar chun an t-idirbhriseadh nó -1 a ardú chun gabháil Ctrl-C a dhíchumasú. + +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/ga-ie/typeshed/stdlib/music.pyi b/lang/ga-ie/typeshed/stdlib/music.pyi new file mode 100644 index 0000000..ce2bc8a --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/music.pyi @@ -0,0 +1,128 @@ +"""Cruthaigh agus seinn séiseanna. (ceol)""" +from typing import Optional, Tuple, Union, List +from .microbit import MicroBitDigitalPin, pin0 +DADADADUM: Tuple[str, ...] +"""Fonn: oscailt 5ú Siansa Beethoven i C mion.""" +ENTERTAINER: Tuple[str, ...] +"""Fonn: an blúire oscailte de chlasaic Ragtime Scott Joplin "The Entertainer". (siamsóir)""" +PRELUDE: Tuple[str, ...] +"""Fonn: oscailt an chéad Réamhrá i C Major de 48 Réamhráite agus Fugues J.S.Bach. (réamhrá)""" +ODE: Tuple[str, ...] +"""Fonn: an téama "Ode to Joy" ó 9ú Siansa Beethoven in D minor.""" +NYAN: Tuple[str, ...] +"""Fonn: téama Nyan Cat (http://www.nyan.cat/). + +The composer is unknown. This is fair use for educational porpoises (as they say in New York).""" +RINGTONE: Tuple[str, ...] +"""Fonn: rud a fhuaimníonn cosúil le clingthon fón póca. (clingthon) + +To be used to indicate an incoming message. +""" +FUNK: Tuple[str, ...] +"""Fonn: líne dord spraíúil do ghníomhairí rúnda agus do mháistir-intinn choiriúla. (func)""" +BLUES: Tuple[str, ...] +"""Fonn: a boogie-woogie 12-bar blues ag siúl Bass.""" +BIRTHDAY: Tuple[str, ...] +"""Fonn: "Breithlá sona duit..." (lá breithe) + +For copyright status see: http://www.bbc.co.uk/news/world-us-canada-34332853 +""" +WEDDING: Tuple[str, ...] +"""Fonn: an curfá bridal ó cheoldráma Wagner "Lohengrin". (pósadh)""" +FUNERAL: Tuple[str, ...] +"""Fonn : an “máirseáil sochraide” ar a dtugtar freisin Sonáid Phianó Uimh. 2 i B♭ beag, Op. 35 le Frédéric Chopin. (sochraid)""" +PUNCHLINE: Tuple[str, ...] +"""Fonn: tá blúire spraoi a léiríonn magadh déanta.""" +PYTHON: Tuple[str, ...] +"""Fonn: Máirseáil John Philip Sousa “Liberty Bell” ar a dtugtar téama “Monty Python’s Flying Circus” (ar a dtugtar an teanga ríomhchlárúcháin Python ina diaidh).""" +BADDY: Tuple[str, ...] +"""Fonn: bealach isteach ré an scannáin chiúin de drochdhuine. (drochdhuine)""" +CHASE: Tuple[str, ...] +"""Fonn: radharc ruaig ré scannán ciúin. (ruaig)""" +BA_DING: Tuple[str, ...] +"""Fonn: comhartha gearr chun a chur in iúl gur tharla rud éigin.""" +WAWAWAWAA: Tuple[str, ...] +"""Fonn: trombón an-bhrónach.""" +JUMP_UP: Tuple[str, ...] +"""Fonn: le húsáid i gcluiche, rud a léiríonn gluaiseacht aníos. (léim suas)""" +JUMP_DOWN: Tuple[str, ...] +"""Séis: le húsáid i gcluiche, rud a léiríonn gluaiseacht anuas. (léim síos)""" +POWER_UP: Tuple[str, ...] +"""Fonn: fonnfóir chun éacht a dhíghlasáil a léiriú. (cumhacht suas)""" +POWER_DOWN: Tuple[str, ...] +"""Fonn: faitíos brónach chun éacht a cailleadh a léiriú. (cumhacht síos)""" + +def set_tempo(ticks: int=4, bpm: int=120) -> None: + """Socraigh an luas garbh le haghaidh athsheinm. (socraigh tempo) + +Example: ``music.set_tempo(bpm=120)`` + +:param ticks: (sceartáin) Líon na sceartán ar buille iad. +:param bpm: Slánuimhir a chinneann cé mhéad buille in aghaidh an nóiméid. + +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]: + """Faigheann an luas reatha mar tupla slánuimhreacha: ``(ticks, bpm)``. (faigh tempo) + +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: + """Seinneann sé ceol. (seinn) + +Example: ``music.play(music.NYAN)`` + +:param music: (ceol) ceol a shonraítear in 'nodaireacht speisialta '_ +:param pin: (biorán) an bioráin aschuir le húsáid le cainteoir seachtrach (réamhshocraithe ``pin0``), ``None`` gan aon fhuaim. +:param wait: (fan) Má tá ``wait`` socraithe go ``True``, tá an fheidhm seo ag blocáil. +:param loop: (lúb) Má tá ``loop`` socraithe go ``True``, athrá ar an tiún go dtí go dtugtar ``stop`` nó go gcuirtear isteach ar an nglao blocála. + +Many built-in melodies are defined in this module.""" + ... + +def pitch(frequency: int, duration: int=-1, pin: Optional[MicroBitDigitalPin]=pin0, wait: bool=True) -> None: + """Seinn nóta. (páirc) + +Example: ``music.pitch(185, 1000)`` + +:param frequency: (minicíocht) Minicíocht slánuimhir +:param duration: (fad) Fad milleasoicind. Má tá fuaim dhiúltach ansin leanúnach go dtí an chéad ghlao eile nó glao ar ``stop``. +:param pin: (biorán) Bioráin aschuir roghnach (réamhshocraithe ``pin0``). +:param wait: (fan) Má tá ``wait`` socraithe go ``True``, tá an fheidhm seo ag blocáil. + +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: + """Stopann sé gach athsheinm ceoil ar an gcainteoir tógtha isteach agus aon fhuaim aschur bioráin. (stad) + +Example: ``music.stop()`` + +:param pin: (pionna) Is féidir argóint roghnach a chur ar fáil chun biorán a shonrú, m.sh. ``music.stop(pin1)``.""" + +def reset() -> None: + """Athshocraigh sceartáin, bpm, fad agus ochtach chuig a luachanna réamhshocraithe. (athshocrú) + +Example: ``music.reset()`` + +Values: +- ``ticks = 4`` +- ``bpm = 120`` +- ``duration = 4`` +- ``octave = 4``""" + ... \ No newline at end of file diff --git a/lang/ga-ie/typeshed/stdlib/neopixel.pyi b/lang/ga-ie/typeshed/stdlib/neopixel.pyi new file mode 100644 index 0000000..b81862f --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/neopixel.pyi @@ -0,0 +1,81 @@ +"""Stiallacha RGB agus RGBW LED atá inseolta ina n-aonar.""" +from .microbit import MicroBitDigitalPin +from typing import Tuple + +class NeoPixel: + + def __init__(self, pin: MicroBitDigitalPin, n: int, bpp: int=3) -> None: + """Túsaigh stiall nua de soilse neopicsel a rialaítear trí bhiorán. + +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: (biorán) An biorán a rialaíonn an stiall neopicsel. +:param n: Líon na neopicsel sa stiall. +:param bpp: Bearta in aghaidh an phicteilín. Maidir le tacaíocht neopicsel RGBW, pas 4 seachas mainneachtain 3 do RGB agus GRB.""" + ... + + def clear(self) -> None: + """Glan na picteilíní go léir. (soiléir) + +Example: ``np.clear()``""" + ... + + def show(self) -> None: + """Taispeáin na picteilíní. (taispeáin) + +Example: ``np.show()`` + +Must be called for any updates to become visible.""" + ... + + def write(self) -> None: + """Taispeáin na picteilíní (micro:bit V2 amháin). (scríobh) + +Example: ``np.write()`` + +Must be called for any updates to become visible. + +Equivalent to ``show``.""" + ... + + def fill(self, colour: Tuple[int, ...]) -> None: + """Dathaigh gach picteilín luach RGB / RGBW ar leith (micro:bit V2 amháin). (líonadh) + +Example: ``np.fill((0, 0, 255))`` + +:param colour: (dath) Tupla den fhad céanna le líon na mbeart in aghaidh an phicteilín (bpp). + +Use in conjunction with ``show()`` to update the neopixels.""" + ... + + def __setitem__(self, key: int, value: Tuple[int, ...]) -> None: + """Socraigh dath picteilín. (socraigh mír) + +Example: ``np[0] = (255, 0, 0)`` + +:param key: (eochair) Uimhir an phicteilín. +:param value: (luach) An dath.""" + + def __getitem__(self, key: int) -> Tuple[int, ...]: + """Faigh dath picteilín. (faigh mír) + +Example: ``r, g, b = np[0]`` + +:param key: (eochair) Uimhir an phicteilín. +:return: The colour tuple.""" + + def __len__(self) -> int: + """Faigh fad an stiall picteilín seo. + +Example: ``len(np)``""" \ No newline at end of file diff --git a/lang/ga-ie/typeshed/stdlib/os.pyi b/lang/ga-ie/typeshed/stdlib/os.pyi new file mode 100644 index 0000000..35de847 --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/os.pyi @@ -0,0 +1,63 @@ +"""Rochtain a fháil ar an gcóras comhad.""" +from typing import Tuple +from typing import List + +def listdir() -> List[str]: + """Liostaigh comhaid. + +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: + """Bain (scrios) comhad. (bain) + +Example: ``os.remove('data.txt')`` + +:param filename: (ainm comhaid) An comhad le scriosadh. + +If the file does not exist an ``OSError`` exception will occur.""" + ... + +def size(filename: str) -> int: + """Tuairisceáin méid comhaid. (méid) + +Example: ``os.size('data.txt')`` + +:param filename: (ainm comhaid) An comhad +: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]): + """Toradh de ``os.uname()`` (toradh uname)""" + sysname: str + """Ainm an chórais oibriúcháin. (ainm an chórais)""" + nodename: str + """Ainm an mheaisín ar an líonra (cur i bhfeidhm sainithe). (ainm nóid)""" + release: str + """Scaoileadh an chórais oibriúcháin. (scaoileadh)""" + version: str + """Leagan an chórais oibriúcháin. (leagan)""" + machine: str + """Aitheantóir crua-earraí. (meaisín)""" + +def uname() -> uname_result: + """Tuairisceáin faisnéis a aithníonn an córas oibriúcháin reatha. + +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/ga-ie/typeshed/stdlib/power.pyi b/lang/ga-ie/typeshed/stdlib/power.pyi new file mode 100644 index 0000000..2be8b27 --- /dev/null +++ b/lang/ga-ie/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/ga-ie/typeshed/stdlib/radio.pyi b/lang/ga-ie/typeshed/stdlib/radio.pyi new file mode 100644 index 0000000..aad25a4 --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/radio.pyi @@ -0,0 +1,130 @@ +"""Cumarsáid a dhéanamh idir micro:bit leis an raidió tógtha. (raidió)""" +from _typeshed import WriteableBuffer +from typing import Optional, Tuple +RATE_1MBIT: int +"""Tairiseach a úsáidtear chun tréchur 1 MBit an dara ceann a léiriú. (ráta 1mbit)""" +RATE_2MBIT: int +"""Tairiseach a úsáidtear chun tréchur 2 MBit an dara ceann a léiriú. (ráta 2mbit)""" + +def on() -> None: + """Casann sé an raidió air. (ar) + +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: + """Múchann sé an raidió, ag sábháil cumhachta agus cuimhne. (as) + +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: + """Cumraigh an raidió. (cumraíocht) + +Example: ``radio.config(group=42)`` + +The default configuration is suitable for most use. + +:param length: (fad) Sainmhíníonn (réamhshocrú=32) an fad uasta, i mbéiteanna, de theachtaireacht a sheoltar tríd an raidió. +Féadfaidh sé a bheith suas le 251 beart ar fhad (254 - 3 beart do réamhrá S0, FAD agus S1). +:param queue: (scuaine) (réamhshocrú = 3) sonraítear líon na dteachtaireachtaí is féidir a stóráil ar an scuaine teachtaireachta isteach. +Mura bhfuil aon spásanna fágtha ar an scuaine le haghaidh teachtaireachtaí isteach, ansin tá an teachtaireacht ag teacht isteach thit. +:param channel: (cainéal) (réamhshocrú = 7) slánuimhir luach ó 0 go 83 (san áireamh) a shainmhíníonn "cainéal" treallach a bhfuil an raidió tiúnta leis. +Seolfar teachtaireachtaí tríd an gcainéal seo agus ní chuirfear ach teachtaireachtaí a fhaightear tríd an gcainéal seo ar an scuaine teachtaireachtaí atá ag teacht isteach. Tá gach céim 1MHz ar leithead, bunaithe ar 2400MHz. +:param power: (cumhacht) (réamhshocrú = 6) Is luach slánuimhir ó 0 go 7 (san áireamh) a chur in iúl ar an neart comhartha a úsáidtear nuair a chraoladh teachtaireacht. +Dá airde an luach is ea is láidre an comhartha, ach is é an gléas is mó a chaitheann an chumhacht. Aistríonn an t-uimhriú go poist sa liosta seo a leanas de luachanna dBm (decibel milliwatt): -30, -20, -16, -12, -8, -4, 0, 4. +:param address: (seoladh) (default=0x75626974) ainm treallach, arna shloinneadh mar sheoladh 32-giotán, a úsáidtear chun paicéid atá ag teacht isteach a scagadh ag leibhéal na crua-earraí, gan ach iad siúd a mheaitseáil leis an seoladh a shocraigh tú a choinneáil. +Is é an réamhshocrú a úsáideann ardáin eile a bhaineann le micro:bit an socrú réamhshocraithe a úsáidtear anseo. +:param group: (grúpa) (default=0) luach 8-giotán (0-255) a úsáidtear leis an ``address`` agus teachtaireachtaí á scagadh. +Go coincheapúil, tá "seoladh" cosúil le seoladh tí / oifige agus tá "grúpa" cosúil leis an duine ag an seoladh sin ar mian leat do theachtaireacht a sheoladh chuige. +:param data_rate: (ráta sonraí) (réamhshocrú=``radio.RATE_1MBIT``) an luas ag a dtarlaíonn tréchur sonraí. +Is féidir a bheith ar cheann de na tairisigh seo a leanas a shainmhínítear sa mhodúl ``radio`` : ``RATE_250KBIT``, ``RATE_1MBIT`` nó ``RATE_2MBIT``. + +If ``config`` is not called then the defaults described above are assumed.""" + ... + +def reset() -> None: + """Athshocraigh na socruithe dá luachanna réamhshocraithe. (athshocrú) + +Example: ``radio.reset()`` + +The defaults as as per the ``config`` function above.""" + ... + +def send_bytes(message: bytes) -> None: + """Seolann seo teachtaireacht ina bhfuil bearta. (seol bearta) + +Example: ``radio.send_bytes(b'hello')`` + +:param message: (teachtaireacht) Na bearta le seoladh.""" + ... + +def receive_bytes() -> Optional[bytes]: + """Faigh an chéad teachtaireacht eile isteach ar an scuaine teachtaireachtaí. (bearta a fháil) + +Example: ``radio.receive_bytes()`` + +:return: The message bytes if any, otherwise ``None``.""" + ... + +def receive_bytes_into(buffer: WriteableBuffer) -> Optional[int]: + """Cóipeáil an chéad teachtaireacht isteach eile ar an scuaine teachtaireachta isteach i maolán. (bearta a fháil isteach i) + +Example: ``radio.receive_bytes_info(buffer)`` + +:param buffer: (maolán) An maolán sprice. Tá an teachtaireacht teasctha má tá sé níos mó ná an maolán. +: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: + """Seolann seo teaghrán teachtaireachta. (seol) + +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: (teachtaireacht) An sreangán le seoladh.""" + ... + +def receive() -> Optional[str]: + """Oibríonn sé ar an mbealach céanna le ``receive_bytes`` ach filleann sé cibé rud a seoladh. (faigh) + +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]]: + """Tuairisceáin tupla ina bhfuil trí luach a léiríonn an chéad teachtaireacht eile ag teacht isteach ar an scuaine teachtaireacht. (faigh iomlán) + +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/ga-ie/typeshed/stdlib/random.pyi b/lang/ga-ie/typeshed/stdlib/random.pyi new file mode 100644 index 0000000..3bfe817 --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/random.pyi @@ -0,0 +1,81 @@ +"""Gin uimhreacha randamacha. (randamach)""" +from typing import TypeVar, Sequence, Union, overload + +def getrandbits(n: int) -> int: + """Gin slánuimhir le ``n`` giotán randamach. + +Example: ``random.getrandbits(1)`` + +:param n: Luach idir 1-30 (san áireamh).""" + ... + +def seed(n: int) -> None: + """Túsaigh an gineadóir uimhreacha randamacha. (síol) + +Example: ``random.seed(0)`` + +:param n: An síol slánuimhir + +This will give you reproducibly deterministic randomness from a given starting +state (``n``).""" + ... + +def randint(a: int, b: int) -> int: + """Roghnaigh slánuimhir randamach idir ``a`` agus ``b`` san áireamh. + +Example: ``random.randint(0, 9)`` + +:param a: Luach tosaigh don raon (san áireamh) +:param b: Luach deiridh don raon (san áireamh) + +Alias for ``randrange(a, b + 1)``.""" + ... + +@overload +def randrange(stop: int) -> int: + """Roghnaigh slánuimhir a roghnaíodh go randamach idir nialas agus suas le (ach ní +lena n-áirítear) ``stop``. + +Example: ``random.randrange(10)`` + +:param stop: (stad) Luach deiridh don raon (eisiach)""" + ... + +@overload +def randrange(start: int, stop: int, step: int=1) -> int: + """Roghnaigh eilimint a roghnaíodh go randamach ó ``range(start, stop, step)``. + +Example: ``random.randrange(0, 10)`` + +:param start: (tús) Tús an raoin (san áireamh) +:param stop: (stad) Deireadh an raoin (eisiach) +:param step: (céim) An chéim.""" + ... +_T = TypeVar('_T') + +def choice(seq: Sequence[_T]) -> _T: + """Roghnaigh eilimint randamach ón seicheamh neamhfholamh ``seq``. (rogha) + +Example: ``random.choice([Image.HAPPY, Image.SAD])`` + +:param seq: Seicheamh. + +If ``seq`` is empty, raises ``IndexError``.""" + ... + +def random() -> float: + """Gin uimhir randamach snámhphointe sa raon [0.0, 1.0). (randamach) + +Example: ``random.random()`` + +:return: The random floating point number""" + ... + +def uniform(a: float, b: float) -> float: + """Seol uimhir randamach snámhphointe ar ais idir ``a`` agus ``b`` san áireamh. (éide) + +Example: ``random.uniform(0, 9)`` + +:param a: Luach tosaigh don raon (san áireamh) +:param b: Luach deiridh don raon (san áireamh)""" + ... \ No newline at end of file diff --git a/lang/ga-ie/typeshed/stdlib/speech.pyi b/lang/ga-ie/typeshed/stdlib/speech.pyi new file mode 100644 index 0000000..b6ae758 --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/speech.pyi @@ -0,0 +1,79 @@ +"""Cuir an micro:bit ag caint, ag canadh agus ag déanamh fuaimeanna eile cosúil le cainte. (óráid)""" +from typing import Optional +from .microbit import MicroBitDigitalPin, pin0 + +def translate(words: str) -> str: + """Aistrigh focail Bhéarla go fóinéimí. (aistrigh) + +Example: ``speech.translate('hello world')`` + +:param words: (focail) Teaghrán focal Béarla. +: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: + """Fóinéimí a fhuaimniú. (fuaimniú) + +Example: ``speech.pronounce(' /HEHLOW WERLD')`` + +:param phonemes: (fóinéimí) An teaghrán fóinéimí a fhuaimniú +:param pitch: (airde) Uimhir a sheasann do pháirc an ghutha +:param speed: (luas) Uimhir a léiríonn luas an ghutha +:param mouth: (béal) Uimhir a sheasann do bhéal an ghutha +:param throat: (scornach) Uimhir a sheasann do scornach an ghutha +:param pin: (biorán) Is féidir argóint roghnach chun an bioráin aschuir a shonrú a úsáid chun mainneachtain ``pin0``a shárú. +Mura dteastaíonn uainn aon fhuaim a sheinm as na bioráin is féidir ``pin=None``a úsáid. micro:bit V2 amháin. + +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: + """Abair focail Bhéarla. (abair) + +Example: ``speech.say('hello world')`` + +:param words: (focail) An teaghrán focal le rá. +:param pitch: (airde) Uimhir a léiríonn airde an ghutha +:param speed: (luas) Uimhir a léiríonn luas an ghlór +:param mouth: (béal) Uimhir a sheasann do bhéal an ghutha +:param throat: (scornach) Uimhir a sheasann do scornach an ghutha +:param pin: (biorán) Is féidir argóint roghnach a úsáid chun an biorán aschuir a shonrú chun an réamhshocrú ``pin0`` a shárú. +Mura dteastaíonn uainn go seinnfí aon fhuaim as na bioráin is féidir ``pin=None`` a úsáid. micro:bit V2 amháin. + +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: + """Can fóinéimí. (canadh) + +Example: ``speech.sing(' /HEHLOW WERLD')`` + +:param phonemes: (fóinéimí) An teaghrán focal le canadh. +:param pitch: (airde) Uimhir a léiríonn airde an ghutha +:param speed: (luas) Uimhir a léiríonn luas an ghlór +:param mouth: (béal) Uimhir a sheasann do bhéal an ghutha +:param throat: (scornach) Uimhir a sheasann do scornach an ghutha +:param pin: (biorán) Is féidir argóint roghnach chun an bioráin aschuir a shonrú a úsáid chun mainneachtain ``pin0``a shárú. +Mura dteastaíonn uainn aon fhuaim a sheinm as na bioráin is féidir ``pin=None``a úsáid. micro:bit V2 amháin. + +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/ga-ie/typeshed/stdlib/struct.pyi b/lang/ga-ie/typeshed/stdlib/struct.pyi new file mode 100644 index 0000000..70fc3e5 --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/struct.pyi @@ -0,0 +1,56 @@ +"""Pacáistiú agus díphacáil cineálacha sonraí bunúsach.""" +from _typeshed import ReadableBuffer, WriteableBuffer +from typing import Any, Tuple, Union + +def calcsize(fmt: str) -> int: + """Faigh líon na mbeart a theastaíonn chun an ``fmt`` tugtha a stóráil. + +Example: ``struct.calcsize('hf')`` + +:param fmt: Teaghrán formáide. +:return The number of bytes needed to store such a value.""" + ... + +def pack(fmt: str, v1: Any, *vn: Any) -> bytes: + """Pacáil luachanna de réir teaghrán formáide. (pacáiste) + +Example: ``struct.pack('hf', 1, 3.1415)`` + +:param fmt: An teaghrán formáide. +:param v1: An chéad luach. +:param *vn: Na luachanna atá fágtha. +:return A bytes object encoding the values.""" + ... + +def pack_into(fmt: str, buffer: WriteableBuffer, offset: int, v1: Any, *vn: Any) -> None: + """Pacáil luachanna de réir teaghrán formáide. (pacáil isteach i) + +Example: ``struct.pack_info('hf', buffer, 1, 3.1415)`` + +:param fmt: An teaghrán formáide. +:param buffer: (maolán) An maolán sprice le scríobh isteach. +:param offset: (fritháireamh) An fritháireamh isteach sa mhaolán. D'fhéadfadh sé a bheith diúltach le comhaireamh ó dheireadh an mhaoláin. +:param v1: An chéad luach. +:param *vn: Na luachanna atá fágtha.""" + ... + +def unpack(fmt: str, data: ReadableBuffer) -> Tuple[Any, ...]: + """Díphacáil sonraí de réir teaghrán formáide. (díphacáil) + +Example: ``v1, v2 = struct.unpack('hf', buffer)`` + +:param fmt: An teaghrán formáide. +:param data: (sonraí) Na sonraí. +:return: A tuple of the unpacked values.""" + ... + +def unpack_from(fmt: str, buffer: ReadableBuffer, offset: int=0) -> Tuple: + """Díphacáil sonraí ó mhaolán de réir teaghrán formáide. (díphacáil ó) + +Example: ``v1, v2 = struct.unpack_from('hf', buffer)`` + +:param fmt: An teaghrán formáide. +:param buffer: (maolán) An maolán foinseach le léamh as. +:param offset: (fritháireamh) An fritháireamh isteach sa mhaolán. D'fhéadfadh sé a bheith diúltach le comhaireamh ó dheireadh an mhaoláin. +:return: A tuple of the unpacked values.""" + ... \ No newline at end of file diff --git a/lang/ga-ie/typeshed/stdlib/sys.pyi b/lang/ga-ie/typeshed/stdlib/sys.pyi new file mode 100644 index 0000000..7d78696 --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/sys.pyi @@ -0,0 +1,96 @@ +"""Feidhmeanna a bhaineann go sonrach leis an gcóras""" +from typing import Any, Dict, List, NoReturn, TextIO, Tuple + +def exit(retval: object=...) -> NoReturn: + """Cuir deireadh leis an ríomhchlár reatha le cód scoir ar leith. (scoir) + +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: An cód scoir nó an teachtaireacht.""" + ... + +def print_exception(exc: Exception) -> None: + """Priontáil eisceacht le rianú siar. (eisceacht priontála) + +Example: ``sys.print_exception(e)`` + +:param exc: An eisceacht maidir le priontáil + +This is simplified version of a function which appears in the +``traceback`` module in CPython.""" +argv: List[str] +"""Liosta inathraithe d'argóintí a cuireadh tús leis an gclár reatha leo.""" +byteorder: str +"""Ord beart an chórais (``"little"`` nó ``"big"``).""" + +class _implementation: + name: str + version: Tuple[int, int, int] +implementation: _implementation +"""Cuspóir le faisnéis faoi chur i bhfeidhm reatha Python. (cur i bhfeidhm) + +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 +""" +Uasluach is féidir le cineál slánuimhir dhúchasach a shealbhú ar an ardán reatha, +nó an luach uasta is féidir a léiriú le cineál slánuimhir MicroPython, má tá sé níos lú +ná uasluach ardáin (is é sin an cás i gcás calafoirt MicroPython gan +tacaíocht int fada). (uasmhéid) + +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] +"""Foclóir modúil luchtaithe. (modúil) + +On some ports, it may not include builtin modules.""" +path: List[str] +"""Liosta inathraithe d’eolairí le cuardach a dhéanamh ar mhodúil allmhairithe. (cosán)""" +platform: str +"""An t-ardán a bhfuil MicroPython ag rith air. (ardán) + +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 +"""Leagan teanga Python a chloíonn leis an gcur i bhfeidhm seo, mar theaghrán. (leagan)""" +version_info: Tuple[int, int, int] +"""Leagan teanga Python a gcomhlíonann an cur i bhfeidhm seo, mar thupla de shláintiúirí. (eolas faoin leagan) + +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/ga-ie/typeshed/stdlib/this.pyi b/lang/ga-ie/typeshed/stdlib/this.pyi new file mode 100644 index 0000000..faf492b --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/this.pyi @@ -0,0 +1 @@ +def authors() -> str: ... diff --git a/lang/ga-ie/typeshed/stdlib/time.pyi b/lang/ga-ie/typeshed/stdlib/time.pyi new file mode 100644 index 0000000..679599d --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/time.pyi @@ -0,0 +1,116 @@ +"""Tomhais am agus cuir moilleanna le ríomhchláir. (am)""" +from typing import Union + +def sleep(seconds: Union[int, float]) -> None: + """Moill a chur ar roinnt soicindí. (codladh) + +Example: ``time.sleep(1)`` + +:param seconds: (soicindí) Líon na soicindí le codladh. +Bain úsáid as uimhir snámhphointe chun codladh ar feadh uimhir chodánach soicind.""" + ... + +def sleep_ms(ms: int) -> None: + """Moill ar líon áirithe milleasoicindí. (codladh ms) + +Example: ``time.sleep_ms(1_000_000)`` + +:param ms: Líon na milleasoicindí moill (>= 0).""" + ... + +def sleep_us(us: int) -> None: + """Moill ar líon áirithe micreasoicindí. (codladh linn) + +Example: ``time.sleep_us(1000)`` + +:param us: (linn) Líon na micreasoicindí moill (>= 0).""" + ... + +def ticks_ms() -> int: + """Faigh cuntar milleasoicind atá ag dul i méid le pointe tagartha treallach, +a chlúdaíonn thart tar éis luach éigin. (sceartáin ms) + +Example: ``time.ticks_ms()`` + +:return: The counter value in milliseconds.""" + ... + +def ticks_us() -> int: + """Faigh cuntar méadaitheach micreasoicind le pointe tagartha treallach, +a chlúdaíonn thart tar éis luach éigin. (tic a chur orainn) + +Example: ``time.ticks_us()`` + +:return: The counter value in microseconds.""" + ... + +def ticks_add(ticks: int, delta: int) -> int: + """Fritháireamh luach ticeanna de réir uimhir ar leith, a d'fhéadfadh a bheith dearfach nó +diúltach. (cuir sceartáin) + +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: (sceartáin) Luach ticeanna +:param delta: (deilte) Fritháireamh slánuimhir + +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: + """Tomhais an difríocht idir luachanna a chuirtear ar ais ó +``time.ticks_ms()`` nó ``ticks_us()``, mar luach sínithe +a d'fhéadfadh timfhilleadh timpeall. (ticeanna difr) + +Example: ``time.ticks_diff(scheduled_time, now)`` + +:param ticks1: (ticeanna1) An luach a dhealú ó +:param ticks2: (ticeanna2) An luach a dhealú + +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/ga-ie/typeshed/stdlib/types.pyi b/lang/ga-ie/typeshed/stdlib/types.pyi new file mode 100644 index 0000000..752b2de --- /dev/null +++ b/lang/ga-ie/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/ga-ie/typeshed/stdlib/typing.pyi b/lang/ga-ie/typeshed/stdlib/typing.pyi new file mode 100644 index 0000000..a494557 --- /dev/null +++ b/lang/ga-ie/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/ga-ie/typeshed/stdlib/typing_extensions.pyi b/lang/ga-ie/typeshed/stdlib/typing_extensions.pyi new file mode 100644 index 0000000..59fe3df --- /dev/null +++ b/lang/ga-ie/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/ga-ie/typeshed/stdlib/uarray.pyi b/lang/ga-ie/typeshed/stdlib/uarray.pyi new file mode 100644 index 0000000..d1ba4d9 --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/uarray.pyi @@ -0,0 +1 @@ +from array import * diff --git a/lang/ga-ie/typeshed/stdlib/ucollections.pyi b/lang/ga-ie/typeshed/stdlib/ucollections.pyi new file mode 100644 index 0000000..9400561 --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/ucollections.pyi @@ -0,0 +1 @@ +from collections import * diff --git a/lang/ga-ie/typeshed/stdlib/uerrno.pyi b/lang/ga-ie/typeshed/stdlib/uerrno.pyi new file mode 100644 index 0000000..5ecb44d --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/uerrno.pyi @@ -0,0 +1 @@ +from errno import * diff --git a/lang/ga-ie/typeshed/stdlib/urandom.pyi b/lang/ga-ie/typeshed/stdlib/urandom.pyi new file mode 100644 index 0000000..1c31bde --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/urandom.pyi @@ -0,0 +1 @@ +from random import * diff --git a/lang/ga-ie/typeshed/stdlib/ustruct.pyi b/lang/ga-ie/typeshed/stdlib/ustruct.pyi new file mode 100644 index 0000000..ee3a9fc --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/ustruct.pyi @@ -0,0 +1 @@ +from struct import * diff --git a/lang/ga-ie/typeshed/stdlib/usys.pyi b/lang/ga-ie/typeshed/stdlib/usys.pyi new file mode 100644 index 0000000..104052c --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/usys.pyi @@ -0,0 +1 @@ +from sys import * diff --git a/lang/ga-ie/typeshed/stdlib/utime.pyi b/lang/ga-ie/typeshed/stdlib/utime.pyi new file mode 100644 index 0000000..72705db --- /dev/null +++ b/lang/ga-ie/typeshed/stdlib/utime.pyi @@ -0,0 +1 @@ +from time import * diff --git a/scripts/build-translations.sh b/scripts/build-translations.sh index 2d7b383..f80485d 100755 --- a/scripts/build-translations.sh +++ b/scripts/build-translations.sh @@ -5,7 +5,7 @@ set -euxo pipefail -languages="ca de fr es-ES ja ko nl pl zh-CN zh-TW lol" +languages="ca de es-ES fr ga-IE ja ko nl pl zh-CN zh-TW lol" for language in $languages; do lower="${language,,}" From c282528e5997cbff32a9b71dd8ed8d4808cddf6f Mon Sep 17 00:00:00 2001 From: Matt Hillsdon Date: Tue, 10 Jun 2025 09:29:51 +0100 Subject: [PATCH 2/2] Skip cache due to inexplicable error This one is very quick anyway. --- .github/workflows/node.js.yml | 22 ++++++++++------------ 1 file changed, 10 insertions(+), 12 deletions(-) diff --git a/.github/workflows/node.js.yml b/.github/workflows/node.js.yml index e424e07..04c0b33 100644 --- a/.github/workflows/node.js.yml +++ b/.github/workflows/node.js.yml @@ -5,13 +5,12 @@ name: Node.js CI on: push: - branches: [ main ] + branches: [main] pull_request: - branches: [ main ] + branches: [main] jobs: build: - runs-on: ubuntu-latest strategy: @@ -20,12 +19,11 @@ jobs: # See supported Node.js release schedule at https://nodejs.org/en/about/releases/ steps: - - uses: actions/checkout@v2 - - name: Use Node.js ${{ matrix.node-version }} - uses: actions/setup-node@v2 - with: - node-version: ${{ matrix.node-version }} - cache: 'npm' - - run: npm ci - - run: npm run build --if-present - - run: npm test + - uses: actions/checkout@v2 + - name: Use Node.js ${{ matrix.node-version }} + uses: actions/setup-node@v2 + with: + node-version: ${{ matrix.node-version }} + - run: npm ci + - run: npm run build --if-present + - run: npm test