o Ýñ h§*ã@sddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddl m Z dd l m Z erJdd lmZdd lmZdd lmZGd d„de ƒZd+dd„Zd,dd„Zd-dd„Zd-dd„Zd-dd„Zd-dd„Zd-d d!„Z " #d.d/d(d)„Zgd*¢Zd"S)0é)Ú annotations)Ú TYPE_CHECKING)ÚAny)ÚIterable)ÚNoReturn)Ú ExprMetadata)Úcombine_metadata)ÚExpr)Úflatten)Útimezone)ÚDType)ÚTimeUnitc@sReZdZddd„Zddd„Zdd d „Zdd d „Zddd„Zddd„Zddd„Z dS)ÚSelectorÚreturnr cCst|j|jƒS©N)r Ú_to_compliant_exprÚ _metadata)Úself©rúF/var/www/vscode/kcb/lib/python3.10/site-packages/narwhals/selectors.pyÚ_to_exprszSelector._to_exprÚotherrcCs"t|tƒr d}t|ƒ‚| ¡|S)Nz=unsupported operand type(s) for op: ('Selector' + 'Selector'))Ú isinstancerÚ TypeErrorr)rrÚmsgrrrÚ__add__s  zSelector.__add__c s:tˆtƒrˆ ‡‡fdd„tˆˆdddd¡Sˆ ¡ˆBS)Ncsˆ |¡ˆ |¡BSr©r©Úplx©rrrrÚ!óz!Selector.__or__..FT©Ú str_as_litÚallow_multi_outputÚto_single_output©rrÚ __class__rr©rrrrrÚ__or__ó  ûþ zSelector.__or__c s:tˆtƒrˆ ‡‡fdd„tˆˆdddd¡Sˆ ¡ˆ@S)Ncsˆ |¡ˆ |¡@Srrrrrrr /r!z"Selector.__and__..FTr"r&r(rrrÚ__and__,r*zSelector.__and__rcCót‚r©ÚNotImplementedErrorr(rrrÚ__rsub__:ózSelector.__rsub__cCr,rr-r(rrrÚ__rand__=r0zSelector.__rand__cCr,rr-r(rrrÚ__ror__@r0zSelector.__ror__N)rr )rrrr )rrrr) Ú__name__Ú __module__Ú __qualname__rrr)r+r/r1r2rrrrrs      rÚdtypesú3DType | type[DType] | Iterable[DType | type[DType]]rcst|ƒ‰t‡fdd„t ¡ƒS)a’Select columns based on their dtype. Arguments: dtypes: one or data types to select Returns: A new expression. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> import narwhals.selectors as ncs >>> df_native = pa.table({"a": [1, 2], "b": ["x", "y"], "c": [4.1, 2.3]}) >>> df = nw.from_native(df_native) Let's select int64 and float64 dtypes and multiply each value by 2: >>> df.select(ncs.by_dtype(nw.Int64, nw.Float64) * 2).to_native() pyarrow.Table a: int64 c: double ---- a: [[2,4]] c: [[8.2,4.6]] có |j ˆ¡Sr)Ú selectorsÚby_dtyper©Ú flattenedrrr `ó zby_dtype..)r rrÚselector_multi_unnamed)r6rr;rr:Ds  þr:ÚpatternÚstrcst‡fdd„t ¡ƒS)aîSelect all columns that match the given regex pattern. Arguments: pattern: A valid regular expression pattern. Returns: A new expression. Examples: >>> import pandas as pd >>> import narwhals as nw >>> import narwhals.selectors as ncs >>> df_native = pd.DataFrame( ... { ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... "zap": [0, 1], ... } ... ) >>> df = nw.from_native(df_native) Let's select column names containing an 'a', preceded by a character that is not 'z': >>> df.select(ncs.matches("[^z]a")).to_native() bar baz 0 123 2.0 1 456 5.5 cr8r)r9Úmatchesr©r?rrr ƒr=zmatches..©rrr>rBrrBrrAes þrAcCótdd„t ¡ƒS)uîSelect numeric columns. Returns: A new expression. Examples: >>> import polars as pl >>> import narwhals as nw >>> import narwhals.selectors as ncs >>> df_native = pl.DataFrame({"a": [1, 2], "b": ["x", "y"], "c": [4.1, 2.3]}) >>> df = nw.from_native(df_native) Let's select numeric dtypes and multiply each value by 2: >>> df.select(ncs.numeric() * 2).to_native() shape: (2, 2) ┌─────┬─────┠│ a ┆ c │ │ --- ┆ --- │ │ i64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 2 ┆ 8.2 │ │ 4 ┆ 4.6 │ └─────┴─────┘ cSó |j ¡Sr)r9Únumericrrrrr £ó znumeric..rCrrrrrFˆó ÿrFcCrD)u¥Select boolean columns. Returns: A new expression. Examples: >>> import polars as pl >>> import narwhals as nw >>> import narwhals.selectors as ncs >>> df_native = pl.DataFrame({"a": [1, 2], "b": ["x", "y"], "c": [False, True]}) >>> df = nw.from_native(df_native) Let's select boolean dtypes: >>> df.select(ncs.boolean()) ┌──────────────────┠|Narwhals DataFrame| |------------------| | shape: (2, 1) | | ┌───────┠| | │ c │ | | │ --- │ | | │ bool │ | | â•žâ•â•â•â•â•â•â•â•¡ | | │ false │ | | │ true │ | | └───────┘ | └──────────────────┘ cSrEr)r9Úbooleanrrrrr ÆrGzboolean..rCrrrrrI§s ÿrIcCrD)uoSelect string columns. Returns: A new expression. Examples: >>> import polars as pl >>> import narwhals as nw >>> import narwhals.selectors as ncs >>> df_native = pl.DataFrame({"a": [1, 2], "b": ["x", "y"], "c": [False, True]}) >>> df = nw.from_native(df_native) Let's select string dtypes: >>> df.select(ncs.string()).to_native() shape: (2, 1) ┌─────┠│ b │ │ --- │ │ str │ â•žâ•â•â•â•â•â•¡ │ x │ │ y │ └─────┘ cSrEr)r9Ústringrrrrr årGzstring..rCrrrrrJÊrHrJcCrD)uûSelect categorical columns. Returns: A new expression. Examples: >>> import polars as pl >>> import narwhals as nw >>> import narwhals.selectors as ncs >>> df_native = pl.DataFrame({"a": [1, 2], "b": ["x", "y"], "c": [False, True]}) Let's convert column "b" to categorical, and then select categorical dtypes: >>> df = nw.from_native(df_native).with_columns( ... b=nw.col("b").cast(nw.Categorical()) ... ) >>> df.select(ncs.categorical()).to_native() shape: (2, 1) ┌─────┠│ b │ │ --- │ │ cat │ â•žâ•â•â•â•â•â•¡ │ x │ │ y │ └─────┘ cSrEr)r9Ú categoricalrrrrr rGzcategorical..rCrrrrrKésþrKcCrD)a×Select all columns. Returns: A new expression. Examples: >>> import pandas as pd >>> import narwhals as nw >>> import narwhals.selectors as ncs >>> df_native = pd.DataFrame({"a": [1, 2], "b": ["x", "y"], "c": [False, True]}) >>> df = nw.from_native(df_native) Let's select all dtypes: >>> df.select(ncs.all()).to_native() a b c 0 1 x False 1 2 y True cSrEr)r9Úallrrrrr rGzall..rCrrrrrL s ÿrLN©Ú*NÚ time_unitú$TimeUnit | Iterable[TimeUnit] | NoneÚ time_zoneú7str | timezone | Iterable[str | timezone | None] | Nonecst‡‡fdd„t ¡ƒS)aSelect all datetime columns, optionally filtering by time unit/zone. Arguments: time_unit: One (or more) of the allowed timeunit precision strings, "ms", "us", "ns" and "s". Omit to select columns with any valid timeunit. time_zone: Specify which timezone(s) to select: * One or more timezone strings, as defined in zoneinfo (to see valid options run `import zoneinfo; zoneinfo.available_timezones()` for a full list). * Set `None` to select Datetime columns that do not have a timezone. * Set `"*"` to select Datetime columns that have *any* timezone. Returns: A new expression. Examples: >>> from datetime import datetime, timezone >>> import pyarrow as pa >>> import narwhals as nw >>> import narwhals.selectors as ncs >>> >>> utc_tz = timezone.utc >>> data = { ... "tstamp_utc": [ ... datetime(2023, 4, 10, 12, 14, 16, 999000, tzinfo=utc_tz), ... datetime(2025, 8, 25, 14, 18, 22, 666000, tzinfo=utc_tz), ... ], ... "tstamp": [ ... datetime(2000, 11, 20, 18, 12, 16, 600000), ... datetime(2020, 10, 30, 10, 20, 25, 123000), ... ], ... "numeric": [3.14, 6.28], ... } >>> df_native = pa.table(data) >>> df_nw = nw.from_native(df_native) >>> df_nw.select(ncs.datetime()).to_native() pyarrow.Table tstamp_utc: timestamp[us, tz=UTC] tstamp: timestamp[us] ---- tstamp_utc: [[2023-04-10 12:14:16.999000Z,2025-08-25 14:18:22.666000Z]] tstamp: [[2000-11-20 18:12:16.600000,2020-10-30 10:20:25.123000]] Select only datetime columns that have any time_zone specification: >>> df_nw.select(ncs.datetime(time_zone="*")).to_native() pyarrow.Table tstamp_utc: timestamp[us, tz=UTC] ---- tstamp_utc: [[2023-04-10 12:14:16.999000Z,2025-08-25 14:18:22.666000Z]] cs|jjˆˆdS)N©rOrQ)r9ÚdatetimerrSrrr \szdatetime..rCrSrrSrrT$s7 þrT)rLrIr:rKrTrArFrJ)r6r7rr)r?r@rr)rr)NrM)rOrPrQrRrr)Ú __future__rÚtypingrrrrÚnarwhals._expression_parsingrrÚ narwhals.exprr Únarwhals.utilsr rTr Únarwhals.dtypesr Únarwhals.typingr rr:rArFrIrJrKrLÚ__all__rrrrÚs2            0 ! #  #  " þ =