code: def read_json(
      path_or_buf=None,
      orient=None,
      typ="frame",
      dtype=True,
      convert_axes=True,
      convert_dates=True,
      keep_default_dates=True,
      numpy=False,
      precise_float=False,
      date_unit=None,
      encoding=None,
      lines=False,
      chunksize=None,
      compression="infer",
  ):
      """
      Convert a JSON string to pandas object.
  
      Parameters
      ----------
      path_or_buf : a valid JSON string or file-like, default: None
          The string could be a URL. Valid URL schemes include http, ftp, s3,
          gcs, and file. For file URLs, a host is expected. For instance, a local
          file could be ``file://localhost/path/to/table.json``
  
      orient : string,
          Indication of expected JSON string format.
          Compatible JSON strings can be produced by ``to_json()`` with a
          corresponding orient value.
          The set of possible orients is:
  
          - ``'split'`` : dict like
            ``{index -> [index], columns -> [columns], data -> [values]}``
          - ``'records'`` : list like
            ``[{column -> value}, ... , {column -> value}]``
          - ``'index'`` : dict like ``{index -> {column -> value}}``
          - ``'columns'`` : dict like ``{column -> {index -> value}}``
          - ``'values'`` : just the values array
  
          The allowed and default values depend on the value
          of the `typ` parameter.
  
          * when ``typ == 'series'``,
  
            - allowed orients are ``{'split','records','index'}``
            - default is ``'index'``
            - The Series index must be unique for orient ``'index'``.
  
          * when ``typ == 'frame'``,
  
            - allowed orients are ``{'split','records','index',
              'columns','values', 'table'}``
            - default is ``'columns'``
            - The DataFrame index must be unique for orients ``'index'`` and
              ``'columns'``.
            - The DataFrame columns must be unique for orients ``'index'``,
              ``'columns'``, and ``'records'``.
  
          .. versionadded:: 0.23.0
             'table' as an allowed value for the ``orient`` argument
  
      typ : type of object to recover (series or frame), default 'frame'
      dtype : boolean or dict, default True
          If True, infer dtypes, if a dict of column to dtype, then use those,
          if False, then don't infer dtypes at all, applies only to the data.
      convert_axes : boolean, default True
          Try to convert the axes to the proper dtypes.
      convert_dates : boolean, default True
          List of columns to parse for dates; If True, then try to parse
          datelike columns default is True; a column label is datelike if
  
          * it ends with ``'_at'``,
  
          * it ends with ``'_time'``,
  
          * it begins with ``'timestamp'``,
  
          * it is ``'modified'``, or
  
          * it is ``'date'``
  
      keep_default_dates : boolean, default True
          If parsing dates, then parse the default datelike columns
      numpy : boolean, default False
          Direct decoding to numpy arrays. Supports numeric data only, but
          non-numeric column and index labels are supported. Note also that the
          JSON ordering MUST be the same for each term if numpy=True.
      precise_float : boolean, default False
          Set to enable usage of higher precision (strtod) function when
          decoding string to double values. Default (False) is to use fast but
          less precise builtin functionality
      date_unit : string, default None
          The timestamp unit to detect if converting dates. The default behaviour
          is to try and detect the correct precision, but if this is not desired
          then pass one of 's', 'ms', 'us' or 'ns' to force parsing only seconds,
          milliseconds, microseconds or nanoseconds respectively.
      encoding : str, default is 'utf-8'
          The encoding to use to decode py3 bytes.
  
          .. versionadded:: 0.19.0
  
      lines : boolean, default False
          Read the file as a json object per line.
  
          .. versionadded:: 0.19.0
  
      chunksize : integer, default None
          Return JsonReader object for iteration.
          See the `line-delimted json docs
          <http://pandas.pydata.org/pandas-docs/stable/io.html#io-jsonl>`_
          for more information on ``chunksize``.
          This can only be passed if `lines=True`.
          If this is None, the file will be read into memory all at once.
  
          .. versionadded:: 0.21.0
  
      compression : {'infer', 'gzip', 'bz2', 'zip', 'xz', None}, default 'infer'
          For on-the-fly decompression of on-disk data. If 'infer', then use
          gzip, bz2, zip or xz if path_or_buf is a string ending in
          '.gz', '.bz2', '.zip', or 'xz', respectively, and no decompression
          otherwise. If using 'zip', the ZIP file must contain only one data
          file to be read in. Set to None for no decompression.
  
          .. versionadded:: 0.21.0
  
      Returns
      -------
      result : Series or DataFrame, depending on the value of `typ`.
  
      See Also
      --------
      DataFrame.to_json
  
      Notes
      -----
      Specific to ``orient='table'``, if a :class:`DataFrame` with a literal
      :class:`Index` name of `index` gets written with :func:`to_json`, the
      subsequent read operation will incorrectly set the :class:`Index` name to
      ``None``. This is because `index` is also used by :func:`DataFrame.to_json`
      to denote a missing :class:`Index` name, and the subsequent
      :func:`read_json` operation cannot distinguish between the two. The same
      limitation is encountered with a :class:`MultiIndex` and any names
      beginning with ``'level_'``.
  
      Examples
      --------
  
      >>> df = pd.DataFrame([['a', 'b'], ['c', 'd']],
      ...                   index=['row 1', 'row 2'],
      ...                   columns=['col 1', 'col 2'])
  
      Encoding/decoding a Dataframe using ``'split'`` formatted JSON:
  
      >>> df.to_json(orient='split')
      '{"columns":["col 1","col 2"],
        "index":["row 1","row 2"],
        "data":[["a","b"],["c","d"]]}'
      >>> pd.read_json(_, orient='split')
            col 1 col 2
      row 1     a     b
      row 2     c     d
  
      Encoding/decoding a Dataframe using ``'index'`` formatted JSON:
  
      >>> df.to_json(orient='index')
      '{"row 1":{"col 1":"a","col 2":"b"},"row 2":{"col 1":"c","col 2":"d"}}'
      >>> pd.read_json(_, orient='index')
            col 1 col 2
      row 1     a     b
      row 2     c     d
  
      Encoding/decoding a Dataframe using ``'records'`` formatted JSON.
      Note that index labels are not preserved with this encoding.
  
      >>> df.to_json(orient='records')
      '[{"col 1":"a","col 2":"b"},{"col 1":"c","col 2":"d"}]'
      >>> pd.read_json(_, orient='records')
        col 1 col 2
      0     a     b
      1     c     d
  
      Encoding with Table Schema
  
      >>> df.to_json(orient='table')
      '{"schema": {"fields": [{"name": "index", "type": "string"},
                              {"name": "col 1", "type": "string"},
                              {"name": "col 2", "type": "string"}],
                      "primaryKey": "index",
                      "pandas_version": "0.20.0"},
          "data": [{"index": "row 1", "col 1": "a", "col 2": "b"},
                  {"index": "row 2", "col 1": "c", "col 2": "d"}]}'
      """
  
      compression = _infer_compression(path_or_buf, compression)
      (
          filepath_or_buffer,
          _,
          compression,
          should_close,
      ) = get_filepath_or_buffer(
          path_or_buf,
          encoding=encoding,
          compression=compression,
      )
  
      json_reader = JsonReader(
          filepath_or_buffer,
          orient=orient,
          typ=typ,
          dtype=dtype,
          convert_axes=convert_axes,
          convert_dates=convert_dates,
          keep_default_dates=keep_default_dates,
          numpy=numpy,
          precise_float=precise_float,
          date_unit=date_unit,
          encoding=encoding,
          lines=lines,
          chunksize=chunksize,
          compression=compression,
      )
  
      if chunksize:
          return json_reader
  
      result = json_reader.read()
      if should_close:
          try:
              filepath_or_buffer.close()
          except:  # noqa: flake8
              pass
      return result
  
imports: from itertools import islice
  import os
  import numpy
  import pandas._libs.json
  from pandas._libs.tslibs import iNaT
  from pandas.compat import StringIO, long, to_str, u
  from pandas.errors import AbstractMethodError
  from pandas.core.dtypes.common import is_period_dtype
  from pandas import DataFrame, MultiIndex, Series, compat, isna, to_datetime
  from pandas.core.reshape.concat import concat
  from pandas.io.common import BaseIterator, _get_handle, _infer_compression, _stringify_path, get_filepath_or_buffer
  from pandas.io.formats.printing import pprint_thing
  from pandas.io.parsers import _validate_integer
  from .normalize import _convert_to_line_delimits
  from .table_schema import build_table_schema, parse_table_schema
label_desc: Use image node_id 2 for calling a global function with example usage: read_json(path_or_buf, orient, typ, dtype, convert_axes, convert_dates, keep_default_dates, numpy, precise_float, date_unit, encoding, lines, chunksize, compression) and returns: result, json_reader