pyqtgraph__pyqtgraph-3278

The user is reporting a `TypeError: Cannot compare structured or void to non-void arrays` when using a NumPy record array to plot data in `pyqtgraph`.

The error happens in `pyqtgraph/graphicsItems/PlotDataItem.py` in the `setData` method:
```python
  File "C:\Users\_\code\.venv\lib\site-packages\pyqtgraph\graphicsItems\PlotDataItem.py", line 719, in setData
    if 'x' in data:
TypeError: Cannot compare structured or void to non-void arrays.
```

This suggests that `data` is a NumPy record array (which is a structured array), and the code is trying to check if `'x'` is in it using the `in` operator. For structured arrays, `in` might be interpreted as an element-wise comparison or something that NumPy doesn't allow in this context when checking for field names. To check for field names in a structured array, one should typically use `data.dtype.names`.

Let's start by reproducing this. I'll create a script that matches the reproduction code provided.

{
  "command": "python3 - <<'PY'\nimport pyqtgraph as pg\nimport numpy as np\nfrom PyQt6 import QtWidgets\n\napp = QtWidgets.QApplication([])\n\ntry:\n    data_array = np.recarray((10,), dtype=[('x', float), ('y', float)])\n    # We don't need pg.exec() for a reproduction that fails at pg.plot()\n    pg.plot(data_array)\n    print(\"Plot succeeded\")\nexcept Exception as e:\n    import traceback\n    traceback.print_exc()\nPY\n"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 3, in <module>\nModuleNotFoundError: No module named 'PyQt6'\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 3, in <module>\nModuleNotFoundError: No module named 'PyQt6'\n",
    "exit_code": 1
  }
}

Ah, I assumed `PyQt6` is installed, but the environment might use another binding. Let me check what's available or use `pyqtgraph.Qt` to be agnostic.
Actually, the reproduction code used `pg.exec()`, which is available in recent pyqtgraph versions.
Wait, if I just want to reproduce the `TypeError`, I don't even need a running QApplication if the error happens during `setData` which is called by `__init__` of `PlotDataItem`.

Let's refine the reproduction script to be more robust. I'll try to import `PyQt6`, `PySide6`, `PyQt5`, or `PySide2` through `pyqtgraph.Qt`.
Actually, `pg.plot()` creates a `PlotWidget` which requires a `QApplication`.

Let's see what Qt bindings are installed.

{
  "command": "pip list | grep -E 'PyQt|PySide'"
}

{
  "status": "ok",
  "stdout": "PyQt5             5.15.11\nPyQt5-Qt5         5.15.18\nPyQt5_sip         12.18.0\n",
  "stderr": "",
  "exit_code": 0
}

Okay, `PyQt5` is installed.

Let's try the reproduction again using `PyQt5`.

{
  "command": "python3 - <<'PY'\nimport pyqtgraph as pg\nimport numpy as np\nfrom PyQt5 import QtWidgets\n\napp = QtWidgets.QApplication([])\n\ntry:\n    data_array = np.recarray((10,), dtype=[('x', float), ('y', float)])\n    pg.plot(data_array)\n    print(\"Plot succeeded\")\nexcept Exception as e:\n    import traceback\n    traceback.print_exc()\nPY\n"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "qt.qpa.xcb: could not connect to display \nqt.qpa.plugin: Could not load the Qt platform plugin \"xcb\" in \"\" even though it was found.\nThis application failed to start because no Qt platform plugin could be initialized. Reinstalling the application may fix this problem.\n\nAvailable platform plugins are: eglfs, linuxfb, minimal, minimalegl, offscreen, vnc, wayland-egl, wayland, wayland-xcomposite-egl, wayland-xcomposite-glx, webgl, xcb.\n\n/bin/bash: line 15:   179 Aborted                 (core dumped) python3 - <<'PY'\nimport pyqtgraph as pg\nimport numpy as np\nfrom PyQt5 import QtWidgets\n\napp = QtWidgets.QApplication([])\n\ntry:\n    data_array = np.recarray((10,), dtype=[('x', float), ('y', float)])\n    pg.plot(data_array)\n    print(\"Plot succeeded\")\nexcept Exception as e:\n    import traceback\n    traceback.print_exc()\nPY\n\n",
  "details": {
    "stdout": "",
    "stderr": "qt.qpa.xcb: could not connect to display \nqt.qpa.plugin: Could not load the Qt platform plugin \"xcb\" in \"\" even though it was found.\nThis application failed to start because no Qt platform plugin could be initialized. Reinstalling the application may fix this problem.\n\nAvailable platform plugins are: eglfs, linuxfb, minimal, minimalegl, offscreen, vnc, wayland-egl, wayland, wayland-xcomposite-egl, wayland-xcomposite-glx, webgl, xcb.\n\n/bin/bash: line 15:   179 Aborted                 (core dumped) python3 - <<'PY'\nimport pyqtgraph as pg\nimport numpy as np\nfrom PyQt5 import QtWidgets\n\napp = QtWidgets.QApplication([])\n\ntry:\n    data_array = np.recarray((10,), dtype=[('x', float), ('y', float)])\n    pg.plot(data_array)\n    print(\"Plot succeeded\")\nexcept Exception as e:\n    import traceback\n    traceback.print_exc()\nPY\n\n",
    "exit_code": 134
  }
}

The environment doesn't have a display. I should use `offscreen` platform plugin for Qt.

{
  "command": "export QT_QPA_PLATFORM=offscreen\npython3 - <<'PY'\nimport pyqtgraph as pg\nimport numpy as np\nfrom PyQt5 import QtWidgets\n\napp = QtWidgets.QApplication([])\n\ntry:\n    data_array = np.recarray((10,), dtype=[('x', float), ('y', float)])\n    pg.plot(data_array)\n    print(\"Plot succeeded\")\nexcept Exception as e:\n    import traceback\n    traceback.print_exc()\nPY\n"
}

{
  "status": "ok",
  "stdout": "",
  "stderr": "QStandardPaths: XDG_RUNTIME_DIR not set, defaulting to '/tmp/runtime-root'\nTraceback (most recent call last):\n  File \"<stdin>\", line 9, in <module>\n  File \"/workspace/pyqtgraph/__init__.py\", line 334, in plot\n    w.plot(*args, **dataArgs)\n  File \"/workspace/pyqtgraph/graphicsItems/PlotItem/PlotItem.py\", line 640, in plot\n    item = PlotDataItem(*args, **kargs)\n  File \"/workspace/pyqtgraph/graphicsItems/PlotDataItem.py\", line 622, in __init__\n    self.setData(*args, **kwargs)\n  File \"/workspace/pyqtgraph/graphicsItems/PlotDataItem.py\", line 1164, in setData\n    if 'x' in data:\nTypeError: Cannot compare structured or void to non-void arrays.\n",
  "exit_code": 0
}

Reproduced! The error is indeed `TypeError: Cannot compare structured or void to non-void arrays.` at `if 'x' in data:` in `pyqtgraph/graphicsItems/PlotDataItem.py`.

Now let's examine `pyqtgraph/graphicsItems/PlotDataItem.py` around line 1164.

{
  "end_line": 1200,
  "filepath": "pyqtgraph/graphicsItems/PlotDataItem.py",
  "start_line": 1140
}

{
  "status": "ok",
  "filepath": "pyqtgraph/graphicsItems/PlotDataItem.py",
  "content": "            Raised when an invalid type was passed in for `x` or `y` data.\n\n        See Also\n        --------\n        :class:`PlotDataItem`\n            The arguments accepted by :meth:`setData` are the same used during \n            initialization, and are listed in the opening section.\n        :func:`~pyqtgraph.arrayToQPath`\n            Explains the constructions of the draw paths.\n        \"\"\"\n        profiler = debug.Profiler()\n        y = None\n        x = None\n        if len(args) == 1:\n            data = args[0]\n            dt = dataType(data)\n            if dt == 'empty':\n                pass\n            elif dt == 'listOfValues':\n                y = np.array(data)\n            elif dt == 'Nx2array':\n                x = data[:, 0]\n                y = data[:, 1]\n            elif dt == 'recarray' or dt == 'dictOfLists':\n                if 'x' in data:\n                    x = np.array(data['x'])\n                if 'y' in data:\n                    y = np.array(data['y'])\n            elif dt == 'listOfDicts':\n                if 'x' in data[0]:\n                    x = np.array([d.get('x',None) for d in data])\n                if 'y' in data[0]:\n                    y = np.array([d.get('y',None) for d in data])\n                for k in [\n                    'data', 'symbolSize', 'symbolPen', 'symbolBrush', 'symbolShape'\n                ]:\n                    if k in data[0]:\n                        kwargs[k] = [d.get(k) for d in data]\n            else:\n                raise TypeError('Invalid data type %s' % type(data))\n\n        elif len(args) == 2:\n            seq = ('listOfValues', 'empty')\n            dtyp = dataType(args[0]), dataType(args[1])\n            if dtyp[0] not in seq or dtyp[1] not in seq:\n                raise TypeError(\n                    (\n                        'When passing two unnamed arguments, both must be a list or '\n                        'array of values. (got %s, %s)'\n                        % (str(type(args[0])), str(type(args[1])))\n                    )\n                )\n            if not isinstance(args[0], np.ndarray):\n                x = np.array(args[0])\n            else:\n                x = args[0].view(np.ndarray)\n            if not isinstance(args[1], np.ndarray):\n                y = np.array(args[1])\n            else:\n                y = args[1].view(np.ndarray)\n",
  "start_line": 1140,
  "end_line": 1200,
  "total_lines": 1839,
  "is_truncated": false
}

The problem is in these lines:
```python
            elif dt == 'recarray' or dt == 'dictOfLists':
                if 'x' in data:
                    x = np.array(data['x'])
                if 'y' in data:
                    y = np.array(data['y'])
```

If `dt == 'recarray'`, `data` is a NumPy record array (structured array). In NumPy, `if 'x' in data` checks if `'x'` is an *element* of the array, not if `'x'` is a *field name*. Since `data` is a structured array of floats (or other types), comparing a string `'x'` to the structure elements fails with `TypeError: Cannot compare structured or void to non-void arrays`.

To check if a field name exists in a NumPy structured array, we should use `data.dtype.names`.

Wait, `dt` is determined by `dt = dataType(data)`. Let's see how `dataType` is implemented. It's likely a helper function in the same file or imported.

{
  "command": "grep -n \"def dataType\" pyqtgraph/graphicsItems/PlotDataItem.py"
}

{
  "status": "ok",
  "stdout": "1799:def dataType(obj) -> str:\n",
  "stderr": "",
  "exit_code": 0
}

Let's read `dataType` implementation.

{
  "filepath": "pyqtgraph/graphicsItems/PlotDataItem.py",
  "start_line": 1799
}

{
  "status": "ok",
  "filepath": "pyqtgraph/graphicsItems/PlotDataItem.py",
  "content": "def dataType(obj) -> str:\n    type_: str\n    if hasattr(obj, '__len__') and len(obj) == 0:\n        type_ = 'empty'\n    elif isinstance(obj, dict):\n        type_ = 'dictOfLists'\n    elif np.iterable(obj):\n        first = obj[0]\n        if isinstance(obj, np.ndarray):\n            if obj.ndim == 1:\n                type_ = 'listOfValues' if obj.dtype.names is None else 'recarray'\n            elif obj.ndim == 2 and obj.dtype.names is None and obj.shape[1] == 2:\n                type_ = 'Nx2array'\n            else:\n                raise ValueError(\n                    f'array shape must be (N,) or (N,2); got {str(obj.shape)} instead'\n                )\n        elif isinstance(first, dict):\n            type_ = 'listOfDicts'\n        else:\n            type_ = 'listOfValues'\n    else:\n        raise ValueError(\"Cannot identify data-structure.\")\n    return type_\n\n\ndef isSequence(obj):\n    warnings.warn(\n        (\n            \"isSequence is deprecated and will be removed in a future version of\"\n            \"pyqtgraph, use np.iterable(obj) instead.\"\n        ), DeprecationWarning, stacklevel=2\n    )\n    return (\n        hasattr(obj, '__iter__') or\n        isinstance(obj, np.ndarray) or\n        (\n            hasattr(obj, 'implements') and\n            obj.implements('MetaArray')\n        )\n    )",
  "start_line": 1799,
  "end_line": 1839,
  "total_lines": 1839,
  "is_truncated": false
}

The `dataType` function correctly identifies `recarray` if `obj.dtype.names` is not None.

```python
            if obj.ndim == 1:
                type_ = 'listOfValues' if obj.dtype.names is None else 'recarray'
```

Now back to `setData`:
```python
            elif dt == 'recarray' or dt == 'dictOfLists':
                if 'x' in data:
                    x = np.array(data['x'])
                if 'y' in data:
                    y = np.array(data['y'])
```

If `dt == 'recarray'`, `data` is a NumPy structured array. To check if `'x'` is one of its fields, I should check `data.dtype.names`.

Example:
```python
import numpy as np
data = np.recarray((10,), dtype=[('x', float), ('y', float)])
print(data.dtype.names) # ('x', 'y')
'x' in data.dtype.names # True
```

If `dt == 'dictOfLists'`, `data` is a dictionary, and `'x' in data` works as expected.

So I should change:
```python
            elif dt == 'recarray' or dt == 'dictOfLists':
                if 'x' in data:
                    x = np.array(data['x'])
                if 'y' in data:
                    y = np.array(data['y'])
```
to something that handles both.

Possibility 1:
```python
            elif dt == 'recarray' or dt == 'dictOfLists':
                # data is either a recarray (numpy structured array) or a dictionary
                if dt == 'recarray':
                    names = data.dtype.names
                else:
                    names = data
                if 'x' in names:
                    x = np.array(data['x'])
                if 'y' in names:
                    y = np.array(data['y'])
```

Wait, if `dt == 'recarray'`, `data['x']` returns a view of the 'x' field.

Let's check if `data` is always a numpy array when `dt == 'recarray'`. Yes, according to `dataType`:
```python
        if isinstance(obj, np.ndarray):
            if obj.ndim == 1:
                type_ = 'listOfValues' if obj.dtype.names is None else 'recarray'
```

Wait, `np.recarray` is a subclass of `np.ndarray`.

If `data` is a dictionary, `'x' in data` is the right way.
If `data` is a structured array, `'x' in data.dtype.names` is the right way.

Wait, can I use a more uniform way?
If `dt == 'recarray'`, `data` is a NumPy structured array.
If `dt == 'dictOfLists'`, `data` is a dictionary.

Both support `data['x']` if the key/field exists. The only issue is the membership check `'x' in data`.

If I use:
```python
            elif dt == 'recarray' or dt == 'dictOfLists':
                try:
                    x = np.array(data['x'])
                except (KeyError, TypeError, IndexError):
                    x = None
                try:
                    y = np.array(data['y'])
                except (KeyError, TypeError, IndexError):
                    y = None
```
But the original code also checked if they were there.

Actually, for NumPy structured arrays, `data.dtype.names` is a tuple of field names.

Let's see:
```python
 import numpy as np
 data = np.recarray((10,), dtype=[('x', float), ('y', float)])
 # 'x' in data  # This raises TypeError
 # 'x' in data.dtype.names # This works
```

What if `data` is a dict?
```python
 data = {'x': [1, 2], 'y': [3, 4]}
 # 'x' in data # This works
 # data.dtype.names # This raises AttributeError
```

So I can do:
```python
            elif dt == 'recarray' or dt == 'dictOfLists':
                names = data.dtype.names if dt == 'recarray' else data
                if 'x' in names:
                    x = np.array(data['x'])
                if 'y' in names:
                    y = np.array(data['y'])
```

Wait, let's check if there are any other places where `dt == 'recarray'` or similar checks are done.
I'll search for `dataType` calls.

{
  "command": "grep -rn \"dataType(\" pyqtgraph/graphicsItems/PlotDataItem.py"
}

{
  "status": "ok",
  "stdout": "1155:            dt = dataType(data)\n1183:            dtyp = dataType(args[0]), dataType(args[1])\n1799:def dataType(obj) -> str:\n",
  "stderr": "",
  "exit_code": 0
}

Only in `setData`.

Wait, I noticed in the original code:
```python
            elif dt == 'recarray' or dt == 'dictOfLists':
                if 'x' in data:
                    x = np.array(data['x'])
                if 'y' in data:
                    y = np.array(data['y'])
```
The `dt == 'recarray'` case was clearly intended to be handled here.

Let's verify my proposed fix with a test script.

{
  "command": "export QT_QPA_PLATFORM=offscreen\npython3 - <<'PY'\nimport pyqtgraph as pg\nimport numpy as np\nfrom PyQt5 import QtWidgets\n\napp = QtWidgets.QApplication([])\n\ntry:\n    print(\"Testing recarray...\")\n    data_array = np.recarray((10,), dtype=[('x', float), ('y', float)])\n    pg.plot(data_array)\n    print(\"Recarray plot succeeded\")\n    \n    print(\"Testing dictOfLists...\")\n    data_dict = {'x': np.arange(10), 'y': np.arange(10)}\n    pg.plot(data_dict)\n    print(\"DictOfLists plot succeeded\")\nexcept Exception as e:\n    import traceback\n    traceback.print_exc()\nPY\n"
}

{
  "status": "ok",
  "stdout": "Testing recarray...\n",
  "stderr": "QStandardPaths: XDG_RUNTIME_DIR not set, defaulting to '/tmp/runtime-root'\nTraceback (most recent call last):\n  File \"<stdin>\", line 10, in <module>\n  File \"/workspace/pyqtgraph/__init__.py\", line 334, in plot\n    w.plot(*args, **dataArgs)\n  File \"/workspace/pyqtgraph/graphicsItems/PlotItem/PlotItem.py\", line 640, in plot\n    item = PlotDataItem(*args, **kargs)\n  File \"/workspace/pyqtgraph/graphicsItems/PlotDataItem.py\", line 622, in __init__\n    self.setData(*args, **kwargs)\n  File \"/workspace/pyqtgraph/graphicsItems/PlotDataItem.py\", line 1164, in setData\n    if 'x' in data:\nTypeError: Cannot compare structured or void to non-void arrays.\n",
  "exit_code": 0
}

Now I will apply the fix.

Actually, to be as clean as possible:
```python
            elif dt == 'recarray' or dt == 'dictOfLists':
                names = data.dtype.names if dt == 'recarray' else data
                if 'x' in names:
                    x = np.array(data['x'])
                if 'y' in names:
                    y = np.array(data['y'])
```

Let's check the lines again.
```python
1158:            elif dt == 'recarray' or dt == 'dictOfLists':
1159:                if 'x' in data:
1160:                    x = np.array(data['x'])
1161:                if 'y' in data:
1162:                    y = np.array(data['y'])
```
Wait, I previously saw the lines were different. Let me read again.

{
  "end_line": 1170,
  "filepath": "pyqtgraph/graphicsItems/PlotDataItem.py",
  "start_line": 1150
}

{
  "status": "ok",
  "filepath": "pyqtgraph/graphicsItems/PlotDataItem.py",
  "content": "        profiler = debug.Profiler()\n        y = None\n        x = None\n        if len(args) == 1:\n            data = args[0]\n            dt = dataType(data)\n            if dt == 'empty':\n                pass\n            elif dt == 'listOfValues':\n                y = np.array(data)\n            elif dt == 'Nx2array':\n                x = data[:, 0]\n                y = data[:, 1]\n            elif dt == 'recarray' or dt == 'dictOfLists':\n                if 'x' in data:\n                    x = np.array(data['x'])\n                if 'y' in data:\n                    y = np.array(data['y'])\n            elif dt == 'listOfDicts':\n                if 'x' in data[0]:\n                    x = np.array([d.get('x',None) for d in data])",
  "start_line": 1150,
  "end_line": 1170,
  "total_lines": 1839,
  "is_truncated": false
}

The lines are:
```python
            elif dt == 'recarray' or dt == 'dictOfLists':
                if 'x' in data:
                    x = np.array(data['x'])
                if 'y' in data:
                    y = np.array(data['y'])
```

Wait, I want to make sure I'm taking the most efficient approach.
If I use:
```python
            elif dt == 'recarray' or dt == 'dictOfLists':
                # Check if data is a recarray (using dt) to use .dtype.names
                # Otherwise treat as dictionary
                names = data.dtype.names if dt == 'recarray' else data
                if 'x' in names:
                    x = np.array(data['x'])
                if 'y' in names:
                    y = np.array(data['y'])
```

Let's double check if `dt == 'recarray'` always means `data` has `.dtype.names`.
Yes, from `dataType`:
```python
        if isinstance(obj, np.ndarray):
            if obj.ndim == 1:
                type_ = 'listOfValues' if obj.dtype.names is None else 'recarray'
```

One more thing: if `dt == 'recarray'`, `data['x']` is already a numpy array (a view). Calling `np.array(data['x'])` will create a copy. That's probably fine and consistent with `dictOfLists` where `data['x']` might be a list.

Let's apply the fix.

{
  "filepath": "pyqtgraph/graphicsItems/PlotDataItem.py",
  "new_string": "            elif dt == 'recarray' or dt == 'dictOfLists':\n                names = data.dtype.names if dt == 'recarray' else data\n                if 'x' in names:\n                    x = np.array(data['x'])\n                if 'y' in names:\n                    y = np.array(data['y'])",
  "old_string": "            elif dt == 'recarray' or dt == 'dictOfLists':\n                if 'x' in data:\n                    x = np.array(data['x'])\n                if 'y' in data:\n                    y = np.array(data['y'])"
}

{
  "status": "ok",
  "filepath": "pyqtgraph/graphicsItems/PlotDataItem.py",
  "occurrences": 1,
  "strategy": "exact",
  "diff": "--- a/pyqtgraph/graphicsItems/PlotDataItem.py\n+++ b/pyqtgraph/graphicsItems/PlotDataItem.py\n@@ -1161,9 +1161,10 @@\n                 x = data[:, 0]\n                 y = data[:, 1]\n             elif dt == 'recarray' or dt == 'dictOfLists':\n-                if 'x' in data:\n+                names = data.dtype.names if dt == 'recarray' else data\n+                if 'x' in names:\n                     x = np.array(data['x'])\n-                if 'y' in data:\n+                if 'y' in names:\n                     y = np.array(data['y'])\n             elif dt == 'listOfDicts':\n                 if 'x' in data[0]:\n",
  "is_truncated": false
}

Now let's verify the fix with the reproduction script.

{
  "command": "export QT_QPA_PLATFORM=offscreen\npython3 - <<'PY'\nimport pyqtgraph as pg\nimport numpy as np\nfrom PyQt5 import QtWidgets\n\napp = QtWidgets.QApplication([])\n\ntry:\n    print(\"Testing recarray...\")\n    data_array = np.recarray((10,), dtype=[('x', float), ('y', float)])\n    pg.plot(data_array)\n    print(\"Recarray plot succeeded\")\n    \n    print(\"Testing dictOfLists...\")\n    data_dict = {'x': np.arange(10), 'y': np.arange(10)}\n    pg.plot(data_dict)\n    print(\"DictOfLists plot succeeded\")\n    \n    print(\"Testing recarray without x...\")\n    # recarray with only 'y' (though not common for this API, but let's check)\n    data_array_no_x = np.recarray((10,), dtype=[('y', float)])\n    pg.plot(data_array_no_x)\n    print(\"Recarray without x plot succeeded\")\n\nexcept Exception as e:\n    import traceback\n    traceback.print_exc()\nPY\n"
}

{
  "status": "ok",
  "stdout": "Testing recarray...\nRecarray plot succeeded\nTesting dictOfLists...\nDictOfLists plot succeeded\nTesting recarray without x...\nRecarray without x plot succeeded\n",
  "stderr": "QStandardPaths: XDG_RUNTIME_DIR not set, defaulting to '/tmp/runtime-root'\n",
  "exit_code": 0
}

The tests pass now.

Let's see if there are any other sibling implementations or similar patterns.
`PlotDataItem.py` seems to be the main place handling data initialization for plots.
The `setData` method is the core.

Wait, did I miss any other `dt == 'recarray'`?
I already checked `grep -rn "dataType(" pyqtgraph/graphicsItems/PlotDataItem.py`.

Let's check if `PlotDataItem` is used in other classes or if there are other classes with `setData` that might have this issue.
`PlotDataItem` is often used for line plots.

I'll search for `dtype.names` in the repository to see if other parts of the code handle structured arrays.

{
  "command": "grep -rn \"dtype.names\" ."
}

{
  "status": "ok",
  "stdout": "./pyqtgraph/flowchart/library/functions.py:220:                name = element.dtype.names[i]\n./pyqtgraph/flowchart/library/functions.py:243:                name = element.dtype.names[i]\n./pyqtgraph/flowchart/library/Display.py:256:            keys = data.dtype.names\n./pyqtgraph/graphicsItems/PlotDataItem.py:1164:                names = data.dtype.names if dt == 'recarray' else data\n./pyqtgraph/graphicsItems/PlotDataItem.py:1810:                type_ = 'listOfValues' if obj.dtype.names is None else 'recarray'\n./pyqtgraph/graphicsItems/PlotDataItem.py:1811:            elif obj.ndim == 2 and obj.dtype.names is None and obj.shape[1] == 2:\n./pyqtgraph/widgets/TableWidget.py:207:            return self.iterate, list(map(str, data.dtype.names))\n./tests/widgets/test_tablewidget.py:16:dictOfLists = OrderedDict([(name, list(recordArray[name])) for name in recordArray.dtype.names])\n./tests/widgets/test_tablewidget.py:17:listOfDicts = [OrderedDict([(name, rec[name]) for name in recordArray.dtype.names]) for rec in recordArray]\n",
  "stderr": "",
  "exit_code": 0
}

It seems `PlotDataItem` was one of the few places where this was handled (incorrectly before).

Wait, look at `pyqtgraph/flowchart/library/Display.py:256: keys = data.dtype.names`. It also accesses `dtype.names`.

Let's see if there are any other places where data is checked for membership.
Actually, the issue report is specifically about `pg.plot()`, which leads to `PlotDataItem`.

One more check: the issue report says:
"According to the API reference, a PlotDataItem can be initialized with a NumPy recarray with `dtype=[('x', float), ('y', float), ...]`, so the above code should plot the (uninitialized) recarray data."

The current implementation handles `recarray` by checking for `'x'` and `'y'` fields and creating arrays from them.

What if the `recarray` has other field names?
`PlotDataItem` specifically looks for `'x'` and `'y'`.

If `dt == 'recarray'`, `names = data.dtype.names`.
Then `if 'x' in names: x = np.array(data['x'])`.

This is exactly how it's done for `dictOfLists`.

I should check if there are any other data types that are treated similarly to `recarray` in `setData`.
```python
            elif dt == 'recarray' or dt == 'dictOfLists':
```
Only these two.

Is there anything else to consider?
The user said: "plot the (uninitialized) recarray data".
My reproduction showed that calling `pg.plot(data_array)` works now.

Let's double check if I should handle cases where `data` might not be a numpy array but `dt == 'recarray'`.
Looking at `dataType`:
```python
        if isinstance(obj, np.ndarray):
            if obj.ndim == 1:
                type_ = 'listOfValues' if obj.dtype.names is None else 'recarray'
```
So `dt == 'recarray'` implies `obj` is a `np.ndarray` with `obj.dtype.names` not None.

One more thing: the `dataType` function uses `obj[0]` to check for `listOfDicts`.
```python
        elif isinstance(first, dict):
            type_ = 'listOfDicts'
```
If `obj` is empty, it returns `'empty'`.
```python
    if hasattr(obj, '__len__') and len(obj) == 0:
        type_ = 'empty'
```

So if `data` is an empty recarray, `dt` will be `'empty'`.
```python
            if dt == 'empty':
                pass
```
This is correct.

What if `data` is a recarray with 0 elements but has the dtype?
`len(obj)` will be 0, so `dt` will be `'empty'`.
If `len(obj) > 0`, then `dt` will be `'recarray'`.

Wait, if `data` is a recarray with 0 elements, it won't plot anything, which is fine.

One final check of the diff.
```diff
--- a/pyqtgraph/graphicsItems/PlotDataItem.py
+++ b/pyqtgraph/graphicsItems/PlotDataItem.py
@@ -1161,9 +1161,10 @@
                 x = data[:, 0]
                 y = data[:, 1]
             elif dt == 'recarray' or dt == 'dictOfLists':
-                if 'x' in data:
+                names = data.dtype.names if dt == 'recarray' else data
+                if 'x' in names:
                     x = np.array(data['x'])
-                if 'y' in data:
+                if 'y' in names:
                     y = np.array(data['y'])
             elif dt == 'listOfDicts':
                 if 'x' in data[0]:
```

Wait, I should verify if this is the best way to write it.
If `dt == 'recarray'`, `data` is a numpy structured array. `data.dtype.names` is a tuple.
If `dt == 'dictOfLists'`, `data` is a dict.

`'x' in names` works for both.
`data['x']` works for both.

Looks good.

Let's check if there's any other place in `setData` where `data` is used similarly.

```python
            elif dt == 'listOfDicts':
                if 'x' in data[0]:
                    x = np.array([d.get('x',None) for d in data])
                if 'y' in data[0]:
                    y = np.array([d.get('y',None) for d in data])
```
This is for a list of dictionaries. it checks the first element.

I think the fix is complete and correct.

Final verification of the environment:
- No untracked files.
- No changes to `tests/`.

I'll run `git status --short && git diff` to be sure.

{
  "command": "git status --short && git diff"
}

{
  "status": "ok",
  "stdout": " M pyqtgraph/graphicsItems/PlotDataItem.py\ndiff --git a/pyqtgraph/graphicsItems/PlotDataItem.py b/pyqtgraph/graphicsItems/PlotDataItem.py\nindex 9d7c7f8..79be936 100644\n--- a/pyqtgraph/graphicsItems/PlotDataItem.py\n+++ b/pyqtgraph/graphicsItems/PlotDataItem.py\n@@ -1161,9 +1161,10 @@ class PlotDataItem(GraphicsObject):\n                 x = data[:, 0]\n                 y = data[:, 1]\n             elif dt == 'recarray' or dt == 'dictOfLists':\n-                if 'x' in data:\n+                names = data.dtype.names if dt == 'recarray' else data\n+                if 'x' in names:\n                     x = np.array(data['x'])\n-                if 'y' in data:\n+                if 'y' in names:\n                     y = np.array(data['y'])\n             elif dt == 'listOfDicts':\n                 if 'x' in data[0]:\n",
  "stderr": "",
  "exit_code": 0
}

Wait, I should check if there are any other `elif dt == 'recarray'` in the entire file.
I already did that with `grep -rn "dataType(" pyqtgraph/graphicsItems/PlotDataItem.py` and the results were:
```
1155:            dt = dataType(data)
1183:            dtyp = dataType(args[0]), dataType(args[1])
1799:def dataType(obj) -> str:
```
Wait, line 1183 is also calling `dataType`. Let's see what it does.

{
  "end_line": 1220,
  "filepath": "pyqtgraph/graphicsItems/PlotDataItem.py",
  "start_line": 1180
}

{
  "status": "ok",
  "filepath": "pyqtgraph/graphicsItems/PlotDataItem.py",
  "content": "                raise TypeError('Invalid data type %s' % type(data))\n\n        elif len(args) == 2:\n            seq = ('listOfValues', 'empty')\n            dtyp = dataType(args[0]), dataType(args[1])\n            if dtyp[0] not in seq or dtyp[1] not in seq:\n                raise TypeError(\n                    (\n                        'When passing two unnamed arguments, both must be a list or '\n                        'array of values. (got %s, %s)'\n                        % (str(type(args[0])), str(type(args[1])))\n                    )\n                )\n            if not isinstance(args[0], np.ndarray):\n                x = np.array(args[0])\n            else:\n                x = args[0].view(np.ndarray)\n            if not isinstance(args[1], np.ndarray):\n                y = np.array(args[1])\n            else:\n                y = args[1].view(np.ndarray)\n\n        if 'x' in kwargs:\n            x = kwargs['x']\n        if 'y' in kwargs:\n            y = kwargs['y']\n\n        profiler('interpret data')\n        # pull in all style arguments.\n        # Use self.opts to fill in anything not present in kwargs.\n\n        if 'name' in kwargs:\n            self.opts['name'] = kwargs['name']\n            self.setProperty('styleWasChanged', True)\n\n        if 'connect' in kwargs:\n            self.opts['connect'] = kwargs['connect']\n            self.setProperty('styleWasChanged', True)\n            \n        if 'skipFiniteCheck' in kwargs:\n            self.opts['skipFiniteCheck'] = kwargs['skipFiniteCheck']",
  "start_line": 1180,
  "end_line": 1220,
  "total_lines": 1840,
  "is_truncated": false
}

In the `len(args) == 2` case, it explicitly rejects `recarray` because `seq = ('listOfValues', 'empty')` and it checks `dtyp[0] not in seq`. Since `recarray` is not in `seq`, it raises a `TypeError`. This seems intended.

So the only problematic line was the one I fixed.

Everything looks good.

{
  "status": "ok",
  "patch_size": 770,
  "files_changed": 1
}

The issue was a `TypeError` when passing a NumPy record array (`np.recarray`) to `pg.plot()`, caused by using the `in` operator on the record array in `PlotDataItem.setData`. I fixed it by checking `data.dtype.names` for record arrays to properly verify field existence.

The `TypeError: Cannot compare structured or void to non-void arrays` occurred in `pyqtgraph/graphicsItems/PlotDataItem.py` because the `setData` method attempted to check for the existence of 'x' and 'y' fields using the `in` operator directly on a NumPy record array. I modified the logic to check `data.dtype.names` when the data type is identified as a `'recarray'`, ensuring compatibility with NumPy's structured array API while maintaining support for dictionaries.