neurodatawithoutborders__pynwb-1669

{
  "status": "ok",
  "stdout": "src/pynwb/icephys.py:15:def ensure_unit(self, name, current_unit, unit, nwb_version):\nsrc/pynwb/icephys.py:25:            % (current_unit, self.__class__.__name__, name, unit, nwb_version))\nsrc/pynwb/icephys.py:218:    def _ensure_stimulus_description(self, name, current_stim_desc, stim_desc, nwb_version):\nsrc/pynwb/icephys.py:228:                % (current_stim_desc, self.__class__.__name__, name, stim_desc, nwb_version))\nsrc/pynwb/__init__.py:245:    def nwb_version(self):\nsrc/pynwb/__init__.py:251:                  and strings, e.g., (2, 5, 1, beta). (None, None) will be returned if the nwb_version\nsrc/pynwb/__init__.py:256:            nwb_version_string = self._file.attrs['nwb_version']\nsrc/pynwb/__init__.py:262:        nwb_version_parts = nwb_version_string.replace(\"-\", \".\").replace(\"_\", \".\").split(\".\")\nsrc/pynwb/__init__.py:263:        nwb_version = tuple([int(i) if i.isnumeric() else i\nsrc/pynwb/__init__.py:264:                             for i in nwb_version_parts])\nsrc/pynwb/__init__.py:265:        return nwb_version_string, nwb_version\nsrc/pynwb/__init__.py:280:            file_version_str, file_version = self.nwb_version\nsrc/pynwb/io/utils.py:7:def get_nwb_version(builder: Builder, include_prerelease=False) -> Tuple[int, ...]:\nsrc/pynwb/io/utils.py:10:    If the \"nwb_version\" attribute on the root builder equals \"2.5.1\", then (2, 5, 1) is returned.\nsrc/pynwb/io/utils.py:11:    If the \"nwb_version\" attribute on the root builder equals \"2.5.1-alpha\" and include_prerelease=False,\nsrc/pynwb/io/utils.py:13:    If the \"nwb_version\" attribute on the root builder equals \"2.5.1-alpha\" and include_prerelease=True,\nsrc/pynwb/io/utils.py:16:    If the \"nwb_version\" attribute == \"2.0b\" (the only deviation from semantic versioning in the 2.x series), then\nsrc/pynwb/io/utils.py:25:    :raises ValueError: if the 'nwb_version' attribute is missing from the root of the NWB file.\nsrc/pynwb/io/utils.py:31:    nwb_version = root_builder.attributes.get(\"nwb_version\")\nsrc/pynwb/io/utils.py:32:    if nwb_version is None:\nsrc/pynwb/io/utils.py:33:        raise ValueError(\"'nwb_version' attribute is missing from the root of the NWB file.\")\nsrc/pynwb/io/utils.py:35:    if nwb_version == \"2.0b\":\nsrc/pynwb/io/utils.py:40:    nwb_version_match = re.match(r\"(\\d+\\.\\d+\\.\\d+)\", nwb_version)[0]  # trim off any non-numeric symbols at end\nsrc/pynwb/io/utils.py:41:    version_list = [int(i) for i in nwb_version_match.split(\".\")]\nsrc/pynwb/io/utils.py:43:        prerelease_info = nwb_version[nwb_version.index(\"-\")+1:]\nsrc/pynwb/io/file.py:8:from .utils import get_nwb_version\nsrc/pynwb/io/file.py:232:            if get_nwb_version(builder) < (2, 6, 0):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "src/pynwb/__init__.py",
  "content": "                manager = get_manager()\n        # Open the file\n        super().__init__(path, manager=manager, mode=mode, file=file_obj, comm=comm, driver=driver)\n\n    @property\n    def nwb_version(self):\n        \"\"\"\n        Get the version of the NWB file opened via this NWBHDF5IO object.\n\n        :returns: Tuple consisting of: 1) the original version string as stored in the file and\n                  2) a tuple with the parsed components of the version string, consisting of integers\n                  and strings, e.g., (2, 5, 1, beta). (None, None) will be returned if the nwb_version\n                  is missing, e.g., in the case when no data has been written to the file yet.\n        \"\"\"\n        # Get the version string for the NWB file\n        try:\n            nwb_version_string = self._file.attrs['nwb_version']\n        #  KeyError occurs  when the file is empty (e.g., when creating a new file nothing has been written)\n        #  or when the HDF5 file is not a valid NWB file\n        except KeyError:\n            return None, None\n        # Parse the version string\n        nwb_version_parts = nwb_version_string.replace(\"-\", \".\").replace(\"_\", \".\").split(\".\")\n        nwb_version = tuple([int(i) if i.isnumeric() else i\n                             for i in nwb_version_parts])\n        return nwb_version_string, nwb_version\n\n    @docval(*get_docval(_HDF5IO.read),\n            {'name': 'skip_version_check', 'type': bool, 'doc': 'skip checking of NWB version', 'default': False})\n    def read(self, **kwargs):\n        \"\"\"",
  "start_line": 240,
  "end_line": 270,
  "total_lines": 384,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "src/pynwb/__init__.py",
  "content": "'''This package will contain functions, classes, and objects\nfor reading and writing data in NWB format\n'''\nimport os.path\nfrom pathlib import Path\nfrom copy import deepcopy\nfrom warnings import warn\nimport h5py\n\nfrom hdmf.spec import NamespaceCatalog\nfrom hdmf.utils import docval, getargs, popargs, get_docval\nfrom hdmf.backends.io import HDMFIO\nfrom hdmf.backends.hdf5 import HDF5IO as _HDF5IO\nfrom hdmf.build import BuildManager, TypeMap\nimport hdmf.common\n\nCORE_NAMESPACE = 'core'\n__core_ns_file_name = 'nwb.namespace.yaml'\n\nfrom .spec import NWBDatasetSpec, NWBGroupSpec, NWBNamespace  # noqa E402\nfrom .validate import validate  # noqa: F401, E402\n\n\ndef __get_resources():\n    from pkg_resources import resource_filename\n    ret = dict()\n    ret['namespace_path'] = os.path.join(resource_filename(__name__, 'nwb-schema/core'), __core_ns_file_name)\n    return ret\n\n\ndef _get_resources():\n    # LEGACY: Needed to support legacy implementation.\n    return __get_resources()\n\n\n# a global namespace catalog\nglobal __NS_CATALOG\nglobal __TYPE_MAP\n\n__NS_CATALOG = NamespaceCatalog(NWBGroupSpec, NWBDatasetSpec, NWBNamespace)\n\nhdmf_typemap = hdmf.common.get_type_map()\n__TYPE_MAP = TypeMap(__NS_CATALOG)\n__TYPE_MAP.merge(hdmf_typemap, ns_catalog=True)\n\n\n@docval({'name': 'extensions', 'type': (str, TypeMap, list),\n         'doc': 'a path to a namespace, a TypeMap, or a list consisting of paths to namespaces and TypeMaps',\n         'default': None},\n        returns=\"TypeMap loaded for the given extension or NWB core namespace\", rtype=tuple,\n        is_method=False)\ndef get_type_map(**kwargs):\n    '''\n    Get the TypeMap for the given extensions. If no extensions are provided,\n    return the TypeMap for the core namespace\n    '''\n    extensions = getargs('extensions', kwargs)\n    type_map = None\n    if extensions is None:\n        type_map = deepcopy(__TYPE_MAP)\n    else:\n        if isinstance(extensions, TypeMap):\n            type_map = extensions\n        else:\n            type_map = deepcopy(__TYPE_MAP)\n        if isinstance(extensions, list):\n            for ext in extensions:\n                if isinstance(ext, str):\n                    type_map.load_namespaces(ext)\n                elif isinstance(ext, TypeMap):\n                    type_map.merge(ext)\n                else:\n                    raise ValueError('extensions must be a list of paths to namespace specs or a TypeMaps')\n        elif isinstance(extensions, str):\n            type_map.load_namespaces(extensions)\n        elif isinstance(extensions, TypeMap):\n            type_map.merge(extensions)\n    return type_map\n\n\n@docval(*get_docval(get_type_map),\n        returns=\"the namespaces loaded from the given file\", rtype=tuple,\n        is_method=False)\ndef get_manager(**kwargs):\n    '''\n    Get a BuildManager to use for I/O using the given extensions. If no extensions are provided,\n    return a BuildManager that uses the core namespace\n    '''\n    type_map = get_type_map(**kwargs)\n    return BuildManager(type_map)\n\n\n@docval({'name': 'namespace_path', 'type': str, 'doc': 'the path to the YAML with the namespace definition'},\n        returns=\"the namespaces loaded from the given file\", rtype=tuple,\n        is_method=False)\ndef load_namespaces(**kwargs):\n    '''\n    Load namespaces from file\n    '''\n    namespace_path = getargs('namespace_path', kwargs)\n    return __TYPE_MAP.load_namespaces(namespace_path)\n\n\n# load the core namespace, i.e. base NWB specification\n__resources = __get_resources()\nif os.path.exists(__resources['namespace_path']):\n    load_namespaces(__resources['namespace_path'])\nelse:\n    raise RuntimeError(\n        \"'core' is not a registered namespace. If you installed PyNWB locally using a git clone, you need to \"\n        \"use the --recurse_submodules flag when cloning. See developer installation instructions here: \"\n        \"https://pynwb.readthedocs.io/en/stable/install_developers.html#install-from-git-repository\"\n    )\n\n\ndef available_namespaces():\n    \"\"\"Returns all namespaces registered in the namespace catalog\"\"\"\n    return __NS_CATALOG.namespaces\n\n\n# a function to register a container classes with the global map\n@docval({'name': 'neurodata_type', 'type': str, 'doc': 'the neurodata_type to get the spec for'},\n        {'name': 'namespace', 'type': str, 'doc': 'the name of the namespace'},\n        {\"name\": \"container_cls\", \"type\": type, \"doc\": \"the class to map to the specified neurodata_type\",\n         'default': None},\n        is_method=False)\ndef register_class(**kwargs):\n    \"\"\"Register an NWBContainer class to use for reading and writing a neurodata_type from a specification\n    If container_cls is not specified, returns a decorator for registering an NWBContainer subclass\n    as the class for neurodata_type in namespace.\n    \"\"\"\n    neurodata_type, namespace, container_cls = getargs('neurodata_type', 'namespace', 'container_cls', kwargs)\n\n    def _dec(cls):\n        __TYPE_MAP.register_container_type(namespace, neurodata_type, cls)\n        return cls\n    if container_cls is None:\n        return _dec\n    else:\n        _dec(container_cls)\n\n\n# a function to register an object mapper for a container class\n@docval({\"name\": \"container_cls\", \"type\": type,\n         \"doc\": \"the Container class for which the given ObjectMapper class gets used\"},\n        {\"name\": \"mapper_cls\", \"type\": type, \"doc\": \"the ObjectMapper class to use to map\", 'default': None},\n        is_method=False)\ndef register_map(**kwargs):\n    \"\"\"Register an ObjectMapper to use for a Container class type\n    If mapper_cls is not specified, returns a decorator for registering an ObjectMapper class as the mapper for",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 384,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "src/pynwb/__init__.py",
  "content": "    container_cls. If mapper_cls is specified, register the class as the mapper for container_cls\n    \"\"\"\n    container_cls, mapper_cls = getargs('container_cls', 'mapper_cls', kwargs)\n\n    def _dec(cls):\n        __TYPE_MAP.register_map(container_cls, cls)\n        return cls\n    if mapper_cls is None:\n        return _dec\n    else:\n        _dec(mapper_cls)\n\n\n@docval({'name': 'neurodata_type', 'type': str, 'doc': 'the neurodata_type to get the NWBContainer class for'},\n        {'name': 'namespace', 'type': str, 'doc': 'the namespace the neurodata_type is defined in'},\n        is_method=False)\ndef get_class(**kwargs):\n    \"\"\"\n    Parse the YAML file for a given neurodata_type that is a subclass of NWBContainer and automatically generate its\n    python API. This will work for most containers, but is known to not work for descendants of MultiContainerInterface\n    and DynamicTable, so these must be defined manually (for now). `get_class` infers the API mapping directly from the\n    specification. If you want to define a custom mapping, you should not use this function and you should define the\n    class manually.\n\n    Examples:\n\n    Generating and registering an extension is as simple as::\n\n        MyClass = get_class('MyClass', 'ndx-my-extension')\n\n    `get_class` defines only the `__init__` for the class. In cases where you want to provide additional methods for\n    querying, plotting, etc. you can still use `get_class` and attach methods to the class after-the-fact, e.g.::\n\n        def get_sum(self, a, b):\n            return self.feat1 + self.feat2\n\n        MyClass.get_sum = get_sum\n\n    \"\"\"\n    neurodata_type, namespace = getargs('neurodata_type', 'namespace', kwargs)\n    return __TYPE_MAP.get_dt_container_cls(neurodata_type, namespace)\n\n\nclass NWBHDF5IO(_HDF5IO):\n\n    @docval({'name': 'path', 'type': (str, Path), 'doc': 'the path to the HDF5 file', 'default': None},\n            {'name': 'mode', 'type': str,\n             'doc': 'the mode to open the HDF5 file with, one of (\"w\", \"r\", \"r+\", \"a\", \"w-\", \"x\")',\n             'default': 'r'},\n            {'name': 'load_namespaces', 'type': bool,\n             'doc': 'whether or not to load cached namespaces from given path - not applicable in write mode',\n             'default': False},\n            {'name': 'manager', 'type': BuildManager, 'doc': 'the BuildManager to use for I/O', 'default': None},\n            {'name': 'extensions', 'type': (str, TypeMap, list),\n             'doc': 'a path to a namespace, a TypeMap, or a list consisting paths to namespaces and TypeMaps',\n             'default': None},\n            {'name': 'file', 'type': [h5py.File, 'S3File'], 'doc': 'a pre-existing h5py.File object', 'default': None},\n            {'name': 'comm', 'type': \"Intracomm\", 'doc': 'the MPI communicator to use for parallel I/O',\n             'default': None},\n            {'name': 'driver', 'type': str, 'doc': 'driver for h5py to use when opening HDF5 file', 'default': None})\n    def __init__(self, **kwargs):\n        path, mode, manager, extensions, load_namespaces, file_obj, comm, driver =\\\n            popargs('path', 'mode', 'manager', 'extensions', 'load_namespaces', 'file', 'comm', 'driver', kwargs)\n        # Define the BuildManager to use\n        if load_namespaces:\n            if manager is not None:\n                warn(\"loading namespaces from file - ignoring 'manager'\")\n            if extensions is not None:\n                warn(\"loading namespaces from file - ignoring 'extensions' argument\")\n            # namespaces are not loaded when creating an NWBHDF5IO object in write mode\n            if 'w' in mode or mode == 'x':\n                raise ValueError(\"cannot load namespaces from file when writing to it\")\n\n            tm = get_type_map()\n            super().load_namespaces(tm, path, file=file_obj, driver=driver)\n            manager = BuildManager(tm)\n\n            # XXX: Leaving this here in case we want to revert to this strategy for\n            #      loading cached namespaces\n            # ns_catalog = NamespaceCatalog(NWBGroupSpec, NWBDatasetSpec, NWBNamespace)\n            # super().load_namespaces(ns_catalog, path)\n            # tm = TypeMap(ns_catalog)\n            # tm.copy_mappers(get_type_map())\n        else:\n            if manager is not None and extensions is not None:\n                raise ValueError(\"'manager' and 'extensions' cannot be specified together\")\n            elif extensions is not None:\n                manager = get_manager(extensions=extensions)\n            elif manager is None:\n                manager = get_manager()\n        # Open the file\n        super().__init__(path, manager=manager, mode=mode, file=file_obj, comm=comm, driver=driver)\n\n    @property\n    def nwb_version(self):\n        \"\"\"\n        Get the version of the NWB file opened via this NWBHDF5IO object.\n\n        :returns: Tuple consisting of: 1) the original version string as stored in the file and\n                  2) a tuple with the parsed components of the version string, consisting of integers\n                  and strings, e.g., (2, 5, 1, beta). (None, None) will be returned if the nwb_version\n                  is missing, e.g., in the case when no data has been written to the file yet.\n        \"\"\"\n        # Get the version string for the NWB file\n        try:\n            nwb_version_string = self._file.attrs['nwb_version']\n        #  KeyError occurs  when the file is empty (e.g., when creating a new file nothing has been written)\n        #  or when the HDF5 file is not a valid NWB file\n        except KeyError:\n            return None, None\n        # Parse the version string\n        nwb_version_parts = nwb_version_string.replace(\"-\", \".\").replace(\"_\", \".\").split(\".\")\n        nwb_version = tuple([int(i) if i.isnumeric() else i\n                             for i in nwb_version_parts])\n        return nwb_version_string, nwb_version\n\n    @docval(*get_docval(_HDF5IO.read),\n            {'name': 'skip_version_check', 'type': bool, 'doc': 'skip checking of NWB version', 'default': False})\n    def read(self, **kwargs):\n        \"\"\"\n        Read the NWB file from the IO source.\n\n        :raises TypeError: If the NWB file version is missing or not supported\n\n        :return: NWBFile container\n        \"\"\"\n        # Check that the NWB file is supported\n        skip_verison_check = popargs('skip_version_check', kwargs)\n        if not skip_verison_check:\n            file_version_str, file_version = self.nwb_version\n            if file_version is None:\n                raise TypeError(\"Missing NWB version in file. The file is not a valid NWB file.\")\n            if file_version[0] < 2:\n                raise TypeError(\"NWB version %s not supported. PyNWB supports NWB files version 2 and above.\" %\n                                str(file_version_str))\n        # read the file\n        return super().read(**kwargs)\n\n    @docval({'name': 'src_io', 'type': HDMFIO,\n             'doc': 'the HDMFIO object (such as NWBHDF5IO) that was used to read the data to export'},\n            {'name': 'nwbfile', 'type': 'NWBFile',\n             'doc': 'the NWBFile object to export. If None, then the entire contents of src_io will be exported',\n             'default': None},\n            {'name': 'write_args', 'type': dict, 'doc': 'arguments to pass to :py:meth:`write_builder`',\n             'default': None})\n    def export(self, **kwargs):\n        \"\"\"\n        Export an NWB file to a new NWB file using the HDF5 backend.\n\n        If ``nwbfile`` is provided, then the build manager of ``src_io`` is used to build the container,",
  "start_line": 151,
  "end_line": 300,
  "total_lines": 384,
  "is_truncated": true
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "/pynwb/src/pynwb/__init__.py:25: 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  from pkg_resources import resource_filename\nTraceback (most recent call last):\n  File \"<stdin>\", line 2, in <module>\n  File \"/pynwb/src/pynwb/__init__.py\", line 109, in <module>\n    raise RuntimeError(\nRuntimeError: 'core' is not a registered namespace. If you installed PyNWB locally using a git clone, you need to use the --recurse_submodules flag when cloning. See developer installation instructions here: https://pynwb.readthedocs.io/en/stable/install_developers.html#install-from-git-repository\n",
  "details": {
    "stdout": "",
    "stderr": "/pynwb/src/pynwb/__init__.py:25: 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  from pkg_resources import resource_filename\nTraceback (most recent call last):\n  File \"<stdin>\", line 2, in <module>\n  File \"/pynwb/src/pynwb/__init__.py\", line 109, in <module>\n    raise RuntimeError(\nRuntimeError: 'core' is not a registered namespace. If you installed PyNWB locally using a git clone, you need to use the --recurse_submodules flag when cloning. See developer installation instructions here: https://pynwb.readthedocs.io/en/stable/install_developers.html#install-from-git-repository\n",
    "exit_code": 1
  }
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "ls: cannot access 'src/pynwb/nwb-schema/core': No such file or directory\n",
  "details": {
    "stdout": "",
    "stderr": "ls: cannot access 'src/pynwb/nwb-schema/core': No such file or directory\n",
    "exit_code": 2
  }
}

{
  "status": "ok",
  "stdout": "src/pynwb/nwb-schema:\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "Result with str: ('2.2.4', (2, 2, 4))\nResult with bytes: a bytes-like object is required, not 'str'\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "src/pynwb/io/utils.py",
  "content": "import re\nfrom typing import Tuple\n\nfrom hdmf.build import Builder\n\n\ndef get_nwb_version(builder: Builder, include_prerelease=False) -> Tuple[int, ...]:\n    \"\"\"Get the version of the NWB file from the root of the given builder, as a tuple.\n\n    If the \"nwb_version\" attribute on the root builder equals \"2.5.1\", then (2, 5, 1) is returned.\n    If the \"nwb_version\" attribute on the root builder equals \"2.5.1-alpha\" and include_prerelease=False,\n    then (2, 5, 1) is returned.\n    If the \"nwb_version\" attribute on the root builder equals \"2.5.1-alpha\" and include_prerelease=True,\n    then (2, 5, 1, \"alpha\") is returned.\n\n    If the \"nwb_version\" attribute == \"2.0b\" (the only deviation from semantic versioning in the 2.x series), then\n    if include_prerelease=True, (2, 0, 0, \"b\") is returned; else, (2, 0, 0) is returned.\n\n    :param builder: Any builder within an NWB file.\n    :type builder: Builder\n    :param include_prerelease: Whether to include prerelease information in the returned tuple.\n    :type include_prerelease: bool\n    :return: The version of the NWB file, as a tuple.\n    :rtype: tuple\n    :raises ValueError: if the 'nwb_version' attribute is missing from the root of the NWB file.\n    \"\"\"\n    temp_builder = builder\n    while temp_builder.parent is not None:\n        temp_builder = temp_builder.parent\n    root_builder = temp_builder\n    nwb_version = root_builder.attributes.get(\"nwb_version\")\n    if nwb_version is None:\n        raise ValueError(\"'nwb_version' attribute is missing from the root of the NWB file.\")\n    # handle special non-semver case\n    if nwb_version == \"2.0b\":\n        if not include_prerelease:\n            return (2, 0, 0)\n        else:\n            return (2, 0, 0, \"b\")\n    nwb_version_match = re.match(r\"(\\d+\\.\\d+\\.\\d+)\", nwb_version)[0]  # trim off any non-numeric symbols at end\n    version_list = [int(i) for i in nwb_version_match.split(\".\")]\n    if include_prerelease:\n        prerelease_info = nwb_version[nwb_version.index(\"-\")+1:]\n        version_list.append(prerelease_info)\n    return tuple(version_list)",
  "start_line": 1,
  "end_line": 45,
  "total_lines": 45,
  "is_truncated": false
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "/pynwb/src/pynwb/__init__.py:25: 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  from pkg_resources import resource_filename\nTraceback (most recent call last):\n  File \"<stdin>\", line 4, in <module>\n  File \"/pynwb/src/pynwb/__init__.py\", line 109, in <module>\n    raise RuntimeError(\nRuntimeError: 'core' is not a registered namespace. If you installed PyNWB locally using a git clone, you need to use the --recurse_submodules flag when cloning. See developer installation instructions here: https://pynwb.readthedocs.io/en/stable/install_developers.html#install-from-git-repository\n",
  "details": {
    "stdout": "",
    "stderr": "/pynwb/src/pynwb/__init__.py:25: 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  from pkg_resources import resource_filename\nTraceback (most recent call last):\n  File \"<stdin>\", line 4, in <module>\n  File \"/pynwb/src/pynwb/__init__.py\", line 109, in <module>\n    raise RuntimeError(\nRuntimeError: 'core' is not a registered namespace. If you installed PyNWB locally using a git clone, you need to use the --recurse_submodules flag when cloning. See developer installation instructions here: https://pynwb.readthedocs.io/en/stable/install_developers.html#install-from-git-repository\n",
    "exit_code": 1
  }
}

{
  "status": "ok",
  "stdout": "Caught exception: cannot use a string pattern on a bytes-like object\n",
  "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 31, in <module>\n  File \"<stdin>\", line 19, in get_nwb_version\n  File \"/usr/local/lib/python3.10/re.py\", line 190, in match\n    return _compile(pattern, flags).match(string)\nTypeError: cannot use a string pattern on a bytes-like object\n",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "src/pynwb/__init__.py",
  "content": "            type_map.load_namespaces(extensions)\n        elif isinstance(extensions, TypeMap):\n            type_map.merge(extensions)\n    return type_map\n\n\n@docval(*get_docval(get_type_map),\n        returns=\"the namespaces loaded from the given file\", rtype=tuple,\n        is_method=False)\ndef get_manager(**kwargs):\n    '''\n    Get a BuildManager to use for I/O using the given extensions. If no extensions are provided,\n    return a BuildManager that uses the core namespace\n    '''\n    type_map = get_type_map(**kwargs)\n    return BuildManager(type_map)\n\n\n@docval({'name': 'namespace_path', 'type': str, 'doc': 'the path to the YAML with the namespace definition'},\n        returns=\"the namespaces loaded from the given file\", rtype=tuple,\n        is_method=False)\ndef load_namespaces(**kwargs):\n    '''\n    Load namespaces from file\n    '''\n    namespace_path = getargs('namespace_path', kwargs)",
  "start_line": 75,
  "end_line": 100,
  "total_lines": 384,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "262:        nwb_version_parts = nwb_version_string.replace(\"-\", \".\").replace(\"_\", \".\").split(\".\")\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "src/pynwb/__init__.py",
  "content": "                  2) a tuple with the parsed components of the version string, consisting of integers\n                  and strings, e.g., (2, 5, 1, beta). (None, None) will be returned if the nwb_version\n                  is missing, e.g., in the case when no data has been written to the file yet.\n        \"\"\"\n        # Get the version string for the NWB file\n        try:\n            nwb_version_string = self._file.attrs['nwb_version']\n        #  KeyError occurs  when the file is empty (e.g., when creating a new file nothing has been written)\n        #  or when the HDF5 file is not a valid NWB file\n        except KeyError:\n            return None, None\n        # Parse the version string\n        nwb_version_parts = nwb_version_string.replace(\"-\", \".\").replace(\"_\", \".\").split(\".\")\n        nwb_version = tuple([int(i) if i.isnumeric() else i\n                             for i in nwb_version_parts])\n        return nwb_version_string, nwb_version\n\n    @docval(*get_docval(_HDF5IO.read),\n            {'name': 'skip_version_check', 'type': bool, 'doc': 'skip checking of NWB version', 'default': False})\n    def read(self, **kwargs):\n        \"\"\"\n        Read the NWB file from the IO source.\n\n        :raises TypeError: If the NWB file version is missing or not supported\n\n        :return: NWBFile container",
  "start_line": 250,
  "end_line": 275,
  "total_lines": 384,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "src/pynwb/__init__.py",
  "occurrences": 1,
  "strategy": "exact",
  "diff": "--- a/src/pynwb/__init__.py\n+++ b/src/pynwb/__init__.py\n@@ -254,6 +254,8 @@\n         # Get the version string for the NWB file\n         try:\n             nwb_version_string = self._file.attrs['nwb_version']\n+            if isinstance(nwb_version_string, bytes):\n+                nwb_version_string = nwb_version_string.decode('utf-8')\n         #  KeyError occurs  when the file is empty (e.g., when creating a new file nothing has been written)\n         #  or when the HDF5 file is not a valid NWB file\n         except KeyError:\n",
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "src/pynwb/io/utils.py",
  "occurrences": 1,
  "strategy": "unescaped",
  "diff": "--- a/src/pynwb/io/utils.py\n+++ b/src/pynwb/io/utils.py\n@@ -31,6 +31,8 @@\n     nwb_version = root_builder.attributes.get(\"nwb_version\")\n     if nwb_version is None:\n         raise ValueError(\"'nwb_version' attribute is missing from the root of the NWB file.\")\n+    if isinstance(nwb_version, bytes):\n+        nwb_version = nwb_version.decode('utf-8')\n     # handle special non-semver case\n     if nwb_version == \"2.0b\":\n         if not include_prerelease:\n",
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "src/pynwb/__init__.py",
  "content": "                manager = get_manager()\n        # Open the file\n        super().__init__(path, manager=manager, mode=mode, file=file_obj, comm=comm, driver=driver)\n\n    @property\n    def nwb_version(self):\n        \"\"\"\n        Get the version of the NWB file opened via this NWBHDF5IO object.\n\n        :returns: Tuple consisting of: 1) the original version string as stored in the file and\n                  2) a tuple with the parsed components of the version string, consisting of integers\n                  and strings, e.g., (2, 5, 1, beta). (None, None) will be returned if the nwb_version\n                  is missing, e.g., in the case when no data has been written to the file yet.\n        \"\"\"\n        # Get the version string for the NWB file\n        try:",
  "start_line": 240,
  "end_line": 255,
  "total_lines": 386,
  "is_truncated": false
}