File: //usr/local/CyberCP/lib/python3.10/site-packages/jsonlines/__pycache__/jsonlines.cpython-310.pyc
o
�h�M � @ s� U d Z ddlZddlZddlZddlZddlZddlZddlZddlZddlm Z m
Z
m Z m Z m
Z
mZmZmZmZmZmZmZmZmZ ddlZeej ed< zddlZW n ey_ dZY nw eej ed< zddl Z W n eyx dZ Y nw e e e e e!e"hZ#dej$�%� fZ&G dd� dej'�Z(ee"e)e ej*f Z+e
ee"e)f ge f Z,e
e gee"e)f f Z-ee e"e f ee f Z.ee e e e"f Z/ee.e/f Z0ed e0d
�Z1ed d d
�Z2edur�ej3Z4n e dur�e j3Z4nej3Z4d
e de"fdd�Z5ej6ddd�G dd� de7��Z8ej6dddd�G dd� de8e9��Z:ej6ddd�G dd � d ��Z;ej6ddd�G dd � d e;��Z<ej6ddd�G d d � d e;��Z=e d4d d �d!e+d"ed# d$ee, de<fd%d&��Z>ed d d d d'�d!e+d"ed( d)ee- d*ee d+ee d,ee de=fd-d&��Z>e d4d d d d d d.�d!e+d"e"d$ee, d)ee- d*ee d+ee d,ee dee<e=f fd/d&��Z> #d5dddddd.�d!e+d"e"d$ee, d)ee- d*ee d+ee d,ee dee<e=f fd0d&�Z>d1ej?e de"fd2d3�Z@dS )6z
jsonlines implementation
� N)�Any�Callable�Dict�Iterable�Iterator�List�Literal�Optional�Tuple�Type�TypeVar�Union�cast�overload�orjson�ujson� c @ s$ e Zd Ze�� Ze�� Ze�� ZdS )�DumpsResultConversionN)�__name__�
__module__� __qualname__�enum�auto� LeaveAsIs�
EncodeToBytes�DecodeToString� r r �F/usr/local/CyberCP/lib/python3.10/site-packages/jsonlines/jsonlines.pyr > s r �
TJSONValue)�bound�TRW�ReaderWriterBase�obj�returnc C � t �)z?
Fake ``dumps()`` function to use as a default marker.
��NotImplementedError)r" r r r �
default_dumpsa s r' T)�auto_exc� auto_attribsc @ s e Zd ZU dZeed< dS )�Errorz
Base error class.
�messageN)r r r �__doc__�str�__annotations__r r r r r* h s
r* F)r( r) �initc sT e Zd ZU dZeeef ed< eed< dedeeef deddf� fdd� Z � Z
S ) �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``.
�line�linenor+ r# Nc s, |� � | _|| _t� �|� d|� d�� d S )Nz (line �))�rstripr1 r2 �super�__init__)�selfr+ r1 r2 �� __class__r r r6 � s
zInvalidLineError.__init__) r r r r, r
r- �bytesr. �intr6 �
__classcell__r r r8 r r0 q s
.r0 )r) �reprc @ s� e Zd ZU dZejddd�Zeej e
ej e df e d< ejddd�Z
ee d< ejddd�Zee d< dd d
�Zde
fd d �Zde
fd
d�Zdedefdd�Zdeee dee deej ddfdd�ZdS )r! zJ
Base class with shared behaviour for both the reader and writer.
NF��defaultr/ �_fp�_closed�_should_close_fpr# c C s6 | j rdS d| _ | jdur| jr| j�� dS dS dS )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)rA r@ rB �close�r7 r r r rC � s �zReaderWriterBase.closec C s0 t | �j}| �� }d|� dt| �d�d|� d�S )Nz <jsonlines.� at 0x�xz
wrapping �>)�typer �_repr_for_wrapped�id)r7 �cls_name�wrappedr r r �__repr__� s
zReaderWriterBase.__repr__c C r$ �Nr% rD r r r rI � � z"ReaderWriterBase._repr_for_wrappedr7 c C s | S rN r rD r r r � __enter__� rO zReaderWriterBase.__enter__�exc_type�exc_val�exc_tbc C s | � � d S rN )rC )r7 rQ rR rS r r r �__exit__� s zReaderWriterBase.__exit__�r# N)r r r r, �attr�ibr@ r
�typing�IOr- r: r. rA �boolrB rC rM rI r rP r r �
BaseException�types�
TracebackTyperT r r r r r! � s(
$�
����c @ s" e Zd ZU dZeeje eje e eeef f e
d< e j dd�Z
eeeeeef f e
d< e j edd�Zee
d< d,d d �Zed
d
d
d�ded
ded ded efdd��Zed
d
d�ded
ded ded ee fdd��Zed
d
d�dee ded ded e fdd��Zed
d�dee ded ded ee fdd��Zed
d
d
d�deee deded ee fdd��Zd
ddd�deee deded ee fdd�Zed
d
d
d
d �ded
ded ded ed ee f
d d ��Z ed
d
d
d �ded
ded ded ed ee f
d!d ��Z ed
d
d
d"�dee ded ded ed ee f
d#d ��Z ed
d
d$�dee ded ded ed eee f
d%d ��Z ed
d
d
d
d �deee deded ed eee f
d&d ��Z
d-deee deded ed eee f
d'd �Z d ee fd(d)�Z d efd*d+�Z d
S ).�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.
Instances are iterable and can be used as a context manager.
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.
:param file_or_iterable: file-like object or iterable yielding lines as
strings
:param loads: custom json decoder callable
�_file_or_iterableF)r/ �
_line_iterT�r? �kw_only�_loadsr# Nc C sB t | jtj�rtttjt tjt f | j�| _
t | jd�| _ d S )N� )
�
isinstancer_ �io�IOBaser r
rX rY r- r: r@ � enumerater` rD r r r �__attrs_post_init__� s �zReader.__attrs_post_init__.�rH �
allow_none�
skip_emptyrH rk rl c C � d S rN r �r7 rH rk rl r r r �read� � z Reader.read)rH rl c C rm rN r rn r r r ro � rp )rk rl c C rm rN r rn r r r ro � rp )rl c C rm rN r rn r r r ro rp c C rm rN r rn r r r ro rp c
C sl | j rtd��|dur|tvrtd��z t| j�\}}|r.|�� s.t| j�\}}|r.|�� r!W n
ty9 td�w t |t
�r_z|� d�}W n t y^ } z t
d|� �||�}||�d}~ww |�t�rj|dd� }z| �|�}W n ty� } z t
d|� �||�}||�d}~ww |du r�|r�dS t
d||��|dur�t ||�} |tu r�t |t�r�d } | s�t
d
||��|S ) a�
Read and decode a line.
The optional `type` argument specifies the expected data type.
Supported types are ``dict``, ``list``, ``str``, ``int``,
``float``, 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 specified�utf-8zline is not valid utf-8: rd z line contains invalid json: zline contains null valueFz"line does not match requested type)rA � RuntimeError� VALID_TYPES�
ValueError�nextr` r4 �
StopIteration�EOFErrorre r: �decode�UnicodeDecodeErrorr0 �
startswith� SKIPPABLE_SINGLE_INITIAL_CHARSrc r; rZ )
r7 rH rk rl r2 r1 �orig_exc�exc�value�validr r r ro s^ �� �
���
���
�)rH rk rl � skip_invalidr� c C rm rN r �r7 rH rk rl r� r r r �iter_ � z Reader.iter)rH rl r� c C rm rN r r� r r r r� k r� )rk rl r� c C rm rN r r� r r r r� w r� )rl r� c C rm rN r r� r r r r� � r� c C rm rN r r� r r r r� � r� c c sL � z z | j |||d�V W n ty |s� Y nw q ty% Y dS w )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.
Trj N)ro r0 rw r� r r r r� � s � � ��� �c C s | � � S )z0
See :py:meth:`~Reader.iter()`.
)r� rD r r r �__iter__� s zReader.__iter__c C s: | j d ur
t| j �S t| j�j}d|� dt| j�d�d�S )N�<rE rF rG )r@ � repr_for_fprH r_ r rJ )r7 �
class_namer r r rI � s
zReader._repr_for_wrappedrU )NFFF)!r r r r, r
rX rY r- r: r r. rV rW r` r r
r; �
default_loadsrc �
LoadsCallableri r r rZ � JSONValuero r r r r r� r� rI r r r r r^ � s\
�(
���� �
���� �
���� �
���� �
�
��� � �
���
�I����� � ����� � ����� � �����
� �
����
� �
����
�!r^ c @ s e Zd ZU dZejdd�Zeej e
ej e f e d< ejddd�Z
ee d< ejddd �Zee d
< ejddd �Zee d < ejddd �Zee d < ejedd �Zee d
< ejejdd�Zee d< ddd�Zdedefdd�Zde e defdd�Z de
fdd�Z dS )�Writera�
Writer for the jsonlines format.
Instances can be used as a context manager.
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.
:param fp: writable file-like object
:param compact: whether to use a compact output format
:param sort_keys: whether to sort object keys
:param dumps: custom encoder callable
:param flush: whether to flush the file-like object after writing each line
N)r? r@ Fr> �
_fp_is_binaryTra �_compact�
_sort_keys�_flush�_dumps�_dumps_result_conversionr# c C s� t | jtj�r d| _n#t | jtj�rd| _nz| j�d� W n ty* d| _Y nw d| _| jt u rCt
j d| j r;dnd| j
d�j| _| �i �}t |t�rV| jrVtj| _d S t |t�rd| jsftj| _d S d S d S )NFT� )�,�:)z, z: )� ensure_ascii�
separators� sort_keys)re r@ rf �
TextIOBaser� rg �write� TypeErrorr� r' �json� JSONEncoderr� r� �encoder- r r r� r: r )r7 �sample_dumps_resultr r r ri � s0
�
��
�zWriter.__attrs_post_init__r" c C s� | j rtd��| �|�}| jtjkr|�� }n
| jtjkr!|�� }| j }|�
|� |�
| j r0dnd� | j r:|�
� t|�d S )z�
Encode and write a single object.
:param obj: the object to encode and write
:return: number of characters or bytes written
zwriter is closed�
�
rd )rA rr r� r� r r r� r rx r@ r� r� r� �flush�len)r7 r" r1 �fpr r r r� s
z Writer.write�iterablec s t � fdd�|D ��S )z�
Encode and write multiple objects.
:param iterable: an iterable of objects
:return: number of characters or bytes written
c 3 s � | ]}� � |�V qd S rN )r� )�.0r" rD r r � <genexpr>1 s � z#Writer.write_all.<locals>.<genexpr>)�sum)r7 r� r rD r � write_all* s zWriter.write_allc C s
t | j�S rN )r� r@ rD r r r rI 3 s
zWriter._repr_for_wrappedrU ) r r r r, rV rW r@ r
rX rY r- r: r. r� rZ r� r� r� r' r� �
DumpsCallabler r r� ri r r; r� r r� rI r r r r r� � s
(�
r� .)�loads�file�mode�rr� c C rm rN r )r� r� r� r r r �open7 s r� )�dumps�compactr� r� )�w�arF r� r� r� r� c C rm rN r )r� r� r� r� r� r� r r r r� A s
�r� r� r� r� r� c C rm rN r )r� r� r� r� r� r� r� r r r r� N s c C s� |dvrt d��|dkrtnt}|dkrdnd}tj| |d |d�} t|||||d�}
d d
� |
�� D �}
|| fi |
��} d | _| S ) u�
Open a jsonlines file for reading or writing.
This is a convenience function to open a file and wrap it in either a
:py:class:`Reader` or :py:class:`Writer` instance, depending on the
specified `mode`.
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: name or ‘path-like object’ of the file to open
:param mode: whether to open the file for reading (``r``),
writing (``w``), appending (``a``), or exclusive creation (``x``).
> r� r� r� rF z+'mode' must be either 'r', 'w', 'a', or 'x'r� z utf-8-sigrq �t)r� �encodingr� c S s i | ] \}}|d ur||�qS rN r )r� �keyr~ r r r �
<dictcomp>� s zopen.<locals>.<dictcomp>T)rt r^ r� �builtinsr� �dict�itemsrB ) r� r� r� r� r� r� r� �clsr� r� �kwargs�instancer r r r� \ s "�r� c C s$ t | dd�}|durt|�S t| �S )z@
Helper to make a useful repr() for a file-like object.
�nameN)�getattrr= )r� r� r r r r� � s r� ).)r� )Ar, r� �codecsr rf r� �osr\ rX r r r r r r r r r
r r r
r r rV �
ModuleTyper. r � ImportErrorr rZ r� �floatr; �listr- rs �BOM_UTF8rx r{ �Enumr r: �PathLike�Openabler� r� �JSONCollection�
JSONScalarr� r r r� r� r' �s� Exceptionr* rt r0 r! r^ r� r� rY r� r r r r �<module> s @ � �� � - n����� � ������� � ���������
����������
� 5