o
    Û­j<C  ã                   @  sÞ   d dl mZ d dlmZmZ d dlZd dlmZmZm	Z	 d dl
Zd dlmZ d dlZd dlmZ er@d dlmZ d dlmZmZ d4dd„Z			 	d5d6dd„Zd7dd„Zd8d d!„Z	d9d:d%d&„Z					'		d;d<d2d3„ZdS )=é    )Úannotations)ÚabcÚdefaultdictN)ÚTYPE_CHECKINGÚAnyÚDefaultDict©Úconvert_json_to_lines)Ú	DataFrame)ÚIterable)ÚIgnoreRaiseÚScalarÚsÚstrÚreturnc                 C  s0   | d dks| d dkr| S | dd… } t | ƒS )zJ
    Helper function that converts JSON lists to line delimited JSON.
    r   ú[éÿÿÿÿú]é   r   )r   © r   úV/var/www/html/CropPilot/venv/lib/python3.10/site-packages/pandas/io/json/_normalize.pyÚconvert_to_line_delimits    s   r   Ú Ú.ÚprefixÚsepÚlevelÚintÚ	max_levelú
int | Nonec              
   C  sâ   d}t | tƒr| g} d}g }| D ]X}t |¡}| ¡ D ]G\}	}
t |	tƒs(t|	ƒ}	|dkr/|	}n|| |	 }t |
tƒrB|durP||krP|dkrO| |	¡}
|
||< q| |	¡}
| t|
|||d |ƒ¡ q| 	|¡ q|ro|d S |S )a�  
    A simplified json_normalize

    Converts a nested dict into a flat dict ("record"), unlike json_normalize,
    it does not attempt to extract a subset of the data.

    Parameters
    ----------
    ds : dict or list of dicts
    prefix: the prefix, optional, default: ""
    sep : str, default '.'
        Nested records will generate names separated by sep,
        e.g., for sep='.', { 'foo' : { 'bar' : 0 } } -> foo.bar
    level: int, optional, default: 0
        The number of levels in the json string.

    max_level: int, optional, default: None
        The max depth to normalize.

    Returns
    -------
    d - dict or list of dicts, matching `ds`

    Examples
    --------
    >>> nested_to_record(
    ...     dict(flat1=1, dict1=dict(c=1, d=2), nested=dict(e=dict(c=1, d=2), d=2))
    ... )
    {'flat1': 1, 'dict1.c': 1, 'dict1.d': 2, 'nested.e.c': 1, 'nested.e.d': 2, 'nested.d': 2}
    FTr   Nr   )
Ú
isinstanceÚdictÚcopyÚdeepcopyÚitemsr   ÚpopÚupdateÚnested_to_recordÚappend)Údsr   r   r   r   Ú	singletonÚnew_dsÚdÚnew_dÚkÚvÚnewkeyr   r   r   r'   -   s2   ,





r'   Údatar   Ú
key_stringÚnormalized_dictúdict[str, Any]Ú	separatorc                 C  sZ   t | tƒr'|  ¡ D ]\}}|› |› |› �}|s| |¡}t||||d� q	|S | ||< |S )a3  
    Main recursive function
    Designed for the most basic use case of pd.json_normalize(data)
    intended as a performance improvement, see #15621

    Parameters
    ----------
    data : Any
        Type dependent on types contained within nested Json
    key_string : str
        New key (with separator(s) in) for data
    normalized_dict : dict
        The new normalized/flattened Json dict
    separator : str, default '.'
        Nested records will generate names separated by sep,
        e.g., for sep='.', { 'foo' : { 'bar' : 0 } } -> foo.bar
    ©r1   r2   r3   r5   )r    r!   r$   ÚremoveprefixÚ_normalise_json)r1   r2   r3   r5   ÚkeyÚvalueÚnew_keyr   r   r   r8   ~   s   

üÿr8   c                 C  s<   dd„ |   ¡ D ƒ}tdd„ |   ¡ D ƒdi |d�}i |¥|¥S )aw  
    Order the top level keys and then recursively go to depth

    Parameters
    ----------
    data : dict or list of dicts
    separator : str, default '.'
        Nested records will generate names separated by sep,
        e.g., for sep='.', { 'foo' : { 'bar' : 0 } } -> foo.bar

    Returns
    -------
    dict or list of dicts, matching `normalised_json_object`
    c                 S  s    i | ]\}}t |tƒs||“qS r   ©r    r!   ©Ú.0r.   r/   r   r   r   Ú
<dictcomp>¶   ó     z+_normalise_json_ordered.<locals>.<dictcomp>c                 S  s    i | ]\}}t |tƒr||“qS r   r<   r=   r   r   r   r?   ¸   r@   r   r6   )r$   r8   )r1   r5   Ú	top_dict_Únested_dict_r   r   r   Ú_normalise_json_ordered§   s   ürC   r)   údict | list[dict]údict | list[dict] | Anyc                   sB   i }t | tƒrt| ˆ d�}|S t | tƒr‡ fdd„| D ƒ}|S |S )a˜  
    A optimized basic json_normalize

    Converts a nested dict into a flat dict ("record"), unlike
    json_normalize and nested_to_record it doesn't do anything clever.
    But for the most basic use cases it enhances performance.
    E.g. pd.json_normalize(data)

    Parameters
    ----------
    ds : dict or list of dicts
    sep : str, default '.'
        Nested records will generate names separated by sep,
        e.g., for sep='.', { 'foo' : { 'bar' : 0 } } -> foo.bar

    Returns
    -------
    frame : DataFrame
    d - dict or list of dicts, matching `normalised_json_object`

    Examples
    --------
    >>> _simple_json_normalize(
    ...     {
    ...         "flat1": 1,
    ...         "dict1": {"c": 1, "d": 2},
    ...         "nested": {"e": {"c": 1, "d": 2}, "d": 2},
    ...     }
    ... )
    {'flat1': 1, 'dict1.c': 1, 'dict1.d': 2, 'nested.e.c': 1, 'nested.e.d': 2, 'nested.d': 2}

    )r1   r5   c                   s   g | ]}t |ˆ d �‘qS )©r   )Ú_simple_json_normalize)r>   ÚrowrF   r   r   Ú
<listcomp>ð   s    z*_simple_json_normalize.<locals>.<listcomp>)r    r!   rC   Úlist)r)   r   Únormalised_json_objectÚnormalised_json_listr   rF   r   rG   À   s   +

ýrG   ÚraiseÚrecord_pathústr | list | NoneÚmetaú"str | list[str | list[str]] | NoneÚmeta_prefixú
str | NoneÚrecord_prefixÚerrorsr   r
   c                   s  	d%d&‡fd
d„‰d'‡fdd„‰t | tƒr| stƒ S t | tƒr#| g} nt | tjƒr3t | tƒs3t| ƒ} nt‚|du rQ|du rQ|du rQˆ	du rQˆdu rQtt| ˆd�ƒS |du rit	dd„ | D ƒƒret
| ˆˆd�} t| ƒS t |tƒsq|g}|du rxg }nt |tƒs€|g}dd„ |D ƒ‰ g ‰
g ‰ttƒ‰‡fdd„ˆ D ƒ‰d(d)‡ ‡‡‡‡‡‡‡‡
‡f
dd„‰ˆ| |i dd� tˆ
ƒ}ˆ	durÃ|j‡	fdd„d �}ˆ ¡ D ]C\}	}
|durÓ||	 }	|	|v rßtd!|	› d"�ƒ‚tj|
td#�}|jd$k�rtjt|
ƒftd#�}t|
ƒD ]\}}
|
||< qú| ˆ¡||	< qÇ|S )*a´  
    Normalize semi-structured JSON data into a flat table.

    Parameters
    ----------
    data : dict or list of dicts
        Unserialized JSON objects.
    record_path : str or list of str, default None
        Path in each object to list of records. If not passed, data will be
        assumed to be an array of records.
    meta : list of paths (str or list of str), default None
        Fields to use as metadata for each record in resulting table.
    meta_prefix : str, default None
        If True, prefix records with dotted (?) path, e.g. foo.bar.field if
        meta is ['foo', 'bar'].
    record_prefix : str, default None
        If True, prefix records with dotted (?) path, e.g. foo.bar.field if
        path to records is ['foo', 'bar'].
    errors : {'raise', 'ignore'}, default 'raise'
        Configures error handling.

        * 'ignore' : will ignore KeyError if keys listed in meta are not
          always present.
        * 'raise' : will raise KeyError if keys listed in meta are not
          always present.
    sep : str, default '.'
        Nested records will generate names separated by sep.
        e.g., for sep='.', {'foo': {'bar': 0}} -> foo.bar.
    max_level : int, default None
        Max number of levels(depth of dict) to normalize.
        if None, normalizes all levels.

    Returns
    -------
    frame : DataFrame
    Normalize semi-structured JSON data into a flat table.

    Examples
    --------
    >>> data = [
    ...     {"id": 1, "name": {"first": "Coleen", "last": "Volk"}},
    ...     {"name": {"given": "Mark", "family": "Regner"}},
    ...     {"id": 2, "name": "Faye Raker"},
    ... ]
    >>> pd.json_normalize(data)
        id name.first name.last name.given name.family        name
    0  1.0     Coleen      Volk        NaN         NaN         NaN
    1  NaN        NaN       NaN       Mark      Regner         NaN
    2  2.0        NaN       NaN        NaN         NaN  Faye Raker

    >>> data = [
    ...     {
    ...         "id": 1,
    ...         "name": "Cole Volk",
    ...         "fitness": {"height": 130, "weight": 60},
    ...     },
    ...     {"name": "Mark Reg", "fitness": {"height": 130, "weight": 60}},
    ...     {
    ...         "id": 2,
    ...         "name": "Faye Raker",
    ...         "fitness": {"height": 130, "weight": 60},
    ...     },
    ... ]
    >>> pd.json_normalize(data, max_level=0)
        id        name                        fitness
    0  1.0   Cole Volk  {'height': 130, 'weight': 60}
    1  NaN    Mark Reg  {'height': 130, 'weight': 60}
    2  2.0  Faye Raker  {'height': 130, 'weight': 60}

    Normalizes nested data up to level 1.

    >>> data = [
    ...     {
    ...         "id": 1,
    ...         "name": "Cole Volk",
    ...         "fitness": {"height": 130, "weight": 60},
    ...     },
    ...     {"name": "Mark Reg", "fitness": {"height": 130, "weight": 60}},
    ...     {
    ...         "id": 2,
    ...         "name": "Faye Raker",
    ...         "fitness": {"height": 130, "weight": 60},
    ...     },
    ... ]
    >>> pd.json_normalize(data, max_level=1)
        id        name  fitness.height  fitness.weight
    0  1.0   Cole Volk             130              60
    1  NaN    Mark Reg             130              60
    2  2.0  Faye Raker             130              60

    >>> data = [
    ...     {
    ...         "state": "Florida",
    ...         "shortname": "FL",
    ...         "info": {"governor": "Rick Scott"},
    ...         "counties": [
    ...             {"name": "Dade", "population": 12345},
    ...             {"name": "Broward", "population": 40000},
    ...             {"name": "Palm Beach", "population": 60000},
    ...         ],
    ...     },
    ...     {
    ...         "state": "Ohio",
    ...         "shortname": "OH",
    ...         "info": {"governor": "John Kasich"},
    ...         "counties": [
    ...             {"name": "Summit", "population": 1234},
    ...             {"name": "Cuyahoga", "population": 1337},
    ...         ],
    ...     },
    ... ]
    >>> result = pd.json_normalize(
    ...     data, "counties", ["state", "shortname", ["info", "governor"]]
    ... )
    >>> result
             name  population    state shortname info.governor
    0        Dade       12345   Florida    FL    Rick Scott
    1     Broward       40000   Florida    FL    Rick Scott
    2  Palm Beach       60000   Florida    FL    Rick Scott
    3      Summit        1234   Ohio       OH    John Kasich
    4    Cuyahoga        1337   Ohio       OH    John Kasich

    >>> data = {"A": [1, 2]}
    >>> pd.json_normalize(data, "A", record_prefix="Prefix.")
        Prefix.0
    0          1
    1          2

    Returns normalized data with columns prefixed with the given string.
    FÚjsr4   Úspecú
list | strÚextract_recordÚboolr   úScalar | Iterablec              
     s¦   | }z t |tƒr|D ]}|du rt|ƒ‚|| }q
W |S || }W |S  tyR } z$|r5td|› d�ƒ|‚ˆ dkrBtjW  Y d}~S td|› d|› d�ƒ|‚d}~ww )zInternal function to pull fieldNzKey zS not found. If specifying a record_path, all elements of data should have the path.Úignorez) not found. To replace missing values of z% with np.nan, pass in errors='ignore')r    rJ   ÚKeyErrorÚnpÚnan)rV   rW   rY   ÚresultÚfieldÚe)rU   r   r   Ú_pull_field‚  s6   

ý
ñò
ÿýÿý€÷z#json_normalize.<locals>._pull_fieldrJ   c                   sH   ˆ | |dd�}t |tƒs"t |¡rg }|S t| › d|› d|› d�ƒ‚|S )z¶
        Internal function to pull field for records, and similar to
        _pull_field, but require to return list. And will raise error
        if has non iterable value.
        T)rY   z has non list value z
 for path z. Must be list or null.)r    rJ   ÚpdÚisnullÚ	TypeError)rV   rW   r`   )rc   r   r   Ú_pull_recordsŸ  s   

üÿz%json_normalize.<locals>._pull_recordsNrF   c                 s  s"   � | ]}d d„ |  ¡ D ƒV  qdS )c                 S  s   g | ]}t |tƒ‘qS r   r<   )r>   Úxr   r   r   rI   Ì  ó    z,json_normalize.<locals>.<genexpr>.<listcomp>N)Úvalues)r>   Úyr   r   r   Ú	<genexpr>Ì  s   €  z!json_normalize.<locals>.<genexpr>©r   r   c                 S  s    g | ]}t |tƒr|n|g‘qS r   )r    rJ   )r>   Úmr   r   r   rI   Þ  r@   z"json_normalize.<locals>.<listcomp>c                   s   g | ]}ˆ   |¡‘qS r   )Újoin)r>   ÚvalrF   r   r   rI   å  ri   r   r   r   ÚNonec           	        s  t | tƒr| g} t|ƒdkrB| D ]/}tˆ ˆƒD ]\}}|d t|ƒkr,ˆ||d ƒ||< qˆ||d  |dd … ||d d� qd S | D ]F}ˆ||d ƒ}‡‡	fdd„|D ƒ}ˆ t|ƒ¡ tˆ ˆƒD ]!\}}|d t|ƒkrt|| }n	ˆ|||d … ƒ}ˆ|  |¡ qcˆ |¡ qDd S )Nr   r   r   ©r   c                   s(   g | ]}t |tƒrt|ˆˆ d �n|‘qS )rm   )r    r!   r'   )r>   Úr)r   r   r   r   rI   ô  s    þÿýz>json_normalize.<locals>._recursive_extract.<locals>.<listcomp>)r    r!   ÚlenÚzipr(   Úextend)	r1   ÚpathÚ	seen_metar   Úobjrp   r9   ÚrecsÚmeta_val)
Ú_metarc   rg   Ú_recursive_extractÚlengthsr   Ú	meta_keysÚ	meta_valsÚrecordsr   r   r   r}   ç  s.   
€&ûü
ïz*json_normalize.<locals>._recursive_extractrr   c                   s   ˆ › | › �S )Nr   )rh   )rT   r   r   Ú<lambda>
  s    z json_normalize.<locals>.<lambda>)ÚcolumnszConflicting metadata name z, need distinguishing prefix )Údtyper   )F)rV   r4   rW   rX   rY   rZ   r   r[   )rV   r4   rW   rX   r   rJ   )r   )r   r   r   rq   )r    rJ   r
   r!   r   r   r   ÚNotImplementedErrorrG   Úanyr'   r   Úrenamer$   Ú
ValueErrorr^   ÚarrayÚobjectÚndimÚemptyrt   Ú	enumerateÚrepeat)r1   rN   rP   rR   rT   rU   r   r   r`   r.   r/   rj   Úir   )r|   rc   rg   r}   rU   r~   r   r   r€   rT   r�   r   r   Újson_normalizeõ   sf    ÿ



"
ÿ
r�   )r   r   r   r   )r   r   r   N)r   r   r   r   r   r   r   r   )
r1   r   r2   r   r3   r4   r5   r   r   r4   )r1   r4   r5   r   r   r4   )r   )r)   rD   r   r   r   rE   )NNNNrM   r   N)r1   rD   rN   rO   rP   rQ   rR   rS   rT   rS   rU   r   r   r   r   r   r   r
   )Ú
__future__r   Úcollectionsr   r   r"   Útypingr   r   r   Únumpyr^   Úpandas._libs.writersr	   Úpandasrd   r
   Úcollections.abcr   Úpandas._typingr   r   r   r'   r8   rC   rG   r�   r   r   r   r   Ú<module>   s:   
û
Q
)þ7ø