.. todo:: docstring for get_data
498458
def get_data(self, datatype, mode, disp):
        

        # Imports
        import os
        from ..const import EnumDispDirection as _E_DD
        from ..const import EnumAnharmRepoData
        from ..error import RepoError as RErr

        # Must be valid mode
        if not (mode >=0 and isinstance(mode, int)):
            raise ValueError("Mode must be a non-negative integer")
        ## end if

        # Must be a valid disp direction
        if not disp in _E_DD:
            raise ValueError("'{0}' is not a valid " +
                    "displacement enum value".format(disp))
        ## end if

        # Must be a valid data type
        if not datatype in EnumAnharmRepoData:
            raise ValueError("'{0}' is not a valid " +
                    "repository data type enum value".format(datatype))
        ## end if

        # Get the appropriate geom group name
        if disp == _E_DD.NO_DISP:
            grpname = self.G_geom_ref
        else:
            grpname = self.F_mode_fmt % \
                                    (mode, self.dircode[disp])
        ## end if

        # Get the group, complaining if repo not bound
        try:
            grp = self._repo.get(grpname)
        except AttributeError:
            raise RErr(RErr.STATUS,
                        "Cannot load; no repository open", "")
        ## end try

        # If succeeded, check if group not found
        if grp is None:
            raise RErr(RErr.GROUP,
                    "Group '" + grpname + "' not found",
                    self.fname)
        ## end if

        # Group found, try loading the data object; complain if not found
        try:
            out_data = grp.get(datatype).value
        except AttributeError:
            raise RErr(RErr.DATA,
                    "Dataset '" + datatype + "' not found",
                    self.fname)
        ## end try

        # Return as-is (h5py creates NumPy arrays of appropriate dimensions)
        return out_data
1283832
def get_data(self):
        
        try:
            return DocumentDataDict(self.__dict__['data'])
        except KeyError:
            self._lazy_load()
            return DocumentDataDict(self.__dict__['data'])
1139315
def getData(self, type: str) -> str:
        
        return self.__data.get(normalize_type(type), '')
1089574
def rpc_get_docstring(self, filename, source, offset):
        
        return self._call_backend("rpc_get_docstring", None, filename,
                                  get_source(source), offset)
797330
def getmethattr(obj, meth):
  
  if hasmethod(obj, meth):
    return getattr(obj, meth)()
  elif hasvar(obj, meth):
    return getattr(obj, meth)
  return None
259296
def GET(self, func, data):
        
        if func not in ['getRegisterUserInfo']:
            s, message = self.checkAccount()

            if s is False:
                return False, message

        url = nurls[func]
        r = self.session.get(url, params = data)
        r.encoding = 'utf-8'

        if self.debug:
            print r.text

        try:
            try:
                metadata = json.loads(r.text)
            except:
                metadata = json.loads(r.text[r.text.find('{'):-1])

            message = metadata['message']
            if message == 'success':
                return True, metadata['resultvalue']
            else:
                return False, message
        except:
            for e in sys.exc_info():
                print e
            sys.exit(1)
            return False, "Error %s: Failed to send GET request" %func
559853
def _get_doc():
    ''''''
    def get_docstring(func):
        '''extract doctstring, if possible'''
        docstring = ':\n'
        if func.__doc__:
            docstring += _indent(func.__doc__, 2)
        return docstring

    ret = ['\nNeurite features (neurite, neuron, neuron population):']
    ret.extend(_INDENT + '- ' + feature + get_docstring(func)
               for feature, func in sorted(NEURITEFEATURES.items()))

    ret.append('\nNeuron features (neuron, neuron population):')
    ret.extend(_INDENT + '- ' + feature + get_docstring(func)
               for feature, func in sorted(NEURONFEATURES.items()))

    return '\n'.join(ret)
45525
function dataToObjects (data) {
  if (!data) return null
  if (data instanceof Array) {
    return data.map(function(doc) { 
      return doc.toObject()
    })
  }
  return data.toObject()
}
1002736
def get(path,data={},headers=nil)
      data_to_query(data)
      if headers == nil
        response = @http.send_request('GET', path, @defaults[:data])
      else
        response = @http.send_request('GET', path, @defaults[:data], headers)
      end
      response
    end
1241577
def get_data(self, request=None):
        """"""
        if request is None:
            raise ValueError
        data = [[] for _ in self.sources]
        for i in range(request):
            try:
                for source_data, example in zip(
                        data, next(self.child_epoch_iterator)):
                    source_data.append(example)
            except StopIteration:
                # If some data has been extracted and `strict` is not set,
                # we should spit out this data before stopping iteration.
                if not self.strictness and data[0]:
                    break
                elif self.strictness > 1 and data[0]:
                    raise ValueError
                raise
        return tuple(numpy.asarray(source_data) for source_data in data)
368843
def data(self):
        
        d = {}
        for key in self._data:
            if key == "plugins":
                d[key] = self.plugins.data()
            else:
                try:
                    d[key] = getattr(self, key)
                except AttributeError:
                    pass  # unknown key, just leave it unchanged
        return d
449060
def datagetter(cls):
        
        with open('myfile', 'rt') as f:
            rows = [r for r in csv.reader(f)]
        dothing = lambda _: [i for i, v in enumerate(_)]
        rows = [dothing(_) for _ in rows]
        raise NotImplementedError('You need to implement this yourlself!')
        return rows
721425
def data
      @data ||= begin
        list = @xml.find('/e:epp/e:response/e:resData/node()').reject { |n| n.empty? }
        list.size > 1 ? list : list[0]
      end
    end
943316
def get(self, method_name):
        
        proto = get_um(method_name)
        if proto is None:
            return None
        message = proto()
        self._data[message] = method_name
        return message
1083682
def get_data_request(data_request_id, opts = {})
      data, _status_code, _headers = get_data_request_with_http_info(data_request_id, opts)
      data
    end
973843
function get_data() {
        $data = parent::get_data();

        if ($data !== null and isset($data->description)) {
            $data->descriptionformat = $data->description['format'];
            $data->description = $data->description['text'];
        }

        return $data;
    }
1339145
def get_data(self):
        
        # NOTE: we assume that the "embed" option is used
        base64_data = self._json_data.get("fdData")
        if base64_data is None:
            return None
        else:
            # need to convert to bytes() with python 3
            return base64.decodestring(six.b(base64_data))