multiprocessing: fix iterator of Array (#12129) (#12130)

stdlib/@tests/test_cases/check_multiprocessing.py

@@ -1,14 +1,19 @@
 from __future__ import annotations
 
-from ctypes import c_char, c_float
+from ctypes import c_char, c_float, c_int
 from multiprocessing import Array, Value
-from multiprocessing.sharedctypes import Synchronized, SynchronizedString
+from multiprocessing.sharedctypes import Synchronized, SynchronizedArray, SynchronizedString
 from typing_extensions import assert_type
 
 string = Array(c_char, 12)
 assert_type(string, SynchronizedString)
 assert_type(string.value, bytes)
 
+numbers = Array(c_int, 3)
+assert_type(numbers, SynchronizedArray[int])
+numbers[0] = 3
+numbers[:] = [0, 1, 2]
+
 field = Value(c_float, 0.0)
 assert_type(field, Synchronized[float])
 field.value = 1.2

stdlib/multiprocessing/context.pyi

@@ -92,17 +92,21 @@ class BaseContext:
     @overload
     def Value(self, typecode_or_type: str | type[_CData], *args: Any, lock: bool | _LockLike = True) -> Any: ...
     @overload
+    def Array(
+        self, typecode_or_type: type[_SimpleCData[_T]], size_or_initializer: int | Sequence[Any], *, lock: Literal[False]
+    ) -> SynchronizedArray[_T]: ...
+    @overload
     def Array(
         self, typecode_or_type: type[c_char], size_or_initializer: int | Sequence[Any], *, lock: Literal[True] | _LockLike = True
     ) -> SynchronizedString: ...
     @overload
     def Array(
-        self, typecode_or_type: type[_CT], size_or_initializer: int | Sequence[Any], *, lock: Literal[False]
-    ) -> SynchronizedArray[_CT]: ...
-    @overload
-    def Array(
-        self, typecode_or_type: type[_CT], size_or_initializer: int | Sequence[Any], *, lock: Literal[True] | _LockLike = True
-    ) -> SynchronizedArray[_CT]: ...
+        self,
+        typecode_or_type: type[_SimpleCData[_T]],
+        size_or_initializer: int | Sequence[Any],
+        *,
+        lock: Literal[True] | _LockLike = True,
+    ) -> SynchronizedArray[_T]: ...
     @overload
     def Array(
         self, typecode_or_type: str, size_or_initializer: int | Sequence[Any], *, lock: Literal[True] | _LockLike = True

stdlib/multiprocessing/sharedctypes.pyi

@@ -39,12 +39,20 @@ def Array(
 ) -> _CT: ...
 @overload
 def Array(
-    typecode_or_type: type[_CT],
+    typecode_or_type: type[c_char],
     size_or_initializer: int | Sequence[Any],
     *,
     lock: Literal[True] | _LockLike = True,
     ctx: BaseContext | None = None,
-) -> SynchronizedArray[_CT]: ...
+) -> SynchronizedString: ...
+@overload
+def Array(
+    typecode_or_type: type[_SimpleCData[_T]],
+    size_or_initializer: int | Sequence[Any],
+    *,
+    lock: Literal[True] | _LockLike = True,
+    ctx: BaseContext | None = None,
+) -> SynchronizedArray[_T]: ...
 @overload
 def Array(
     typecode_or_type: str,
@@ -65,9 +73,11 @@ def copy(obj: _CT) -> _CT: ...
 @overload
 def synchronized(obj: _SimpleCData[_T], lock: _LockLike | None = None, ctx: Any | None = None) -> Synchronized[_T]: ...
 @overload
-def synchronized(obj: ctypes.Array[c_char], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedString: ...
+def synchronized(obj: ctypes.Array[c_char], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedString: ...  # type: ignore
 @overload
-def synchronized(obj: ctypes.Array[_CT], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedArray[_CT]: ...
+def synchronized(
+    obj: ctypes.Array[_SimpleCData[_T]], lock: _LockLike | None = None, ctx: Any | None = None
+) -> SynchronizedArray[_T]: ...
 @overload
 def synchronized(obj: _CT, lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedBase[_CT]: ...
 
@@ -89,19 +99,30 @@ class SynchronizedBase(Generic[_CT]):
 class Synchronized(SynchronizedBase[_SimpleCData[_T]], Generic[_T]):
     value: _T
 
-class SynchronizedArray(SynchronizedBase[ctypes.Array[_CT]], Generic[_CT]):
+class SynchronizedArray(SynchronizedBase[ctypes.Array[_SimpleCData[_T]]], Generic[_T]):
     def __len__(self) -> int: ...
     @overload
-    def __getitem__(self, i: slice) -> list[_CT]: ...
+    def __getitem__(self, i: slice) -> list[_T]: ...
     @overload
-    def __getitem__(self, i: int) -> _CT: ...
+    def __getitem__(self, i: int) -> _T: ...
     @overload
-    def __setitem__(self, i: slice, value: Iterable[_CT]) -> None: ...
+    def __setitem__(self, i: slice, value: Iterable[_T]) -> None: ...
     @overload
-    def __setitem__(self, i: int, value: _CT) -> None: ...
-    def __getslice__(self, start: int, stop: int) -> list[_CT]: ...
-    def __setslice__(self, start: int, stop: int, values: Iterable[_CT]) -> None: ...
+    def __setitem__(self, i: int, value: _T) -> None: ...
+    def __getslice__(self, start: int, stop: int) -> list[_T]: ...
+    def __setslice__(self, start: int, stop: int, values: Iterable[_T]) -> None: ...
+
+class SynchronizedString(SynchronizedArray[bytes]):
+    @overload  # type: ignore[override]
+    def __getitem__(self, i: slice) -> bytes: ...
+    @overload  # type: ignore[override]
+    def __getitem__(self, i: int) -> bytes: ...
+    @overload  # type: ignore[override]
+    def __setitem__(self, i: slice, value: bytes) -> None: ...
+    @overload  # type: ignore[override]
+    def __setitem__(self, i: int, value: bytes) -> None: ...  # type: ignore[override]
+    def __getslice__(self, start: int, stop: int) -> bytes: ...  # type: ignore[override]
+    def __setslice__(self, start: int, stop: int, values: bytes) -> None: ...  # type: ignore[override]
 
-class SynchronizedString(SynchronizedArray[c_char]):
     value: bytes
     raw: bytes