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.",
  "start_line": 796,
  "end_line": 850,
  "total_lines": 1155,
  "is_truncated": false
}

{
  "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*'})",
  "start_line": 892,
  "end_line": 950,
  "total_lines": 1619,
  "is_truncated": false
}

{
  "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",
  "stdout": "970:    def __len__(self):\n1535:    def __len__(self):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "src/hdmf/container.py",
  "content": "        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",
  "start_line": 960,
  "end_line": 980,
  "total_lines": 1619,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "Shape of [Data, Data]: (2, 2)\nShape of [Image, Image]: (2, 10, 20)\n",
  "stderr": "",
  "exit_code": 0
}

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

{
  "status": "ok",
  "filepath": "src/hdmf/container.py",
  "content": "        if len(kwargs) != 1:\n            raise ValueError(\"only one column can be queried\")\n        colname, value = kwargs.popitem()\n        idx = self.__colidx__.get(colname)\n        if idx is None:\n            msg = \"no '%s' column in %s\" % (colname, self.__class__.__name__)\n            raise KeyError(msg)\n        ret = list()\n        for i in range(len(self.data)):\n            row = self.data[i]\n            row_val = row[idx]\n            if row_val == value:\n                ret.append(i)\n        return ret\n\n    def __len__(self):\n        return len(self.data)\n\n    def __getitem__(self, args):\n        idx = args\n        col = None\n        if isinstance(args, tuple):\n            idx = args[1]\n            if isinstance(args[0], str):\n                col = self.__col_index.get(args[0])\n            elif isinstance(args[0], int):\n                col = args[0]\n            else:\n                raise KeyError('first argument must be a column name or index')\n            return self.data[idx][col]\n        elif isinstance(args, str):",
  "start_line": 1520,
  "end_line": 1550,
  "total_lines": 1619,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "src/hdmf/container.py",
  "content": "                setattr(cls, '__init__', __init__)\n\n            if cls.add_row == bases[-1].add_row:  # check if add_row is overridden\n\n                @docval(*columns)\n                def add_row(self, **kwargs):\n                    return super(cls, self).add_row(kwargs)\n\n                setattr(cls, 'add_row', add_row)\n\n    @docval({'name': 'columns', 'type': (list, tuple), 'doc': 'a list of the columns in this table'},\n            {'name': 'name', 'type': str, 'doc': 'the name of this container'},\n            {'name': 'data', 'type': ('array_data', 'data'), 'doc': 'the source of the data', 'default': list()})\n    def __init__(self, **kwargs):\n        self.__columns = tuple(popargs('columns', kwargs))\n        self.__col_index = {name: idx for idx, name in enumerate(self.__columns)}\n        if getattr(self, '__rowclass__') is not None:\n            self.row = RowGetter(self)\n        super().__init__(**kwargs)\n\n    @property\n    def columns(self):\n        return self.__columns\n\n    @docval({'name': 'values', 'type': dict, 'doc': 'the values for each column'})\n    def add_row(self, **kwargs):\n        values = getargs('values', kwargs)\n        if not isinstance(self.data, list):\n            msg = 'Cannot append row to %s' % type(self.data)\n            raise ValueError(msg)\n        ret = len(self.data)\n        row = [values[col] for col in self.columns]\n        row = [v.idx if isinstance(v, Row) else v for v in row]\n        self.data.append(tuple(row))\n        return ret\n\n    def which(self, **kwargs):\n        '''\n        Query a table\n        '''\n        if len(kwargs) != 1:\n            raise ValueError(\"only one column can be queried\")\n        colname, value = kwargs.popitem()\n        idx = self.__colidx__.get(colname)\n        if idx is None:\n            msg = \"no '%s' column in %s\" % (colname, self.__class__.__name__)\n            raise KeyError(msg)\n        ret = list()\n        for i in range(len(self.data)):\n            row = self.data[i]\n            row_val = row[idx]\n            if row_val == value:\n                ret.append(i)\n        return ret\n\n    def __len__(self):",
  "start_line": 1480,
  "end_line": 1535,
  "total_lines": 1619,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "src/hdmf/container.py",
  "content": "    '''\n\n    # This class attribute is used to indicate which Row class should be used when\n    # adding RowGetter functionality to the Table.\n    __rowclass__ = None\n\n    @ExtenderMeta.pre_init\n    def __build_table_class(cls, name, bases, classdict):\n        if hasattr(cls, '__columns__'):\n            columns = getattr(cls, '__columns__')\n\n            idx = dict()\n            for i, col in enumerate(columns):\n                idx[col['name']] = i\n            setattr(cls, '__colidx__', idx)\n\n            if cls.__init__ == bases[-1].__init__:  # check if __init__ is overridden\n                name = {'name': 'name', 'type': str, 'doc': 'the name of this table'}\n                defname = getattr(cls, '__defaultname__', None)\n                if defname is not None:\n                    name['default'] = defname  # override the name with the default name if present\n\n                @docval(name,\n                        {'name': 'data', 'type': ('array_data', 'data'), 'doc': 'the data in this table',\n                         'default': list()})\n                def __init__(self, **kwargs):\n                    name, data = getargs('name', 'data', kwargs)\n                    colnames = [i['name'] for i in columns]\n                    super(cls, self).__init__(colnames, name, data)\n\n                setattr(cls, '__init__', __init__)",
  "start_line": 1450,
  "end_line": 1480,
  "total_lines": 1619,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "20:    \"\"\"Set a class as being experimental\"\"\"\n34:class HERDManager:\n36:    This class manages whether to set/attach an instance of HERD to the subclass.\n52:    # The name of the class attribute that subclasses use to autogenerate properties\n54:    # the class attribute name to something domain-specific\n62:    # Subclasses use this class attribute to add properties to autogenerate\n67:    # It holds all the values in __fields__ for this class and its parent classes.\n220:        This classmethod will be called during class declaration in the metaclass to automatically\n236:        # check whether this class overrides __fields__\n251:                # prepend field specs from base class to fields list of this class\n282:        Static method of the object class called by Python to create the object first and then\n426:        Subclasses use this class attribute to add properties to autogenerate.\n563:        \"\"\"Returns a list of setter functions for the given field to be added to the class during class declaration.\"\"\"\n703:        This function can be overwritten by a child class to implement customized html representations.\n761:            object_class = array.__class__.__name__\n887:        if data_chunk_iterator_class is not None:\n894:    A class for representing dataset containers\n946:        if data_chunk_iterator_class is not None:\n1013:class MultiContainerInterface(Container):\n1016:    To use, extend this class and create a dictionary as a class attribute with any of the following keys:\n1030:            raise TypeError(\"Can't instantiate class MultiContainerInterface.\")\n1032:            raise TypeError(\"MultiContainerInterface subclass %s is missing __clsconf__ attribute. Please check that \"\n1033:                            \"the class is properly defined.\" % cls.__name__)\n1239:        This method is called prior to __new__ and __init__ during class declaration in the metaclass.\n1251:            raise TypeError(\"'__clsconf__' for MultiContainerInterface subclass %s must be a dict or a list of \"\n1264:        # i.e. it is the same method as the parent class constructor\n1273:            msg = \"MultiContainerInterface subclass %s is missing 'add' key in __clsconf__\" % cls.__name__\n1281:            msg = \"MultiContainerInterface subclass %s is missing 'attr' key in __clsconf__\" % cls.__name__\n1289:            msg = \"MultiContainerInterface subclass %s is missing 'type' key in __clsconf__\" % cls.__name__\n1310:                msg = (\"Cannot specify 'create' key in __clsconf__ for MultiContainerInterface subclass %s \"\n1322:class Row(object, metaclass=ExtenderMeta):\n1324:    A class for representing rows from a Table.\n1326:    The Table class can be indicated with the __table__. Doing so\n1327:    will set constructor arguments for the Row class and ensure that\n1329:    also add functionality to the Table class for getting Row objects.\n1331:    Note, the Row class is not needed for working with Table objects. This\n1409:class RowGetter:\n1411:    A simple class for providing __getitem__ functionality that returns\n1430:    Subclasses should specify the class attribute \\_\\_columns\\_\\_.\n1443:    The class attribute __defaultname__ can also be set to specify a default name\n1445:    need to be specified when the class is instantiated.\n1447:    A Table class can be paired with a Row class for conveniently working with rows of\n1448:    a Table. This pairing must be indicated in the Row class implementation. See Row\n1452:    # This class attribute is used to indicate which Row class should be used when\n1591:                'unrecognized column(s) {} for table class {} (columns {})'.format(\n1602:                'missing column(s) {} for table class {} (columns {}, provided {})'.format(\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "1428:class Table(Data):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "892:class Data(AbstractContainer):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "src/hdmf/utils.py",
  "content": "    '''\n    func_docval = getattr(func, docval_attr_name, None)\n    if func_docval:\n        if args:\n            docval_idx = getattr(func, docval_idx_name, None)\n            try:\n                return tuple(docval_idx[name] for name in args)\n            except KeyError as ke:\n                raise ValueError('Function %s does not have docval argument %s' % (func.__name__, str(ke)))\n        return tuple(func_docval[__docval_args_loc])\n    else:\n        if args:\n            raise ValueError('Function %s has no docval arguments' % func.__name__)\n        return tuple()\n\n\ndef __resolve_type(t):\n    if t is None:\n        return t\n    if isinstance(t, str):\n        if t in __macros:\n            return tuple(__macros[t])\n        else:\n            return t\n    elif isinstance(t, type):\n        return t\n    elif isinstance(t, (list, tuple)):\n        ret = list()\n        for i in t:\n            resolved = __resolve_type(i)\n            if isinstance(resolved, tuple):\n                ret.extend(resolved)\n            else:\n                ret.append(resolved)\n        return tuple(ret)\n    else:\n        msg = \"argtype must be a type, a str, a list, a tuple, or None - got %s\" % type(t)\n        raise ValueError(msg)\n\n\ndef __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",
  "start_line": 400,
  "end_line": 500,
  "total_lines": 1155,
  "is_truncated": false
}