read text from filepath (`open(find_filepath(expand_filepath(fp)))`) then json.loads()
    
    >>> read_json('HTTP_1.1  Status Code Definitions.html.json')
    {'100': 'Continue',
     '101': 'Switching Protocols',...
511409
def read_json(filepath, intkeys=True, intvalues=True):
    
    d = json.load(ensure_open(find_filepath(filepath), mode='rt'))
    d = update_dict_types(d, update_keys=intkeys, update_values=intvalues)
    return d
605833
function readJSON(path) {
  return new Promise(function ($return, $error) {
    var file, parsed;
    return Promise.resolve(read(path)).then(function ($await_1) {
      try {
        file = $await_1;
        parsed = JSON.parse(file);
        return $return(parsed);
      } catch ($boundEx) {
        return $error($boundEx);
      }
    }.bind(this), $error);
  }.bind(this));
}
172022
def read_json_document(title):
    
    if not title.endswith('.json'):
        juicer.utils.Log.log_warn("File name (%s) does not end with '.json', appending it automatically." % title)
        title += '.json'

    if not os.path.exists(title):
        raise IOError("Could not find file: '%s'" % title)

    f = open(title, 'r')
    doc = f.read()
    f.close()

    return load_json_str(doc)
268544
def read_strings_file(path)
      raise ArgumentError, "File '#{path}' doesn't exist" unless path.exist?
      raise ArgumentError, "File '#{path}' is not a file" unless path.file?
      error = `plutil -lint -s "#{path}" 2>&1`
      raise ArgumentError, "File %s is malformed:\n#{error}" % path.to_s unless $?.success?
      json_or_error = `plutil -convert json "#{path}" -o -`.chomp
      raise ArgumentError, "File %s couldn't be converted to JSON.\n#{json_or_error}" % path.to_s unless $?.success?
      JSON.parse(json_or_error.force_encoding('UTF-8'))
    rescue EncodingError => e
      raise StandardError, "Encoding error in #{path}: #{e}"
    end
433432
def read_json(self):
        
        line = self.stdin.readline()
        if line == '':
            raise EOFError()
        return json.loads(line)
469107
def _parse_content(self, text):
        '''
        '''
        try:
            return json.loads(text)
        except ValueError:
            raise exc.UnexpectedlyNotJSON(
                "The resource at {.uri} wasn't valid JSON", self)
1167884
def read_json_file(fpath):
    
    if not os.path.exists(fpath):
        raise Exception('ERROR: file %s does not exist.' % fpath)
    with open(fpath, 'r') as fh:
        raw = fh.read()
    res = json.loads(raw)
    return res
1310033
def loadJson(self, filename):
        
        jsonConfig = {}
        if os.path.isfile(filename):
            jsonConfig = json.loads(' '.join(open(filename, 'r').readlines()))
        return jsonConfig
1263315
def load_json(filename, **kwargs):
    

    with open(filename, 'r', encoding='utf-8') as f:
        return json.load(f, **kwargs)
686455
def read(self, src):
        
        geojson = None
        if not self.is_valid_src(src):
            error = "File < {0} > does not exists or does start with 'http'."
            raise ValueError(error.format(src))
        if not self.is_url(src):
            return open(src, 'r').read().decode('latin-1').encode('utf-8')
        tmp = self.get_location(src)
        # if src poits to url that was already downloaded
        # read from local file instead
        if os.path.isfile(tmp):
            with open(tmp, 'r') as f:
                return f.read()
        # download file and write to local filesystem before returning
        response = urllib2.urlopen(src)
        data = response.read().decode('latin-1').encode('utf-8')
        with open(tmp, 'w') as f:
            f.write(data)
            return data
33235
def _load_json_file_or_url(self, json_path_or_url):
        '''
        '''
        try:
            if os.path.isfile(json_path_or_url):
                with open(json_path_or_url, 'r') as f:
                    result = json.load(f)
            else:
                res = requests.get(json_path_or_url)
                res.raise_for_status()
                result = res.json()

            return result

        except (ValueError,
                requests.exceptions.RequestException) as e:
            six.raise_from(DataPackageRegistryException(e), e)
416496
def read(cls, data):
        
        if isinstance(data, OrderedDict):
            return cls(data)
        elif isinstance(data, basestring)\
             and data.startswith(("http://", "https://", "ftp://", "ftps://")):
            return cls(request(data))
        elif isinstance(data, basestring):
            try:
                json_dict = json.loads(data, object_pairs_hook=OrderedDict)
                return cls(json_dict)
            except ValueError:
                raise
        else:
            try:
                json_dict = json.load(data, object_pairs_hook=OrderedDict)
                return cls(json_dict)
            except ValueError:
                raise
918641
def _read_jsonl(filepath, kwargs):
    """"""
    with open(filepath) as data_file:
        data = [json.loads(line, **kwargs)
                for line in data_file
                if len(line) > 0]
    return data
198042
def read_file
      json_string = ''
      if ApiExplorer::use_file
        json_path = ApiExplorer::json_path
        json_string = File.read(json_path)
      else
        json_string = ApiExplorer::json_string
      end
       
      @methods = JSON.parse(json_string)["methods"]
    end
158003
def read_json(location):
    
    location = ensure_path(location)
    with location.open('r', encoding='utf8') as f:
        return ujson.load(f)
92779
def read_json_file(path):
    

    with open(path, 'r', encoding='utf-8') as f:
        data = json.load(f)

    return data
595806
def load_swagger_spec(self, filepath=None):
        
        if filepath is True or filepath is None:
            filepath = self.file_spec.format(server=self.server)

        return json.load(open(filepath))