
    `VgMI                    ~   d dl mZ d dlZd dlmZ d dlZd dlZd dlm	Z	m
Z
 d dlmZ d dlmZmZ d dlmZ d dlmZ d dlmc mZ d d	lmZ d dlmc mZ d d
lmZmZ d dl m!Z! d dl"m#Z# d dl$m%Z% d dl&m'Z' erd dl(m)Z)  e	e%d   dddz        	 	 	 	 	 	 d	 	 	 	 	 dd       Z* e
dd      ddd       Z+	 d	 	 	 	 	 	 	 ddZ,y)    )annotationsN)TYPE_CHECKING)Appenderdeprecate_kwarg)find_stack_level)is_extension_array_dtypeis_list_like)concat_compat)notna)Categorical)Index
MultiIndex)concat)tile_compat)_shared_docs)
to_numeric)	DataFramemeltzpd.melt(df, zDataFrame.melt)callerotherc                	   t        | j                  t              r#| j                  D cg c]  }|D ]  }|  }	}}nt        | j                        }	|| j                  v r$t	        j
                  dt        t                      |t        |      s|g}nt        | j                  t              rt        |t              st        d      t        |      }t        t        j                  |            j                  |	      }
|
j                  st        dt        |
             g }|t        |      s|g}nt        | j                  t              rt        |t              st        d      t        |      }t        t        j                  |            j                  |	      }
|
j                  st        dt        |
             |.| j                  j!                  |      j#                  ||z         }n1t%        j&                  | j                  j)                  ||z               }| j*                  d d |f   } n| j-                         } | | j                  j!                  |      | _        |t        | j                  t              rt/        | j                  j0                        t/        t3        | j                  j0                              k(  r| j                  j0                  }nht5        t/        | j                  j0                              D cg c]  }d| 	 }}n/| j                  j6                  | j                  j6                  ndg}t        |t8              r|g}| j:                  \  }}|t/        |      z  }i }|D ]  }| j=                  |      }t?        |      r@|d	kD  rtA        |g|z  d
      }nI tC        |      g |j6                  |jD                        }n tG        jH                  |jJ                  |      }|||<    ||z   |gz   }| jJ                  jM                  d      ||<   tO        |      D ]E  \  }}tG        jP                  | j                  jS                  |            jU                  |      ||<   G | jW                  ||      }|stY        | jZ                  |      |_-        |S c c}}w c c}w )NzThis dataframe has a column name that matches the 'value_name' column name of the resulting Dataframe. In the future this will raise an error, please set the 'value_name' parameter of DataFrame.melt to a unique name.)
stacklevelz>id_vars must be a list of tuples when columns are a MultiIndexz:The following 'id_vars' are not present in the DataFrame: zAvalue_vars must be a list of tuples when columns are a MultiIndexz=The following 'value_vars' are not present in the DataFrame: 	variable_variabler   T)ignore_index)namedtypeFcolumns).
isinstancer    r   listwarningswarnFutureWarningr   r	   
ValueErrorr   comflatten
differenceemptyKeyErrorget_level_valuesget_indexeralgosuniqueget_indexer_foriloccopylennamessetranger   strshapepopr   r   typer   nptile_valuesravel	enumerate
asanyarray_get_level_valuesrepeat_constructorr   index)frameid_vars
value_varsvar_name
value_name	col_levelr   cxcolsmissingidxiNKmdatacolid_datamcolumnsresults                       Y/var/www/html/hubwallet-dev/venv/lib/python3.12/site-packages/pandas/core/reshape/melt.pyr   r   &   s    %--, ==4a!4Q444EMM"U]]"< ')	
 G$iGz2:gt;TP 
 7mGCKK01<<TBG==))-g9 
 J'$Jz2:jRV;WS  j)JCKK
34??EG==&&*7m_6   --00;GG*$C ,,u}}<<Wz=QRSC

1c6"

66yAemmZ05==&&'3s5==3F3F/G+HH ==..5:3u}}?R?R;S5TUisOUU ',mm&8&8&D""*H (C :;;DAqWAE ))C.#G,1u 'QTB ($w-W]]S gggooq1Gc
 !ZL0H ++C0E*H% 3
 ]]MM++A.

&) 	c
 x8F"5;;2Mc 5H Vs   R:S label)old_arg_namenew_arg_namec                   t        |t              r3t        |j                               }t        |j	                               }nt        | \  }}t        t        j                  d |D               }t        | j                  j                  |            }t        |d         }|D ]  }	t        |	      |k7  st        d       i }
g }t        ||      D ]@  \  }}|D cg c]  }| |   j                   }}t        |      |
|<   |j                  |       B |D ](  }t        j                   | |   j                  |      |
|<   * |rxt        j"                  t        |
|d            t$              }|D ]  }|t'        |
|         z  } |j)                         s&|
j+                         D ci c]  \  }}|||    }
}}| j-                  |
||z         S c c}w c c}}w )a  
    Reshape wide-format data to long. Generalized inverse of DataFrame.pivot.

    Accepts a dictionary, ``groups``, in which each key is a new column name
    and each value is a list of old column names that will be "melted" under
    the new column name as part of the reshape.

    Parameters
    ----------
    data : DataFrame
        The wide-format DataFrame.
    groups : dict
        {new_name : list_of_columns}.
    dropna : bool, default True
        Do not include columns whose entries are all NaN.
    label : None
        Not used.

        .. deprecated:: 1.0.0

    Returns
    -------
    DataFrame
        Reshaped DataFrame.

    See Also
    --------
    melt : Unpivot a DataFrame from wide to long format, optionally leaving
        identifiers set.
    pivot : Create a spreadsheet-style pivot table as a DataFrame.
    DataFrame.pivot : Pivot without aggregation that can handle
        non-numeric data.
    DataFrame.pivot_table : Generalization of pivot that can handle
        duplicate values for one index/column pair.
    DataFrame.unstack : Pivot based on the index values instead of a
        column.
    wide_to_long : Wide panel to long format. Less flexible but more
        user-friendly than melt.

    Examples
    --------
    >>> data = pd.DataFrame({'hr1': [514, 573], 'hr2': [545, 526],
    ...                      'team': ['Red Sox', 'Yankees'],
    ...                      'year1': [2007, 2007], 'year2': [2008, 2008]})
    >>> data
       hr1  hr2     team  year1  year2
    0  514  545  Red Sox   2007   2008
    1  573  526  Yankees   2007   2008

    >>> pd.lreshape(data, {'year': ['year1', 'year2'], 'hr': ['hr1', 'hr2']})
          team  year   hr
    0  Red Sox  2007  514
    1  Yankees  2007  573
    2  Red Sox  2008  545
    3  Yankees  2008  526
    c              3  2   K   | ]  }t        |        y wN)r5   ).0rL   s     rX   	<genexpr>zlreshape.<locals>.<genexpr>   s     71A7s   r   z$All column lists must be same length)r   r   )r!   dictr"   keysvalueszipr5   unionr    r)   r3   r&   r=   r
   appendr;   r<   onesboolr   allitemsrC   )datagroupsdropnarY   rb   rc   all_colsid_colsrR   seqrS   
pivot_colstargetr4   rT   	to_concatmaskrK   kvs                       rX   lreshaperw      s   t &$FKKM"fmmo&F|fCII7789H4<<**845GF1IA Es8q=CDDE EJT6* "2783T#Y&&8	8%i0f&!	"  3WWT#Y..2c
3 wws5A/0= 	$AE%(O#D	$xxz,1KKM:DAqQ$Z:E:UGj,@AA 9 ;s   G*Gc                z   dd}dd}t              sgnt              t        fd| j                  D              rt	        d      t        |      s|g}nt        |      }| |   j                         j                         rt	        d      D cg c]  } || |||       }	}|	D 
cg c]  }
|
D ]  }|  }}
}t        t        | j                  j                               j                  |            }t        |	      D cg c]  \  }} || |||||       }}}|d   j                  |dd d	
      }t        |      dk(  r%| |   j                  |      j                  |      }|S | |   j                  |j                         |      j                  ||gz         }|S c c}w c c}}
w c c}}w )ax   
    Unpivot a DataFrame from wide to long format.

    Less flexible but more user-friendly than melt.

    With stubnames ['A', 'B'], this function expects to find one or more
    group of columns with format
    A-suffix1, A-suffix2,..., B-suffix1, B-suffix2,...
    You specify what you want to call this suffix in the resulting long format
    with `j` (for example `j='year'`)

    Each row of these wide variables are assumed to be uniquely identified by
    `i` (can be a single column name or a list of column names)

    All remaining variables in the data frame are left intact.

    Parameters
    ----------
    df : DataFrame
        The wide-format DataFrame.
    stubnames : str or list-like
        The stub name(s). The wide format variables are assumed to
        start with the stub names.
    i : str or list-like
        Column(s) to use as id variable(s).
    j : str
        The name of the sub-observation variable. What you wish to name your
        suffix in the long format.
    sep : str, default ""
        A character indicating the separation of the variable names
        in the wide format, to be stripped from the names in the long format.
        For example, if your column names are A-suffix1, A-suffix2, you
        can strip the hyphen by specifying `sep='-'`.
    suffix : str, default '\\d+'
        A regular expression capturing the wanted suffixes. '\\d+' captures
        numeric suffixes. Suffixes with no numbers could be specified with the
        negated character class '\\D+'. You can also further disambiguate
        suffixes, for example, if your wide variables are of the form A-one,
        B-two,.., and you have an unrelated column A-rating, you can ignore the
        last one by specifying `suffix='(!?one|two)'`. When all suffixes are
        numeric, they are cast to int64/float64.

    Returns
    -------
    DataFrame
        A DataFrame that contains each stub name as a variable, with new index
        (i, j).

    See Also
    --------
    melt : Unpivot a DataFrame from wide to long format, optionally leaving
        identifiers set.
    pivot : Create a spreadsheet-style pivot table as a DataFrame.
    DataFrame.pivot : Pivot without aggregation that can handle
        non-numeric data.
    DataFrame.pivot_table : Generalization of pivot that can handle
        duplicate values for one index/column pair.
    DataFrame.unstack : Pivot based on the index values instead of a
        column.

    Notes
    -----
    All extra variables are left untouched. This simply uses
    `pandas.melt` under the hood, but is hard-coded to "do the right thing"
    in a typical case.

    Examples
    --------
    >>> np.random.seed(123)
    >>> df = pd.DataFrame({"A1970" : {0 : "a", 1 : "b", 2 : "c"},
    ...                    "A1980" : {0 : "d", 1 : "e", 2 : "f"},
    ...                    "B1970" : {0 : 2.5, 1 : 1.2, 2 : .7},
    ...                    "B1980" : {0 : 3.2, 1 : 1.3, 2 : .1},
    ...                    "X"     : dict(zip(range(3), np.random.randn(3)))
    ...                   })
    >>> df["id"] = df.index
    >>> df
      A1970 A1980  B1970  B1980         X  id
    0     a     d    2.5    3.2 -1.085631   0
    1     b     e    1.2    1.3  0.997345   1
    2     c     f    0.7    0.1  0.282978   2
    >>> pd.wide_to_long(df, ["A", "B"], i="id", j="year")
    ... # doctest: +NORMALIZE_WHITESPACE
                    X  A    B
    id year
    0  1970 -1.085631  a  2.5
    1  1970  0.997345  b  1.2
    2  1970  0.282978  c  0.7
    0  1980 -1.085631  d  3.2
    1  1980  0.997345  e  1.3
    2  1980  0.282978  f  0.1

    With multiple id columns

    >>> df = pd.DataFrame({
    ...     'famid': [1, 1, 1, 2, 2, 2, 3, 3, 3],
    ...     'birth': [1, 2, 3, 1, 2, 3, 1, 2, 3],
    ...     'ht1': [2.8, 2.9, 2.2, 2, 1.8, 1.9, 2.2, 2.3, 2.1],
    ...     'ht2': [3.4, 3.8, 2.9, 3.2, 2.8, 2.4, 3.3, 3.4, 2.9]
    ... })
    >>> df
       famid  birth  ht1  ht2
    0      1      1  2.8  3.4
    1      1      2  2.9  3.8
    2      1      3  2.2  2.9
    3      2      1  2.0  3.2
    4      2      2  1.8  2.8
    5      2      3  1.9  2.4
    6      3      1  2.2  3.3
    7      3      2  2.3  3.4
    8      3      3  2.1  2.9
    >>> l = pd.wide_to_long(df, stubnames='ht', i=['famid', 'birth'], j='age')
    >>> l
    ... # doctest: +NORMALIZE_WHITESPACE
                      ht
    famid birth age
    1     1     1    2.8
                2    3.4
          2     1    2.9
                2    3.8
          3     1    2.2
                2    2.9
    2     1     1    2.0
                2    3.2
          2     1    1.8
                2    2.8
          3     1    1.9
                2    2.4
    3     1     1    2.2
                2    3.3
          2     1    2.3
                2    3.4
          3     1    2.1
                2    2.9

    Going from long back to wide just takes some creative use of `unstack`

    >>> w = l.unstack()
    >>> w.columns = w.columns.map('{0[0]}{0[1]}'.format)
    >>> w.reset_index()
       famid  birth  ht1  ht2
    0      1      1  2.8  3.4
    1      1      2  2.9  3.8
    2      1      3  2.2  2.9
    3      2      1  2.0  3.2
    4      2      2  1.8  2.8
    5      2      3  1.9  2.4
    6      3      1  2.2  3.3
    7      3      2  2.3  3.4
    8      3      3  2.1  2.9

    Less wieldy column names are also handled

    >>> np.random.seed(0)
    >>> df = pd.DataFrame({'A(weekly)-2010': np.random.rand(3),
    ...                    'A(weekly)-2011': np.random.rand(3),
    ...                    'B(weekly)-2010': np.random.rand(3),
    ...                    'B(weekly)-2011': np.random.rand(3),
    ...                    'X' : np.random.randint(3, size=3)})
    >>> df['id'] = df.index
    >>> df # doctest: +NORMALIZE_WHITESPACE, +ELLIPSIS
       A(weekly)-2010  A(weekly)-2011  B(weekly)-2010  B(weekly)-2011  X  id
    0        0.548814        0.544883        0.437587        0.383442  0   0
    1        0.715189        0.423655        0.891773        0.791725  1   1
    2        0.602763        0.645894        0.963663        0.528895  1   2

    >>> pd.wide_to_long(df, ['A(weekly)', 'B(weekly)'], i='id',
    ...                 j='year', sep='-')
    ... # doctest: +NORMALIZE_WHITESPACE
             X  A(weekly)  B(weekly)
    id year
    0  2010  0   0.548814   0.437587
    1  2010  1   0.715189   0.891773
    2  2010  1   0.602763   0.963663
    0  2011  0   0.544883   0.383442
    1  2011  1   0.423655   0.791725
    2  2011  1   0.645894   0.528895

    If we have many columns, we could also use a regex to find our
    stubnames and pass that list on to wide_to_long

    >>> stubnames = sorted(
    ...     set([match[0] for match in df.columns.str.findall(
    ...         r'[A-B]\(.*\)').values if match != []])
    ... )
    >>> list(stubnames)
    ['A(weekly)', 'B(weekly)']

    All of the above examples have integers as suffixes. It is possible to
    have non-integers as suffixes.

    >>> df = pd.DataFrame({
    ...     'famid': [1, 1, 1, 2, 2, 2, 3, 3, 3],
    ...     'birth': [1, 2, 3, 1, 2, 3, 1, 2, 3],
    ...     'ht_one': [2.8, 2.9, 2.2, 2, 1.8, 1.9, 2.2, 2.3, 2.1],
    ...     'ht_two': [3.4, 3.8, 2.9, 3.2, 2.8, 2.4, 3.3, 3.4, 2.9]
    ... })
    >>> df
       famid  birth  ht_one  ht_two
    0      1      1     2.8     3.4
    1      1      2     2.9     3.8
    2      1      3     2.2     2.9
    3      2      1     2.0     3.2
    4      2      2     1.8     2.8
    5      2      3     1.9     2.4
    6      3      1     2.2     3.3
    7      3      2     2.3     3.4
    8      3      3     2.1     2.9

    >>> l = pd.wide_to_long(df, stubnames='ht', i=['famid', 'birth'], j='age',
    ...                     sep='_', suffix=r'\w+')
    >>> l
    ... # doctest: +NORMALIZE_WHITESPACE
                      ht
    famid birth age
    1     1     one  2.8
                two  3.4
          2     one  2.9
                two  3.8
          3     one  2.2
                two  2.9
    2     1     one  2.0
                two  3.2
          2     one  1.8
                two  2.8
          3     one  1.9
                two  2.4
    3     1     one  2.2
                two  3.3
          2     one  2.3
                two  3.4
          3     one  2.1
                two  2.9
    c                    dt        j                  |       t        j                  |       | d}t        j                  |      }| j                  D cg c]  }|j	                  |      s| c}S c c}w )N^$)reescapecompiler    match)dfstubsepsuffixregexpatternrT   s          rX   get_var_namesz#wide_to_long.<locals>.get_var_names  s[    RYYt_%biin%5fXQ?**U#!zz@W]]3-?@@@s   A2+A2c                &   t        | |||j                  |      |      }t        ||         ||<   ||   j                  j	                  t        j                  ||z         dd      ||<   t        ||   d      ||<   |j                  ||gz         S )N)rF   rG   rI   rH    T)r   ignore)errors)	r   rstripr   r7   replacer|   r}   r   	set_index)r   r   rP   jrG   r   newdfs          rX   	melt_stubzwide_to_long.<locals>.melt_stub  s    !{{3'
 uQx(a8<<''		$*(=r'Na eAhx8aqA3w''    c              3  &   K   | ]  }|v  
 y wr^    )r_   rT   	stubnamess     rX   r`   zwide_to_long.<locals>.<genexpr>  s     
23)
2s   z,stubname can't be identical to a column namez3the id variables need to uniquely identify each rowr      Nouter)how)on)r   r7   r   r7   r   r7   returnz	list[str])r   r7   r   r7   )r	   r"   anyr    r&   
duplicatedr5   tolistr)   rd   joinr3   r   mergereset_index)r   r   rP   r   r   r   r   r   r   rG   sublistevalue_vars_flattenedrF   srv   _meltedmeltednews    `                 rX   wide_to_longr     s   \A
(  	"K	O	

2rzz
22GHH?CG	!uNOOCLM4-D#v6MJM-7I'IAAIAII3rzz((*+667KLMG:=i:TU$!QyQ1a-UGUQZ__WQR[g_6F
1v{k##A&++F3

W+

F..0Q

7
A
A!qc'
JCJ NI Vs   F,0F1F7)NNNvalueNT)rE   r   r   rh   r   r   )TN)rk   r   rm   rh   r   r   )r   z\d+)r   r   r   r7   r   r7   r   r   )-
__future__r   r|   typingr   r#   numpyr;   pandas.util._decoratorsr   r   pandas.util._exceptionsr   pandas.core.dtypes.commonr   r	   pandas.core.dtypes.concatr
   pandas.core.dtypes.missingr   pandas.core.algorithmscore
algorithmsr.   pandas.core.arraysr   pandas.core.commoncommonr'   pandas.core.indexes.apir   r   pandas.core.reshape.concatr   pandas.core.reshape.utilr   pandas.core.shared_docsr   pandas.core.tools.numericr   pandasr   r   rw   r   r   r   rX   <module>r      s   " 	     5 4 , & & *     . 0 0 0  
,v
NEU!V
VW }} } } X}@ gD9[B :[B~ BHaa),a;>aar   