researchobject__ro-crate-py-102

The user is reporting a `TypeError: 'NoneType' object is not subscriptable` when accessing a property of an `Entity` (specifically `crate.mainEntity["name"]`) that has a `null` value in the underlying JSON.

The traceback points to `rocrate/model/entity.py`, line 81, in `__getitem__`.

```python
  File "/home/simleo/git/ro-crate-py/rocrate/model/entity.py", line 81, in __getitem__
    deref_values = [self.crate.dereference(_["@id"], _["@id"]) for _ in values]
  File "/home/simleo/git/ro-crate-py/rocrate/model/entity.py", line 81, in <listcomp>
    deref_values = [self.crate.dereference(_["@id"], _["@id"]) for _ in values]
TypeError: 'NoneType' object is not subscriptable
```

It seems `values` contains `None`, and the list comprehension tries to access `_["@id"]` on it.

Let's start by examining `rocrate/model/entity.py` around line 81.

{
  "end_line": 100,
  "filepath": "rocrate/model/entity.py",
  "start_line": 60
}

{
  "status": "ok",
  "filepath": "rocrate/model/entity.py",
  "content": "            return clsName\n        return \"Thing\"\n\n    def canonical_id(self):\n        return self.crate.resolve_id(self.id)\n\n    def __hash__(self):\n        return hash(self.canonical_id())\n\n    def _empty(self):\n        val = {\n            \"@id\": self.id,\n            \"@type\": self._default_type\n        }\n        return val\n\n    def __getitem__(self, key):\n        v = self._jsonld[key]\n        if isinstance(v, str) or key.startswith(\"@\"):\n            return v\n        values = v if isinstance(v, list) else [v]\n        deref_values = [self.crate.dereference(_[\"@id\"], _[\"@id\"]) for _ in values]\n        return deref_values if isinstance(v, list) else deref_values[0]\n\n    def __setitem__(self, key: str, value):\n        if key.startswith(\"@\"):\n            raise KeyError(f\"cannot set '{key}'\")\n        values = value if isinstance(value, list) else [value]\n        ref_values = [{\"@id\": _.id} if isinstance(_, Entity) else _ for _ in values]\n        self._jsonld[key] = ref_values if isinstance(value, list) else ref_values[0]\n\n    def __delitem__(self, key: str):\n        if key.startswith(\"@\"):\n            raise KeyError(f\"cannot delete '{key}'\")\n        del self._jsonld[key]\n\n    def popitem(self):\n        raise NotImplementedError\n\n    def clear(self):\n        raise NotImplementedError",
  "start_line": 60,
  "end_line": 100,
  "total_lines": 141,
  "is_truncated": false
}

The `__getitem__` method is:

```python
    def __getitem__(self, key):
        v = self._jsonld[key]
        if isinstance(v, str) or key.startswith(\"@\"):\n            return v
        values = v if isinstance(v, list) else [v]
        deref_values = [self.crate.dereference(_["@id"], _["@id"]) for _ in values]
        return deref_values if isinstance(v, list) else deref_values[0]
```

In the example provided:
```javascript
    {
      "@id": "sort-and-change-case.ga",
      "@type": [
        "File",
        "SoftwareSourceCode",
        "ComputationalWorkflow"
      ],
      "programmingLanguage": {
        "@id": "#galaxy"
      },
      "name": null
    }
```
When `key` is `"name"`, `v` will be `None` (because JSON `null` is parsed as Python `None`).
`isinstance(v, str)` is `False`. `key.startswith("@")` is `False`.
`values = v if isinstance(v, list) else [v]` results in `values = [None]`.
Then `deref_values = [self.crate.dereference(_["@id"], _["@id"]) for _ in values]` fails because `_` is `None`.

We should check if `_` is a dictionary before trying to access `["@id"]`.

Wait, if `v` is `None`, it should probably just return `None`.

Let's see how other values are handled. If `v` is a string, it's returned immediately.
If `v` is not a string and not starting with `@`, it's treated as something that might need dereferencing.

If `v` is `None`, `values` is `[None]`.
We should probably check if `v` is `None` at the beginning.

```python
    def __getitem__(self, key):
        v = self._jsonld[key]
        if v is None or isinstance(v, str) or key.startswith("@"):
            return v
        values = v if isinstance(v, list) else [v]
        deref_values = [self.crate.dereference(_["@id"], _["@id"]) if isinstance(_, dict) and "@id" in _ else _ for _ in values]
        return deref_values if isinstance(v, list) else deref_values[0]
```

Wait, let's look at how `dereference` is used.
If `v` is a dict like `{"@id": "#galaxy"}`, `_` is `{"@id": "#galaxy"}`, and it calls `self.crate.dereference("#galaxy", "#galaxy")`.

If `v` is not a dict and not a list, it's currently wrapped in a list and then dereferenced.
If `v` was, say, an integer (though unlikely in this context), `_` would be an integer, and `_["@id"]` would fail.

Actually, the current implementation assumes that if it's not a string and not an `@` key, it MUST be a list or a dict (or something that supports `["@id"]`).

If `v` is `None`, it's not a string, it's not a list, so it goes into `values = [None]`.

Let's reproduce this.

{
  "command": "python3 - <<'PY'\nfrom rocrate.rocrate import ROcrate\nfrom rocrate.model.entity import Entity\n\nclass MockCrate:\n    def dereference(self, id1, id2):\n        return f\"deref({id1})\"\n\nclass MockEntity(Entity):\n    def __init__(self, jsonld):\n        self.crate = MockCrate()\n        self._jsonld = jsonld\n\n# Use the example from the issue\njsonld = {\n    \"@id\": \"sort-and-change-case.ga\",\n    \"@type\": [\"File\", \"SoftwareSourceCode\", \"ComputationalWorkflow\"],\n    \"programmingLanguage\": {\"@id\": \"#galaxy\"},\n    \"name\": None\n}\n\nentity = MockEntity(jsonld)\ntry:\n    print(f\"name: {entity['name']}\")\nexcept Exception as e:\n    print(f\"Error getting name: {e}\")\n\ntry:\n    print(f\"progLang: {entity['programmingLanguage']}\")\nexcept Exception as e:\n    print(f\"Error getting progLang: {e}\")\nPY\n"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "/workspace/rocrate/vocabs.py:21: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n  import pkg_resources\nTraceback (most recent call last):\n  File \"<stdin>\", line 1, in <module>\nImportError: cannot import name 'ROcrate' from 'rocrate.rocrate' (/workspace/rocrate/rocrate.py)\n",
  "details": {
    "stdout": "",
    "stderr": "/workspace/rocrate/vocabs.py:21: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n  import pkg_resources\nTraceback (most recent call last):\n  File \"<stdin>\", line 1, in <module>\nImportError: cannot import name 'ROcrate' from 'rocrate.rocrate' (/workspace/rocrate/rocrate.py)\n",
    "exit_code": 1
  }
}

Ah, `from rocrate.rocrate import ROcrate` failed. Let me check `rocrate/rocrate.py`.

{
  "filepath": "rocrate/rocrate.py"
}

{
  "status": "ok",
  "filepath": "rocrate/rocrate.py",
  "content": "#!/usr/bin/env python\n\n# Copyright 2019-2021 The University of Manchester, UK\n# Copyright 2020-2021 Vlaams Instituut voor Biotechnologie (VIB), BE\n# Copyright 2020-2021 Barcelona Supercomputing Center (BSC), ES\n# Copyright 2020-2021 Center for Advanced Studies, Research and Development in Sardinia (CRS4), IT\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n#     http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport errno\nimport json\nimport os\nimport uuid\nimport zipfile\nimport atexit\nimport shutil\nimport tempfile\n\nfrom collections import OrderedDict\nfrom pathlib import Path\nfrom urllib.parse import urljoin\n\nfrom .model.contextentity import ContextEntity\nfrom .model.entity import Entity\nfrom .model.root_dataset import RootDataset\nfrom .model.data_entity import DataEntity\nfrom .model.file_or_dir import FileOrDir\nfrom .model.file import File\nfrom .model.dataset import Dataset\nfrom .model.metadata import Metadata, LegacyMetadata, TESTING_EXTRA_TERMS, metadata_class\nfrom .model.preview import Preview\nfrom .model.testdefinition import TestDefinition\nfrom .model.computationalworkflow import ComputationalWorkflow, galaxy_to_abstract_cwl\nfrom .model.computerlanguage import ComputerLanguage, get_lang\nfrom .model.testinstance import TestInstance\nfrom .model.testservice import TestService, get_service\nfrom .model.softwareapplication import SoftwareApplication, get_app, PLANEMO_DEFAULT_VERSION\nfrom .model.testsuite import TestSuite\n\nfrom .utils import is_url, subclasses, get_norm_value\n\n\ndef read_metadata(metadata_path):\n    \"\"\"\\\n    Read an RO-Crate metadata file.\n\n    Return a tuple of two elements: the context; a dictionary that maps entity\n    ids to the entities themselves.\n    \"\"\"\n    with open(metadata_path) as f:\n        metadata = json.load(f)\n    try:\n        context = metadata['@context']\n        graph = metadata['@graph']\n    except KeyError:\n        raise ValueError(f\"{metadata_path} must have a @context and a @graph\")\n    return context, {_[\"@id\"]: _ for _ in graph}\n\n\ndef pick_type(json_entity, type_map, fallback=None):\n    try:\n        t = json_entity[\"@type\"]\n    except KeyError:\n        raise ValueError(f'entity {json_entity[\"@id\"]!r} has no @type')\n    types = {_.strip() for _ in set(t if isinstance(t, list) else [t])}\n    for name, c in type_map.items():\n        if name in types:\n            return c\n    return fallback\n\n\nclass ROCrate():\n\n    def __init__(self, source=None, gen_preview=False, init=False):\n        self.__entity_map = {}\n        self.default_entities = []\n        self.data_entities = []\n        self.contextual_entities = []\n        # TODO: add this as @base in the context? At least when loading\n        # from zip\n        self.uuid = uuid.uuid4()\n        self.arcp_base_uri = f\"arcp://uuid,{self.uuid}/\"\n        self.preview = None\n        if gen_preview:\n            self.add(Preview(self))\n        if not source:\n            # create a new ro-crate\n            self.add(RootDataset(self), Metadata(self))\n        elif init:\n            self.__init_from_tree(source, gen_preview=gen_preview)\n        else:\n            source = self.__read(source, gen_preview=gen_preview)\n        # in the zip case, self.source is the extracted dir\n        self.source = source\n\n    def __init_from_tree(self, top_dir, gen_preview=False):\n        top_dir = Path(top_dir)\n        if not top_dir.is_dir():\n            raise NotADirectoryError(errno.ENOTDIR, f\"'{top_dir}': not a directory\")\n        self.add(RootDataset(self), Metadata(self))\n        for root, dirs, files in os.walk(top_dir):\n            root = Path(root)\n            for name in dirs:\n                source = root / name\n                self.add_dataset(source, source.relative_to(top_dir))\n            for name in files:\n                source = root / name\n                if source == top_dir / Metadata.BASENAME or source == top_dir / LegacyMetadata.BASENAME:\n                    continue\n                if source != top_dir / Preview.BASENAME:\n                    self.add_file(source, source.relative_to(top_dir))\n                elif not gen_preview:\n                    self.add(Preview(self, source))\n\n    def __read(self, source, gen_preview=False):\n        source = Path(source)\n        if not source.exists():\n            raise FileNotFoundError(errno.ENOENT, f\"'{source}' not found\")\n        if zipfile.is_zipfile(source):\n            zip_path = tempfile.mkdtemp(prefix=\"rocrate_\")\n            atexit.register(shutil.rmtree, zip_path)\n            with zipfile.ZipFile(source, \"r\") as zf:\n                zf.extractall(zip_path)\n            source = Path(zip_path)\n        metadata_path = source / Metadata.BASENAME\n        if not metadata_path.is_file():\n            metadata_path = source / LegacyMetadata.BASENAME\n        if not metadata_path.is_file():\n            raise ValueError(f\"Not a valid RO-Crate: missing {Metadata.BASENAME}\")\n        _, entities = read_metadata(metadata_path)\n        self.__read_data_entities(entities, source, gen_preview)\n        self.__read_contextual_entities(entities)\n        return source\n\n    def find_root_entity_id(self, entities):\n        \"\"\"Find Metadata file and Root Data Entity in RO-Crate.\n\n        Returns a tuple of the @id identifiers (metadata, root)\n        \"\"\"\n        # Note that for all cases below we will deliberately",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 585,
  "is_truncated": true
}

The class is `ROCrate` (case sensitive), not `ROcrate`. Let me fix my reproduction script.
Also, the import `from rocrate.rocrate import ROCrate` should work.

Actually, I can just use `from rocrate.model.entity import Entity` and my `MockEntity` and `MockCrate` and it should be enough without needing `ROCrate` if I just want to test `__getitem__`.

{
  "command": "python3 - <<'PY'\nfrom rocrate.model.entity import Entity\n\nclass MockCrate:\n    def dereference(self, id1, id2):\n        return f\"deref({id1})\"\n\nclass MockEntity(Entity):\n    def __init__(self, jsonld):\n        self.crate = MockCrate()\n        self._jsonld = jsonld\n\n# Use the example from the issue\njsonld = {\n    \"@id\": \"sort-and-change-case.ga\",\n    \"@type\": [\"File\", \"SoftwareSourceCode\", \"ComputationalWorkflow\"],\n    \"programmingLanguage\": {\"@id\": \"#galaxy\"},\n    \"name\": None\n}\n\nentity = MockEntity(jsonld)\nprint(\"Testing name (which is None):\")\ntry:\n    print(f\"name: {entity['name']}\")\nexcept Exception as e:\n    import traceback\n    traceback.print_exc()\n\nprint(\"\\nTesting programmingLanguage (which is a dict):\")\ntry:\n    print(f\"progLang: {entity['programmingLanguage']}\")\nexcept Exception as e:\n    import traceback\n    traceback.print_exc()\n\nprint(\"\\nTesting @id (which is a string):\")\ntry:\n    print(f\"@id: {entity['@id']}\")\nexcept Exception as e:\n    import traceback\n    traceback.print_exc()\nPY\n"
}

{
  "status": "ok",
  "stdout": "Testing name (which is None):\n\nTesting programmingLanguage (which is a dict):\nprogLang: deref(#galaxy)\n\nTesting @id (which is a string):\n@id: sort-and-change-case.ga\n",
  "stderr": "/workspace/rocrate/vocabs.py:21: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n  import pkg_resources\nTraceback (most recent call last):\n  File \"<stdin>\", line 23, in <module>\n  File \"/workspace/rocrate/model/entity.py\", line 81, in __getitem__\n    deref_values = [self.crate.dereference(_[\"@id\"], _[\"@id\"]) for _ in values]\n  File \"/workspace/rocrate/model/entity.py\", line 81, in <listcomp>\n    deref_values = [self.crate.dereference(_[\"@id\"], _[\"@id\"]) for _ in values]\nTypeError: 'NoneType' object is not subscriptable\n",
  "exit_code": 0
}

Confirmed. The crash happens exactly as reported.

Now let's look at the fix.
The current code:
```python
    def __getitem__(self, key):
        v = self._jsonld[key]
        if isinstance(v, str) or key.startswith("@"):
            return v
        values = v if isinstance(v, list) else [v]
        deref_values = [self.crate.dereference(_["@id"], _["@id"]) for _ in values]
        return deref_values if isinstance(v, list) else deref_values[0]
```

If `v` is `None`, it fails at `_["@id"]`.
If `v` is something else that isn't a string and doesn't have `["@id"]`, it would also fail.

Is it possible for `v` to be something else?
According to JSON-LD and how `ro-crate-py` seems to work, values are usually strings, lists, or dictionaries (which are treated as potential references if they have `@id`).

If `v` is `None`, returning `None` is correct.
If `v` is not a dict (and not a string/list), it should probably be returned as is.

Proposed fix:

```python
    def __getitem__(self, key):
        v = self._jsonld[key]
        if v is None or isinstance(v, str) or key.startswith("@"):
            return v
        values = v if isinstance(v, list) else [v]
        deref_values = [self.crate.dereference(_["@id"], _["@id"]) if isinstance(_, dict) and "@id" in _ else _ for _ in values]
        return deref_values if isinstance(v, list) else deref_values[0]
```

Wait, let's check if `_` being a dict but NOT having `@id` is possible.
If `_` is a dict and doesn't have `@id`, it should probably be returned as a dict.
If `_` is not a dict, it should be returned as is.

What if `v` is a list containing `None`? `[None, {"@id": "..."}]`
The current code would crash on `None`.

My proposed `deref_values` list comprehension handles that:
`[self.crate.dereference(_["@id"], _["@id"]) if isinstance(_, dict) and "@id" in _ else _ for _ in values]`

Let's refine the implementation.

```python
    def __getitem__(self, key):
        v = self._jsonld[key]
        if v is None or isinstance(v, str) or key.startswith("@"):
            return v
        values = v if isinstance(v, list) else [v]
        deref_values = [self.crate.dereference(_["@id"], _["@id"]) if isinstance(_, dict) and "@id" in _ else _ for _ in values]
        return deref_values if isinstance(v, list) else deref_values[0]
```

Let's test this logic with various inputs:
1. `v = None` -> returns `None` (at the first `if v is None`)
2. `v = "some string"` -> returns `"some string"` (at `isinstance(v, str)`)
3. `key = "@type"` -> returns `v` (at `key.startswith("@")`)
4. `v = {"@id": "abc"}` -> `values = [{"@id": "abc"}]` -> `deref_values = [crate.dereference("abc", "abc")]` -> returns `crate.dereference("abc", "abc")`.
5. `v = [{"@id": "abc"}, {"@id": "def"}]` -> `values = [{"@id": "abc"}, {"@id": "def"}]` -> `deref_values = [crate.dereference("abc", "abc"), crate.dereference("def", "def")]` -> returns list.
6. `v = [{"@id": "abc"}, None]` -> `values = [{"@id": "abc"}, None]` -> `deref_values = [crate.dereference("abc", "abc"), None]` -> returns list.
7. `v = [None]` -> `values = [None]` -> `deref_values = [None]` -> returns list `[None]`.
8. `v = 123` -> `values = [123]` -> `deref_values = [123]` -> returns `123`.

This seems robust.

Wait, what if `v` is a list that contains a list?
`v = [[{"@id": "abc"}]]`
`values = [[{"@id": "abc"}]]`
`_` is `[{"@id": "abc"}]`. `isinstance(_, dict)` is `False`.
`deref_values = [[{"@id": "abc"}]]`
Returns `[[{"@id": "abc"}]]`.
Is this desired? Probably, since it's not a simple reference.

Wait, let's look at `__setitem__` as well.
```python
    def __setitem__(self, key: str, value):
        if key.startswith("@"):
            raise KeyError(f"cannot set '{key}'")
        values = value if isinstance(value, list) else [value]
        ref_values = [{"@id": _.id} if isinstance(_, Entity) else _ for _ in values]
        self._jsonld[key] = ref_values if isinstance(value, list) else ref_values[0]
```
`__setitem__` handles `Entity` objects by converting them to references. If `value` is `None`, `values` is `[None]`, `ref_values` is `[None]`, and `self._jsonld[key]` becomes `None`. Correct.

Now, let's apply the fix to `rocrate/model/entity.py`.

One more thing: check if there are other classes that inherit from `Entity` and override `__getitem__`.
`rocrate/model/__init__.py` or other files in `rocrate/model/` might have such classes.

{
  "command": "grep -rn \"def __getitem__\" rocrate/model/"
}

{
  "status": "ok",
  "stdout": "rocrate/model/entity.py:76:    def __getitem__(self, key):\n",
  "stderr": "",
  "exit_code": 0
}

Only `Entity` defines `__getitem__`.

Let's double check the line numbers for `edit_file`.
Line 76 is `def __getitem__(self, key):`.

```python
    def __getitem__(self, key):
        v = self._jsonld[key]
        if isinstance(v, str) or key.startswith("@"):
            return v
        values = v if isinstance(v, list) else [v]
        deref_values = [self.crate.dereference(_["@id"], _["@id"]) for _ in values]
        return deref_values if isinstance(v, list) else deref_values[0]
```

I will replace it with:

```python
    def __getitem__(self, key):
        v = self._jsonld[key]
        if v is None or isinstance(v, str) or key.startswith("@"):
            return v
        values = v if isinstance(v, list) else [v]
        deref_values = [self.crate.dereference(_["@id"], _["@id"]) if isinstance(_, dict) and "@id" in _ else _ for _ in values]
        return deref_values if isinstance(v, list) else deref_values[0]
```

Wait, let's check if `v is None` check is needed at the beginning if I add the check inside the list comprehension.

If `v` is `None`:
`values = [None]`
`deref_values = [None]` (since `isinstance(_, dict)` is `False`)
`return deref_values[0]` which is `None`.

So `v is None` check at the beginning is not strictly necessary for correctness, but it's a nice shortcut.

Let's check if `isinstance(v, str)` is also covered by the list comprehension.
If `v` is `"foo"`:
`isinstance(v, str)` is `True`, it returns `"foo"`. (Consistent)

If I removed `isinstance(v, str)`, and `v` was `"foo"`:
`values = ["foo"]`
`deref_values = ["foo"]` (since `isinstance(_, dict)` is `False`)
`return deref_values[0]` which is `"foo"`.

So actually, the only thing that really needs the special case is `key.startswith("@")` (which returns the value directly regardless of its type) and `v` being a string (which is correctly handled both ways).

However, we should keep it minimal.

Let's just add the check in the list comprehension.

Wait, the current code returns `v` if it's a string. Let's keep that.

```python
    def __getitem__(self, key):
        v = self._jsonld[key]
        if isinstance(v, str) or key.startswith("@"):
            return v
        values = v if isinstance(v, list) else [v]
        deref_values = [self.crate.dereference(_["@id"], _["@id"]) if isinstance(_, dict) and "@id" in _ else _ for _ in values]
        return deref_values if isinstance(v, list) else deref_values[0]
```

Wait, if `v` is `None`, `isinstance(v, str)` is `False`, `key.startswith("@")` is `False`.
`values = [None]`.
`deref_values = [None]`.
Returns `deref_values[0]` which is `None`.

This works. And it's more surgical.

Wait, if `v` is `None`, the current code failed.
My proposed change:
`deref_values = [self.crate.dereference(_["@id"], _["@id"]) if isinstance(_, dict) and "@id" in _ else _ for _ in values]`
This will not crash if `_` is `None`.

Let's verify with the reproduction script again.

{
  "command": "python3 - <<'PY'\nfrom rocrate.model.entity import Entity\n\nclass MockCrate:\n    def dereference(self, id1, id2):\n        return f\"deref({id1})\"\n\nclass MockEntity(Entity):\n    def __init__(self, jsonld):\n        self.crate = MockCrate()\n        self._jsonld = jsonld\n\n    def __getitem__(self, key):\n        v = self._jsonld[key]\n        if isinstance(v, str) or key.startswith(\"@\"):\n            return v\n        values = v if isinstance(v, list) else [v]\n        deref_values = [self.crate.dereference(_[\"@id\"], _[\"@id\"]) if isinstance(_, dict) and \"@id\" in _ else _ for _ in values]\n        return deref_values if isinstance(v, list) else deref_values[0]\n\n# Use the example from the issue\njsonld = {\n    \"@id\": \"sort-and-change-case.ga\",\n    \"@type\": [\"File\", \"SoftwareSourceCode\", \"ComputationalWorkflow\"],\n    \"programmingLanguage\": {\"@id\": \"#galaxy\"},\n    \"name\": None\n}\n\nentity = MockEntity(jsonld)\nprint(f\"name: {entity['name']}\") # Should be None\nprint(f\"progLang: {entity['programmingLanguage']}\") # Should be deref(#galaxy)\nprint(f\"@id: {entity['@id']}\") # Should be sort-and-change-case.ga\n\n# Testing list of values including None\njsonld2 = {\n    \"@id\": \"foo\",\n    \"tags\": [{\"@id\": \"tag1\"}, None, \"tag2\"]\n}\nentity2 = MockEntity(jsonld2)\nprint(f\"tags: {entity2['tags']}\") # Should be [deref(tag1), None, \"tag2\"]\nPY\n"
}

{
  "status": "ok",
  "stdout": "name: None\nprogLang: deref(#galaxy)\n@id: sort-and-change-case.ga\ntags: ['deref(tag1)', None, 'tag2']\n",
  "stderr": "/workspace/rocrate/vocabs.py:21: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n  import pkg_resources\n",
  "exit_code": 0
}

Perfect.

Now I will apply the change to `rocrate/model/entity.py`.

```python
    def __getitem__(self, key):
        v = self._jsonld[key]
        if isinstance(v, str) or key.startswith("@"):
            return v
        values = v if isinstance(v, list) else [v]
        deref_values = [self.crate.dereference(_["@id"], _["@id"]) for _ in values]
        return deref_values if isinstance(v, list) else deref_values[0]
```

to

```python
    def __getitem__(self, key):
        v = self._jsonld[key]
        if isinstance(v, str) or key.startswith("@"):
            return v
        values = v if isinstance(v, list) else [v]
        deref_values = [self.crate.dereference(_["@id"], _["@id"]) if isinstance(_, dict) and "@id" in _ else _ for _ in values]
        return deref_values if isinstance(v, list) else deref_values[0]
```

Wait, I should check if `_` can be something else. If `_` is a dict but doesn't have `@id`, the current code would fail with `KeyError: '@id'`.
My fix handles that with `and "@id" in _`.

Is it possible for `__getitem__` to be called with a key that doesn't exist?
`v = self._jsonld[key]` will raise `KeyError` if `key` is not in `_jsonld`. This is consistent with how `__getitem__` usually works.

Let's apply the change.

{
  "filepath": "rocrate/model/entity.py",
  "new_string": "        deref_values = [self.crate.dereference(_[\\\"@id\\\"], _[\\\"@id\\\"]) if isinstance(_, dict) and \\\"@id\\\" in _ else _ for _ in values]",
  "old_string": "        deref_values = [self.crate.dereference(_[\\\"@id\\\"], _[\\\"@id\\\"]) for _ in values]"
}

{
  "status": "ok",
  "filepath": "rocrate/model/entity.py",
  "occurrences": 1,
  "strategy": "unescaped",
  "diff": "--- a/rocrate/model/entity.py\n+++ b/rocrate/model/entity.py\n@@ -78,7 +78,7 @@\n         if isinstance(v, str) or key.startswith(\"@\"):\n             return v\n         values = v if isinstance(v, list) else [v]\n-        deref_values = [self.crate.dereference(_[\"@id\"], _[\"@id\"]) for _ in values]\n+        deref_values = [self.crate.dereference(_[\"@id\"], _[\"@id\"]) if isinstance(_, dict) and \"@id\" in _ else _ for _ in values]\n         return deref_values if isinstance(v, list) else deref_values[0]\n \n     def __setitem__(self, key: str, value):\n",
  "is_truncated": false
}

Now I should run the existing tests to make sure I haven't broken anything.

{
  "command": "pytest test/test_model.py -q --tb=short --no-header"
}

{
  "status": "ok",
  "stdout": ".................                                                        [100%]\n=============================== warnings summary ===============================\nrocrate/vocabs.py:21\n  /workspace/rocrate/vocabs.py:21: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n    import pkg_resources\n\n-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html\n17 passed, 1 warning in 0.13s\n",
  "stderr": "",
  "exit_code": 0
}

Everything passes. Let's do a final check of the diff and status.

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

{
  "status": "ok",
  "stdout": " M rocrate/model/entity.py\ndiff --git a/rocrate/model/entity.py b/rocrate/model/entity.py\nindex 826b564..d6e4380 100644\n--- a/rocrate/model/entity.py\n+++ b/rocrate/model/entity.py\n@@ -78,7 +78,7 @@ class Entity(MutableMapping):\n         if isinstance(v, str) or key.startswith(\"@\"):\n             return v\n         values = v if isinstance(v, list) else [v]\n-        deref_values = [self.crate.dereference(_[\"@id\"], _[\"@id\"]) for _ in values]\n+        deref_values = [self.crate.dereference(_[\"@id\"], _[\"@id\"]) if isinstance(_, dict) and \"@id\" in _ else _ for _ in values]\n         return deref_values if isinstance(v, list) else deref_values[0]\n \n     def __setitem__(self, key: str, value):\n",
  "stderr": "",
  "exit_code": 0
}

The diff looks clean. I have handled the `None` value (null JSON) and also added a safeguard for dictionaries without `@id`.

I'll run the reproduction script one last time on the actual code (without MockEntity overriding `__getitem__`).

{
  "command": "python3 - <<'PY'\nfrom rocrate.rocrate import ROCrate\nfrom rocrate.model.entity import Entity\n\nclass MockCrate:\n    def dereference(self, id1, id2):\n        return f\"deref({id1})\"\n\nclass MockEntity(Entity):\n    def __init__(self, jsonld):\n        self.crate = MockCrate()\n        self._jsonld = jsonld\n\n# Use the example from the issue\njsonld = {\n    \"@id\": \"sort-and-change-case.ga\",\n    \"@type\": [\"File\", \"SoftwareSourceCode\", \"ComputationalWorkflow\"],\n    \"programmingLanguage\": {\"@id\": \"#galaxy\"},\n    \"name\": None\n}\n\nentity = MockEntity(jsonld)\nprint(f\"name: {entity['name']}\")\nprint(f\"progLang: {entity['programmingLanguage']}\")\nprint(f\"@id: {entity['@id']}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "name: None\nprogLang: deref(#galaxy)\n@id: sort-and-change-case.ga\n",
  "stderr": "/workspace/rocrate/vocabs.py:21: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n  import pkg_resources\n",
  "exit_code": 0
}

One more check: what happens if `v` is a list and one of the elements is `None`?

{
  "command": "python3 - <<'PY'\nfrom rocrate.model.entity import Entity\n\nclass MockCrate:\n    def dereference(self, id1, id2):\n        return f\"deref({id1})\"\n\nclass MockEntity(Entity):\n    def __init__(self, jsonld):\n        self.crate = MockCrate()\n        self._jsonld = jsonld\n\njsonld2 = {\n    \"@id\": \"foo\",\n    \"tags\": [{\"@id\": \"tag1\"}, None, \"tag2\"]\n}\nentity2 = MockEntity(jsonld2)\nprint(f\"tags: {entity2['tags']}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "tags: ['deref(tag1)', None, 'tag2']\n",
  "stderr": "/workspace/rocrate/vocabs.py:21: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n  import pkg_resources\n",
  "exit_code": 0
}

Everything is working as expected.

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

I have successfully resolved the issue where `Entity.__getitem__` crashed when encountering null JSON values. The fix involves adding a type check to the list comprehension that handles dereferencing of entity references, ensuring that only dictionaries with an `@id` key are dereferenced.

The issue was caused by a `TypeError` in `Entity.__getitem__` when a property value was `None` (corresponding to a `null` value in JSON), as the code attempted to access `["@id"]` on the `None` object. I updated the list comprehension in `rocrate/model/entity.py` to verify that each value is a dictionary containing an `@id` key before attempting to dereference it, ensuring that `None` and other non-reference types are returned as-is.