We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
cupy.copyto behaves differently from numpy.copyto when src is a python scalar
Code:
```python
import numpy
import cupy

def copyto_check(xp):
    x = xp.zeros(3, dtype=numpy.float32)
    # replace first and third items with 1.0
    xp.copyto(x, 1.0, where=xp.asarray([True, False, True]))
    print(x)

print('numpy', numpy.__version__)
copyto_check(numpy)
print('cupy', cupy.__version__)
copyto_check(cupy)
```
Output:
```
numpy 1.14.0
[1. 0. 1.]
cupy 2.2.0
[1. 1. 1.]
```

--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `cupy/manipulation/basic.py`
Content:
```
1 import numpy
2 import six
3 
4 from cupy import core
5 
6 
7 def copyto(dst, src, casting='same_kind', where=None):
8     """Copies values from one array to another with broadcasting.
9 
10     This function can be called for arrays on different devices. In this case,
11     casting, ``where``, and broadcasting is not supported, and an exception is
12     raised if these are used.
13 
14     Args:
15         dst (cupy.ndarray): Target array.
16         src (cupy.ndarray): Source array.
17         casting (str): Casting rule. See :func:`numpy.can_cast` for detail.
18         where (cupy.ndarray of bool): If specified, this array acts as a mask,
19             and an element is copied only if the corresponding element of
20             ``where`` is True.
21 
22     .. seealso:: :func:`numpy.copyto`
23 
24     """
25 
26     src_type = type(src)
27     src_is_python_scalar = (src_type in six.integer_types or
28                             src_type in (bool, float, complex))
29     if src_is_python_scalar:
30         src_dtype = numpy.dtype(type(src))
31         can_cast = numpy.can_cast(src, dst.dtype, casting)
32     else:
33         src_dtype = src.dtype
34         can_cast = numpy.can_cast(src_dtype, dst.dtype, casting)
35 
36     if not can_cast:
37         raise TypeError('Cannot cast %s to %s in %s casting mode' %
38                         (src_dtype, dst.dtype, casting))
39     if dst.size == 0:
40         return
41 
42     if src_is_python_scalar:
43         dst.fill(src)
44         return
45 
46     if where is None:
47         if _can_memcpy(dst, src):
48             dst.data.copy_from(src.data, src.nbytes)
49         else:
50             device = dst.device
51             with device:
52                 if src.device != device:
53                     src = src.copy()
54                 core.elementwise_copy(src, dst)
55     else:
56         core.elementwise_copy_where(src, where, dst)
57 
58 
59 def _can_memcpy(dst, src):
60     c_contiguous = dst.flags.c_contiguous and src.flags.c_contiguous
61     f_contiguous = dst.flags.f_contiguous and src.flags.f_contiguous
62     return (c_contiguous or f_contiguous) and dst.dtype == src.dtype and \
63         dst.size == src.size
64
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/cupy/manipulation/basic.py b/cupy/manipulation/basic.py
--- a/cupy/manipulation/basic.py
+++ b/cupy/manipulation/basic.py
@@ -39,7 +39,7 @@
     if dst.size == 0:
         return
 
-    if src_is_python_scalar:
+    if src_is_python_scalar and where is None:
         dst.fill(src)
         return

{"golden_diff": "diff --git a/cupy/manipulation/basic.py b/cupy/manipulation/basic.py\n--- a/cupy/manipulation/basic.py\n+++ b/cupy/manipulation/basic.py\n@@ -39,7 +39,7 @@\n     if dst.size == 0:\n         return\n \n-    if src_is_python_scalar:\n+    if src_is_python_scalar and where is None:\n         dst.fill(src)\n         return\n", "issue": "cupy.copyto behaves differently from numpy.copyto when src is a python scalar\nCode:\r\n```python\r\nimport numpy\r\nimport cupy\r\n\r\ndef copyto_check(xp):\r\n    x = xp.zeros(3, dtype=numpy.float32)\r\n    # replace first and third items with 1.0\r\n    xp.copyto(x, 1.0, where=xp.asarray([True, False, True]))\r\n    print(x)\r\n\r\nprint('numpy', numpy.__version__)\r\ncopyto_check(numpy)\r\nprint('cupy', cupy.__version__)\r\ncopyto_check(cupy)\r\n```\r\nOutput:\r\n```\r\nnumpy 1.14.0\r\n[1. 0. 1.]\r\ncupy 2.2.0\r\n[1. 1. 1.]\r\n```\n", "before_files": [{"content": "import numpy\nimport six\n\nfrom cupy import core\n\n\ndef copyto(dst, src, casting='same_kind', where=None):\n    \"\"\"Copies values from one array to another with broadcasting.\n\n    This function can be called for arrays on different devices. In this case,\n    casting, ``where``, and broadcasting is not supported, and an exception is\n    raised if these are used.\n\n    Args:\n        dst (cupy.ndarray): Target array.\n        src (cupy.ndarray): Source array.\n        casting (str): Casting rule. See :func:`numpy.can_cast` for detail.\n        where (cupy.ndarray of bool): If specified, this array acts as a mask,\n            and an element is copied only if the corresponding element of\n            ``where`` is True.\n\n    .. seealso:: :func:`numpy.copyto`\n\n    \"\"\"\n\n    src_type = type(src)\n    src_is_python_scalar = (src_type in six.integer_types or\n                            src_type in (bool, float, complex))\n    if src_is_python_scalar:\n        src_dtype = numpy.dtype(type(src))\n        can_cast = numpy.can_cast(src, dst.dtype, casting)\n    else:\n        src_dtype = src.dtype\n        can_cast = numpy.can_cast(src_dtype, dst.dtype, casting)\n\n    if not can_cast:\n        raise TypeError('Cannot cast %s to %s in %s casting mode' %\n                        (src_dtype, dst.dtype, casting))\n    if dst.size == 0:\n        return\n\n    if src_is_python_scalar:\n        dst.fill(src)\n        return\n\n    if where is None:\n        if _can_memcpy(dst, src):\n            dst.data.copy_from(src.data, src.nbytes)\n        else:\n            device = dst.device\n            with device:\n                if src.device != device:\n                    src = src.copy()\n                core.elementwise_copy(src, dst)\n    else:\n        core.elementwise_copy_where(src, where, dst)\n\n\ndef _can_memcpy(dst, src):\n    c_contiguous = dst.flags.c_contiguous and src.flags.c_contiguous\n    f_contiguous = dst.flags.f_contiguous and src.flags.f_contiguous\n    return (c_contiguous or f_contiguous) and dst.dtype == src.dtype and \\\n        dst.size == src.size\n", "path": "cupy/manipulation/basic.py"}], "after_files": [{"content": "import numpy\nimport six\n\nfrom cupy import core\n\n\ndef copyto(dst, src, casting='same_kind', where=None):\n    \"\"\"Copies values from one array to another with broadcasting.\n\n    This function can be called for arrays on different devices. In this case,\n    casting, ``where``, and broadcasting is not supported, and an exception is\n    raised if these are used.\n\n    Args:\n        dst (cupy.ndarray): Target array.\n        src (cupy.ndarray): Source array.\n        casting (str): Casting rule. See :func:`numpy.can_cast` for detail.\n        where (cupy.ndarray of bool): If specified, this array acts as a mask,\n            and an element is copied only if the corresponding element of\n            ``where`` is True.\n\n    .. seealso:: :func:`numpy.copyto`\n\n    \"\"\"\n\n    src_type = type(src)\n    src_is_python_scalar = (src_type in six.integer_types or\n                            src_type in (bool, float, complex))\n    if src_is_python_scalar:\n        src_dtype = numpy.dtype(type(src))\n        can_cast = numpy.can_cast(src, dst.dtype, casting)\n    else:\n        src_dtype = src.dtype\n        can_cast = numpy.can_cast(src_dtype, dst.dtype, casting)\n\n    if not can_cast:\n        raise TypeError('Cannot cast %s to %s in %s casting mode' %\n                        (src_dtype, dst.dtype, casting))\n    if dst.size == 0:\n        return\n\n    if src_is_python_scalar and where is None:\n        dst.fill(src)\n        return\n\n    if where is None:\n        if _can_memcpy(dst, src):\n            dst.data.copy_from(src.data, src.nbytes)\n        else:\n            device = dst.device\n            with device:\n                if src.device != device:\n                    src = src.copy()\n                core.elementwise_copy(src, dst)\n    else:\n        core.elementwise_copy_where(src, where, dst)\n\n\ndef _can_memcpy(dst, src):\n    c_contiguous = dst.flags.c_contiguous and src.flags.c_contiguous\n    f_contiguous = dst.flags.f_contiguous and src.flags.f_contiguous\n    return (c_contiguous or f_contiguous) and dst.dtype == src.dtype and \\\n        dst.size == src.size\n", "path": "cupy/manipulation/basic.py"}]}