o
    ¹­§i\  ã                   @  sä  U d dl mZ d dlZd dlmZmZ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 d d	lmZ d d
lm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#Z# e $e%¡ d dl&m'Z' W d  ƒ n1 sw   Y  erÐd dl(Z(d dl)m*Z*m+Z+m,Z, d dl-m.Z. d dlm/Z/m0Z0m1Z1m2Z2 e(j3dkr²d dlm4Z4 nd dl5m4Z4 ee!B e#B ejB ej#e/ B ej6B ej7B Z8de9d< dgZ:d-dd„Z;d.d!d"„Z<ddd#œd/d*d+„Z=G d,d„ dee ƒZ>dS )0é    )ÚannotationsN)ÚTYPE_CHECKINGÚGenericÚoverload)Ú_check_for_pandasÚ_check_for_pyarrow)Úpandas)Úpyarrow)Ú	FrameType)Údeprecate_renamed_parameter)Úis_pycapsule)Úissue_unstable_warning)Ú_get_stack_localsÚqualified_type_name)Úwrap_ldf)Ú
from_arrowÚfrom_pandas)Ú	DataFrame)Ú	LazyFrame)ÚSeries)ÚPySQLContext)ÚCallableÚ
CollectionÚMapping)ÚTracebackType)ÚAnyÚFinalÚLiteralÚ	TypeAlias)é   é   )ÚSelfr   ÚCompatibleFrameTypeÚ
SQLContextÚobjr   ÚreturnÚboolc                 C  sF   t | ƒp"t| tƒp"t| ƒot| tjtjfƒp"t| ƒo"t| tj	tj
fƒS )z2Check if the object can be converted to DataFrame.)r   Ú
isinstancer   r   Úpdr   r   r   ÚpaÚTableÚRecordBatch)r$   © r,   úI/home/app/Keep/.python/lib/python3.10/site-packages/polars/sql/context.pyÚ_compatible_frame3   s   ÿþür.   r   c                 C  s¬   t | ttfƒr|  ¡ S t | tƒr|  ¡  ¡ S t| ƒr4t | tjtjfƒr4t t| ƒ }tƒr0| ¡ }| ¡ S t	| ƒsEt
| ƒrKt | tjtjfƒrKt| ƒ ¡ S dt| ƒ› }t|ƒ‚)z'Return LazyFrame from compatible input.zunrecognised frame type: )r'   r   r   Zlazyr   Zto_framer   r(   r   r   r   r)   r*   r+   r   r   Ú
ValueError)r$   ÚframeÚmsgr,   r,   r-   Ú_ensure_lazyframe=   s    
ÿÿr2   )Ú	n_objectsÚnamedÚall_compatibler3   ú
int | Noner4   ú4str | Collection[str] | Callable[[str], bool] | Noneúdict[str, Any]c                 C  s    | rt ntttf}t|||dS )z5Return compatible frame objects from the local stack.)Úof_typer3   r4   )r.   r   r   r   r   )r5   r3   r4   r9   r,   r,   r-   Ú_get_frame_localsP   s   r:   c                   @  sÐ  e Zd ZU dZded< ded< ded< e	d]ddd	d
œd^dd„ƒZe	d]dddœd_dd„ƒZe	d]dddœd`dd„ƒZed dd!d"	#dad	d	d$œdbd%d„ƒZeed	d&œdcd*d+„ƒƒZ	eeddd-d+„ƒƒZ	eeded/d+„ƒƒZ	ed	d&œded0d+„ƒZ	dfd2d3„Z
dgd:d;„Zdhd<d=„Zedd&œdid>d?„ƒZedjd@d?„ƒZedkdAd?„ƒZedd&œdldBd?„ƒZedmdCd?„ƒZedndDd?„ƒZedd&œdodGd?„ƒZd#d&œdodHd?„ZdpdLdM„Z	#dadNdOœdqdRdS„Z	#dadrdTdU„ZdsdXdY„Zdtd[d\„Zd#S )ur#   a   
    Run SQL queries against DataFrame, LazyFrame, and Series data.

    .. warning::
        This functionality is considered **unstable**, although it is close to being
        considered stable. It may be changed at any point without it being considered
        a breaking change.
    r   Ú_ctxtzFinal[bool]Ú_eager_executionzlist[set[str]]Ú_tables_scope_stack.F)Úregister_globalsr5   ÚeagerÚselfúSQLContext[LazyFrame]Úframesú/Mapping[str, CompatibleFrameType | None] | Noner>   ú
bool | intr5   r&   r?   úLiteral[False]Únamed_framesúCompatibleFrameType | Noner%   ÚNonec                K  ó   d S ©Nr,   ©r@   rB   r>   r5   r?   rF   r,   r,   r-   Ú__init__o   ó   	zSQLContext.__init__)r>   r5   úSQLContext[DataFrame]úLiteral[True]c                K  rI   rJ   r,   rK   r,   r,   r-   rL   z   rM   c                K  rI   rJ   r,   rK   r,   r,   r-   rL   …   rM   Zeager_executionz0.20.31)ÚversionN)r>   r?   c                K  s|   t dƒ t ¡ | _|| _t|pi ƒ}|r,tdd ¡ D ]\}}||vr+||vr+|||< q|s0|r<| |¡ |  	|¡ dS dS )uØ  
        Initialize a new `SQLContext`.

        .. versionchanged:: 0.20.31
            The `eager_execution` parameter was renamed `eager`.

        Parameters
        ----------
        frames
            A `{name:frame, ...}` mapping which can include Polars frames *and*
            pandas DataFrames, Series and pyarrow Table and RecordBatch objects.
        register_globals
            Register compatible objects (polars DataFrame, LazyFrame, and Series) found
            in the globals, automatically mapping their variable name to a table name.
            To register other objects (pandas/pyarrow data) pass them explicitly, or
            call the `execute_global` classmethod. If given an integer then only the
            most recent "n" objects found will be registered.
        eager
            If True, returns execution results as `DataFrame` instead of `LazyFrame`.
            (Note that the query itself is always executed in lazy-mode; this parameter
            impacts whether :meth:`execute` returns an eager or lazy result frame).
        **named_frames
            Named eager/lazy frames, provided as kwargs.

        Examples
        --------
        >>> lf = pl.LazyFrame({"a": [1, 2, 3], "b": ["x", None, "z"]})
        >>> res = pl.SQLContext(frame=lf).execute(
        ...     "SELECT b, a*2 AS two_a FROM frame WHERE b IS NOT NULL"
        ... )
        >>> res.collect()
        shape: (2, 2)
        â”Œâ”€â”€â”€â”€â”€â”¬â”€â”€â”€â”€â”€â”€â”€â”
        â”‚ b   â”† two_a â”‚
        â”‚ --- â”† ---   â”‚
        â”‚ str â”† i64   â”‚
        â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡
        â”‚ x   â”† 2     â”‚
        â”‚ z   â”† 6     â”‚
        â””â”€â”€â”€â”€â”€â”´â”€â”€â”€â”€â”€â”€â”€â”˜
        zY`SQLContext` is considered **unstable**, although it is close to being considered stable.F©r5   N)
r   r   Únewr;   r<   Údictr:   ÚitemsÚupdateÚregister_many)r@   rB   r>   r?   rF   Únamer$   r,   r,   r-   rL      s&   2ÿ
ÿ
þ€
þ)r?   ÚqueryÚstrr   c                C  rI   rJ   r,   ©ÚclsrX   r?   r,   r,   r-   Úexecute_globalÔ   s   zSQLContext.execute_globalr   c                C  rI   rJ   r,   rZ   r,   r,   r-   r\   Ú   ó   úDataFrame | LazyFramec                C  rI   rJ   r,   rZ   r,   r,   r-   r\   Þ   r]   c                C  s^   t tj|dddƒ}td|d}| |dd}|j||dW  d  ƒ S 1 s(w   Y  dS )uÌ  
        Immediately execute a SQL query, automatically registering frame globals.

        Notes
        -----
        * This convenience method automatically registers all compatible objects in
          the local stack that are referenced in the query, mapping their variable name
          to a table name. Note that in addition to polars DataFrame, LazyFrame, and
          Series this method *also* registers pandas DataFrame, Series, and pyarrow
          Table and RecordBatch objects.
        * Instead of calling this classmethod you should consider using `pl.sql`,
          which will use this code internally.

        Parameters
        ----------
        query
            A valid SQL query string.
        eager
            If True, returns execution results as `DataFrame` instead of `LazyFrame`.
            (Note that the query itself is always executed in lazy-mode).

        Examples
        --------
        >>> import pandas as pd
        >>> df = pl.LazyFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
        >>> df_pandas = pd.DataFrame({"a": [2, 3, 4], "c": [7, 8, 9]})

        Join a polars LazyFrame with a pandas DataFrame (note use of the preferred
        `pl.sql` method, which is equivalent to `SQLContext.execute_global`):

        >>> pl.sql("SELECT df.*, c FROM df JOIN df_pandas USING(a)").collect()
        shape: (2, 3)
        â”Œâ”€â”€â”€â”€â”€â”¬â”€â”€â”€â”€â”€â”¬â”€â”€â”€â”€â”€â”
        â”‚ a   â”† b   â”† c   â”‚
        â”‚ --- â”† --- â”† --- â”‚
        â”‚ i64 â”† i64 â”† i64 â”‚
        â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡
        â”‚ 2   â”† 5   â”† 7   â”‚
        â”‚ 3   â”† 6   â”† 8   â”‚
        â””â”€â”€â”€â”€â”€â”´â”€â”€â”€â”€â”€â”´â”€â”€â”€â”€â”€â”˜
        FT)Zinclude_schemaÚunique)r5   r4   )rB   r>   )rX   r?   N)Úsetr   Ztable_identifiersr:   Úexecute)r[   rX   r?   Ztable_namesrF   Úctxr,   r,   r-   r\   â   s   /ýÿ$ÿúSQLContext[FrameType]c                 C  s&   t | dg ƒ| _| j t|  ¡ ƒ¡ | S )zITrack currently registered tables on scope entry; supports nested scopes.r=   )Úgetattrr=   Úappendr`   Útables©r@   r,   r,   r-   Ú	__enter__  s   zSQLContext.__enter__Úexc_typeútype[BaseException] | NoneÚexc_valúBaseException | NoneÚexc_tbúTracebackType | Nonec                 C  s"   | j t|  ¡ ƒ| j ¡  d dS )z
        Unregister any tables created within the given scope on context exit.

        See Also
        --------
        unregister
        )ÚnamesN)Ú
unregisterr`   rf   r=   Úpop)r@   ri   rk   rm   r,   r,   r-   Ú__exit__#  s   
ÿzSQLContext.__exit__c                 C  s$   t |  ¡ ƒ}d|› dt| ƒd›dS )Nz<SQLContext [tables:z] at 0xÚxú>)Úlenrf   Úid)r@   Zn_tablesr,   r,   r-   Ú__repr__4  s   zSQLContext.__repr__c                C  rI   rJ   r,   ©r@   rX   r?   r,   r,   r-   ra   ;  ó   zSQLContext.executec                C  rI   rJ   r,   rx   r,   r,   r-   ra   @  ry   c                C  rI   rJ   r,   rx   r,   r,   r-   ra   E  ry   c                C  rI   rJ   r,   rx   r,   r,   r-   ra   J  ry   c                C  rI   rJ   r,   rx   r,   r,   r-   ra   O  ry   c                C  rI   rJ   r,   rx   r,   r,   r-   ra   T  ry   úbool | NoneúLazyFrame | DataFramec                C  rI   rJ   r,   rx   r,   r,   r-   ra   Y  ry   c                C  s&   t | j |¡ƒ}|s| jr| ¡ S |S )u—  
        Parse the given SQL query and execute it against the registered frame data.

        Parameters
        ----------
        query
            A valid string SQL query.
        eager
            Apply the query eagerly, returning `DataFrame` instead of `LazyFrame`.
            If unset, the value of the init-time "eager" parameter will be used.
            Note that the query itself is always executed in lazy-mode; this
            parameter only impacts the type of the returned frame.

        Examples
        --------
        Declare frame data and register with a SQLContext:

        >>> df = pl.DataFrame(
        ...     data=[
        ...         ("The Godfather", 1972, 6_000_000, 134_821_952, 9.2),
        ...         ("The Dark Knight", 2008, 185_000_000, 533_316_061, 9.0),
        ...         ("Schindler's List", 1993, 22_000_000, 96_067_179, 8.9),
        ...         ("Pulp Fiction", 1994, 8_000_000, 107_930_000, 8.9),
        ...         ("The Shawshank Redemption", 1994, 25_000_000, 28_341_469, 9.3),
        ...     ],
        ...     schema=["title", "release_year", "budget", "gross", "imdb_score"],
        ...     orient="row",
        ... )
        >>> ctx = pl.SQLContext(films=df)

        Execute a SQL query against the registered frame data:

        >>> ctx.execute(
        ...     '''
        ...     SELECT title, release_year, imdb_score
        ...     FROM films
        ...     WHERE release_year > 1990
        ...     ORDER BY imdb_score DESC
        ...     ''',
        ...     eager=True,
        ... )
        shape: (4, 3)
        â”Œâ”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”¬â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”¬â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”
        â”‚ title                    â”† release_year â”† imdb_score â”‚
        â”‚ ---                      â”† ---          â”† ---        â”‚
        â”‚ str                      â”† i64          â”† f64        â”‚
        â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•¡
        â”‚ The Shawshank Redemption â”† 1994         â”† 9.3        â”‚
        â”‚ The Dark Knight          â”† 2008         â”† 9.0        â”‚
        â”‚ Schindler's List         â”† 1993         â”† 8.9        â”‚
        â”‚ Pulp Fiction             â”† 1994         â”† 8.9        â”‚
        â””â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”´â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”´â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”˜

        Execute a GROUP BY query:

        >>> ctx.execute(
        ...     '''
        ...     SELECT
        ...         MAX(release_year / 10) * 10 AS decade,
        ...         SUM(gross) AS total_gross,
        ...         COUNT(title) AS n_films,
        ...     FROM films
        ...     GROUP BY (release_year / 10) -- decade
        ...     ORDER BY total_gross DESC
        ...     ''',
        ...     eager=True,
        ... )
        shape: (3, 3)
        â”Œâ”€â”€â”€â”€â”€â”€â”€â”€â”¬â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”¬â”€â”€â”€â”€â”€â”€â”€â”€â”€â”
        â”‚ decade â”† total_gross â”† n_films â”‚
        â”‚ ---    â”† ---         â”† ---     â”‚
        â”‚ i64    â”† i64         â”† u32     â”‚
        â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•¡
        â”‚ 2000   â”† 533316061   â”† 1       â”‚
        â”‚ 1990   â”† 232338648   â”† 3       â”‚
        â”‚ 1970   â”† 134821952   â”† 1       â”‚
        â””â”€â”€â”€â”€â”€â”€â”€â”€â”´â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”´â”€â”€â”€â”€â”€â”€â”€â”€â”€â”˜
        )r   r;   ra   r<   Zcollect)r@   rX   r?   Úresr,   r,   r-   ra   ^  s   QrW   r0   r!   c                 C  s*   |du rt ƒ nt|ƒ}| j ||j¡ | S )uý  
        Register a single frame as a table, using the given name.

        Parameters
        ----------
        name
            Name of the table.
        frame
            eager/lazy frame to associate with this table name.

        See Also
        --------
        register_globals
        register_many
        unregister

        Examples
        --------
        >>> df = pl.DataFrame({"hello": ["world"]})
        >>> ctx = pl.SQLContext()
        >>> ctx.register("frame_data", df).execute("SELECT * FROM frame_data").collect()
        shape: (1, 1)
        â”Œâ”€â”€â”€â”€â”€â”€â”€â”
        â”‚ hello â”‚
        â”‚ ---   â”‚
        â”‚ str   â”‚
        â•žâ•â•â•â•â•â•â•â•¡
        â”‚ world â”‚
        â””â”€â”€â”€â”€â”€â”€â”€â”˜
        N)r   r2   r;   ÚregisterZ_ldf)r@   rW   r0   r,   r,   r-   r}   ²  s   zSQLContext.registerTrQ   Únr6   c                C  s   t ||d}| j|dS )u9  
        Register all frames (lazy or eager) found in the current globals scope.

        Automatically maps variable names to table names.

        See Also
        --------
        register
        register_many
        unregister

        Parameters
        ----------
        n
            Register only the most recent "n" frames.
        all_compatible
            Control whether we *also* register pandas DataFrame, Series, and
            pyarrow Table and RecordBatch objects. If False, only Polars
            classes are registered with the SQL engine.

        Examples
        --------
        >>> df1 = pl.DataFrame({"a": [1, 2, 3], "b": ["x", None, "z"]})
        >>> df2 = pl.DataFrame({"a": [2, 3, 4], "c": ["t", "w", "v"]})

        Register frames directly from variables found in the current globals scope:

        >>> ctx = pl.SQLContext(register_globals=True)
        >>> ctx.tables()
        ['df1', 'df2']

        Query using the register variable/frame names

        >>> ctx.execute(
        ...     "SELECT a, b, c FROM df1 LEFT JOIN df2 USING (a) ORDER BY a DESC"
        ... ).collect()
        shape: (3, 3)
        â”Œâ”€â”€â”€â”€â”€â”¬â”€â”€â”€â”€â”€â”€â”¬â”€â”€â”€â”€â”€â”€â”
        â”‚ a   â”† b    â”† c    â”‚
        â”‚ --- â”† ---  â”† ---  â”‚
        â”‚ i64 â”† str  â”† str  â”‚
        â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡
        â”‚ 3   â”† z    â”† w    â”‚
        â”‚ 2   â”† null â”† t    â”‚
        â”‚ 1   â”† x    â”† null â”‚
        â””â”€â”€â”€â”€â”€â”´â”€â”€â”€â”€â”€â”€â”´â”€â”€â”€â”€â”€â”€â”˜
        )r5   r3   )rB   )r:   rV   )r@   r~   r5   rB   r,   r,   r-   r>   Õ  s   2zSQLContext.register_globalsc                 K  s8   t |pi ƒ}| |¡ | ¡ D ]
\}}|  ||¡ q| S )a   
        Register multiple eager/lazy frames as tables, using the associated names.

        Parameters
        ----------
        frames
            A `{name:frame, ...}` mapping.
        **named_frames
            Named eager/lazy frames, provided as kwargs.

        See Also
        --------
        register
        register_globals
        unregister

        Examples
        --------
        >>> lf1 = pl.LazyFrame({"a": [1, 2, 3], "b": ["m", "n", "o"]})
        >>> lf2 = pl.LazyFrame({"a": [2, 3, 4], "c": ["p", "q", "r"]})
        >>> lf3 = pl.LazyFrame({"a": [3, 4, 5], "b": ["s", "t", "u"]})
        >>> lf4 = pl.LazyFrame({"a": [4, 5, 6], "c": ["v", "w", "x"]})

        Register multiple frames at once, either by passing in as a dict...

        >>> ctx = pl.SQLContext().register_many({"tbl1": lf1, "tbl2": lf2})
        >>> ctx.tables()
        ['tbl1', 'tbl2']

        ...or using keyword args:

        >>> ctx.register_many(tbl3=lf3, tbl4=lf4).tables()
        ['tbl1', 'tbl2', 'tbl3', 'tbl4']
        )rS   rU   rT   r}   )r@   rB   rF   rW   r0   r,   r,   r-   rV   
  s
   '
zSQLContext.register_manyro   ústr | Collection[str]c                 C  s*   t |tƒr|g}|D ]}| j |¡ q
| S )a¡  
        Unregister one or more eager/lazy frames by name.

        Parameters
        ----------
        names
            Names of the tables to unregister.

        Notes
        -----
        You can also control table registration lifetime by using `SQLContext` as a
        context manager; this can often be more useful when such control is wanted:

        >>> df0 = pl.DataFrame({"colx": [0, 1, 2]})
        >>> df1 = pl.DataFrame({"colx": [1, 2, 3]})
        >>> df2 = pl.DataFrame({"colx": [2, 3, 4]})

        Frames registered in-scope are automatically unregistered on scope-exit. Note
        that frames registered on construction will persist through subsequent scopes.

        >>> # register one frame at construction time, and the other two in-scope
        >>> with pl.SQLContext(tbl0=df0) as ctx:
        ...     ctx.register_many(tbl1=df1, tbl2=df2).tables()
        ['tbl0', 'tbl1', 'tbl2']

        After scope exit, none of the tables registered in-scope remain:

        >>> ctx.tables()
        ['tbl0']

        See Also
        --------
        register
        register_globals
        register_many

        Examples
        --------
        >>> df0 = pl.DataFrame({"ints": [9, 8, 7, 6, 5]})
        >>> lf1 = pl.LazyFrame({"text": ["a", "b", "c"]})
        >>> lf2 = pl.LazyFrame({"misc": ["testing1234"]})

        Register with a SQLContext object:

        >>> ctx = pl.SQLContext(test1=df0, test2=lf1, test3=lf2)
        >>> ctx.tables()
        ['test1', 'test2', 'test3']

        Unregister one or more of the tables:

        >>> ctx.unregister(["test1", "test3"]).tables()
        ['test2']
        >>> ctx.unregister("test2").tables()
        []
        )r'   rY   r;   rp   )r@   ro   Únmr,   r,   r-   rp   7  s
   
8zSQLContext.unregisterú	list[str]c                 C  s   t | j ¡ ƒS )u)  
        Return a list of the registered table names.

        Notes
        -----
        The :meth:`tables` method will return the same values as the
        "SHOW TABLES" SQL statement, but as a list instead of a frame.

        Executing as SQL:

        >>> frame_data = pl.DataFrame({"hello": ["world"]})
        >>> ctx = pl.SQLContext(hello_world=frame_data)
        >>> ctx.execute("SHOW TABLES", eager=True)
        shape: (1, 1)
        â”Œâ”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”
        â”‚ name        â”‚
        â”‚ ---         â”‚
        â”‚ str         â”‚
        â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•¡
        â”‚ hello_world â”‚
        â””â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”˜

        Calling the method:

        >>> ctx.tables()
        ['hello_world']

        Examples
        --------
        >>> df1 = pl.DataFrame({"hello": ["world"]})
        >>> df2 = pl.DataFrame({"foo": ["bar", "baz"]})
        >>> ctx = pl.SQLContext(hello_data=df1, foo_bar=df2)
        >>> ctx.tables()
        ['foo_bar', 'hello_data']
        )Úsortedr;   Z
get_tablesrg   r,   r,   r-   rf   u  s   $zSQLContext.tables).)r@   rA   rB   rC   r>   rD   r5   r&   r?   rE   rF   rG   r%   rH   )r@   rN   rB   rC   r>   rD   r5   r&   r?   rO   rF   rG   r%   rH   )r@   rN   rB   rC   r>   rD   r5   r&   r?   r&   rF   rG   r%   rH   rJ   )
rB   rC   r>   rD   r?   r&   rF   rG   r%   rH   )rX   rY   r?   rE   r%   r   )rX   rY   r?   rO   r%   r   )rX   rY   r?   r&   r%   r^   )r%   rc   )ri   rj   rk   rl   rm   rn   r%   rH   )r%   rY   )r@   rN   rX   rY   r?   rH   r%   r   )r@   rN   rX   rY   r?   rE   r%   r   )r@   rN   rX   rY   r?   rO   r%   r   )r@   rA   rX   rY   r?   rH   r%   r   )r@   rA   rX   rY   r?   rE   r%   r   )r@   rA   rX   rY   r?   rO   r%   r   )rX   rY   r?   rz   r%   r{   )rW   rY   r0   rG   r%   r!   )r~   r6   r5   r&   r%   r!   )rB   rC   rF   rG   r%   r!   )ro   r   r%   r!   )r%   r   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__r   rL   r   Úclassmethodr\   rh   rr   rw   ra   r}   r>   rV   rp   rf   r,   r,   r,   r-   r#   [   s”   
 	þú
þû
þû
þûCÿÿ
:

ÿÿÿÿ
T$ÿÿ7þ
->)r$   r   r%   r&   )r$   r   r%   r   )r5   r&   r3   r6   r4   r7   r%   r8   )?Ú
__future__r   Ú
contextlibÚtypingr   r   r   Zpolars._dependenciesr   r   r   r(   r	   r)   Zpolars._typingr
   Zpolars._utils.deprecationr   Zpolars._utils.pycapsuler   Zpolars._utils.unstabler   Zpolars._utils.variousr   r   Zpolars._utils.wrapr   Zpolars.convertr   r   Zpolars.dataframer   Zpolars.lazyframer   Zpolars.seriesr   ÚsuppressÚImportErrorZpolars._plrr   ÚsysÚcollections.abcr   r   r   Útypesr   r   r   r   r   Úversion_infor!   Ztyping_extensionsr*   r+   r"   r‡   Ú__all__r.   r2   r:   r#   r,   r,   r,   r-   Ú<module>   s`    ÿ
ÿþýüûú
ÿ



ü