o Pεi*@sdZddlZddlZddlZddlZeeeeeeje ej e e ej ej e e iZGdddeZGdddeeZGdddeZGd d d eZGd d d eZdddZdS)z jsonlines implementation Nc@seZdZdZdS)ErrorzBase error class.N)__name__ __module__ __qualname____doc__rrG/home/ubuntu/.local/lib/python3.10/site-packages/jsonlines/jsonlines.pyrsrcs(eZdZdZdZdZfddZZS)InvalidLineErrora Error raised when an invalid line is encountered. This happens when the line does not contain valid JSON, or if a specific data type has been requested, and the line contained a different data type. The original line itself is stored on the exception instance as the ``.line`` attribute, and the line number as ``.lineno``. This class subclasses both ``jsonlines.Error`` and the built-in ``ValueError``. Ncs0d||}||_||_tt||dS)Nz {} (line {}))formatrstriplinelinenosuperr __init__)selfmsgr r  __class__rrr0s  zInvalidLineError.__init__)rrrrr r r __classcell__rrrrr s r c@s0eZdZdZddZddZddZdd Zd S) ReaderWriterBasezJ Base class with shared behaviour for both the reader and writer. cCs(|jrdSd|_|jr|jdSdS)z Close this reader/writer. This closes the underlying file if that file has been opened by this reader/writer. When an already opened file-like object was provided, the caller is responsible for closing it. NT)_closed_should_close_fp_fpcloserrrrr;s zReaderWriterBase.closecCsNt|jdd}|rt|}n dt|jjt|j}dt|jt||S)Nnamez<{} at 0x{:x}>z$)getattrrreprr typerid)rrwrappingrrr__repr__Is  zReaderWriterBase.__repr__cCs|SNrrrrr __enter__TszReaderWriterBase.__enter__cGs |dS)NF)r)rexc_inforrr__exit__WszReaderWriterBase.__exit__N)rrrrrr!r#r%rrrrr7s  rc@s:eZdZdZd ddZd ddZ  ddd Zd d ZdS)Readera Reader for the jsonlines format. The first argument must be an iterable that yields JSON encoded strings. Usually this will be a readable file-like object, such as an open file or an ``io.TextIO`` instance, but it can also be something else as long as it yields strings when iterated over. The `loads` argument can be used to replace the standard json decoder. If specified, it must be a callable that accepts a (unicode) string and returns the decoded object. Instances are iterable and can be used as a context manager. :param file-like iterable: iterable yielding lines as strings :param callable loads: custom json decoder callable NcCs6||_d|_d|_|durtj}||_t|d|_dS)NF)rrrjsonloads_loads enumerate _line_iter)riterabler)rrrrnszReader.__init__Fc Cs|jrtd|dur|tvrtdzt|j\}}|r.|s.t|j\}}|r.|r!Wnty>t t dYnwt |tj rnz| d}Wn!tym}ztd|||}t ||WYd}~nd}~wwz||}Wn!ty}ztd|||}t ||WYd}~nd}~ww|dur|rdStd|||durt |t|} |ttjfvr| ot |t } | std|||S) a Read and decode a line. The optional `type` argument specifies the expected data type. Supported types are ``dict``, ``list``, ``str``, ``int``, ``float``, ``numbers.Number`` (accepts both integers and floats), and ``bool``. When specified, non-conforming lines result in :py:exc:`InvalidLineError`. By default, input lines containing ``null`` (in JSON) are considered invalid, and will cause :py:exc:`InvalidLineError`. The `allow_none` argument can be used to change this behaviour, in which case ``None`` will be returned instead. If `skip_empty` is set to ``True``, empty lines and lines containing only whitespace are silently skipped. zreader is closedNzinvalid type specifiedutf-8zline is not valid utf-8: {}zline contains invalid json: {}zline contains null valuez"line does not match requested type)r RuntimeError TYPE_MAPPING ValueErrornextr,r StopIterationsix raise_fromEOFError isinstance binary_typedecodeUnicodeDecodeErrorr r r*intnumbersNumberbool) rr allow_none skip_emptyr r orig_excexcvaluevalidrrrreadwsb    z Reader.readccsLz z |j|||dVWn ty|sYnwqty%YdSw)a Iterate over all lines. This is the iterator equivalent to repeatedly calling :py:meth:`~Reader.read()`. If no arguments are specified, this is the same as directly iterating over this :py:class:`Reader` instance. When `skip_invalid` is set to ``True``, invalid lines will be silently ignored. See :py:meth:`~Reader.read()` for a description of the other arguments. T)rr?r@N)rEr r6)rrr?r@ skip_invalidrrriters$  z Reader.itercCs|S)z0 See :py:meth:`~Reader.iter()`. )rGrrrr__iter__szReader.__iter__r")NFF)NFFF)rrrrrrErGrHrrrrr&\s  ? r&c@s,eZdZdZ d ddZddZdd ZdS) Writera Writer for the jsonlines format. The `fp` argument must be a file-like object with a ``.write()`` method accepting either text (unicode) or bytes. The `compact` argument can be used to to produce smaller output. The `sort_keys` argument can be used to sort keys in json objects, and will produce deterministic output. For more control, provide a a custom encoder callable using the `dumps` argument. The callable must produce (unicode) string output. If specified, the `compact` and `sort` arguments will be ignored. When the `flush` argument is set to ``True``, the writer will call ``fp.flush()`` after each written line. Instances can be used as a context manager. :param file-like fp: writable file-like object :param bool compact: whether to use a compact output format :param bool sort_keys: whether to sort object keys :param callable dumps: custom encoder callable :param bool flush: whether to flush the file-like object after writing each line FNcCsd|_z |dd|_Wn tyd|_Ynw|dur5td|d}|r,|jddtjdi|j}||_ d|_ ||_ ||_ dS)NFT) ensure_ascii sort_keys),:) separatorsr) rwrite _fp_is_binary TypeErrordictupdater( JSONEncoderencoderr_dumps_flush)rfpcompactrLdumpsflushencoder_kwargsrrrrs        zWriter.__init__cCs|jrtd||}|jr't|tjs|d}|j ||j dnt|tj s2| d}|j ||j d|j rH|j dSdS)zg Encode and write a single object. :param obj: the object to encode and write zwriter is closedr. ascii N)rr/rWrQr7r4r8rVrrP text_typer9rXr\)robjr rrrrPs        z Writer.writecCs|D]}||qdS)ze Encode and write multiple objects. :param iterable: an iterable of objects N)rP)rr-rbrrr write_all"s zWriter.write_all)FFNF)rrrrrrPrcrrrrrIs   rIrcKsX|dvrtdtj||ddd}|dkrt|fi|}nt|fi|}d|_|S)a Open a jsonlines file for reading or writing. This is a convenience function that opens a file, and wraps it in either a :py:class:`Reader` or :py:class:`Writer` instance, depending on the specified `mode`. Any additional keyword arguments will be passed on to the reader and writer: see their documentation for available options. The resulting reader or writer must be closed after use by the caller, which will also close the opened file. This can be done by calling ``.close()``, but the easiest way to ensure proper resource finalisation is to use a ``with`` block (context manager), e.g. :: with jsonlines.open('out.jsonl', mode='w') as writer: writer.write(...) :param file-like fp: name of the file to open :param str mode: whether to open the file for reading (``r``), writing (``w``) or appending (``a``). :param \*\*kwargs: additional arguments, forwarded to the reader or writer >ardwz&'mode' must be either 'r', 'w', or 'a'tr.)modeencodingrdT)r1ioopenr&rIr)rrhkwargsrYinstancerrrrk,srk)rd)rr<rjr(r4rSliststrrar; integer_typesfloatr=r>r0 Exceptionrr1r objectrr&rIrkrrrrs& %~R