hdmf-dev__hdmf-1270

{
  "status": "ok",
  "stdout": "src/hdmf/utils.py:796:def get_data_shape(data, strict_no_data_load=False):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "src/hdmf/utils.py",
  "content": "def get_data_shape(data, strict_no_data_load=False):\n    \"\"\"\n    Helper function used to determine the shape of the given array.\n\n    In order to determine the shape of nested tuples, lists, and sets, this function\n    recursively inspects elements along the dimensions, assuming that the data has a regular,\n    rectangular shape. In the case of out-of-core iterators, this means that the first item\n    along each dimension would potentially be loaded into memory. Set strict_no_data_load=True\n    to enforce that this does not happen, at the cost that we may not be able to determine\n    the shape of the array.\n\n    :param data: Array for which we should determine the shape. Can be any object that supports __len__ or .shape.\n    :type data: List, numpy.ndarray, DataChunkIterator\n    :param strict_no_data_load: If True and data is an out-of-core iterator, None may be returned. If False (default),\n                                the first element of data may be loaded into memory.\n    :return: Tuple of ints indicating the size of known dimensions. Dimensions for which the size is unknown\n             will be set to None.\n    \"\"\"\n\n    def __get_shape_helper(local_data):\n        shape = list()\n        if hasattr(local_data, '__len__'):\n            shape.append(len(local_data))\n            if len(local_data):\n                el = next(iter(local_data))\n                if not isinstance(el, (str, bytes)):\n                    shape.extend(__get_shape_helper(el))\n        return tuple(shape)\n\n    # NOTE: data.maxshape will fail on empty h5py.Dataset without shape or maxshape. this will be fixed in h5py 3.0\n    if hasattr(data, 'maxshape'):\n        return data.maxshape\n    if hasattr(data, 'shape') and data.shape is not None:\n        return data.shape\n    if isinstance(data, dict):\n        return None\n    if hasattr(data, '__len__') and not isinstance(data, (str, bytes)):\n        if not strict_no_data_load or isinstance(data, (list, tuple, set)):\n            return __get_shape_helper(data)\n    return None\n\n\ndef pystr(s):\n    \"\"\"\n    Convert a string of characters to Python str object\n    \"\"\"\n    if isinstance(s, bytes):\n        return s.decode('utf-8')\n    else:\n        return s\n\n\ndef to_uint_array(arr):\n    \"\"\"\n    Convert a numpy array or array-like object to a numpy array of unsigned integers with the same dtype itemsize.\n\n    For example, a list of int32 values is converted to a numpy array with dtype uint32.\n    :raises ValueError: if input array contains values that are not unsigned integers or non-negative integers.\n    \"\"\"\n    if not isinstance(arr, np.ndarray):\n        arr = np.array(arr)\n    if np.issubdtype(arr.dtype, np.unsignedinteger):\n        return arr\n    if np.issubdtype(arr.dtype, np.integer):\n        if (arr < 0).any():\n            raise ValueError('Cannot convert negative integer values to uint.')\n        dt = np.dtype('uint' + str(int(arr.dtype.itemsize*8)))  # keep precision\n        return arr.astype(dt)\n    raise ValueError('Cannot convert array of dtype %s to uint.' % arr.dtype)\n\n\ndef is_ragged(data):\n    \"\"\"\n    Test whether a list of lists or array is ragged / jagged\n    \"\"\"\n    if isinstance(data, (list, tuple)):\n        lengths = [len(sub_data) if isinstance(sub_data, (list, tuple)) else 1 for sub_data in data]\n        if len(set(lengths)) > 1:\n            return True  # ragged at this level\n\n        return any(is_ragged(sub_data) for sub_data in data)  # check next level\n\n    return False\n\ndef is_newer_version(version_a: str, version_b: str) -> bool:\n    # this method could be replaced by packaging.version if packaging is added as a dependency\n    version_a_match = re.match(r\"(\\d+\\.\\d+\\.\\d+)\", version_a)[0]  # trim off any non-numeric symbols at end\n    version_a_list = [int(i) for i in version_a_match.split(\".\")]\n\n    version_b_match = re.match(r\"(\\d+\\.\\d+\\.\\d+)\", version_b)[0]  # trim off any non-numeric symbols at end\n    version_b_list = [int(i) for i in version_b_match.split(\".\")]\n\n    for a, b in zip(version_a_list, version_b_list):\n        if a > b:\n            return True\n        elif a < b:\n            return False\n\n    return False\n\ndef get_basic_array_info(array):\n    def convert_bytes_to_str(bytes_size):\n        suffixes = ['bytes', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB']\n        i = 0\n        while bytes_size >= 1024 and i < len(suffixes)-1:\n            bytes_size /= 1024.\n            i += 1\n        return f\"{bytes_size:.2f} {suffixes[i]}\"\n\n    if hasattr(array, \"nbytes\"):  # TODO: Remove this after h5py minimal version is larger than 3.0\n        array_size_in_bytes = array.nbytes\n    else:\n        array_size_in_bytes = array.size * array.dtype.itemsize\n    array_size_repr = convert_bytes_to_str(array_size_in_bytes)\n    basic_array_info_dict = {\"Data type\": array.dtype, \"Shape\": array.shape, \"Array size\": array_size_repr}\n\n    return basic_array_info_dict\n\ndef generate_array_html_repr(array_info_dict, array, dataset_type=None):\n    def html_table(item_dicts) -> str:\n        \"\"\"\n        Generates an html table from a dictionary\n        \"\"\"\n        report = '<table class=\"data-info\">'\n        report += \"<tbody>\"\n        for k, v in item_dicts.items():\n            report += (\n                f\"<tr>\"\n                f'<th style=\"text-align: left\">{k}</th>'\n                f'<td style=\"text-align: left\">{v}</td>'\n                f\"</tr>\"\n            )\n        report += \"</tbody>\"\n        report += \"</table>\"\n        return report\n\n    array_info_html = html_table(array_info_dict)\n    repr_html = dataset_type + \"<br>\" + array_info_html if dataset_type is not None else array_info_html\n\n    # Array like might lack nbytes (h5py < 3.0) or size (DataIO object)\n    if hasattr(array, \"nbytes\"):\n        array_size_bytes = array.nbytes\n    else:\n        if hasattr(array, \"size\"):\n            array_size = array.size\n        else:\n            import math\n            array_size = math.prod(array.shape)\n        array_size_bytes = array_size * array.dtype.itemsize\n",
  "start_line": 796,
  "end_line": 945,
  "total_lines": 1155,
  "is_truncated": true
}

{
  "status": "ok",
  "stdout": "src/hdmf/backends/hdf5/h5_utils.py:120:class DatasetOfReferences(H5Dataset, ReferenceResolver, metaclass=ABCMeta):\nsrc/hdmf/data_utils.py:479:class DataChunkIterator(AbstractDataChunkIterator):\nsrc/hdmf/data_utils.py:763:class DataChunk:\nsrc/hdmf/data_utils.py:1005:class DataIO:\nsrc/hdmf/build/builders.py:320:class DatasetBuilder(BaseBuilder):\nsrc/hdmf/common/io/resources.py:12:           The DatasetBuilder for name is associated with data_type Data and container class Data,\nsrc/hdmf/spec/spec.py:659:class DatasetSpec(BaseStorageSpec):\nsrc/hdmf/monitor.py:19:class DataChunkProcessor(AbstractDataChunkIterator, metaclass=ABCMeta):\nsrc/hdmf/validate/validator.py:418:class DatasetValidator(BaseStorageValidator):\nsrc/hdmf/container.py:892:class Data(AbstractContainer):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "src/hdmf/container.py",
  "content": "class Data(AbstractContainer):\n    \"\"\"\n    A class for representing dataset containers\n    \"\"\"\n    @docval({'name': 'name', 'type': str, 'doc': 'the name of this container'},\n            {'name': 'data', 'type': ('scalar_data', 'array_data', 'data'), 'doc': 'the source of the data'})\n    def __init__(self, **kwargs):\n        data = popargs('data', kwargs)\n        super().__init__(**kwargs)\n\n        self._validate_new_data(data)\n        self.__data = data\n\n    @property\n    def data(self):\n        return self.__data\n\n    @property\n    def shape(self):\n        \"\"\"\n        Get the shape of the data represented by this container\n        :return: Shape tuple\n        :rtype: tuple of ints\n        \"\"\"\n        return get_data_shape(self.__data)\n\n    def set_data_io(\n        self,\n        data_io_class: Type[DataIO],\n        data_io_kwargs: dict,\n        data_chunk_iterator_class: Optional[Type[AbstractDataChunkIterator]] = None,\n        data_chunk_iterator_kwargs: dict = None,\n    ) -> None:\n        \"\"\"\n        Apply DataIO object to the data held by this Data object.\n\n        Parameters\n        ----------\n        data_io_class: Type[DataIO]\n            The DataIO to apply to the data held by this Data.\n        data_io_kwargs: dict\n            The keyword arguments to pass to the DataIO.\n        data_chunk_iterator_class: Type[AbstractDataChunkIterator]\n            The DataChunkIterator to use for the DataIO. If None, no DataChunkIterator is used.\n        data_chunk_iterator_kwargs: dict\n            The keyword arguments to pass to the DataChunkIterator.\n\n        Notes\n        -----\n        If data_chunk_iterator_class is not None, the data is wrapped in the DataChunkIterator before being wrapped in\n        the DataIO. This allows for rewriting the backend configuration of hdf5 datasets.\n        \"\"\"\n        data_chunk_iterator_kwargs = data_chunk_iterator_kwargs or dict()\n        data = self.__data\n        if data_chunk_iterator_class is not None:\n            data = data_chunk_iterator_class(data=data, **data_chunk_iterator_kwargs)\n        self.__data = data_io_class(data=data, **data_io_kwargs)\n\n    @docval({'name': 'func', 'type': types.FunctionType, 'doc': 'a function to transform *data*'})\n    def transform(self, **kwargs):\n        \"\"\"\n        Transform data from the current underlying state.\n\n        This function can be used to permanently load data from disk, or convert to a different\n        representation, such as a torch.Tensor\n        \"\"\"\n        func = getargs('func', kwargs)\n        self.__data = func(self.__data)\n        return self\n\n    def __bool__(self):\n        if self.data is not None:\n            if isinstance(self.data, (np.ndarray, tuple, list)):\n                return len(self.data) != 0\n            if self.data:\n                return True\n        return False\n\n    def __len__(self):\n        return len(self.__data)\n\n    def __getitem__(self, args):\n        return self.get(args)\n\n    def get(self, args):\n        if isinstance(self.data, (tuple, list)) and isinstance(args, (tuple, list, np.ndarray)):\n            return [self.data[i] for i in args]\n        if isinstance(self.data, h5py.Dataset) and isinstance(args, np.ndarray):\n            # This is needed for h5py 2.9 compatibility\n            args = args.tolist()\n        return self.data[args]\n\n    def append(self, arg):\n        self._validate_new_data_element(arg)\n        self.__data = append_data(self.__data, arg)\n\n    def extend(self, arg):\n        \"\"\"\n        The extend_data method adds all the elements of the iterable arg to the\n        end of the data of this Data container.\n\n        :param arg: The iterable to add to the end of this VectorData\n        \"\"\"\n        self._validate_new_data(arg)\n        self.__data = extend_data(self.__data, arg)\n\n    def _validate_new_data(self, data):\n        \"\"\"Function to validate a new array that will be set or added to data. Raises an error if the data is invalid.\n\n        Subclasses should override this function to perform class-specific validation.\n        \"\"\"\n        pass\n\n    def _validate_new_data_element(self, arg):\n        \"\"\"Function to validate a new value that will be added to the data. Raises an error if the data is invalid.\n\n        Subclasses should override this function to perform class-specific validation.\n        \"\"\"\n        pass\n\n\nclass MultiContainerInterface(Container):\n    \"\"\"Class that dynamically defines methods to support a Container holding multiple Containers of the same type.\n\n    To use, extend this class and create a dictionary as a class attribute with any of the following keys:\n    * 'attr' to name the attribute that stores the Container instances\n    * 'type' to provide the Container object type (type or list/tuple of types, type can be a docval macro)\n    * 'add' to name the method for adding Container instances\n    * 'get' to name the method for getting Container instances\n    * 'create' to name the method for creating Container instances (only if a single type is specified)\n\n    If the attribute does not exist in the class, it will be generated. If it does exist, it should behave like a dict.\n\n    The keys 'attr', 'type', and 'add' are required.\n    \"\"\"\n\n    def __new__(cls, *args, **kwargs):\n        if cls is MultiContainerInterface:\n            raise TypeError(\"Can't instantiate class MultiContainerInterface.\")\n        if not hasattr(cls, '__clsconf__'):\n            raise TypeError(\"MultiContainerInterface subclass %s is missing __clsconf__ attribute. Please check that \"\n                            \"the class is properly defined.\" % cls.__name__)\n        return super().__new__(cls, *args, **kwargs)\n\n    @staticmethod\n    def __add_article(noun):\n        if isinstance(noun, tuple):\n            noun = noun[0]\n        if isinstance(noun, type):\n            noun = noun.__name__",
  "start_line": 892,
  "end_line": 1041,
  "total_lines": 1619,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "src/hdmf/utils.py",
  "content": "import collections\nimport copy as _copy\nimport re\nimport types\nimport warnings\nfrom abc import ABCMeta\nfrom enum import Enum\n\nimport h5py\nimport numpy as np\n\n\n__macros = {\n    'array_data': [np.ndarray, list, tuple, h5py.Dataset],\n    'scalar_data': [str, int, float, bytes, bool],\n    'data': []\n}\n\ntry:\n    # optionally accept zarr.Array as array data to support conversion of data from Zarr to HDMF\n    import zarr\n    __macros['array_data'].append(zarr.Array)\nexcept ImportError:\n    pass\n\n\n# code to signify how to handle positional arguments in docval\nAllowPositional = Enum('AllowPositional', 'ALLOWED WARNING ERROR')\n\n__supported_bool_types = (bool, np.bool_)\n__supported_uint_types = (np.uint8, np.uint16, np.uint32, np.uint64)\n__supported_int_types = (int, np.int8, np.int16, np.int32, np.int64)\n__supported_float_types = [float, np.float16, np.float32, np.float64]\nif hasattr(np, \"float128\"):  # pragma: no cover\n    __supported_float_types.append(np.float128)\nif hasattr(np, \"longdouble\"):  # pragma: no cover\n    # on windows python<=3.5, h5py floats resolve float64s as either np.float64 or np.longdouble\n    # non-deterministically. a future version of h5py will fix this. see #112\n    __supported_float_types.append(np.longdouble)\n__supported_float_types = tuple(__supported_float_types)\n__allowed_enum_types = (__supported_bool_types + __supported_uint_types + __supported_int_types\n                        + __supported_float_types + (str,))\n\n\ndef docval_macro(macro):\n    \"\"\"Class decorator to add the class to a list of types associated with the key macro in the __macros dict\n    \"\"\"\n\n    def _dec(cls):\n        if macro not in __macros:\n            __macros[macro] = list()\n        __macros[macro].append(cls)\n        return cls\n\n    return _dec\n\n\ndef get_docval_macro(key=None):\n    \"\"\"\n    Return a deepcopy of the docval macros, i.e., strings that represent a customizable list of types for use in docval.\n\n    :param key: Name of the macro. If key=None, then a dictionary of all macros is returned. Otherwise, a tuple of\n                the types associated with the key is returned.\n    \"\"\"\n    if key is None:\n        return _copy.deepcopy(__macros)\n    else:\n        return tuple(__macros[key])\n\n\ndef check_type(value, argtype, allow_none=False):\n    \"\"\"Check a value against a type\n\n       The difference between this function and :py:func:`isinstance` is that\n       it allows specifying a type as a string. Furthermore, strings allow for specifying more general\n       types, such as a simple numeric type (i.e. ``argtype=\"num\"``).\n\n       Args:\n           value (Any): the value to check\n           argtype (type, str): the type to check for\n           allow_none (bool): whether or not to allow None as a valid value\n\n\n       Returns:\n           bool: True if value is a valid instance of argtype\n    \"\"\"\n    if value is None:\n        return allow_none\n    if isinstance(argtype, str):\n        if argtype in __macros:\n            return check_type(value, __macros[argtype], allow_none=allow_none)\n        elif argtype == 'uint':\n            return __is_uint(value)\n        elif argtype == 'int':\n            return __is_int(value)\n        elif argtype == 'float':\n            return __is_float(value)\n        elif argtype == 'bool':\n            return __is_bool(value)\n        cls_names = []",
  "start_line": 1,
  "end_line": 100,
  "total_lines": 1155,
  "is_truncated": false
}

{
  "error": "Invoking `write_file()` failed as the following mandatory input parameters are not present:\nfilepath\nYou could retry calling this tool, but it is IMPORTANT for you to provide all the mandatory parameters."
}

{
  "status": "error",
  "error_type": "FileWriteError",
  "error_message": "Path traversal detected: '/tmp/repro_get_data_shape.py' escapes workspace root."
}

{
  "status": "ok",
  "filepath": "repro_get_data_shape.py",
  "size": 889
}

{
  "status": "ok",
  "stdout": "Shape of data_list: (2, 2)\nTest failed: Expected (2,), got (2, 2)\n",
  "stderr": "Traceback (most recent call last):\n  File \"/workspace/repro_get_data_shape.py\", line 19, in <module>\n    test_get_data_shape_with_data_objects()\n  File \"/workspace/repro_get_data_shape.py\", line 9, in test_get_data_shape_with_data_objects\n    assert shape == (2,), f\"Expected (2,), got {shape}\"\nAssertionError: Expected (2,), got (2, 2)\n",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "src/hdmf/container.py",
  "content": "import types\nfrom collections import OrderedDict\nfrom copy import deepcopy\nfrom typing import Type, Optional\nfrom uuid import uuid4\nfrom warnings import warn\nimport os\n\nimport h5py\nimport numpy as np\nimport pandas as pd\n\nfrom .data_utils import DataIO, append_data, extend_data, AbstractDataChunkIterator\nfrom .utils import (docval, get_docval, getargs, ExtenderMeta, get_data_shape, popargs, LabelledDict,\n                    get_basic_array_info, generate_array_html_repr)\n\nfrom .term_set import TermSet, TermSetWrapper\n\ndef _set_exp(cls):\n    \"\"\"Set a class as being experimental\"\"\"\n    cls._experimental = True\n\n\ndef _exp_warn_msg(cls):\n    \"\"\"Generate a warning message experimental features\"\"\"\n    pfx = cls\n    if isinstance(cls, type):\n        pfx = cls.__name__\n    msg = ('%s is experimental -- it may be removed in the future and '\n           'is not guaranteed to maintain backward compatibility') % pfx\n    return msg\n\n\nclass HERDManager:\n    \"\"\"\n    This class manages whether to set/attach an instance of HERD to the subclass.\n    \"\"\"\n\n    @docval({'name': 'herd', 'type': 'HERD',\n             'doc': 'The external resources to be used for the container.'},)\n    def link_resources(self, **kwargs):\n        \"\"\"\n        Method to attach an instance of HERD in order to auto-add terms/references to data.\n        \"\"\"\n        self._herd = kwargs['herd']\n\n    def get_linked_resources(self):\n        return self._herd if hasattr(self, \"_herd\") else None\n\n\nclass AbstractContainer(metaclass=ExtenderMeta):\n    # The name of the class attribute that subclasses use to autogenerate properties\n    # This parameterization is supplied in case users would like to configure\n    # the class attribute name to something domain-specific\n\n    _experimental = False\n\n    _fieldsname = '__fields__'\n\n    _data_type_attr = 'data_type'\n\n    # Subclasses use this class attribute to add properties to autogenerate\n    # Autogenerated properties will store values in self.__field_values\n    __fields__ = tuple()\n\n    # This field is automatically set by __gather_fields before initialization.\n    # It holds all the values in __fields__ for this class and its parent classes.\n    __fieldsconf = tuple()\n\n    _pconf_allowed_keys = {'name', 'doc', 'settable'}\n\n    # Override the _setter factor function, so directives that apply to\n    # Container do not get used on Data\n    @classmethod\n    def _setter(cls, field):\n        \"\"\"\n        Make a setter function for creating a :py:func:`property`\n        \"\"\"\n        name = field['name']\n        if not field.get('settable', True):\n            return None\n\n        def setter(self, val):\n            if val is None:\n                return\n            if name in self.fields:\n                msg = \"can't set attribute '%s' -- already set\" % name\n                raise AttributeError(msg)\n            self.fields[name] = self._field_config(arg_name=name,\n                                                   val=val,\n                                                   type_map=self._get_type_map())\n        return setter\n\n    def _get_type_map(self):\n        from hdmf.common import get_type_map # circular import\n        return get_type_map()\n\n    @property\n    def data_type(self):\n        \"\"\"\n        Return the spec data type associated with this container.\n        \"\"\"\n        return getattr(self, self._data_type_attr)\n\n    def _field_config(self, arg_name, val, type_map):\n        \"\"\"\n        This method will be called in the setter. The termset configuration will be used (if loaded)\n        to check for a defined TermSet associated with the field. If found, the value of the field\n        will be wrapped with a TermSetWrapper.\n\n        Even though the path field in the configurator can be a list of paths, the config\n        itself is only one file. When a user loads custom configs, the config is appended/modified.\n        The modifications are not written to file, avoiding permanent modifications.\n        \"\"\"\n        configurator = type_map.type_config\n\n        if len(configurator.path)>0:\n            # The type_map has a config always set; however, when toggled off, the config path is empty.\n            CUR_DIR = os.path.dirname(os.path.realpath(configurator.path[0]))\n            termset_config = configurator.config\n        else:\n            return val\n\n        # If the val has been manually wrapped then skip checking the config for the attr\n        if isinstance(val, TermSetWrapper):\n            msg = \"Field value already wrapped with TermSetWrapper.\"\n            warn(msg)\n            return val\n\n        # check to see that the namespace for the container is in the config\n        if self.namespace not in termset_config['namespaces']:\n            msg = \"%s not found within loaded configuration.\" % self.namespace\n            warn(msg)\n            return val\n        else:\n            # check to see that the container type is in the config under the namespace\n            config_namespace = termset_config['namespaces'][self.namespace]\n            data_type = self.data_type\n\n            if data_type not in config_namespace['data_types']:\n                msg = '%s not found within the configuration for %s' % (data_type, self.namespace)\n                warn(msg)\n                return val\n            else:\n                # Get the ObjectMapper\n                obj_mapper = type_map.get_map(self)\n\n                # Get the spec for the constructor arg\n                spec = obj_mapper.get_carg_spec(arg_name)\n                if spec is None:",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 1619,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "src/hdmf/utils.py",
  "content": "    elif isinstance(argtype, type):\n        if argtype is int:\n            return __is_int(value)\n        elif argtype is float:\n            return __is_float(value)\n        elif argtype is bool:\n            return __is_bool(value)\n        return isinstance(value, argtype)\n    elif isinstance(argtype, tuple) or isinstance(argtype, list):\n        return any(check_type(value, i) for i in argtype)\n    else:  # argtype is None\n        return True\n\n\ndef __shape_okay_multi(value, argshape):\n    if type(argshape[0]) in (tuple, list):  # if multiple shapes are present\n        return any(__shape_okay(value, a) for a in argshape)\n    else:\n        return __shape_okay(value, argshape)\n\n\ndef __shape_okay(value, argshape):\n    valshape = get_data_shape(value)\n    if not len(valshape) == len(argshape):\n        return False\n    for a, b in zip(valshape, argshape):\n        if b not in (a, None):\n            return False\n    return True\n\n\ndef __is_uint(value):\n    return isinstance(value, __supported_uint_types)\n\n\ndef __is_int(value):\n    return isinstance(value, __supported_int_types)\n\n\ndef __is_float(value):\n    return isinstance(value, __supported_float_types)\n\n\ndef __is_bool(value):\n    return isinstance(value, __supported_bool_types)\n\n\ndef __format_type(argtype):\n    if isinstance(argtype, str):\n        return argtype\n    elif isinstance(argtype, type):\n        return argtype.__name__\n    elif isinstance(argtype, tuple) or isinstance(argtype, list):\n        types = [__format_type(i) for i in argtype]\n        if len(types) > 1:\n            return \"%s or %s\" % (\", \".join(types[:-1]), types[-1])",
  "start_line": 105,
  "end_line": 160,
  "total_lines": 1155,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "45:def docval_macro(macro):\n447:def docval(*validator, **options):  # noqa: C901\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "src/hdmf/utils.py",
  "content": "def __check_enum_argtype(argtype):\n    \"\"\"Return True/False whether the given argtype or list/tuple of argtypes is a supported docval enum type\"\"\"\n    if isinstance(argtype, (list, tuple)):\n        return all(x in __allowed_enum_types for x in argtype)\n    return argtype in __allowed_enum_types\n\n\ndef docval(*validator, **options):  # noqa: C901\n    '''A decorator for documenting and enforcing type for instance method arguments.\n\n    This decorator takes a list of dictionaries that specify the method parameters. These\n    dictionaries are used for enforcing type and building a Sphinx docstring.\n\n    The first arguments are dictionaries that specify the positional\n    arguments and keyword arguments of the decorated function. These dictionaries\n    must contain the following keys: ``'name'``, ``'type'``, and ``'doc'``. This will define a\n    positional argument. To define a keyword argument, specify a default value\n    using the key ``'default'``. To validate the dimensions of an input array\n    add the optional ``'shape'`` parameter. To allow a None value for an argument,\n    either the default value must be None or a different default value must be provided\n    and ``'allow_none': True`` must be passed.\n\n    The decorated method must take ``self`` and ``**kwargs`` as arguments.\n\n    When using this decorator, the functions :py:func:`getargs` and\n    :py:func:`popargs` can be used for easily extracting arguments from\n    kwargs.\n\n    The following code example demonstrates the use of this decorator:\n\n    .. code-block:: python\n\n       @docval({'name': 'arg1':,   'type': str,           'doc': 'this is the first positional argument'},\n               {'name': 'arg2':,   'type': int,           'doc': 'this is the second positional argument'},\n               {'name': 'kwarg1':, 'type': (list, tuple), 'doc': 'this is a keyword argument', 'default': list()},\n               returns='foo object', rtype='Foo'))\n       def foo(self, **kwargs):\n           arg1, arg2, kwarg1 = getargs('arg1', 'arg2', 'kwarg1', **kwargs)\n           ...\n\n    :param enforce_type: Enforce types of input parameters (Default=True)\n    :param returns: String describing the return values\n    :param rtype: String describing the data type of the return values\n    :param is_method: True if this is decorating an instance or class method, False otherwise (Default=True)\n    :param enforce_shape: Enforce the dimensions of input arrays (Default=True)\n    :param validator: :py:class:`dict` objects specifying the method parameters\n    :param allow_extra: Allow extra arguments (Default=False)\n    :param allow_positional: Allow positional arguments (Default=True)\n    :param options: additional options for documenting and validating method parameters\n    '''\n    enforce_type = options.pop('enforce_type', True)\n    enforce_shape = options.pop('enforce_shape', True)\n    returns = options.pop('returns', None)\n    rtype = options.pop('rtype', None)\n    is_method = options.pop('is_method', True)\n    allow_extra = options.pop('allow_extra', False)\n    allow_positional = options.pop('allow_positional', True)\n\n    def dec(func):\n        _docval = _copy.copy(options)\n        _docval['allow_extra'] = allow_extra\n        _docval['allow_positional'] = allow_positional\n        func.__name__ = _docval.get('func_name', func.__name__)\n        func.__doc__ = _docval.get('doc', func.__doc__)\n        pos = list()\n        kw = list()\n        for a in validator:\n            # catch unsupported keys\n            allowable_terms = ('name', 'doc', 'type', 'shape', 'enum', 'default', 'allow_none', 'help')\n            unsupported_terms = set(a.keys()) - set(allowable_terms)\n            if unsupported_terms:\n                raise Exception('docval for {}: keys {} are not supported by docval'.format(a['name'],\n                                                                                            sorted(unsupported_terms)))\n            # check that arg type is valid\n            try:\n                a['type'] = __resolve_type(a['type'])\n            except Exception as e:\n                msg = \"docval for %s: error parsing argument type: %s\" % (a['name'], e.args[0])\n                raise Exception(msg)\n            if 'enum' in a:\n                # check that value for enum key is a list or tuple (cannot have only one allowed value)\n                if not isinstance(a['enum'], (list, tuple)):\n                    msg = ('docval for %s: enum value must be a list or tuple (received %s)'\n                           % (a['name'], type(a['enum'])))\n                    raise Exception(msg)\n                # check that arg type is compatible with enum\n                if not __check_enum_argtype(a['type']):\n                    msg = 'docval for {}: enum checking cannot be used with arg type {}'.format(a['name'], a['type'])\n                    raise Exception(msg)\n                # check that enum allowed values are allowed by arg type\n                if any([not check_type(x, a['type']) for x in a['enum']]):\n                    msg = ('docval for {}: enum values are of types not allowed by arg type (got {}, '\n                           'expected {})'.format(a['name'], [type(x) for x in a['enum']], a['type']))\n                    raise Exception(msg)\n            if a.get('allow_none', False) and 'default' not in a:\n                msg = 'docval for {}: allow_none=True can only be set if a default value is provided.'.format(a['name'])\n                raise Exception(msg)\n            if 'default' in a:\n                kw.append(a)\n            else:\n                pos.append(a)\n        loc_val = pos + kw\n        _docval[__docval_args_loc] = loc_val\n\n        def _check_args(args, kwargs):\n            \"\"\"Parse and check arguments to decorated function. Raise warnings and errors as appropriate.\"\"\"\n            # this function was separated from func_call() in order to make stepping through lines of code using pdb\n            # easier\n\n            parsed = __parse_args(\n                loc_val,",
  "start_line": 440,
  "end_line": 550,
  "total_lines": 1155,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "src/hdmf/container.py",
  "content": "class Data(AbstractContainer):\n    \"\"\"\n    A class for representing dataset containers\n    \"\"\"\n    @docval({'name': 'name', 'type': str, 'doc': 'the name of this container'},\n            {'name': 'data', 'type': ('scalar_data', 'array_data', 'data'), 'doc': 'the source of the data'})\n    def __init__(self, **kwargs):\n        data = popargs('data', kwargs)\n        super().__init__(**kwargs)\n\n        self._validate_new_data(data)\n        self.__data = data\n\n    @property\n    def data(self):\n        return self.__data\n\n    @property\n    def shape(self):\n        \"\"\"\n        Get the shape of the data represented by this container\n        :return: Shape tuple\n        :rtype: tuple of ints\n        \"\"\"\n        return get_data_shape(self.__data)\n\n    def set_data_io(\n        self,\n        data_io_class: Type[DataIO],\n        data_io_kwargs: dict,\n        data_chunk_iterator_class: Optional[Type[AbstractDataChunkIterator]] = None,\n        data_chunk_iterator_kwargs: dict = None,\n    ) -> None:\n        \"\"\"\n        Apply DataIO object to the data held by this Data object.\n\n        Parameters\n        ----------\n        data_io_class: Type[DataIO]\n            The DataIO to apply to the data held by this Data.\n        data_io_kwargs: dict\n            The keyword arguments to pass to the DataIO.\n        data_chunk_iterator_class: Type[AbstractDataChunkIterator]\n            The DataChunkIterator to use for the DataIO. If None, no DataChunkIterator is used.\n        data_chunk_iterator_kwargs: dict\n            The keyword arguments to pass to the DataChunkIterator.\n\n        Notes\n        -----\n        If data_chunk_iterator_class is not None, the data is wrapped in the DataChunkIterator before being wrapped in\n        the DataIO. This allows for rewriting the backend configuration of hdf5 datasets.\n        \"\"\"\n        data_chunk_iterator_kwargs = data_chunk_iterator_kwargs or dict()\n        data = self.__data\n        if data_chunk_iterator_class is not None:\n            data = data_chunk_iterator_class(data=data, **data_chunk_iterator_kwargs)\n        self.__data = data_io_class(data=data, **data_io_kwargs)\n\n    @docval({'name': 'func', 'type': types.FunctionType, 'doc': 'a function to transform *data*'})",
  "start_line": 892,
  "end_line": 950,
  "total_lines": 1619,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "Len of Data object: 2\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "970:    def __len__(self):\n1535:    def __len__(self):\n",
  "stderr": "",
  "exit_code": 0
}