
    q-Ph6                        d dl mZ d dlmZmZmZ d dlmZ d dlm	Z	 d dl
mZ d dlmZ d dlmZ er4d dlZd d	lmZ d d
lmZ d dlmZ d dlmZ ej        dk    rd dlmZ nd dlmZ  G d d          ZdS )    )annotations)TYPE_CHECKINGLiteraloverload)
deprecated)serialize_polars_object)display_dot_graph	wrap_expr)ComputeErrorN)IOBase)Path)Expr)SerializationFormat)      c                     e Zd ZdZdZdNdZdOdZdOdZdOdZdOdZ	dPdZ
dPdZdPdZdddQdZdddQdZedddRd            ZedSd            ZdddTd ZdUd"ZdVd$ZdWd%ZdWd&ZdXd'ZdXd(ZdXd)ZdXd*Ze	 dYd+d,dZd1            ZedYd[d3            Zed+d,d\d6            Z	 d]d8d,d^d;ZedYd_d<            Zed`d=            Z ed>          d]dad?            ZedbdA            ZedcdB            ZddCdddDZdd7ddEdFdedMZd7S )fExprMetaNameSpacez*Namespace for expressions on a meta level.metaexprr   returnNonec                    |j         | _         d S N)_pyexpr)selfr   s     P/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/polars/expr/meta.py__init__zExprMetaNameSpace.__init__   s    |    otherExprMetaNameSpace | Exprboolc                @    | j                             |j                   S r   r   meta_eqr   r    s     r   __eq__zExprMetaNameSpace.__eq__!   s    |##EM222r   c                    | |k     S r    r&   s     r   __ne__zExprMetaNameSpace.__ne__$   s    5=  r   c                @    | j                             |j                   S )aX  
        Indicate if this expression is the same as another expression.

        Examples
        --------
        >>> foo_bar = pl.col("foo").alias("bar")
        >>> foo = pl.col("foo")
        >>> foo_bar.meta.eq(foo)
        False
        >>> foo_bar2 = pl.col("foo").alias("bar")
        >>> foo_bar.meta.eq(foo_bar2)
        True
        r$   r&   s     r   eqzExprMetaNameSpace.eq'   s     |##EM222r   c                .    |                      |           S )a\  
        Indicate if this expression is NOT the same as another expression.

        Examples
        --------
        >>> foo_bar = pl.col("foo").alias("bar")
        >>> foo = pl.col("foo")
        >>> foo_bar.meta.ne(foo)
        True
        >>> foo_bar2 = pl.col("foo").alias("bar")
        >>> foo_bar.meta.ne(foo_bar2)
        False
        )r,   r&   s     r   nezExprMetaNameSpace.ne7   s     775>>!!r   c                4    | j                                         S )z
        Indicate if this expression expands into multiple expressions.

        Examples
        --------
        >>> e = pl.col(["a", "b"]).name.suffix("_foo")
        >>> e.meta.has_multiple_outputs()
        True
        )r   meta_has_multiple_outputsr   s    r   has_multiple_outputsz&ExprMetaNameSpace.has_multiple_outputsG   s     |55777r   c                4    | j                                         S )aq  
        Indicate if this expression is a basic (non-regex) unaliased column.

        Examples
        --------
        >>> e = pl.col("foo")
        >>> e.meta.is_column()
        True
        >>> e = pl.col("foo") * pl.col("bar")
        >>> e.meta.is_column()
        False
        >>> e = pl.col(r"^col.*\d+$")
        >>> e.meta.is_column()
        False
        )r   meta_is_columnr1   s    r   	is_columnzExprMetaNameSpace.is_columnS   s      |**,,,r   c                4    | j                                         S )z
        Indicate if this expression expands to columns that match a regex pattern.

        Examples
        --------
        >>> e = pl.col("^.*$").name.prefix("foo_")
        >>> e.meta.is_regex_projection()
        True
        )r   meta_is_regex_projectionr1   s    r   is_regex_projectionz%ExprMetaNameSpace.is_regex_projectione   s     |44666r   F)allow_aliasingr9   c               6    | j                             |          S )az  
        Indicate if this expression only selects columns (optionally with aliasing).

        This can include bare columns, columns matched by regex or dtype, selectors
        and exclude ops, and (optionally) column/expression aliasing.

        .. versionadded:: 0.20.30

        Parameters
        ----------
        allow_aliasing
            If False (default), any aliasing is not considered to be column selection.
            Set True to allow for column selection that also includes aliasing.

        Examples
        --------
        >>> import polars.selectors as cs
        >>> e = pl.col("foo")
        >>> e.meta.is_column_selection()
        True
        >>> e = pl.col("foo").alias("bar")
        >>> e.meta.is_column_selection()
        False
        >>> e.meta.is_column_selection(allow_aliasing=True)
        True
        >>> e = pl.col("foo") * pl.col("bar")
        >>> e.meta.is_column_selection()
        False
        >>> e = cs.starts_with("foo")
        >>> e.meta.is_column_selection()
        True
        >>> e = cs.starts_with("foo").exclude("foo!")
        >>> e.meta.is_column_selection()
        True
        )r   meta_is_column_selectionr   r9   s     r   is_column_selectionz%ExprMetaNameSpace.is_column_selectionq   s    H |44^DDDr   c               6    | j                             |          S )a  
        Indicate if this expression is a literal value (optionally aliased).

        .. versionadded:: 1.14

        Parameters
        ----------
        allow_aliasing
            If False (default), only a bare literal will match.
            Set True to also allow for aliased literals.

        Examples
        --------
        >>> from datetime import datetime
        >>> e = pl.lit(123)
        >>> e.meta.is_literal()
        True
        >>> e = pl.lit(987.654321).alias("foo")
        >>> e.meta.is_literal()
        False
        >>> e = pl.lit(datetime.now()).alias("bar")
        >>> e.meta.is_literal(allow_aliasing=True)
        True
        )r   meta_is_literalr<   s     r   
is_literalzExprMetaNameSpace.is_literal   s    2 |++N;;;r   T)raise_if_undeterminedrA   Literal[True]strc                   d S r   r)   r   rA   s     r   output_namezExprMetaNameSpace.output_name   s    RURUr   Literal[False]
str | Nonec                   d S r   r)   rE   s     r   rF   zExprMetaNameSpace.output_name   s    SVSVr   c               ^    	 | j                                         S # t          $ r |sY dS  w xY w)aa  
        Get the column name that this expression would produce.

        It may not always be possible to determine the output name as that can depend
        on the schema of the context; in that case this will raise `ComputeError` if
        `raise_if_undetermined` is True (the default), or `None` otherwise.

        Examples
        --------
        >>> e = pl.col("foo") * pl.col("bar")
        >>> e.meta.output_name()
        'foo'
        >>> e_filter = pl.col("foo").filter(pl.col("bar") == 13)
        >>> e_filter.meta.output_name()
        'foo'
        >>> e_sum_over = pl.sum("foo").over("groups")
        >>> e_sum_over.meta.output_name()
        'foo'
        >>> e_sum_slice = pl.sum("foo").slice(pl.len() - 10, pl.col("bar"))
        >>> e_sum_slice.meta.output_name()
        'foo'
        >>> pl.len().meta.output_name()
        'len'
        N)r   meta_output_namer   rE   s     r   rF   zExprMetaNameSpace.output_name   sH    2	<00222 	 	 	( tt	s    ,,
list[Expr]c                H    d | j                                         D             S )a9  
        Pop the latest expression and return the input(s) of the popped expression.

        Returns
        -------
        list of Expr
            A list of expressions which in most cases will have a unit length.
            This is not the case when an expression has multiple inputs.
            For instance in a `fold` expression.

        Examples
        --------
        >>> e = pl.col("foo").alias("bar")
        >>> first = e.meta.pop()[0]
        >>> first.meta == pl.col("foo")
        True
        >>> first.meta == pl.col("bar")
        False
        c                ,    g | ]}t          |          S r)   r
   ).0es     r   
<listcomp>z)ExprMetaNameSpace.pop.<locals>.<listcomp>   s    >>>	!>>>r   )r   meta_popr1   s    r   popzExprMetaNameSpace.pop   s&    ( ?>dl&;&;&=&=>>>>r   	list[str]c                4    | j                                         S )aD  
        Get a list with the root column name.

        Examples
        --------
        >>> e = pl.col("foo") * pl.col("bar")
        >>> e.meta.root_names()
        ['foo', 'bar']
        >>> e_filter = pl.col("foo").filter(pl.col("bar") == 13)
        >>> e_filter.meta.root_names()
        ['foo', 'bar']
        >>> e_sum_over = pl.sum("foo").over("groups")
        >>> e_sum_over.meta.root_names()
        ['foo', 'groups']
        >>> e_sum_slice = pl.sum("foo").slice(pl.len() - 10, pl.col("bar"))
        >>> e_sum_slice.meta.root_names()
        ['foo', 'bar']
        )r   meta_root_namesr1   s    r   
root_nameszExprMetaNameSpace.root_names   s    & |++---r   c                N    t          | j                                                  S )aR  
        Undo any renaming operation like `alias` or `name.keep`.

        Examples
        --------
        >>> e = pl.col("foo").alias("bar")
        >>> e.meta.undo_aliases().meta == pl.col("foo")
        True
        >>> e = pl.col("foo").sum().over("bar")
        >>> e.name.keep().meta.undo_aliases().meta == e
        True
        )r   r   meta_undo_aliasesr1   s    r   undo_aliaseszExprMetaNameSpace.undo_aliases  s      7799:::r   c                N    t          | j                                                  S )z#Turn this expression in a selector.)r   r   _meta_as_selectorr1   s    r   _as_selectorzExprMetaNameSpace._as_selector  s    7799:::r   c                Z    t          | j                            |j                            S )zAdd ('+') selectors.)r   r   _meta_selector_addr&   s     r   _selector_addzExprMetaNameSpace._selector_add  "    88GGHHHr   c                Z    t          | j                            |j                            S )zAnd ('&') selectors.)r   r   _meta_selector_andr&   s     r   _selector_andzExprMetaNameSpace._selector_and  ra   r   c                Z    t          | j                            |j                            S )zSubtract ('-') selectors.)r   r   _meta_selector_subr&   s     r   _selector_subzExprMetaNameSpace._selector_sub  ra   r   c                Z    t          | j                            |j                            S )zXor ('^') selectors.)r   r   _meta_selector_xorr&   s     r   _selector_xorzExprMetaNameSpace._selector_xor"  ra   r   .formatfilerl   Literal['binary']bytesc                   d S r   r)   r   rm   rl   s      r   	serializezExprMetaNameSpace.serialize&  s	     r   Literal['json']c                   d S r   r)   rq   s      r   rr   zExprMetaNameSpace.serialize+  s    NQcr   IOBase | str | Pathr   c                   d S r   r)   rq   s      r   rr   zExprMetaNameSpace.serialize.  s	     sr   NbinaryIOBase | str | Path | Nonebytes | str | Nonec                   |dk    r| j         j        }n'|dk    r| j         j        }nd|}t          |          t	          |||          S )u  
        Serialize this expression to a file or string in JSON format.

        Parameters
        ----------
        file
            File path to which the result should be written. If set to `None`
            (default), the output is returned as a string instead.
        format
            The format in which to serialize. Options:

            - `"binary"`: Serialize to binary format (bytes). This is the default.
            - `"json"`: Serialize to JSON format (string).

        See Also
        --------
        Expr.deserialize

        Notes
        -----
        Serialization is not stable across Polars versions: a LazyFrame serialized
        in one Polars version may not be deserializable in another Polars version.

        Examples
        --------
        Serialize the expression into a binary representation.

        >>> expr = pl.col("foo").sum().over("bar")
        >>> bytes = expr.meta.serialize()
        >>> type(bytes)
        <class 'bytes'>

        The bytes can later be deserialized back into an `Expr` object.

        >>> import io
        >>> pl.Expr.deserialize(io.BytesIO(bytes))  # doctest: +ELLIPSIS
        <Expr ['col("foo").sum().over([col("ba…'] at ...>
        rw   jsonz0`format` must be one of {'binary', 'json'}, got )r   serialize_binaryserialize_json
ValueErrorr   )r   rm   rl   
serializermsgs        r   rr   zExprMetaNameSpace.serialize3  s^    X X6JJv4JJQvQQCS//!&z4@@@r   c                    d S r   r)   r   rm   s     r   
write_jsonzExprMetaNameSpace.write_jsoni  s    363r   c                    d S r   r)   r   s     r   r   zExprMetaNameSpace.write_jsonl  s    =@Sr   z;`meta.write_json` was renamed; use `meta.serialize` insteadc                0    |                      |d          S )z
        Write expression to json.

        .. deprecated:: 0.20.11
            This method has been renamed to :meth:`serialize`.
        r{   rk   )rr   r   s     r   r   zExprMetaNameSpace.write_jsono  s     ~~d6~222r   return_as_stringc                   d S r   r)   r   r   s     r   tree_formatzExprMetaNameSpace.tree_formaty  s    HKr   c                   d S r   r)   r   s     r   r   zExprMetaNameSpace.tree_format|  s    FIcr   )r   c               ^    | j                                         }|r|S t          |           dS )ar  
        Format the expression as a tree.

        Parameters
        ----------
        return_as_string:
            If True, return as string rather than printing to stdout.

        Examples
        --------
        >>> e = (pl.col("foo") * pl.col("bar")).sum().over(pl.col("ham")) / 2
        >>> e.meta.tree_format(return_as_string=True)  # doctest: +SKIP
        N)r   meta_tree_formatprint)r   r   ss      r   r   zExprMetaNameSpace.tree_format  s4     L))++ 	H!HHH4r   )g      0@g      (@)showoutput_path
raw_outputfigsizer   r   str | Path | Noner   r   tuple[float, float]c               \    | j                                         }t          |||||          S )a  
        Format the expression as a Graphviz graph.

        Note that Graphviz must be installed to render the visualization (if not
        already present, you can download it here: `<https://graphviz.org/download>`_).

        Parameters
        ----------
        show
            Show the figure.
        output_path
            Write the figure to disk.
        raw_output
            Return dot syntax. This cannot be combined with `show` and/or `output_path`.
        figsize
            Passed to matplotlib if `show == True`.

        Examples
        --------
        >>> e = (pl.col("foo") * pl.col("bar")).sum().over(pl.col("ham")) / 2
        >>> e.meta.show_graph()  # doctest: +SKIP
        )dotr   r   r   r   )r   meta_show_graphr	   )r   r   r   r   r   r   s         r   
show_graphzExprMetaNameSpace.show_graph  s=    < l**,, #!
 
 
 	
r   )r   r   r   r   )r    r!   r   r"   )r   r"   )r9   r"   r   r"   )rA   rB   r   rC   )rA   rG   r   rH   )rA   r"   r   rH   )r   rL   )r   rT   )r   r   )r    r   r   r   ).)rm   r   rl   rn   r   ro   )rm   r   rl   rs   r   rC   )rm   ru   rl   r   r   r   r   )rm   rx   rl   r   r   ry   )rm   r   r   rC   )rm   ru   r   r   )rm   rx   r   rH   )r   rG   r   r   )r   rB   r   rC   )r   r"   r   rH   )
r   r"   r   r   r   r"   r   r   r   rH   )__name__
__module____qualname____doc__	_accessorr   r'   r*   r,   r.   r2   r5   r8   r=   r@   r   rF   rS   rW   rZ   r]   r`   rd   rg   rj   rr   r   r   r   r   r)   r   r   r   r      s       44I$ $ $ $3 3 3 3! ! ! !3 3 3 3 " " " " 
8 
8 
8 
8- - - -$
7 
7 
7 
7 =B $E $E $E $E $E $EL 49 < < < < < <6 DHUUUUU XUVVV XV;?      @? ? ? ?,. . . .*; ; ; ;; ; ; ;I I I II I I II I I II I I I ?B     X QQQQ XQJM     X ,04A '/	4A 4A 4A 4A 4A 4Al 6666 X6@@@ X@ZMNN3 3 3 3 ON3 KKK XKIII XI6;      0 )- '3%
 %
 %
 %
 %
 %
 %
 %
r   r   )
__future__r   typingr   r   r   polars._utils.deprecationr   polars._utils.serder   polars._utils.variousr	   polars._utils.wrapr   polars.exceptionsr   sysior   pathlibr   polarsr   polars._typingr   version_infowarningstyping_extensionsr   r)   r   r   <module>r      sY   " " " " " " 3 3 3 3 3 3 3 3 3 3 0 0 0 0 0 0 7 7 7 7 7 7 3 3 3 3 3 3 ( ( ( ( ( ( * * * * * * 1JJJ222222
7""'''''''000000`
 `
 `
 `
 `
 `
 `
 `
 `
 `
r   