Add Catalan (preview quality) (#88)

Author: microbit-matt-hillsdon

crowdin/translated/api.ca.json

@@ -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-

lang/ca/typeshed/stdlib/VERSIONS

@@ -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]: ...

lang/ca/typeshed/stdlib/_typeshed/__init__.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: ...

lang/ca/typeshed/stdlib/abc.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

lang/ca/typeshed/stdlib/antigravity.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,
+)