Added support for asarray on sequences with arrays from incop. queues

```
In [1]: import dpctl, dpctl.tensor as dpt

In [2]: m = dpt.zeros((2, 4), dtype="i2", device="cpu")

In [3]: w = dpt.full(4, -1, device="opencl:gpu")

In [4]: res = dpt.asarray([m, [w, [0,] * 4 ]], dtype="f4", device="cpu")

In [5]: res
Out[5]:
usm_ndarray([[[ 0.,  0.,  0.,  0.],
              [ 0.,  0.,  0.,  0.]],
             [[-1., -1., -1., -1.],
	      [ 0.,  0.,  0.,  0.]]], dtype=float32)

In [6]: res.device
Out[6]: Device(opencl:cpu:0)
```

This usage requires user to specify sycl_queue or device keyword to
indicate where the result is created, or ExecitionPlacementError is
raised.

Author: oleksandr-pavlyk

dpctl/tensor/_ctors.py

@@ -329,6 +329,10 @@ def _usm_types_walker(o, usm_types_list):
         usm_ar = _usm_ndarray_from_suai(o)
         usm_types_list.append(usm_ar.usm_type)
         return
+    if _is_object_with_buffer_protocol(o):
+        return
+    if isinstance(o, (int, bool, float, complex)):
+        return
     if isinstance(o, (list, tuple)):
         for el in o:
             _usm_types_walker(el, usm_types_list)
@@ -361,11 +365,37 @@ def _device_copy_walker(seq_o, res, events):
 
 def _copy_through_host_walker(seq_o, usm_res):
     if isinstance(seq_o, dpt.usm_ndarray):
-        usm_res[...] = dpt.asnumpy(seq_o).copy()
-        return
+        if (
+            dpctl.utils.get_execution_queue(
+                (
+                    usm_res.sycl_queue,
+                    seq_o.sycl_queue,
+                )
+            )
+            is None
+        ):
+            usm_res[...] = dpt.asnumpy(seq_o).copy()
+            return
+        else:
+            usm_res[...] = seq_o
     if hasattr(seq_o, "__sycl_usm_array_interface__"):
         usm_ar = _usm_ndarray_from_suai(seq_o)
-        usm_res[...] = dpt.asnumpy(usm_ar).copy()
+        if (
+            dpctl.utils.get_execution_queue(
+                (
+                    usm_res.sycl_queue,
+                    usm_ar.sycl_queue,
+                )
+            )
+            is None
+        ):
+            usm_res[...] = dpt.asnumpy(usm_ar).copy()
+        else:
+            usm_res[...] = usm_ar
+        return
+    if _is_object_with_buffer_protocol(seq_o):
+        np_ar = np.asarray(seq_o)
+        usm_res[...] = np_ar
         return
     if isinstance(seq_o, (list, tuple)):
         for i, el in enumerate(seq_o):
@@ -378,10 +408,10 @@ def _asarray_from_seq(
     seq_obj,
     seq_shape,
     seq_dt,
-    seq_dev,
+    alloc_q,
+    exec_q,
     dtype=None,
     usm_type=None,
-    sycl_queue=None,
     order="C",
 ):
     "`obj` is a sequence"
@@ -390,24 +420,13 @@ def _asarray_from_seq(
         _usm_types_walker(seq_obj, usm_types_in_seq)
         usm_type = dpctl.utils.get_coerced_usm_type(usm_types_in_seq)
     dpctl.utils.validate_usm_type(usm_type)
-    if sycl_queue is None:
-        exec_q = seq_dev
-        alloc_q = seq_dev
-    else:
-        exec_q = dpctl.utils.get_execution_queue(
-            (
-                sycl_queue,
-                seq_dev,
-            )
-        )
-        alloc_q = sycl_queue
     if dtype is None:
         dtype = _map_to_device_dtype(seq_dt, alloc_q)
     else:
         _mapped_dt = _map_to_device_dtype(dtype, alloc_q)
         if _mapped_dt != dtype:
             raise ValueError(
-                f"Device {sycl_queue.sycl_device} "
+                f"Device {alloc_q.sycl_device} "
                 f"does not support {dtype} natively."
             )
         dtype = _mapped_dt
@@ -437,6 +456,39 @@ def _asarray_from_seq(
         return res
 
 
+def _asarray_from_seq_single_device(
+    obj,
+    seq_shape,
+    seq_dt,
+    seq_dev,
+    dtype=None,
+    usm_type=None,
+    sycl_queue=None,
+    order="C",
+):
+    if sycl_queue is None:
+        exec_q = seq_dev
+        alloc_q = seq_dev
+    else:
+        exec_q = dpctl.utils.get_execution_queue(
+            (
+                sycl_queue,
+                seq_dev,
+            )
+        )
+        alloc_q = sycl_queue
+    return _asarray_from_seq(
+        obj,
+        seq_shape,
+        seq_dt,
+        alloc_q,
+        exec_q,
+        dtype=dtype,
+        usm_type=usm_type,
+        order=order,
+    )
+
+
 def asarray(
     obj,
     dtype=None,
@@ -576,16 +628,51 @@ def asarray(
                 order=order,
             )
         elif len(devs) == 1:
-            return _asarray_from_seq(
+            seq_dev = list(devs)[0]
+            return _asarray_from_seq_single_device(
                 obj,
                 seq_shape,
                 seq_dt,
-                list(devs)[0],
+                seq_dev,
                 dtype=dtype,
                 usm_type=usm_type,
                 sycl_queue=sycl_queue,
                 order=order,
             )
+        elif len(devs) > 1:
+            devs = [dev for dev in devs if dev is not None]
+            if len(devs) == 1:
+                seq_dev = devs[0]
+                return _asarray_from_seq_single_device(
+                    obj,
+                    seq_shape,
+                    seq_dt,
+                    seq_dev,
+                    dtype=dtype,
+                    usm_type=usm_type,
+                    sycl_queue=sycl_queue,
+                    order=order,
+                )
+            else:
+                if sycl_queue is None:
+                    raise dpctl.utils.ExecutionPlacementError(
+                        "Please specify `device` or `sycl_queue` keyword "
+                        "argument to determine where to allocated the "
+                        "resulting array."
+                    )
+                alloc_q = sycl_queue
+                exec_q = None  # force copying via host
+                return _asarray_from_seq(
+                    obj,
+                    seq_shape,
+                    seq_dt,
+                    alloc_q,
+                    exec_q,
+                    dtype=dtype,
+                    usm_type=usm_type,
+                    order=order,
+                )
+
         raise NotImplementedError(
             "Converting Python sequences is not implemented"
         )