Reset repository and upload final project (part 9)

.gitattributes

@@ -68,3 +68,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 .venv_haddock/lib/python3.12/site-packages/haddock/prodrg/prodrg_aarch64-linux filter=lfs diff=lfs merge=lfs -text
 .venv_haddock/lib/python3.12/site-packages/haddock/prodrg/prodrg_arm64-darwin filter=lfs diff=lfs merge=lfs -text
 .venv_haddock/lib/python3.12/site-packages/haddock/prodrg/prodrg_x86_64-linux filter=lfs diff=lfs merge=lfs -text
+.venv_haddock/lib/python3.12/site-packages/numpy/_core/_multiarray_tests.cpython-312-darwin.so filter=lfs diff=lfs merge=lfs -text
+.venv_haddock/lib/python3.12/site-packages/numpy/_core/_multiarray_umath.cpython-312-darwin.so filter=lfs diff=lfs merge=lfs -text
+.venv_haddock/lib/python3.12/site-packages/numpy/_core/_simd.cpython-312-darwin.so filter=lfs diff=lfs merge=lfs -text

.venv_haddock/lib/python3.12/site-packages/narwhals-2.19.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

.venv_haddock/lib/python3.12/site-packages/narwhals-2.19.0.dist-info/METADATA

@@ -0,0 +1,349 @@
+Metadata-Version: 2.4
+Name: narwhals
+Version: 2.19.0
+Summary: Extremely lightweight compatibility layer between dataframe libraries
+Project-URL: Homepage, https://github.com/narwhals-dev/narwhals
+Project-URL: Documentation, https://narwhals-dev.github.io/narwhals/
+Project-URL: Repository, https://github.com/narwhals-dev/narwhals
+Project-URL: Bug Tracker, https://github.com/narwhals-dev/narwhals/issues
+Author-email: Marco Gorelli <hello_narwhals@proton.me>
+License: MIT License
+        
+        Copyright (c) 2024 to present, Marco Gorelli
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE.md
+Keywords: cudf,dask,dataframes,interoperability,modin,pandas,polars,pyarrow
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Free Threading :: 2 - Beta
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Provides-Extra: cudf
+Requires-Dist: cudf-cu12>=24.10.0; extra == 'cudf'
+Provides-Extra: dask
+Requires-Dist: dask[dataframe]>=2024.8; extra == 'dask'
+Provides-Extra: duckdb
+Requires-Dist: duckdb>=1.1; extra == 'duckdb'
+Provides-Extra: ibis
+Requires-Dist: ibis-framework>=6.0.0; extra == 'ibis'
+Requires-Dist: packaging; extra == 'ibis'
+Requires-Dist: pyarrow-hotfix; extra == 'ibis'
+Requires-Dist: rich; extra == 'ibis'
+Provides-Extra: modin
+Requires-Dist: modin; extra == 'modin'
+Provides-Extra: pandas
+Requires-Dist: pandas>=1.1.3; extra == 'pandas'
+Provides-Extra: polars
+Requires-Dist: polars>=0.20.4; extra == 'polars'
+Provides-Extra: pyarrow
+Requires-Dist: pyarrow>=13.0.0; extra == 'pyarrow'
+Provides-Extra: pyspark
+Requires-Dist: pyspark>=3.5.0; extra == 'pyspark'
+Provides-Extra: pyspark-connect
+Requires-Dist: pyspark[connect]>=3.5.0; extra == 'pyspark-connect'
+Provides-Extra: sql
+Requires-Dist: duckdb>=1.1; extra == 'sql'
+Requires-Dist: sqlparse; extra == 'sql'
+Provides-Extra: sqlframe
+Requires-Dist: sqlframe!=3.39.3,>=3.22.0; extra == 'sqlframe'
+Description-Content-Type: text/markdown
+
+# Narwhals
+
+<h1 align="center">
+	<img
+		width="400"
+		alt="narwhals_small"
+		src="https://github.com/user-attachments/assets/968545af-ea0f-48bb-8377-144e93f7abf8">
+</h1>
+
+[![PyPI version](https://badge.fury.io/py/narwhals.svg)](https://badge.fury.io/py/narwhals)
+[![Downloads](https://static.pepy.tech/badge/narwhals/month)](https://pepy.tech/project/narwhals)
+[![Trusted publishing](https://img.shields.io/badge/Trusted_publishing-Provides_attestations-bright_green)](https://peps.python.org/pep-0740/)
+[![PYPI - Types](https://img.shields.io/pypi/types/narwhals)](https://pypi.org/project/narwhals)
+
+Extremely lightweight and extensible compatibility layer between dataframe libraries!
+
+- **Full API support**: cuDF, Modin, pandas, Polars, PyArrow.
+- **Lazy-only support**: Daft, Dask, DuckDB, Ibis, PySpark, SQLFrame.
+
+Seamlessly support all, without depending on any!
+
+- ✅ **Just use** [a subset of **the Polars API**](https://narwhals-dev.github.io/narwhals/api-reference/), no need to learn anything new
+- ✅ **Zero dependencies**, Narwhals only uses what
+  the user passes in so your library can stay lightweight
+- ✅ Separate **lazy** and eager APIs, use **expressions**
+- ✅ Support pandas' complicated type system and index, without
+  either getting in the way
+- ✅ **100% branch coverage**, tested against pandas and Polars nightly builds
+- ✅ **Negligible overhead**, see [overhead](https://narwhals-dev.github.io/narwhals/overhead/)
+- ✅ Let your IDE help you thanks to **full static typing**, see [typing](https://narwhals-dev.github.io/narwhals/api-reference/typing/)
+- ✅ **Perfect backwards compatibility policy**,
+  see [stable api](https://narwhals-dev.github.io/narwhals/backcompat/) for how to opt-in
+
+Get started!
+
+- [Read the documentation](https://narwhals-dev.github.io/narwhals/)
+- [Chat with us on Discord!](https://discord.gg/V3PqtB4VA4)
+- [Join our community call](https://calendar.google.com/calendar/embed?src=27ff6dc5f598c1d94c1f6e627a1aaae680e2fac88f848bda1f2c7946ae74d5ab%40group.calendar.google.com)
+- [Read the contributing guide](https://github.com/narwhals-dev/narwhals/blob/main/CONTRIBUTING.md)
+
+<details>
+<summary>Table of contents</summary>
+
+- [Narwhals](#narwhals)
+  - [Installation](#installation)
+  - [Usage](#usage)
+  - [Example](#example)
+  - [Scope](#scope)
+  - [Roadmap](#roadmap)
+  - [Used by](#used-by)
+  - [Sponsors and institutional partners](#sponsors-and-institutional-partners)
+  - [Support](#support)
+  - [Appears on](#appears-on)
+  - [Why "Narwhals"?](#why-narwhals)
+
+</details>
+
+## Installation
+
+- pip (recommended, as it's the most up-to-date)
+  ```
+  pip install narwhals
+  ```
+- conda-forge (also fine, but the latest version may take longer to appear)
+  ```
+  conda install -c conda-forge narwhals
+  ```
+
+## Usage
+
+There are three steps to writing dataframe-agnostic code using Narwhals:
+
+1. use `narwhals.from_native` to wrap a pandas/Polars/Modin/cuDF/PyArrow
+   DataFrame/LazyFrame in a Narwhals class
+2. use the [subset of the Polars API supported by Narwhals](https://narwhals-dev.github.io/narwhals/api-reference/)
+3. use `narwhals.to_native` to return an object to the user in its original
+   dataframe flavour. For example:
+
+   - if you started with pandas, you'll get pandas back
+   - if you started with Polars, you'll get Polars back
+   - if you started with Modin, you'll get Modin back (and compute will be distributed)
+   - if you started with cuDF, you'll get cuDF back (and compute will happen on GPU)
+   - if you started with PyArrow, you'll get PyArrow back
+
+<h1 align="left">
+	<img
+		width="600"
+		alt="narwhals_gif"
+		src="https://github.com/user-attachments/assets/88292d3c-6359-4155-973d-d0f8e3fbf5ac">
+
+</h1>
+
+## Example
+
+Narwhals allows you to define dataframe-agnostic functions. For example:
+
+```python
+import narwhals as nw
+from narwhals.typing import IntoFrameT
+
+
+def agnostic_function(
+    df_native: IntoFrameT,
+    date_column: str,
+    price_column: str,
+) -> IntoFrameT:
+    return (
+        nw.from_native(df_native)
+        .group_by(nw.col(date_column).dt.truncate("1mo"))
+        .agg(nw.col(price_column).mean())
+        .sort(date_column)
+        .to_native()
+    )
+```
+
+You can then pass `pandas.DataFrame`, `polars.DataFrame`, `polars.LazyFrame`, `duckdb.DuckDBPyRelation`,
+`pyspark.sql.DataFrame`, `pyarrow.Table`, and more, to `agnostic_function`. In each case, no additional
+dependencies will be required, and computation will stay native to the input library:
+
+```python
+import pandas as pd
+import polars as pl
+from datetime import datetime
+
+data = {
+    "date": [datetime(2020, 1, 1), datetime(2020, 1, 8), datetime(2020, 2, 3)],
+    "price": [1, 4, 3],
+}
+print("pandas result:")
+print(agnostic_function(pd.DataFrame(data), "date", "price"))
+print()
+print("Polars result:")
+print(agnostic_function(pl.DataFrame(data), "date", "price"))
+```
+
+```terminal
+pandas result:
+        date  price
+0 2020-01-01    2.5
+1 2020-02-01    3.0
+
+Polars result:
+shape: (2, 2)
+┌─────────────────────┬───────┐
+│ date                ┆ price │
+│ ---                 ┆ ---   │
+│ datetime[μs]        ┆ f64   │
+╞═════════════════════╪═══════╡
+│ 2020-01-01 00:00:00 ┆ 2.5   │
+│ 2020-02-01 00:00:00 ┆ 3.0   │
+└─────────────────────┴───────┘
+```
+
+See the [tutorial](https://narwhals-dev.github.io/narwhals/basics/dataframe/) for several examples!
+
+## Scope
+
+- Do you maintain a dataframe-consuming library?
+- Do you have a specific Polars function in mind that you would like Narwhals to have in order to make your work easier?
+
+If you said yes to both, we'd love to hear from you!
+
+## Roadmap
+
+See [roadmap discussion on GitHub](https://github.com/narwhals-dev/narwhals/discussions/1370)
+for an up-to-date plan of future work.
+
+## Used by
+
+Join the party!
+
+- [altair](https://github.com/vega/altair/)
+- [bokeh](https://github.com/bokeh/bokeh)
+- [darts](https://github.com/unit8co/darts)
+- [fairlearn](https://github.com/fairlearn/fairlearn)
+- [formulaic](https://github.com/matthewwardrop/formulaic)
+- [gt-extras](https://github.com/posit-dev/gt-extras)
+- [hierarchicalforecast](https://github.com/Nixtla/hierarchicalforecast)
+- [marimo](https://github.com/marimo-team/marimo)
+- [metalearners](https://github.com/Quantco/metalearners)
+- [mosaic](https://github.com/uwdata/mosaic)
+- [panel-graphic-walker](https://github.com/panel-extensions/panel-graphic-walker)
+- [plotly](https://plotly.com)
+- [pointblank](https://github.com/posit-dev/pointblank)
+- [pymarginaleffects](https://github.com/vincentarelbundock/pymarginaleffects)
+- [pyreadstat](https://github.com/Roche/pyreadstat)
+- [py-shiny](https://github.com/posit-dev/py-shiny)
+- [rio](https://github.com/rio-labs/rio)
+- [scikit-lego](https://github.com/koaning/scikit-lego)
+- [scikit-playtime](https://github.com/koaning/scikit-playtime)
+- [tabmat](https://github.com/Quantco/tabmat)
+- [tea-tasting](https://github.com/e10v/tea-tasting)
+- [timebasedcv](https://github.com/FBruzzesi/timebasedcv)
+- [tubular](https://github.com/lvgig/tubular)
+- [Validoopsie](https://github.com/akmalsoliev/Validoopsie)
+- [vegafusion](https://github.com/vega/vegafusion)
+- [wimsey](https://github.com/benrutter/wimsey)
+
+Feel free to add your project to the list if it's missing, and/or
+[chat with us on Discord](https://discord.gg/V3PqtB4VA4) if you'd like any support.
+
+## Sponsors and institutional partners
+
+Narwhals is 100% independent, community-driven, and community-owned.
+We are extremely grateful to the following organisations for having
+provided some funding / development time:
+
+- [Quansight Labs](https://labs.quansight.org)
+- [Quansight Futures](https://www.qi.ventures)
+- [OpenTeams](https://www.openteams.com)
+- [POSSEE initiative](https://possee.org)
+- [BYU-Idaho](https://www.byui.edu)
+
+If you contribute to Narwhals on your organization's time, please let us know. We'd be happy to add your employer
+to this list!
+
+## Support
+
+If you'd like to say "thank you", please give us a ⭐ star ⭐.
+
+Please contact [hello_narwhals@proton.me](hello_narwhals@proton.me) if you would like to:
+
+- Receive professional support (e.g., if you're using or would like to use Narwhals at your company).
+- Have any Narwhals fixes / features prioritised.
+- Commission any Narwhals plugins for new backends.
+
+## Appears on
+
+Narwhals has been featured in several talks, podcasts, and blog posts:
+
+- [Inspiring Computing Podcast](https://www.inspiringcomputing.com/2107763/episodes/16702460-the-rise-of-narwhals-in-open-source)
+  The Rise of Narwhals in Open-Source
+
+- [PyCon DE & PyData 2025](https://youtu.be/DJk782DWcss)
+  How Narwhals is silently bringing pandas, Polars, DuckDB, PyArrow, and more together
+
+- [The Python Exchange March 2025](https://youtu.be/TvFWFlK-2po)
+  What Can Narwhals Do for You?
+
+- [PyData London 2025](https://youtu.be/r2PxJlO7_QA)
+  How Narwhals brings Polars, DuckDB, PyArrow, & pandas together
+
+- [Talk Python to me Podcast](https://youtu.be/FSH7BZ0tuE0)
+  Ahoy, Narwhals are bridging the data science APIs
+
+- [Python Bytes Podcast](https://www.youtube.com/live/N7w_ESVW40I?si=y-wN1uCsAuJOKlOT&t=382)
+  Episode 402, topic #2
+
+- [Super Data Science: ML & AI Podcast](https://www.youtube.com/watch?v=TeG4U8R0U8U)  
+  Narwhals: For Pandas-to-Polars DataFrame Compatibility
+
+- [Sample Space Podcast | probabl](https://youtu.be/8hYdq4sWbbQ?si=WG0QP1CZ6gkFf18b)  
+  How Narwhals has many end users ... that never use it directly. - Marco Gorelli
+
+- [The Real Python Podcast](https://www.youtube.com/watch?v=w5DFZbFYzCM)
+  Narwhals: Expanding DataFrame Compatibility Between Libraries
+
+- [Pycon Lithuania 2024](https://www.youtube.com/watch?v=-mdx7Cn6_6E)  
+  Marco Gorelli - DataFrame interoperatiblity - what's been achieved, and what comes next?
+
+- [Pycon Italy 2024](https://www.youtube.com/watch?v=3IqUli9XsmQ)  
+  How you can write a dataframe-agnostic library - Marco Gorelli
+
+- [Polars Blog Post](https://pola.rs/posts/lightweight_plotting/)  
+  Polars has a new lightweight plotting backend
+
+- [Quansight Labs blog post (w/ Scikit-Lego)](https://labs.quansight.org/blog/scikit-lego-narwhals)  
+  How Narwhals and scikit-lego came together to achieve dataframe-agnosticism
+
+## Why "Narwhals"?
+
+[Coz they are so awesome](https://youtu.be/ykwqXuMPsoc?si=A-i8LdR38teYsos4).
+
+Thanks to [Olha Urdeichuk](https://www.fiverr.com/olhaurdeichuk) for the illustration!

.venv_haddock/lib/python3.12/site-packages/narwhals-2.19.0.dist-info/RECORD

@@ -0,0 +1,330 @@
+narwhals-2.19.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+narwhals-2.19.0.dist-info/METADATA,sha256=LFbVqYTtwz5TWaaKr9cLNbc7v5F42KlooRzWyo3T48Q,14081
+narwhals-2.19.0.dist-info/RECORD,,
+narwhals-2.19.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+narwhals-2.19.0.dist-info/licenses/LICENSE.md,sha256=gRRF8wFHuPDJ1ETJAl_VKPlTLFS3uD9uI2hHPckc_fA,1082
+narwhals/__init__.py,sha256=2K-Vi5Dtx6Sc6-EwIlMGKYg50WiP8AXB2GWB-v_AUa4,3339
+narwhals/__pycache__/__init__.cpython-312.pyc,,
+narwhals/__pycache__/_constants.cpython-312.pyc,,
+narwhals/__pycache__/_duration.cpython-312.pyc,,
+narwhals/__pycache__/_enum.cpython-312.pyc,,
+narwhals/__pycache__/_exceptions.cpython-312.pyc,,
+narwhals/__pycache__/_expression_parsing.cpython-312.pyc,,
+narwhals/__pycache__/_namespace.cpython-312.pyc,,
+narwhals/__pycache__/_native.cpython-312.pyc,,
+narwhals/__pycache__/_translate.cpython-312.pyc,,
+narwhals/__pycache__/_typing.cpython-312.pyc,,
+narwhals/__pycache__/_typing_compat.cpython-312.pyc,,
+narwhals/__pycache__/_utils.cpython-312.pyc,,
+narwhals/__pycache__/compliant.cpython-312.pyc,,
+narwhals/__pycache__/dataframe.cpython-312.pyc,,
+narwhals/__pycache__/dependencies.cpython-312.pyc,,
+narwhals/__pycache__/dtypes.cpython-312.pyc,,
+narwhals/__pycache__/exceptions.cpython-312.pyc,,
+narwhals/__pycache__/expr.cpython-312.pyc,,
+narwhals/__pycache__/expr_cat.cpython-312.pyc,,
+narwhals/__pycache__/expr_dt.cpython-312.pyc,,
+narwhals/__pycache__/expr_list.cpython-312.pyc,,
+narwhals/__pycache__/expr_name.cpython-312.pyc,,
+narwhals/__pycache__/expr_str.cpython-312.pyc,,
+narwhals/__pycache__/expr_struct.cpython-312.pyc,,
+narwhals/__pycache__/functions.cpython-312.pyc,,
+narwhals/__pycache__/group_by.cpython-312.pyc,,
+narwhals/__pycache__/plugins.cpython-312.pyc,,
+narwhals/__pycache__/schema.cpython-312.pyc,,
+narwhals/__pycache__/selectors.cpython-312.pyc,,
+narwhals/__pycache__/series.cpython-312.pyc,,
+narwhals/__pycache__/series_cat.cpython-312.pyc,,
+narwhals/__pycache__/series_dt.cpython-312.pyc,,
+narwhals/__pycache__/series_list.cpython-312.pyc,,
+narwhals/__pycache__/series_str.cpython-312.pyc,,
+narwhals/__pycache__/series_struct.cpython-312.pyc,,
+narwhals/__pycache__/sql.cpython-312.pyc,,
+narwhals/__pycache__/this.cpython-312.pyc,,
+narwhals/__pycache__/translate.cpython-312.pyc,,
+narwhals/__pycache__/typing.cpython-312.pyc,,
+narwhals/__pycache__/utils.cpython-312.pyc,,
+narwhals/_arrow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+narwhals/_arrow/__pycache__/__init__.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/dataframe.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/expr.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/group_by.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/namespace.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/selectors.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/series.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/series_cat.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/series_dt.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/series_list.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/series_str.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/series_struct.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/typing.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/utils.cpython-312.pyc,,
+narwhals/_arrow/dataframe.py,sha256=SIlHQrE80jg19Vq33Y2pCwNzhWDJj-0k-VD3zkzBYCw,31067
+narwhals/_arrow/expr.py,sha256=T0F5hG0k4jeITT__B6UIHVGvkgGK1uXpZTyu8ZuzPyg,9433
+narwhals/_arrow/group_by.py,sha256=3kNOSdauoXDWtMMAhOQfrQtbmhC1bzSN7Sl56QfwQE4,9174
+narwhals/_arrow/namespace.py,sha256=gpxdqsMjeKUTw93dabbCPRlmZJ_w8LvwEG5VQYK7xYo,11272
+narwhals/_arrow/selectors.py,sha256=kShb4WWC9UKQO_MTrYoLNKyo2KLdofjFRh1KBRtXCKQ,882
+narwhals/_arrow/series.py,sha256=ZdmyaElQif1QOUKvMdeyGpswgzndXMDkz-Toq_8yL2c,45518
+narwhals/_arrow/series_cat.py,sha256=j2DFbFEoaW2vSnLnCycspYNtbNYeWvVSeLELYb_3zF0,686
+narwhals/_arrow/series_dt.py,sha256=xTQt39PKTVPkeVwh87soCld_ll6-v_OQJTdUKJBBjS4,9026
+narwhals/_arrow/series_list.py,sha256=EDwxUa5bm5jrYci8SIK9sXa8gMv8k7GnCUndixg55gs,1461
+narwhals/_arrow/series_str.py,sha256=n87Jqa7q-O-GonBiwWy3V7itGrDYB168Jk9Z-yj7_ns,5179
+narwhals/_arrow/series_struct.py,sha256=MorW6vTLKxqpR96NhB5RxkkBWOxrCTyvJ76Ilnwb7LY,504
+narwhals/_arrow/typing.py,sha256=W3Vz_kc5zw94VeYzrC9xNPYpJBZ3DOSyfpuWPUVEW1M,2359
+narwhals/_arrow/utils.py,sha256=9ntQC59VAxpuZDsd2C6NNc510dNWle1VxEMKoLSEOjs,21010
+narwhals/_compliant/__init__.py,sha256=Xzk2TdU1KItMCg-r_cs599PPF8x9BMjgSMiOalW9Vjs,2319
+narwhals/_compliant/__pycache__/__init__.cpython-312.pyc,,
+narwhals/_compliant/__pycache__/any_namespace.cpython-312.pyc,,
+narwhals/_compliant/__pycache__/column.cpython-312.pyc,,
+narwhals/_compliant/__pycache__/dataframe.cpython-312.pyc,,
+narwhals/_compliant/__pycache__/expr.cpython-312.pyc,,
+narwhals/_compliant/__pycache__/group_by.cpython-312.pyc,,
+narwhals/_compliant/__pycache__/namespace.cpython-312.pyc,,
+narwhals/_compliant/__pycache__/selectors.cpython-312.pyc,,
+narwhals/_compliant/__pycache__/series.cpython-312.pyc,,
+narwhals/_compliant/__pycache__/typing.cpython-312.pyc,,
+narwhals/_compliant/__pycache__/window.cpython-312.pyc,,
+narwhals/_compliant/any_namespace.py,sha256=1Zbv6m0x21qbHJqG5YbhlmPDBKWS0XcGdqbm6s5Rwgk,4411
+narwhals/_compliant/column.py,sha256=d5watE0NL3f9tsIMqpELlI5OYIeKSMYKqZg1JAEZBEQ,5273
+narwhals/_compliant/dataframe.py,sha256=FlbZXtq3xuN1YlAXH7mUUZnEljeAv00gs6xyVoO3Pss,16819
+narwhals/_compliant/expr.py,sha256=YayC8nTW1BKfTEpK6k5P_K1IuGbcsRh3r9kTYO1yaxM,42125
+narwhals/_compliant/group_by.py,sha256=0eKCV-jxXe506ZVGRDQnoL0LsBeMMUHgqkalHkO8VQo,7050
+narwhals/_compliant/namespace.py,sha256=ai7Tj7tGeWPBYNd7Bbkxvz-Y7zVKcqQW-y1j-RX3PPk,11348
+narwhals/_compliant/selectors.py,sha256=und99_KqUg9zrdhBlfxQVl_6R-VPv6NsL3vv6Bcwhuk,11902
+narwhals/_compliant/series.py,sha256=g4kTQv140Hykaon14-VZazPgdjMmVPCezqmQiHbt-RY,13790
+narwhals/_compliant/typing.py,sha256=xQ6omwtoRfLCiGXlgh-o7FuR_zHwmxL_QEvp6S0EZ1U,7498
+narwhals/_compliant/window.py,sha256=_ji4goVKkT4YPTyZa_I0N2yGmwBfB1_LDG0WSXGbmlo,505
+narwhals/_constants.py,sha256=kE1KWsIky4ryabH-Z117ZtGW24ccTcreWOZJjpacO6I,1094
+narwhals/_dask/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+narwhals/_dask/__pycache__/__init__.cpython-312.pyc,,
+narwhals/_dask/__pycache__/dataframe.cpython-312.pyc,,
+narwhals/_dask/__pycache__/expr.cpython-312.pyc,,
+narwhals/_dask/__pycache__/expr_dt.cpython-312.pyc,,
+narwhals/_dask/__pycache__/expr_str.cpython-312.pyc,,
+narwhals/_dask/__pycache__/group_by.cpython-312.pyc,,
+narwhals/_dask/__pycache__/namespace.cpython-312.pyc,,
+narwhals/_dask/__pycache__/selectors.cpython-312.pyc,,
+narwhals/_dask/__pycache__/utils.cpython-312.pyc,,
+narwhals/_dask/dataframe.py,sha256=tCT7sjZQ-5s3ykXJI-U-dIvQjIWukvf2MoroHEx_g6A,19856
+narwhals/_dask/expr.py,sha256=VSd6j1ucRuFXkkiEg6hsVs7LLxo-wN3b9bFSrhFNa78,26735
+narwhals/_dask/expr_dt.py,sha256=gtLt-UgD0Kw_Vev32rOZUdmP_XQfvU9XrKjtgmkQYps,6276
+narwhals/_dask/expr_str.py,sha256=XE6bKZd-PTfMsZOJ49mWzl1miiQQoKQlTG2U_i97gic,3885
+narwhals/_dask/group_by.py,sha256=nwgSODQljSjJ10snNGvOvKN3ctBXNertD6pciA5H0cs,5083
+narwhals/_dask/namespace.py,sha256=lfE8aXPwpb7ejdIhkxE5kFZy4GasGGrYEqraRaxpTBE,13416
+narwhals/_dask/selectors.py,sha256=W8tLFVUbafUb5EKi5rg09-cP9JA4T3MwiIjKCYk1YH0,927
+narwhals/_dask/utils.py,sha256=pAUYw9k1krePgRzGWxWVBj4OyMaT6AALaRILOR6ehxo,5445
+narwhals/_duckdb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+narwhals/_duckdb/__pycache__/__init__.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/dataframe.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/expr.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/expr_dt.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/expr_list.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/expr_str.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/expr_struct.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/group_by.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/namespace.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/selectors.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/series.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/typing.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/utils.cpython-312.pyc,,
+narwhals/_duckdb/dataframe.py,sha256=SjQP-dj-XAd_lRCLqDmH-hHWT74yypUwvy9bNFEI4Bw,20462
+narwhals/_duckdb/expr.py,sha256=k35p2V98KcjhMchjvdvkowap7Sw8WBrbVAFXPcej4wc,12486
+narwhals/_duckdb/expr_dt.py,sha256=RDqYnsM0pDPEh59hq0BHrl6YNLFBR7w8gLIdxVWdzvY,5157
+narwhals/_duckdb/expr_list.py,sha256=OgnTsvii5lJDZ2vBJQIXBGT0hMqK2HfGOX_Dvrli2es,2734
+narwhals/_duckdb/expr_str.py,sha256=ksmAAAnRr9fE5dzLI8ZkcIkxCdv-o1lbE3k9zlVsv7k,1870
+narwhals/_duckdb/expr_struct.py,sha256=eN06QA1JS6wjAt7_AZzW3xoztHM_hoadlFUl_hwsEiE,576
+narwhals/_duckdb/group_by.py,sha256=e07h9TN45G6HUveqhalRDKp9PngacCRLa-o3WlkoW5o,1276
+narwhals/_duckdb/namespace.py,sha256=g-4cU0j3CVwe4ljTc4brdYRoNSJM18b6g3vnvCY4EKQ,6400
+narwhals/_duckdb/selectors.py,sha256=yA16Z-MlJUJBjOu0XI9qVO4Zx7L_T5FN2DQqNAYhu-o,1033
+narwhals/_duckdb/series.py,sha256=xBpuPUnSSIQ1vYEKjHQFZN7ix1ZyMwSchliDPpkf3Wk,1397
+narwhals/_duckdb/typing.py,sha256=gO_Odyinkn4QZY_TU4uuzda6mbeo38glOOUUripcWgg,454
+narwhals/_duckdb/utils.py,sha256=yqg4XsFY_URuzEMBxew2a8aDdgHD2FMXfBBXqA-Bbz4,15810
+narwhals/_duration.py,sha256=WGzj3FVcC2KogqRhNeim3YDIwUn8HkXQHAljtvHrjwQ,3139
+narwhals/_enum.py,sha256=6mWLGvqHP8JhLRhBjGof4Ungx-SDasqu-G0M2pX0Oew,1142
+narwhals/_exceptions.py,sha256=uVgFKgx_6ub9MHJ_qJ7xC5zie-uRVtbJo0j3FDoXAqk,1894
+narwhals/_expression_parsing.py,sha256=M-GhKye9mecJLjI9lF3jiDVSQWijZ0j2nH6-DkPSYKc,33387
+narwhals/_ibis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+narwhals/_ibis/__pycache__/__init__.cpython-312.pyc,,
+narwhals/_ibis/__pycache__/dataframe.cpython-312.pyc,,
+narwhals/_ibis/__pycache__/expr.cpython-312.pyc,,
+narwhals/_ibis/__pycache__/expr_dt.cpython-312.pyc,,
+narwhals/_ibis/__pycache__/expr_list.cpython-312.pyc,,
+narwhals/_ibis/__pycache__/expr_str.cpython-312.pyc,,
+narwhals/_ibis/__pycache__/expr_struct.cpython-312.pyc,,
+narwhals/_ibis/__pycache__/group_by.cpython-312.pyc,,
+narwhals/_ibis/__pycache__/namespace.cpython-312.pyc,,
+narwhals/_ibis/__pycache__/selectors.cpython-312.pyc,,
+narwhals/_ibis/__pycache__/series.cpython-312.pyc,,
+narwhals/_ibis/__pycache__/utils.cpython-312.pyc,,
+narwhals/_ibis/dataframe.py,sha256=ihqiWfvAeCRs3Vlcyj75yAel-Z4lGR8IL4g80MjX2cU,16388
+narwhals/_ibis/expr.py,sha256=2Unv20zbWJ52goEPNIlq7zCKXtfDC9Z_B044G54BY_g,14018
+narwhals/_ibis/expr_dt.py,sha256=0RS1B1geFYxyS5RplyG9VES8mFg4tylcG75dIKczvNs,3308
+narwhals/_ibis/expr_list.py,sha256=1REKJRa7930JTMofZbSb4rghjBg1mOAZf8sRcKx1EUs,2343
+narwhals/_ibis/expr_str.py,sha256=fvYzDibIaGH8bE3ZhTUF9yfs--0ONM6l7f5zeW7neLk,3443
+narwhals/_ibis/expr_struct.py,sha256=FDsa5MqcHhqPmpZIEfGBASdqxPkyImrlGTH7XUSw3cs,565
+narwhals/_ibis/group_by.py,sha256=enNzAPUsA_LIwPNJ7jG_MJKyqG2HyCiesBEX3pJgJBg,1031
+narwhals/_ibis/namespace.py,sha256=H3d9nO20RAEF0UVQzBaN4jHkSmk3JHR2iV2tP26uzKE,5635
+narwhals/_ibis/selectors.py,sha256=SkFxoukpKc_OjwKoKHRm8VwMaphCMUeWBJ2g_oWz3D0,961
+narwhals/_ibis/series.py,sha256=CZDwDPsdELKtdr7OWmcFyGqexr33Ucfnv_RU95VJxIQ,1218
+narwhals/_ibis/utils.py,sha256=j2nf-cb3wXP0OOlMuyg3qMsFOYZHD_c5pnW_qwu4uy0,10591
+narwhals/_interchange/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+narwhals/_interchange/__pycache__/__init__.cpython-312.pyc,,
+narwhals/_interchange/__pycache__/dataframe.cpython-312.pyc,,
+narwhals/_interchange/__pycache__/series.cpython-312.pyc,,
+narwhals/_interchange/dataframe.py,sha256=FC_2WuxxI4RPUBMqcau68rkdfsxhClou4zCErx1flcw,6034
+narwhals/_interchange/series.py,sha256=nSxdlOZrw3wtavS42TMR_b_EGgPBv224ioZBMo5eoC8,1651
+narwhals/_namespace.py,sha256=ARbIk31MgCvYDAxlAz7J9TGKktG0_p-Eu9myDi3nurs,8551
+narwhals/_native.py,sha256=ByNgFo_kGIsgr_dSte8mT6snLjiBbsvAFGrECnXjl-g,15402
+narwhals/_pandas_like/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+narwhals/_pandas_like/__pycache__/__init__.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/dataframe.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/expr.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/group_by.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/namespace.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/selectors.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/series.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/series_cat.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/series_dt.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/series_list.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/series_str.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/series_struct.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/typing.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/utils.cpython-312.pyc,,
+narwhals/_pandas_like/dataframe.py,sha256=S7yOLQzPJkDD0_WG3FRFNXHGi1slBusZ_sFtZlavNbo,46397
+narwhals/_pandas_like/expr.py,sha256=8S2dcPNbB-PpsxWloB_PTVAIg5-wiKXMGHrSws9Eznw,16990
+narwhals/_pandas_like/group_by.py,sha256=09zHMYyVXnQBM7efTHbWYMO4a-QdUYcVBfO3kY9oWjg,15484
+narwhals/_pandas_like/namespace.py,sha256=hEs23p2AqNEp_NqPp_ZCYY9s_geiIuMCJgJ8_hH80mk,17025
+narwhals/_pandas_like/selectors.py,sha256=ksx2a0Pf1g2OJu2dsWGnuUH3095v40OnhzT7zkolfhA,1015
+narwhals/_pandas_like/series.py,sha256=hNPg9jRyDUon9UDJ1xgklako2Dn--cUBfldnBFw_llE,48087
+narwhals/_pandas_like/series_cat.py,sha256=MJwCnJ49hfnODh6JgMHOCQ2KBlTbmySU6_X4XWaqiz4,527
+narwhals/_pandas_like/series_dt.py,sha256=Mq6Dhrki-HoV2yqnbsKWT60W2li1UjtOTnKB5V3FTzA,11814
+narwhals/_pandas_like/series_list.py,sha256=Ew6nc4z3cddOWDAwj-8s-ouHew7Eq9mTQbb55iw7JGI,2960
+narwhals/_pandas_like/series_str.py,sha256=XCX1xE2-GjV5E6VVQWQXVmuyS7UNuG3e5jhgwaDu4ek,4875
+narwhals/_pandas_like/series_struct.py,sha256=vX9HoO42vHackvVozUfp8odM9uJ4owct49ydKDnohdk,518
+narwhals/_pandas_like/typing.py,sha256=4-y2QKdz3GChKp8HStqFLW8Fwe5KUMFFJDtjGR76ERQ,1059
+narwhals/_pandas_like/utils.py,sha256=DBFU2dBqxbaXBP2mClNEGMuL_0hByOsn4yLnUHZLmPE,26543
+narwhals/_polars/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+narwhals/_polars/__pycache__/__init__.cpython-312.pyc,,
+narwhals/_polars/__pycache__/dataframe.cpython-312.pyc,,
+narwhals/_polars/__pycache__/expr.cpython-312.pyc,,
+narwhals/_polars/__pycache__/group_by.cpython-312.pyc,,
+narwhals/_polars/__pycache__/namespace.cpython-312.pyc,,
+narwhals/_polars/__pycache__/series.cpython-312.pyc,,
+narwhals/_polars/__pycache__/typing.cpython-312.pyc,,
+narwhals/_polars/__pycache__/utils.cpython-312.pyc,,
+narwhals/_polars/dataframe.py,sha256=vTeRBVrS103xVvdGhHJ8Hs31WCpuBGle421Csbi7dYI,26141
+narwhals/_polars/expr.py,sha256=QdRHd7aKjEO1J595zzp4jwLq5lOqoO5c7yPDjB1dcB0,17882
+narwhals/_polars/group_by.py,sha256=PsxQPWX7QWy2iXUWJEelC5O6mR1TKr9MB_i6O5RVxms,2373
+narwhals/_polars/namespace.py,sha256=AFRy05M9TLzYlJVwwKlk1YN7Mb8EWdAc7i132CjGblE,10469
+narwhals/_polars/series.py,sha256=Pdp4B1k6AR4moNWugq4xTUvkHJQizz04wzE1ZAEfaf4,28502
+narwhals/_polars/typing.py,sha256=d11nVYqv1dqC_H2A-PXz1oHYYCAOnkK_s87ytm4twMA,302
+narwhals/_polars/utils.py,sha256=NcNC8kPirVuo3FRVtOcoXMPIfElikdwQ05nfR49flLM,13035
+narwhals/_spark_like/__init__.py,sha256=T7_UCePrrYs1ZeMatvCUYUvQcXvrDjQ4b08_ugWIHAo,87
+narwhals/_spark_like/__pycache__/__init__.cpython-312.pyc,,
+narwhals/_spark_like/__pycache__/dataframe.cpython-312.pyc,,
+narwhals/_spark_like/__pycache__/expr.cpython-312.pyc,,
+narwhals/_spark_like/__pycache__/expr_dt.cpython-312.pyc,,
+narwhals/_spark_like/__pycache__/expr_list.cpython-312.pyc,,
+narwhals/_spark_like/__pycache__/expr_str.cpython-312.pyc,,
+narwhals/_spark_like/__pycache__/expr_struct.cpython-312.pyc,,
+narwhals/_spark_like/__pycache__/group_by.cpython-312.pyc,,
+narwhals/_spark_like/__pycache__/namespace.cpython-312.pyc,,
+narwhals/_spark_like/__pycache__/selectors.cpython-312.pyc,,
+narwhals/_spark_like/__pycache__/utils.cpython-312.pyc,,
+narwhals/_spark_like/dataframe.py,sha256=tcQSJl1RO6i1DuV4bsji1mHWSqHLOy5CAC3UoVsP3tY,23329
+narwhals/_spark_like/expr.py,sha256=oBtmPMTlS356IoDQ47HXzCujDqmh4QXgQQn2le71qC4,15337
+narwhals/_spark_like/expr_dt.py,sha256=EuvgesSi-N4DN3F3zRy9kS2So6gx-w7bxlGbyrJieBU,7874
+narwhals/_spark_like/expr_list.py,sha256=1B9OsYCXYEWJqIUm5Id2ikMMKNTwoCyeia5LXRYp-OA,3853
+narwhals/_spark_like/expr_str.py,sha256=iM2nmJpIeNQP8v5W9kyug1wlVir3cM8VDXHVGyHQMPU,2452
+narwhals/_spark_like/expr_struct.py,sha256=haBDpuRhn_nGAFjMF3arhhRr6NfefNei9vEmAOa0fQI,613
+narwhals/_spark_like/group_by.py,sha256=DH7fgToOMLaQXEVPSkMjqzTpdz2ZjDIAM0WoK8XjQFU,1247
+narwhals/_spark_like/namespace.py,sha256=k1UTQez8qMdgQRj6H8yi4jEcAqhZe7a8w83PwVaFLlk,8522
+narwhals/_spark_like/selectors.py,sha256=SzJPoFjyIEviSSvPRvL81o1jjQJcM-Veqb52vFU66JQ,1086
+narwhals/_spark_like/utils.py,sha256=hRQT2SDrKJfZrfFFqDhW-s8UVkfc0LcKuTjbgoeTcj0,11892
+narwhals/_sql/__init__.py,sha256=T7_UCePrrYs1ZeMatvCUYUvQcXvrDjQ4b08_ugWIHAo,87
+narwhals/_sql/__pycache__/__init__.cpython-312.pyc,,
+narwhals/_sql/__pycache__/dataframe.cpython-312.pyc,,
+narwhals/_sql/__pycache__/expr.cpython-312.pyc,,
+narwhals/_sql/__pycache__/expr_dt.cpython-312.pyc,,
+narwhals/_sql/__pycache__/expr_str.cpython-312.pyc,,
+narwhals/_sql/__pycache__/group_by.cpython-312.pyc,,
+narwhals/_sql/__pycache__/namespace.cpython-312.pyc,,
+narwhals/_sql/__pycache__/typing.cpython-312.pyc,,
+narwhals/_sql/dataframe.py,sha256=itTHoiLQ74S0Z8SeRgFT_Ss4jbWBs9La5DrME4Mm3xU,2451
+narwhals/_sql/expr.py,sha256=-7VO3_RWNAmr-2YANZD0_K6EKD3_dBMUTMi1sHtqI20,34572
+narwhals/_sql/expr_dt.py,sha256=QcBGKkp9_gUgPOMGXcfuGsqeC7iT1AAGrq5ZDX-nEKo,1700
+narwhals/_sql/expr_str.py,sha256=RPsPIqySlNmAOOMGVai0nUnpUqhldc1X6jx-Bsnq6TM,7433
+narwhals/_sql/group_by.py,sha256=-yR5J2-Kk0awFRoFnLici00rfTK_5CxFKJSxc-Bt8Zs,1669
+narwhals/_sql/namespace.py,sha256=hvSGHpWebsx05PYipMQp8GRlM1Zx-_qCopPzhv7nbXo,3352
+narwhals/_sql/typing.py,sha256=e3LkLPI4oa2IzykR7BgO9IIfCKRw0vrX4uHxPTB-uJM,487
+narwhals/_translate.py,sha256=z9BXuXTI6YSjep4I1o9hRE35JT-7sLGt8Z9GF01GhRc,9389
+narwhals/_typing.py,sha256=eneOfgi2z_4rGbYnvT_IWmEyMgSUhWrTZ1kaGFWVLNQ,6497
+narwhals/_typing_compat.py,sha256=h-BtLEl7CrZ-hYLlwYTOcCdsUS3dvgvkxQTcDQ7RYmA,2516
+narwhals/_utils.py,sha256=0P_V4Avv5NdS5HSJg_8ECjzQiadLoSlyEdYU6ekiynU,73287
+narwhals/compliant.py,sha256=MYzN7r6qgieJjw68g4I-HKXum0r_fhlf1vAlfRL47yk,920
+narwhals/dataframe.py,sha256=ChwNNRfP78bDtQMlC6FP_Y0f869avDcRCHvAuWwBxq4,137172
+narwhals/dependencies.py,sha256=ABk7GskzfO4JnEBoH4WotfEEYR3KylOqY8anDjt8140,19926
+narwhals/dtypes.py,sha256=iFv3WabAXslxxDd3ZHshkbLXuTvKNFV4kY7EvoeFAcE,33117
+narwhals/exceptions.py,sha256=97IIfR_YmJYZEb53uwoARpegXleq-Im3QMDjZs7thGo,3758
+narwhals/expr.py,sha256=YB1pRIzmMsfZh3D9qW913EAo-LbQMeMoCn_jdx07Xns,110482
+narwhals/expr_cat.py,sha256=Rfyy4Q_oyFmfz2enTebUY2MCQtwA8ZtBFmhUpQ295UU,1250
+narwhals/expr_dt.py,sha256=FFPj3KcdgZrvv4M7-_IKPvivv5GZFTbjsnULxOB3_6Q,31816
+narwhals/expr_list.py,sha256=K99FGLW9IYeK7NRiVKrICJ6NseQJl86YJcf47sfdHPw,14228
+narwhals/expr_name.py,sha256=yhMal_7caymLduWhTs1NRYb5y35bincnoZK5gCQWX5U,4814
+narwhals/expr_str.py,sha256=b45kQ86rDc5oBETxqw_QXKFEKRJ0E6X9DC40o8wgmic,25270
+narwhals/expr_struct.py,sha256=9sHY743_UDsduwgUfip4X_xs-_A-aCHSVdlMsDk8WNA,1790
+narwhals/functions.py,sha256=q4slLkkjBV-17bPPiTDStZi8TETJ7WrMHixtHM6KMgw,71617
+narwhals/group_by.py,sha256=JLE0hEdi_-0dVAL_ayby7DqUUbxQjSMwBsIh0Cb0OtY,6632
+narwhals/plugins.py,sha256=8ZIhps5rCUgf9ilwvmtgqO4sMOaSaRSekvixlLyzRxg,3878
+narwhals/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+narwhals/schema.py,sha256=4yiRz6Qv373ATpN6kCFNSblUb4vMDX9USpKeJTDRrYI,12369
+narwhals/selectors.py,sha256=Wig5bbVEE8IYYlErkH_xIeTykC6x7tDb1eXqUDlLfBc,10200
+narwhals/series.py,sha256=ET5N0CkDXu4FdcMi7XKQbYPhRWPdAEMGgsNRVH6_grA,103178
+narwhals/series_cat.py,sha256=mikr2q3S8kWo8uTJ4s2z6ZKv9cgn-jC1xNy_tYQaQyw,831
+narwhals/series_dt.py,sha256=O3ZRXCPbwtQbcyqahyNBw3PMMhJAGMd732pSYjGaF4c,23051
+narwhals/series_list.py,sha256=8QsdcP_HGrvcu-w-l_WT28o_tJ2_C7xKWaN5sCf9-_g,7954
+narwhals/series_str.py,sha256=dPKgIEyb1BP6l1hW4Hl8RsngKPWayXcaWdamkbjuxU0,19378
+narwhals/series_struct.py,sha256=bixxdASlxYyP1prDjMmfltVU5212a596VQZE11yszUg,930
+narwhals/sql.py,sha256=MhWT4E3S4gV4fiQCmVlFd6k01irkF4aJhbpzOEdQIas,3767
+narwhals/stable/__init__.py,sha256=WX57ijebHmAZMq_ngLYyOZFTxiBc99dnxldiXkBDccQ,95
+narwhals/stable/__pycache__/__init__.cpython-312.pyc,,
+narwhals/stable/v1/__init__.py,sha256=twpERqdSTJfqf0EC8gZ0kJrxVXRLuC3Z2BlkzgJXpUY,36571
+narwhals/stable/v1/__pycache__/__init__.cpython-312.pyc,,
+narwhals/stable/v1/__pycache__/_dtypes.cpython-312.pyc,,
+narwhals/stable/v1/__pycache__/_namespace.cpython-312.pyc,,
+narwhals/stable/v1/__pycache__/dependencies.cpython-312.pyc,,
+narwhals/stable/v1/__pycache__/dtypes.cpython-312.pyc,,
+narwhals/stable/v1/__pycache__/selectors.cpython-312.pyc,,
+narwhals/stable/v1/__pycache__/typing.cpython-312.pyc,,
+narwhals/stable/v1/_dtypes.py,sha256=ngGP8hQRdYv19GJgtynHPMEg-RUIDOs_jdbGrt5YO9E,2722
+narwhals/stable/v1/_namespace.py,sha256=gfsbT4R4aLmmdArY35LRpEHPiUeZKEEnXGiY9ypFtwE,296
+narwhals/stable/v1/dependencies.py,sha256=aM0IShF4hbaaMEDRJQXvsu4RABZOdBG4QhrpJPxb7fg,5001
+narwhals/stable/v1/dtypes.py,sha256=u2NFDJyCkjsK6p3K9ULJS7CoG16z0Z1MQiACTVkhkH4,1082
+narwhals/stable/v1/selectors.py,sha256=xEA9bBzkpTwUanGGoFwBCcHIAXb8alwrPX1mjzE9mDM,312
+narwhals/stable/v1/typing.py,sha256=9YhcvKJ8jtN8mQBD0q12HShEM6Q-D10DYB-m4lQYzDM,4998
+narwhals/stable/v2/__init__.py,sha256=7eG-5HA3p70dRpmNIG0SRk6A7bq9qahE9yOibwO2KmA,40312
+narwhals/stable/v2/__pycache__/__init__.cpython-312.pyc,,
+narwhals/stable/v2/__pycache__/_namespace.cpython-312.pyc,,
+narwhals/stable/v2/__pycache__/dependencies.cpython-312.pyc,,
+narwhals/stable/v2/__pycache__/dtypes.cpython-312.pyc,,
+narwhals/stable/v2/__pycache__/selectors.cpython-312.pyc,,
+narwhals/stable/v2/__pycache__/typing.cpython-312.pyc,,
+narwhals/stable/v2/_namespace.py,sha256=oYB5nrFGxqqTonkRx9vUanyBxGs2Yb0j7_juMyvnvWA,296
+narwhals/stable/v2/dependencies.py,sha256=vpYWx_dron6wFdbQ60G06EV2UJ_LMd52LDodCrAY5Jg,86
+narwhals/stable/v2/dtypes.py,sha256=iMpk2Kc1mNiQYmboOSgmiAijklSUBHSHF2LTKMKnGe8,80
+narwhals/stable/v2/selectors.py,sha256=sjJL3agHd8Rgf_lWhgCmEKruhWEkwHdX32-n85OqVJU,83
+narwhals/stable/v2/typing.py,sha256=pAR_JL07FgNaLgCenpQVO3E0oFwYAi2wxCS2htgUJUs,2494
+narwhals/testing/__init__.py,sha256=eCy8mtRcHySZiaWPV2r21DLZrznjtRQggj8ygoQms28,219
+narwhals/testing/__pycache__/__init__.cpython-312.pyc,,
+narwhals/testing/asserts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+narwhals/testing/asserts/__pycache__/__init__.cpython-312.pyc,,
+narwhals/testing/asserts/__pycache__/frame.cpython-312.pyc,,
+narwhals/testing/asserts/__pycache__/series.cpython-312.pyc,,
+narwhals/testing/asserts/__pycache__/utils.cpython-312.pyc,,
+narwhals/testing/asserts/frame.py,sha256=SUNo7tFyLcXEyEKK1SHaPmM6O99YSpGYKNf5kY3Obm8,10511
+narwhals/testing/asserts/series.py,sha256=MWhbghtXnT7GX8hsOS31TkoX0TpmkLmsFReaUaPR1F8,11118
+narwhals/testing/asserts/utils.py,sha256=3VLqrRONh5e_-sQfhweOEr7gDjvZISq_o-XxGBn4mrU,2188
+narwhals/this.py,sha256=BbKcj0ReWqE01lznzKjuqq7otXONvjBevWWC5aJhQxs,1584
+narwhals/translate.py,sha256=YlS3UQWdU7JXbZq2ZcY1HVPBQLAKIMFhlY3AOQ_67cM,24169
+narwhals/typing.py,sha256=2imWqcYKdpbSfjjNtwNSQ1Y_hm078_rre1cGX0ox3qg,13970
+narwhals/utils.py,sha256=2GT3XxucWI6l9r9jTwMw7Aha2G73FsSXgXNFZ3O_ZyA,223

.venv_haddock/lib/python3.12/site-packages/narwhals-2.19.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

.venv_haddock/lib/python3.12/site-packages/narwhals-2.19.0.dist-info/licenses/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 to present, Marco Gorelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

.venv_haddock/lib/python3.12/site-packages/narwhals/dependencies.py

@@ -0,0 +1,631 @@
+# pandas / Polars / etc. : if a user passes a dataframe from one of these
+# libraries, it means they must already have imported the given module.
+# So, we can just check sys.modules.
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING, Any
+
+from narwhals._exceptions import issue_warning
+
+if TYPE_CHECKING:
+    import cudf
+    import dask.dataframe as dd
+    import duckdb
+    import ibis
+    import modin.pandas as mpd
+    import pandas as pd
+    import polars as pl
+    import pyarrow as pa
+    import pyspark.sql as pyspark_sql
+    from pyspark.sql.connect.dataframe import DataFrame as PySparkConnectDataFrame
+    from typing_extensions import TypeGuard, TypeIs
+
+    from narwhals._spark_like.dataframe import SQLFrameDataFrame
+    from narwhals.dataframe import DataFrame, LazyFrame
+    from narwhals.series import Series
+    from narwhals.typing import (
+        IntoDataFrameT,
+        IntoLazyFrameT,
+        IntoSeriesT,
+        PandasLikeDType,
+        _1DArray,
+        _1DArrayInt,
+        _2DArray,
+        _NDArray,
+        _NumpyScalar,
+        _ShapeT,
+    )
+
+
+# We silently allow these but - given that they claim
+# to be drop-in replacements for pandas - testing is
+# their responsibility.
+IMPORT_HOOKS = frozenset(["fireducks"])
+
+
+def get_polars() -> Any:
+    """Get Polars module (if already imported - else return None)."""
+    return sys.modules.get("polars", None)
+
+
+def get_pandas() -> Any:
+    """Get pandas module (if already imported - else return None)."""
+    return sys.modules.get("pandas", None)
+
+
+def get_modin() -> Any:  # pragma: no cover
+    """Get modin.pandas module (if already imported - else return None)."""
+    return sys.modules.get("modin.pandas", None)
+
+
+def get_cudf() -> Any:
+    """Get cudf module (if already imported - else return None)."""
+    return sys.modules.get("cudf", None)
+
+
+def get_cupy() -> Any:
+    """Get cupy module (if already imported - else return None)."""
+    return sys.modules.get("cupy", None)
+
+
+def get_pyarrow() -> Any:  # pragma: no cover
+    """Get pyarrow module (if already imported - else return None)."""
+    return sys.modules.get("pyarrow", None)
+
+
+def get_numpy() -> Any:
+    """Get numpy module (if already imported - else return None)."""
+    return sys.modules.get("numpy", None)
+
+
+def get_dask() -> Any:  # pragma: no cover
+    """Get dask (if already imported - else return None)."""
+    return sys.modules.get("dask", None)
+
+
+def get_dask_dataframe() -> Any:
+    """Get dask.dataframe module (if already imported - else return None)."""
+    return sys.modules.get("dask.dataframe", None)
+
+
+def get_duckdb() -> Any:
+    """Get duckdb module (if already imported - else return None)."""
+    return sys.modules.get("duckdb", None)
+
+
+def get_ibis() -> Any:
+    """Get ibis module (if already imported - else return None)."""
+    return sys.modules.get("ibis", None)
+
+
+def get_dask_expr() -> Any:  # pragma: no cover
+    """Get dask_expr module (if already imported - else return None)."""
+    if (dd := get_dask_dataframe()) is not None and hasattr(dd, "dask_expr"):
+        return dd.dask_expr
+    return sys.modules.get("dask_expr", None)
+
+
+def get_pyspark() -> Any:  # pragma: no cover
+    """Get pyspark module (if already imported - else return None)."""
+    return sys.modules.get("pyspark", None)
+
+
+def get_pyspark_sql() -> Any:
+    """Get pyspark.sql module (if already imported - else return None)."""
+    return sys.modules.get("pyspark.sql", None)
+
+
+def get_pyspark_connect() -> Any:
+    """Get pyspark.sql.connect module (if already imported - else return None)."""
+    return sys.modules.get("pyspark.sql.connect", None)
+
+
+def get_sqlframe() -> Any:
+    """Get sqlframe module (if already imported - else return None)."""
+    return sys.modules.get("sqlframe", None)
+
+
+def _warn_if_narwhals_df_or_lf(df: Any) -> None:
+    if is_narwhals_dataframe(df) or is_narwhals_lazyframe(df):
+        msg = (
+            f"You passed a `{type(df)}` to `is_pandas_dataframe`.\n\n"
+            "Hint: Instead of e.g. `is_pandas_dataframe(df)`, "
+            "did you mean `is_pandas_dataframe(df.to_native())`?"
+        )
+        issue_warning(msg, UserWarning)
+
+
+def _warn_if_narwhals_series(ser: Any) -> None:
+    if is_narwhals_series(ser):
+        msg = (
+            f"You passed a `{type(ser)}` to `is_pandas_series`.\n\n"
+            "Hint: Instead of e.g. `is_pandas_series(ser)`, "
+            "did you mean `is_pandas_series(ser.to_native())`?"
+        )
+        issue_warning(msg, UserWarning)
+
+
+def is_pandas_dataframe(df: Any) -> TypeIs[pd.DataFrame]:
+    """Check whether `df` is a pandas DataFrame without importing pandas.
+
+    Warning:
+        This method cannot be called on a Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return ((pd := get_pandas()) is not None and isinstance(df, pd.DataFrame)) or any(
+        (mod := sys.modules.get(module_name, None)) is not None
+        and isinstance(df, mod.pandas.DataFrame)
+        for module_name in IMPORT_HOOKS
+    )
+
+
+def is_pandas_series(ser: Any) -> TypeIs[pd.Series[Any]]:
+    """Check whether `ser` is a pandas Series without importing pandas.
+
+    Warning:
+        This method cannot be called on Narwhals Series.
+    """
+    _warn_if_narwhals_series(ser)
+    return ((pd := get_pandas()) is not None and isinstance(ser, pd.Series)) or any(
+        (mod := sys.modules.get(module_name, None)) is not None
+        and isinstance(ser, mod.pandas.Series)
+        for module_name in IMPORT_HOOKS
+    )
+
+
+def is_pandas_index(index: Any) -> TypeIs[pd.Index[Any]]:
+    """Check whether `index` is a pandas Index without importing pandas."""
+    return ((pd := get_pandas()) is not None and isinstance(index, pd.Index)) or any(
+        (mod := sys.modules.get(module_name, None)) is not None
+        and isinstance(index, mod.pandas.Index)
+        for module_name in IMPORT_HOOKS
+    )
+
+
+def is_modin_dataframe(df: Any) -> TypeIs[mpd.DataFrame]:
+    """Check whether `df` is a modin DataFrame without importing modin.
+
+    Warning:
+        This method cannot be called on a Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return (mpd := get_modin()) is not None and isinstance(df, mpd.DataFrame)
+
+
+def is_modin_series(ser: Any) -> TypeIs[mpd.Series]:
+    """Check whether `ser` is a modin Series without importing modin.
+
+    Warning:
+        This method cannot be called on Narwhals Series.
+    """
+    _warn_if_narwhals_series(ser)
+    return (mpd := get_modin()) is not None and isinstance(ser, mpd.Series)
+
+
+def is_modin_index(index: Any) -> TypeIs[mpd.Index[Any]]:  # pragma: no cover
+    """Check whether `index` is a modin Index without importing modin."""
+    return (mpd := get_modin()) is not None and isinstance(index, mpd.Index)
+
+
+def is_cudf_dataframe(df: Any) -> TypeIs[cudf.DataFrame]:
+    """Check whether `df` is a cudf DataFrame without importing cudf.
+
+    Warning:
+        This method cannot be called on a Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return (cudf := get_cudf()) is not None and isinstance(df, cudf.DataFrame)
+
+
+def is_cudf_series(ser: Any) -> TypeIs[cudf.Series[Any]]:
+    """Check whether `ser` is a cudf Series without importing cudf.
+
+    Warning:
+        This method cannot be called on Narwhals Series.
+    """
+    _warn_if_narwhals_series(ser)
+    return (cudf := get_cudf()) is not None and isinstance(ser, cudf.Series)
+
+
+def is_cudf_index(index: Any) -> TypeIs[cudf.Index]:
+    """Check whether `index` is a cudf Index without importing cudf."""
+    return (cudf := get_cudf()) is not None and isinstance(
+        index, cudf.Index
+    )  # pragma: no cover
+
+
+def is_cupy_scalar(obj: Any) -> bool:
+    return (
+        (cupy := get_cupy()) is not None
+        and isinstance(obj, cupy.ndarray)
+        and obj.size == 1
+    )  # pragma: no cover
+
+
+def is_dask_dataframe(df: Any) -> TypeIs[dd.DataFrame]:
+    """Check whether `df` is a Dask DataFrame without importing Dask.
+
+    Warning:
+        This method cannot be called on a Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return (dd := get_dask_dataframe()) is not None and isinstance(df, dd.DataFrame)
+
+
+def is_duckdb_relation(df: Any) -> TypeIs[duckdb.DuckDBPyRelation]:
+    """Check whether `df` is a DuckDB Relation without importing DuckDB.
+
+    Warning:
+        This method cannot be called on Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return (duckdb := get_duckdb()) is not None and isinstance(
+        df, duckdb.DuckDBPyRelation
+    )
+
+
+def is_ibis_table(df: Any) -> TypeIs[ibis.Table]:
+    """Check whether `df` is a Ibis Table without importing Ibis.
+
+    Warning:
+        This method cannot be called on Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return (ibis := get_ibis()) is not None and isinstance(df, ibis.expr.types.Table)
+
+
+def is_polars_dataframe(df: Any) -> TypeIs[pl.DataFrame]:
+    """Check whether `df` is a Polars DataFrame without importing Polars.
+
+    Warning:
+        This method cannot be called on a Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return (pl := get_polars()) is not None and isinstance(df, pl.DataFrame)
+
+
+def is_polars_lazyframe(df: Any) -> TypeIs[pl.LazyFrame]:
+    """Check whether `df` is a Polars LazyFrame without importing Polars.
+
+    Warning:
+        This method cannot be called on Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return (pl := get_polars()) is not None and isinstance(df, pl.LazyFrame)
+
+
+def is_polars_series(ser: Any) -> TypeIs[pl.Series]:
+    """Check whether `ser` is a Polars Series without importing Polars.
+
+    Warning:
+        This method cannot be called on Narwhals Series.
+    """
+    _warn_if_narwhals_series(ser)
+    return (pl := get_polars()) is not None and isinstance(ser, pl.Series)
+
+
+def is_polars_schema(obj: Any) -> TypeIs[pl.Schema]:
+    return (
+        bool(pl := get_polars()) and hasattr(pl, "Schema") and isinstance(obj, pl.Schema)
+    )
+
+
+# NOTE: For `pl.Schema` only instantiated dtypes are expected
+def is_polars_data_type(obj: Any) -> TypeIs[pl.DataType]:
+    return bool(pl := get_polars()) and isinstance(obj, pl.DataType)
+
+
+def is_pyarrow_chunked_array(ser: Any) -> TypeIs[pa.ChunkedArray[Any]]:
+    """Check whether `ser` is a PyArrow ChunkedArray without importing PyArrow.
+
+    Warning:
+        This method cannot be called on Narwhals Series.
+    """
+    _warn_if_narwhals_series(ser)
+    return (pa := get_pyarrow()) is not None and isinstance(ser, pa.ChunkedArray)
+
+
+def is_pyarrow_table(df: Any) -> TypeIs[pa.Table]:
+    """Check whether `df` is a PyArrow Table without importing PyArrow.
+
+    Warning:
+        This method cannot be called on Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return (pa := get_pyarrow()) is not None and isinstance(df, pa.Table)
+
+
+def is_pyarrow_scalar(obj: Any) -> TypeIs[pa.Scalar[Any]]:
+    return (pa := get_pyarrow()) is not None and isinstance(obj, pa.Scalar)
+
+
+def is_pyarrow_schema(obj: Any) -> TypeIs[pa.Schema]:
+    return bool(pa := get_pyarrow()) and isinstance(obj, pa.Schema)
+
+
+def is_pyarrow_data_type(obj: Any) -> TypeIs[pa.DataType]:
+    return bool(pa := get_pyarrow()) and isinstance(obj, pa.DataType)
+
+
+def is_pyspark_dataframe(df: Any) -> TypeIs[pyspark_sql.DataFrame]:
+    """Check whether `df` is a PySpark DataFrame without importing PySpark.
+
+    Warning:
+        This method cannot be called on a Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return bool(
+        (pyspark_sql := get_pyspark_sql()) is not None
+        and isinstance(df, pyspark_sql.DataFrame)
+    )
+
+
+def is_pyspark_connect_dataframe(df: Any) -> TypeIs[PySparkConnectDataFrame]:
+    """Check whether `df` is a PySpark Connect DataFrame without importing PySpark.
+
+    Warning:
+        This method cannot be called on a Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    if get_pyspark_connect() is not None:  # pragma: no cover
+        try:
+            from pyspark.sql.connect.dataframe import DataFrame
+        except ImportError:
+            return False
+        return isinstance(df, DataFrame)
+    return False
+
+
+def is_sqlframe_dataframe(df: Any) -> TypeIs[SQLFrameDataFrame]:
+    """Check whether `df` is a SQLFrame DataFrame without importing SQLFrame.
+
+    Warning:
+        This method cannot be called on a Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    if get_sqlframe() is not None:
+        from sqlframe.base.dataframe import BaseDataFrame
+
+        return isinstance(df, BaseDataFrame)
+    return False  # pragma: no cover
+
+
+def is_numpy_array(arr: Any | _NDArray[_ShapeT]) -> TypeIs[_NDArray[_ShapeT]]:
+    """Check whether `arr` is a NumPy Array without importing NumPy."""
+    return (np := get_numpy()) is not None and isinstance(arr, np.ndarray)
+
+
+def is_numpy_array_1d(arr: Any) -> TypeIs[_1DArray]:
+    """Check whether `arr` is a 1D NumPy Array without importing NumPy."""
+    return is_numpy_array(arr) and arr.ndim == 1
+
+
+def is_numpy_array_1d_int(arr: Any) -> TypeIs[_1DArrayInt]:
+    return (
+        (np := get_numpy())
+        and is_numpy_array_1d(arr)
+        and np.issubdtype(arr.dtype, np.integer)
+    )
+
+
+def is_numpy_array_1d_bool(arr: Any) -> TypeIs[_1DArrayInt]:
+    return (
+        (np := get_numpy())
+        and is_numpy_array_1d(arr)
+        and np.issubdtype(arr.dtype, np.bool_)
+    )
+
+
+def is_numpy_array_2d(arr: Any) -> TypeIs[_2DArray]:
+    """Check whether `arr` is a 2D NumPy Array without importing NumPy."""
+    return is_numpy_array(arr) and arr.ndim == 2
+
+
+def is_numpy_scalar(scalar: Any) -> TypeGuard[_NumpyScalar]:
+    """Check whether `scalar` is a NumPy Scalar without importing NumPy."""
+    # NOTE: Needs to stay as `TypeGuard`
+    # - Used in `Series.__getitem__`, but not annotated
+    # - `TypeGuard` is *hiding* that the check introduces an intersection
+    return (np := get_numpy()) is not None and isinstance(scalar, np.generic)
+
+
+def is_pandas_like_dataframe(df: Any) -> bool:
+    """Check whether `df` is a pandas-like DataFrame without doing any imports.
+
+    By "pandas-like", we mean: pandas, Modin, cuDF.
+
+    Warning:
+        This method cannot be called on a Narwhals DataFrame/LazyFrame.
+    """
+    _warn_if_narwhals_df_or_lf(df)
+    return is_pandas_dataframe(df) or is_modin_dataframe(df) or is_cudf_dataframe(df)
+
+
+def is_pandas_like_series(ser: Any) -> bool:
+    """Check whether `ser` is a pandas-like Series without doing any imports.
+
+    By "pandas-like", we mean: pandas, Modin, cuDF.
+
+    Warning:
+        This method cannot be called on Narwhals Series.
+    """
+    _warn_if_narwhals_series(ser)
+    return is_pandas_series(ser) or is_modin_series(ser) or is_cudf_series(ser)
+
+
+def is_pandas_like_index(index: Any) -> bool:
+    """Check whether `index` is a pandas-like Index without doing any imports.
+
+    By "pandas-like", we mean: pandas, Modin, cuDF.
+    """
+    return (
+        is_pandas_index(index) or is_modin_index(index) or is_cudf_index(index)
+    )  # pragma: no cover
+
+
+def is_pandas_like_dtype(obj: Any) -> TypeIs[PandasLikeDType]:
+    return bool(pd := get_pandas()) and isinstance(
+        obj, (pd.api.extensions.ExtensionDtype, get_numpy().dtype)
+    )
+
+
+def is_cudf_dtype(
+    obj: Any,
+) -> TypeIs[pd.api.extensions.ExtensionDtype]:  # pragma: no cover
+    return (
+        bool(pd := get_pandas())
+        and isinstance(obj, (pd.api.extensions.ExtensionDtype))
+        and hasattr(obj, "to_arrow")
+    )
+
+
+def is_into_series(native_series: Any | IntoSeriesT) -> TypeIs[IntoSeriesT]:
+    """Check whether `native_series` can be converted to a Narwhals Series.
+
+    Arguments:
+        native_series: The object to check.
+
+    Examples:
+        >>> import pandas as pd
+        >>> import polars as pl
+        >>> import numpy as np
+        >>> import narwhals as nw
+
+        >>> s_pd = pd.Series([1, 2, 3])
+        >>> s_pl = pl.Series([1, 2, 3])
+        >>> np_arr = np.array([1, 2, 3])
+
+        >>> nw.dependencies.is_into_series(s_pd)
+        True
+        >>> nw.dependencies.is_into_series(s_pl)
+        True
+        >>> nw.dependencies.is_into_series(np_arr)
+        False
+    """
+    from narwhals.series import Series
+
+    return (
+        isinstance(native_series, Series)
+        or hasattr(native_series, "__narwhals_series__")
+        or is_polars_series(native_series)
+        or is_pyarrow_chunked_array(native_series)
+        or is_pandas_like_series(native_series)
+    )
+
+
+def is_into_dataframe(native_dataframe: Any | IntoDataFrameT) -> TypeIs[IntoDataFrameT]:
+    """Check whether `native_dataframe` can be converted to a Narwhals DataFrame.
+
+    Arguments:
+        native_dataframe: The object to check.
+
+    Examples:
+        >>> import pandas as pd
+        >>> import polars as pl
+        >>> import numpy as np
+        >>> from narwhals.dependencies import is_into_dataframe
+
+        >>> df_pd = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+        >>> df_pl = pl.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+        >>> np_arr = np.array([[1, 4], [2, 5], [3, 6]])
+
+        >>> is_into_dataframe(df_pd)
+        True
+        >>> is_into_dataframe(df_pl)
+        True
+        >>> is_into_dataframe(np_arr)
+        False
+    """
+    from narwhals.dataframe import DataFrame
+
+    return (
+        isinstance(native_dataframe, DataFrame)
+        or hasattr(native_dataframe, "__narwhals_dataframe__")
+        or is_polars_dataframe(native_dataframe)
+        or is_pyarrow_table(native_dataframe)
+        or is_pandas_like_dataframe(native_dataframe)
+    )
+
+
+def is_narwhals_dataframe(
+    df: DataFrame[IntoDataFrameT] | Any,
+) -> TypeIs[DataFrame[IntoDataFrameT]]:
+    """Check whether `df` is a Narwhals DataFrame.
+
+    This is useful if you expect a user to pass in a Narwhals
+    DataFrame directly, and you want to catch both `narwhals.DataFrame`
+    and `narwhals.stable.v1.DataFrame`.
+    """
+    from narwhals.dataframe import DataFrame
+
+    return isinstance(df, DataFrame)
+
+
+def is_narwhals_lazyframe(
+    lf: Any | LazyFrame[IntoLazyFrameT],
+) -> TypeIs[LazyFrame[IntoLazyFrameT]]:
+    """Check whether `lf` is a Narwhals LazyFrame.
+
+    This is useful if you expect a user to pass in a Narwhals
+    LazyFrame directly, and you want to catch both `narwhals.LazyFrame`
+    and `narwhals.stable.v1.LazyFrame`.
+    """
+    from narwhals.dataframe import LazyFrame
+
+    return isinstance(lf, LazyFrame)
+
+
+def is_narwhals_series(ser: Any | Series[IntoSeriesT]) -> TypeIs[Series[IntoSeriesT]]:
+    """Check whether `ser` is a Narwhals Series.
+
+    This is useful if you expect a user to pass in a Narwhals
+    Series directly, and you want to catch both `narwhals.Series`
+    and `narwhals.stable.v1.Series`.
+    """
+    from narwhals.series import Series
+
+    return isinstance(ser, Series)
+
+
+def is_narwhals_series_int(ser: Any | Series[IntoSeriesT]) -> TypeIs[Series[IntoSeriesT]]:
+    return is_narwhals_series(ser) and ser.dtype.is_integer()
+
+
+def is_narwhals_series_bool(
+    ser: Any | Series[IntoSeriesT],
+) -> TypeIs[Series[IntoSeriesT]]:
+    return is_narwhals_series(ser) and ser.dtype.is_boolean()
+
+
+__all__ = [
+    "get_cudf",
+    "get_ibis",
+    "get_modin",
+    "get_numpy",
+    "get_pandas",
+    "get_polars",
+    "get_pyarrow",
+    "is_cudf_dataframe",
+    "is_cudf_series",
+    "is_dask_dataframe",
+    "is_ibis_table",
+    "is_into_dataframe",
+    "is_into_series",
+    "is_modin_dataframe",
+    "is_modin_series",
+    "is_narwhals_dataframe",
+    "is_narwhals_lazyframe",
+    "is_narwhals_series",
+    "is_numpy_array",
+    "is_pandas_dataframe",
+    "is_pandas_index",
+    "is_pandas_like_dataframe",
+    "is_pandas_like_series",
+    "is_pandas_series",
+    "is_polars_dataframe",
+    "is_polars_lazyframe",
+    "is_polars_series",
+    "is_pyarrow_chunked_array",
+    "is_pyarrow_table",
+]

.venv_haddock/lib/python3.12/site-packages/narwhals/dtypes.py

@@ -0,0 +1,1042 @@
+from __future__ import annotations
+
+import enum
+from collections import OrderedDict
+from collections.abc import Iterable, Mapping
+from datetime import timezone
+from itertools import starmap
+from typing import TYPE_CHECKING
+
+from narwhals._utils import (
+    _DeferredIterable,
+    isinstance_or_issubclass,
+    qualified_type_name,
+)
+from narwhals.exceptions import InvalidOperationError
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator, Sequence
+    from typing import Any
+
+    import _typeshed
+    from typing_extensions import Self, TypeIs
+
+    from narwhals.typing import IntoDType, TimeUnit
+
+
+def _validate_dtype(dtype: DType | type[DType]) -> None:
+    if not isinstance_or_issubclass(dtype, DType):
+        msg = (
+            f"Expected Narwhals dtype, got: {type(dtype)}.\n\n"
+            "Hint: if you were trying to cast to a type, use e.g. nw.Int64 instead of 'int64'."
+        )
+        raise TypeError(msg)
+
+
+def _is_into_dtype(obj: Any) -> TypeIs[IntoDType]:
+    return isinstance(obj, DType) or (
+        isinstance(obj, DTypeClass) and not issubclass(obj, NestedType)
+    )
+
+
+def _is_nested_type(obj: Any) -> TypeIs[type[NestedType]]:
+    return isinstance(obj, DTypeClass) and issubclass(obj, NestedType)
+
+
+def _validate_into_dtype(dtype: Any) -> None:
+    if not _is_into_dtype(dtype):
+        if _is_nested_type(dtype):
+            name = f"nw.{dtype.__name__}"
+            msg = (
+                f"{name!r} is not valid in this context.\n\n"
+                f"Hint: instead of:\n\n"
+                f"    {name}\n\n"
+                "use:\n\n"
+                f"    {name}(...)"
+            )
+        else:
+            msg = f"Expected Narwhals dtype, got: {qualified_type_name(dtype)!r}."
+        raise TypeError(msg)
+
+
+class DTypeClass(type):
+    """Metaclass for DType classes.
+
+    - Nicely print classes.
+    - Ensure [`__slots__`] are always defined to prevent `__dict__` creation (empty by default).
+
+    [`__slots__`]: https://docs.python.org/3/reference/datamodel.html#object.__slots__
+    """
+
+    def __repr__(cls) -> str:
+        return cls.__name__
+
+    # https://github.com/python/typeshed/blob/776508741d76b58f9dcb2aaf42f7d4596a48d580/stdlib/abc.pyi#L13-L19
+    # https://github.com/python/typeshed/blob/776508741d76b58f9dcb2aaf42f7d4596a48d580/stdlib/_typeshed/__init__.pyi#L36-L40
+    # https://github.com/astral-sh/ruff/issues/8353#issuecomment-1786238311
+    # https://docs.python.org/3/reference/datamodel.html#creating-the-class-object
+    def __new__(
+        metacls: type[_typeshed.Self],
+        cls_name: str,
+        bases: tuple[type, ...],
+        namespace: dict[str, Any],
+        /,
+        **kwds: Any,
+    ) -> _typeshed.Self:
+        namespace.setdefault("__slots__", ())
+        return super().__new__(metacls, cls_name, bases, namespace, **kwds)  # type: ignore[no-any-return, misc]
+
+
+class DType(metaclass=DTypeClass):
+    """Base class for all Narwhals data types."""
+
+    __slots__ = ()  # NOTE: Keep this one defined manually for the type checker
+
+    def __repr__(self) -> str:
+        return self.__class__.__qualname__
+
+    @classmethod
+    def base_type(cls) -> type[Self]:
+        """Return this DType's fundamental/root type class.
+
+        Examples:
+            >>> import narwhals as nw
+            >>> nw.Datetime("us").base_type()
+            Datetime
+            >>> nw.String.base_type()
+            String
+            >>> nw.List(nw.Int64).base_type()
+            List
+        """
+        return cls
+
+    @classmethod
+    def is_numeric(cls: type[Self]) -> bool:
+        """Check whether the data type is a numeric type."""
+        return issubclass(cls, NumericType)
+
+    @classmethod
+    def is_integer(cls: type[Self]) -> bool:
+        """Check whether the data type is an integer type."""
+        return issubclass(cls, IntegerType)
+
+    @classmethod
+    def is_signed_integer(cls: type[Self]) -> bool:
+        """Check whether the data type is a signed integer type."""
+        return issubclass(cls, SignedIntegerType)
+
+    @classmethod
+    def is_unsigned_integer(cls: type[Self]) -> bool:
+        """Check whether the data type is an unsigned integer type."""
+        return issubclass(cls, UnsignedIntegerType)
+
+    @classmethod
+    def is_float(cls: type[Self]) -> bool:
+        """Check whether the data type is a floating point type."""
+        return issubclass(cls, FloatType)
+
+    @classmethod
+    def is_decimal(cls: type[Self]) -> bool:
+        """Check whether the data type is a decimal type."""
+        return issubclass(cls, Decimal)
+
+    @classmethod
+    def is_temporal(cls: type[Self]) -> bool:
+        """Check whether the data type is a temporal type."""
+        return issubclass(cls, TemporalType)
+
+    @classmethod
+    def is_nested(cls: type[Self]) -> bool:
+        """Check whether the data type is a nested type."""
+        return issubclass(cls, NestedType)
+
+    @classmethod
+    def is_boolean(cls: type[Self]) -> bool:
+        """Check whether the data type is a boolean type."""
+        return issubclass(cls, Boolean)
+
+    def __eq__(self, other: DType | type[DType]) -> bool:  # type: ignore[override]
+        """Check if this DType is equivalent to another DType.
+
+        Examples:
+            >>> import narwhals as nw
+            >>> nw.String() == nw.String()
+            True
+            >>> nw.String() == nw.String
+            True
+            >>> nw.Int16() == nw.Int32
+            False
+            >>> nw.Boolean() == nw.Int8
+            False
+            >>> nw.Date() == nw.Datetime
+            False
+        """
+        return isinstance_or_issubclass(other, type(self))
+
+    def __hash__(self) -> int:
+        return hash(self.__class__)
+
+
+class NumericType(DType):
+    """Base class for numeric data types."""
+
+
+class IntegerType(NumericType):
+    """Base class for integer data types."""
+
+
+class SignedIntegerType(IntegerType):
+    """Base class for signed integer data types."""
+
+
+class UnsignedIntegerType(IntegerType):
+    """Base class for unsigned integer data types."""
+
+
+class FloatType(NumericType):
+    """Base class for float data types."""
+
+
+class TemporalType(DType):
+    """Base class for temporal data types."""
+
+
+class NestedType(DType):
+    """Base class for nested data types."""
+
+
+class Decimal(NumericType):
+    """Decimal 128-bit type with an optional precision and non-negative scale.
+
+    Arguments:
+        precision: Maximum number of digits in each number. If set to `None` (default),
+            the precision is set to 38 (the maximum supported by Polars).
+        scale: Number of digits to the right of the decimal point in each number.
+
+    Examples:
+        >>> import polars as pl
+        >>> import narwhals as nw
+        >>> s = pl.Series(["1.5"], dtype=pl.Decimal)
+        >>> nw.from_native(s, series_only=True).dtype
+        Decimal(precision=2, scale=1)
+    """
+
+    __slots__ = ("precision", "scale")
+
+    precision: int
+    scale: int
+
+    # !NOTE: Reason for `precision: int | None = None` rather than `precision: int = 38`
+    # is to mirror polars signature https://github.com/pola-rs/polars/blob/bb79993c3aa91d0db7d20be8f75c8075cad97067/py-polars/src/polars/datatypes/classes.py#L450-L454
+    def __init__(self, precision: int | None = None, scale: int = 0) -> None:
+        precision = 38 if precision is None else precision
+
+        if not ((is_int := isinstance(precision, int)) and 0 <= precision <= 38):
+            msg = f"precision must be a positive integer between 0 and 38, found {precision!r}"
+            raise ValueError(msg) if is_int else TypeError(msg)
+
+        if not ((is_int := isinstance(scale, int)) and scale >= 0):
+            msg = f"scale must be a positive integer, found {scale!r}"
+            raise ValueError(msg) if is_int else TypeError(msg)
+
+        if scale > precision:
+            msg = "scale must be less than or equal to precision"
+            raise InvalidOperationError(msg)
+
+        self.precision = precision
+        self.scale = scale
+
+    def __eq__(self, other: DType | type[DType]) -> bool:  # type: ignore[override]
+        return (other is Decimal) or (
+            isinstance(other, self.__class__)
+            and self.precision == other.precision
+            and self.scale == other.scale
+        )
+
+    def __hash__(self) -> int:  # pragma: no cover
+        return hash((self.__class__, self.precision, self.scale))
+
+    def __repr__(self) -> str:  # pragma: no cover
+        class_name = self.__class__.__name__
+        return f"{class_name}(precision={self.precision!r}, scale={self.scale!r})"
+
+
+class Int128(SignedIntegerType):
+    """128-bit signed integer type.
+
+    Examples:
+        >>> import polars as pl
+        >>> import pyarrow as pa
+        >>> import narwhals as nw
+        >>> import duckdb
+        >>> s_native = pl.Series([2, 1, 3, 7])
+        >>> s = nw.from_native(s_native, series_only=True)
+        >>> df_native = pa.table({"a": [2, 1, 3, 7]})
+        >>> rel = duckdb.sql(" SELECT CAST (a AS INT128) AS a FROM df_native ")
+
+        >>> s.cast(nw.Int128).dtype
+        Int128
+        >>> nw.from_native(rel).collect_schema()["a"]
+        Int128
+    """
+
+
+class Int64(SignedIntegerType):
+    """64-bit signed integer type.
+
+    Examples:
+        >>> import polars as pl
+        >>> import narwhals as nw
+        >>> s_native = pl.Series([2, 1, 3, 7])
+        >>> s = nw.from_native(s_native, series_only=True)
+        >>> s.cast(nw.Int64).dtype
+        Int64
+    """
+
+
+class Int32(SignedIntegerType):
+    """32-bit signed integer type.
+
+    Examples:
+        >>> import pyarrow as pa
+        >>> import narwhals as nw
+        >>> s_native = pa.chunked_array([[2, 1, 3, 7]])
+        >>> s = nw.from_native(s_native, series_only=True)
+        >>> s.cast(nw.Int32).dtype
+        Int32
+    """
+
+
+class Int16(SignedIntegerType):
+    """16-bit signed integer type.
+
+    Examples:
+        >>> import polars as pl
+        >>> import narwhals as nw
+        >>> s_native = pl.Series([2, 1, 3, 7])
+        >>> s = nw.from_native(s_native, series_only=True)
+        >>> s.cast(nw.Int16).dtype
+        Int16
+    """
+
+
+class Int8(SignedIntegerType):
+    """8-bit signed integer type.
+
+    Examples:
+        >>> import pandas as pd
+        >>> import narwhals as nw
+        >>> s_native = pd.Series([2, 1, 3, 7])
+        >>> s = nw.from_native(s_native, series_only=True)
+        >>> s.cast(nw.Int8).dtype
+        Int8
+    """
+
+
+class UInt128(UnsignedIntegerType):
+    """128-bit unsigned integer type.
+
+    Examples:
+        >>> import pandas as pd
+        >>> import narwhals as nw
+        >>> import duckdb
+        >>> df_native = pd.DataFrame({"a": [2, 1, 3, 7]})
+        >>> rel = duckdb.sql(" SELECT CAST (a AS UINT128) AS a FROM df_native ")
+        >>> nw.from_native(rel).collect_schema()["a"]
+        UInt128
+    """
+
+
+class UInt64(UnsignedIntegerType):
+    """64-bit unsigned integer type.
+
+    Examples:
+        >>> import pandas as pd
+        >>> import narwhals as nw
+        >>> s_native = pd.Series([2, 1, 3, 7])
+        >>> s = nw.from_native(s_native, series_only=True)
+        >>> s.cast(nw.UInt64).dtype
+        UInt64
+    """
+
+
+class UInt32(UnsignedIntegerType):
+    """32-bit unsigned integer type.
+
+    Examples:
+        >>> import polars as pl
+        >>> import narwhals as nw
+        >>> s_native = pl.Series([2, 1, 3, 7])
+        >>> s = nw.from_native(s_native, series_only=True)
+        >>> s.cast(nw.UInt32).dtype
+        UInt32
+    """
+
+
+class UInt16(UnsignedIntegerType):
+    """16-bit unsigned integer type.
+
+    Examples:
+        >>> import polars as pl
+        >>> import narwhals as nw
+        >>> s_native = pl.Series([2, 1, 3, 7])
+        >>> s = nw.from_native(s_native, series_only=True)
+        >>> s.cast(nw.UInt16).dtype
+        UInt16
+    """
+
+
+class UInt8(UnsignedIntegerType):
+    """8-bit unsigned integer type.
+
+    Examples:
+        >>> import polars as pl
+        >>> import narwhals as nw
+        >>> s_native = pl.Series([2, 1, 3, 7])
+        >>> s = nw.from_native(s_native, series_only=True)
+        >>> s.cast(nw.UInt8).dtype
+        UInt8
+    """
+
+
+class Float64(FloatType):
+    """64-bit floating point type.
+
+    Examples:
+        >>> import pyarrow as pa
+        >>> import narwhals as nw
+        >>> s_native = pa.chunked_array([[0.001, 0.1, 0.01, 0.1]])
+        >>> s = nw.from_native(s_native, series_only=True)
+        >>> s.cast(nw.Float64).dtype
+        Float64
+    """
+
+
+class Float32(FloatType):
+    """32-bit floating point type.
+
+    Examples:
+        >>> import polars as pl
+        >>> import narwhals as nw
+        >>> s_native = pl.Series([0.001, 0.1, 0.01, 0.1])
+        >>> s = nw.from_native(s_native, series_only=True)
+        >>> s.cast(nw.Float32).dtype
+        Float32
+    """
+
+
+class String(DType):
+    """UTF-8 encoded string type.
+
+    Examples:
+        >>> import pandas as pd
+        >>> import narwhals as nw
+        >>> s_native = pd.Series(["beluga", "narwhal", "orca", "vaquita"])
+        >>> nw.from_native(s_native, series_only=True).dtype
+        String
+    """
+
+
+class Boolean(DType):
+    """Boolean type.
+
+    Examples:
+        >>> import pyarrow as pa
+        >>> import narwhals as nw
+        >>> s_native = pa.chunked_array([[True, False, False, True]])
+        >>> nw.from_native(s_native, series_only=True).dtype
+        Boolean
+    """
+
+
+class Object(DType):
+    """Data type for wrapping arbitrary Python objects.
+
+    Examples:
+        >>> import pandas as pd
+        >>> import narwhals as nw
+        >>> class Foo: ...
+        >>> s_native = pd.Series([Foo(), Foo()])
+        >>> nw.from_native(s_native, series_only=True).dtype
+        Object
+    """
+
+
+class Unknown(DType):
+    """Type representing DataType values that could not be determined statically.
+
+    Examples:
+        >>> import pandas as pd
+        >>> import narwhals as nw
+        >>> s_native = pd.Series(pd.period_range("2000-01", periods=4, freq="M"))
+        >>> nw.from_native(s_native, series_only=True).dtype
+        Unknown
+    """
+
+
+class _DatetimeMeta(DTypeClass):
+    @property
+    def time_unit(cls) -> TimeUnit:
+        """Unit of time. Defaults to `'us'` (microseconds)."""
+        return "us"
+
+    @property
+    def time_zone(cls) -> str | None:
+        """Time zone string. Defaults to `None`."""
+        return None
+
+
+class Datetime(TemporalType, metaclass=_DatetimeMeta):
+    """Data type representing a calendar date and time of day.
+
+    Arguments:
+        time_unit: Unit of time. Defaults to `'us'` (microseconds).
+        time_zone: Time zone string, as defined in zoneinfo (to see valid strings run
+            `import zoneinfo; zoneinfo.available_timezones()` for a full list).
+
+    Notes:
+        Adapted from [Polars implementation](https://github.com/pola-rs/polars/blob/py-1.7.1/py-polars/polars/datatypes/classes.py#L398-L457)
+
+    Examples:
+        >>> from datetime import datetime, timedelta
+        >>> import polars as pl
+        >>> import narwhals as nw
+        >>> s_native = (
+        ...     pl.Series([datetime(2024, 12, 9) + timedelta(days=n) for n in range(5)])
+        ...     .cast(pl.Datetime("ms"))
+        ...     .dt.replace_time_zone("Africa/Accra")
+        ... )
+        >>> nw.from_native(s_native, series_only=True).dtype
+        Datetime(time_unit='ms', time_zone='Africa/Accra')
+    """
+
+    __slots__ = ("time_unit", "time_zone")
+
+    def __init__(
+        self, time_unit: TimeUnit = "us", time_zone: str | timezone | None = None
+    ) -> None:
+        if time_unit not in {"s", "ms", "us", "ns"}:
+            msg = (
+                "invalid `time_unit`"
+                f"\n\nExpected one of {{'ns','us','ms', 's'}}, got {time_unit!r}."
+            )
+            raise ValueError(msg)
+
+        if isinstance(time_zone, timezone):
+            time_zone = str(time_zone)
+
+        self.time_unit: TimeUnit = time_unit
+        """Unit of time."""
+        self.time_zone: str | None = time_zone
+        """Time zone string, as defined in zoneinfo.
+
+        Notes:
+            To see valid strings run `import zoneinfo; zoneinfo.available_timezones()` for a full list.
+        """
+
+    def __eq__(self, other: DType | type[DType]) -> bool:  # type: ignore[override]
+        """Check if this Datetime is equivalent to another DType.
+
+        Examples:
+            >>> import narwhals as nw
+            >>> nw.Datetime("s") == nw.Datetime("s")
+            True
+            >>> nw.Datetime() == nw.Datetime("us")
+            True
+            >>> nw.Datetime("us") == nw.Datetime("ns")
+            False
+            >>> nw.Datetime("us", "UTC") == nw.Datetime(time_unit="us", time_zone="UTC")
+            True
+            >>> nw.Datetime(time_zone="UTC") == nw.Datetime(time_zone="EST")
+            False
+            >>> nw.Datetime() == nw.Duration()
+            False
+            >>> nw.Datetime("ms") == nw.Datetime
+            True
+        """
+        if type(other) is _DatetimeMeta:
+            return True
+        if isinstance(other, self.__class__):
+            return self.time_unit == other.time_unit and self.time_zone == other.time_zone
+        return False  # pragma: no cover
+
+    def __hash__(self) -> int:  # pragma: no cover
+        return hash((self.__class__, self.time_unit, self.time_zone))
+
+    def __repr__(self) -> str:  # pragma: no cover
+        class_name = self.__class__.__name__
+        return f"{class_name}(time_unit={self.time_unit!r}, time_zone={self.time_zone!r})"
+
+
+class _DurationMeta(DTypeClass):
+    @property
+    def time_unit(cls) -> TimeUnit:
+        """Unit of time. Defaults to `'us'` (microseconds)."""
+        return "us"
+
+
+class Duration(TemporalType, metaclass=_DurationMeta):
+    """Data type representing a time duration.
+
+    Arguments:
+        time_unit: Unit of time. Defaults to `'us'` (microseconds).
+
+    Notes:
+        Adapted from [Polars implementation](https://github.com/pola-rs/polars/blob/py-1.7.1/py-polars/polars/datatypes/classes.py#L460-L502)
+
+    Examples:
+        >>> from datetime import timedelta
+        >>> import pyarrow as pa
+        >>> import narwhals as nw
+        >>> s_native = pa.chunked_array(
+        ...     [[timedelta(seconds=d) for d in range(1, 4)]], type=pa.duration("ms")
+        ... )
+        >>> nw.from_native(s_native, series_only=True).dtype
+        Duration(time_unit='ms')
+    """
+
+    __slots__ = ("time_unit",)
+
+    def __init__(self, time_unit: TimeUnit = "us") -> None:
+        if time_unit not in {"s", "ms", "us", "ns"}:
+            msg = (
+                "invalid `time_unit`"
+                f"\n\nExpected one of {{'ns','us','ms', 's'}}, got {time_unit!r}."
+            )
+            raise ValueError(msg)
+
+        self.time_unit: TimeUnit = time_unit
+        """Unit of time."""
+
+    def __eq__(self, other: DType | type[DType]) -> bool:  # type: ignore[override]
+        """Check if this Duration is equivalent to another DType.
+
+        Examples:
+            >>> import narwhals as nw
+            >>> nw.Duration("us") == nw.Duration("us")
+            True
+            >>> nw.Duration() == nw.Duration("us")
+            True
+            >>> nw.Duration("us") == nw.Duration("ns")
+            False
+            >>> nw.Duration() == nw.Datetime()
+            False
+            >>> nw.Duration("ms") == nw.Duration
+            True
+        """
+        if type(other) is _DurationMeta:
+            return True
+        if isinstance(other, self.__class__):
+            return self.time_unit == other.time_unit
+        return False  # pragma: no cover
+
+    def __hash__(self) -> int:  # pragma: no cover
+        return hash((self.__class__, self.time_unit))
+
+    def __repr__(self) -> str:  # pragma: no cover
+        class_name = self.__class__.__name__
+        return f"{class_name}(time_unit={self.time_unit!r})"
+
+
+class Categorical(DType):
+    """A categorical encoding of a set of strings.
+
+    Examples:
+        >>> import polars as pl
+        >>> import narwhals as nw
+        >>> s_native = pl.Series(["beluga", "narwhal", "orca"])
+        >>> nw.from_native(s_native, series_only=True).cast(nw.Categorical).dtype
+        Categorical
+    """
+
+
+class Enum(DType):
+    """A fixed categorical encoding of a unique set of strings.
+
+    Polars has an Enum data type. In pandas, ordered categories get mapped
+    to Enum. PyArrow has no Enum equivalent.
+
+    Examples:
+       >>> import narwhals as nw
+       >>> nw.Enum(["beluga", "narwhal", "orca"])
+       Enum(categories=['beluga', 'narwhal', 'orca'])
+    """
+
+    __slots__ = ("_cached_categories", "_delayed_categories")
+
+    def __init__(self, categories: Iterable[str] | type[enum.Enum]) -> None:
+        self._delayed_categories: _DeferredIterable[str] | None = None
+        self._cached_categories: tuple[str, ...] | None = None
+
+        if isinstance(categories, _DeferredIterable):
+            self._delayed_categories = categories
+        elif isinstance(categories, type) and issubclass(categories, enum.Enum):
+            self._cached_categories = tuple(member.value for member in categories)
+        else:
+            self._cached_categories = tuple(categories)
+
+    @property
+    def categories(self) -> tuple[str, ...]:
+        """The categories in the dataset."""
+        if (cached := self._cached_categories) is not None:
+            return cached
+        if (delayed := self._delayed_categories) is not None:
+            self._cached_categories = delayed.to_tuple()
+            return self._cached_categories
+        msg = f"Internal structure of {type(self).__name__!r} is invalid."  # pragma: no cover
+        raise TypeError(msg)  # pragma: no cover
+
+    def __eq__(self, other: DType | type[DType]) -> bool:  # type: ignore[override]
+        """Check if this Enum is equivalent to another DType.
+
+        Examples:
+            >>> import narwhals as nw
+            >>> nw.Enum(["a", "b", "c"]) == nw.Enum(["a", "b", "c"])
+            True
+            >>> import polars as pl
+            >>> categories = pl.Series(["a", "b", "c"])
+            >>> nw.Enum(["a", "b", "c"]) == nw.Enum(categories)
+            True
+            >>> nw.Enum(["a", "b", "c"]) == nw.Enum(["b", "a", "c"])
+            False
+            >>> nw.Enum(["a", "b", "c"]) == nw.Enum(["a"])
+            False
+            >>> nw.Enum(["a", "b", "c"]) == nw.Categorical
+            False
+            >>> nw.Enum(["a", "b", "c"]) == nw.Enum
+            True
+        """
+        if type(other) is DTypeClass:
+            return other is Enum
+        return isinstance(other, type(self)) and self.categories == other.categories
+
+    def __hash__(self) -> int:
+        return hash((self.__class__, tuple(self.categories)))
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(categories={list(self.categories)!r})"
+
+
+class Field:
+    """Definition of a single field within a `Struct` DType.
+
+    Arguments:
+        name: The name of the field within its parent `Struct`.
+        dtype: The `DType` of the field's values.
+
+    Examples:
+       >>> import pyarrow as pa
+       >>> import narwhals as nw
+       >>> data = [{"a": 1, "b": ["narwhal", "beluga"]}, {"a": 2, "b": ["orca"]}]
+       >>> ser_pa = pa.chunked_array([data])
+       >>> nw.from_native(ser_pa, series_only=True).dtype.fields
+       [Field('a', Int64), Field('b', List(String))]
+    """
+
+    __slots__ = ("dtype", "name")
+    name: str
+    """The name of the field within its parent `Struct`."""
+    dtype: IntoDType
+    """The `DType` of the field's values."""
+
+    def __init__(self, name: str, dtype: IntoDType) -> None:
+        self.name = name
+        self.dtype = dtype
+
+    def __eq__(self, other: Field) -> bool:  # type: ignore[override]
+        """Check if this Field is equivalent to another Field.
+
+        Two fields are equivalent if they have the same name and the same dtype.
+
+        Examples:
+            >>> import narwhals as nw
+            >>> nw.Field("a", nw.String) == nw.Field("a", nw.String())
+            True
+            >>> nw.Field("a", nw.String) == nw.Field("a", nw.String)
+            True
+            >>> nw.Field("a", nw.String) == nw.Field("a", nw.Datetime)
+            False
+            >>> nw.Field("a", nw.String) == nw.Field("b", nw.String)
+            False
+            >>> nw.Field("a", nw.String) == nw.String
+            False
+        """
+        return (
+            isinstance(other, Field)
+            and (self.name == other.name)
+            and (self.dtype == other.dtype)
+        )
+
+    def __hash__(self) -> int:
+        return hash((self.name, self.dtype))
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        return f"{class_name}({self.name!r}, {self.dtype})"
+
+
+class Struct(NestedType):
+    """Struct composite type.
+
+    Arguments:
+        fields: The fields that make up the struct. Can be either a sequence of Field
+            objects or a mapping of column names to data types.
+
+    Examples:
+       >>> import pyarrow as pa
+       >>> import narwhals as nw
+       >>> s_native = pa.chunked_array(
+       ...     [[{"a": 1, "b": ["narwhal", "beluga"]}, {"a": 2, "b": ["orca"]}]]
+       ... )
+       >>> nw.from_native(s_native, series_only=True).dtype
+       Struct({'a': Int64, 'b': List(String)})
+    """
+
+    __slots__ = ("fields",)
+    fields: list[Field]
+    """The fields that make up the struct."""
+
+    def __init__(self, fields: Sequence[Field] | Mapping[str, IntoDType]) -> None:
+        if isinstance(fields, Mapping):
+            self.fields = list(starmap(Field, fields.items()))
+        else:
+            self.fields = list(fields)
+
+    def __eq__(self, other: DType | type[DType]) -> bool:  # type: ignore[override]
+        """Check if this Struct is equivalent to another DType.
+
+        Examples:
+            >>> import narwhals as nw
+            >>> nw.Struct({"a": nw.Int64}) == nw.Struct({"a": nw.Int64})
+            True
+            >>> nw.Struct({"a": nw.Int64}) == nw.Struct({"a": nw.Boolean})
+            False
+            >>> nw.Struct({"a": nw.Int64}) == nw.Struct({"b": nw.Int64})
+            False
+            >>> nw.Struct({"a": nw.Int64}) == nw.Struct([nw.Field("a", nw.Int64)])
+            True
+
+            If a parent type is not specific about its inner type, we infer it as equal
+
+            >>> nw.Struct({"a": nw.Int64}) == nw.Struct
+            True
+        """
+        if type(other) is DTypeClass and issubclass(other, self.__class__):
+            return True
+        if isinstance(other, self.__class__):
+            return self.fields == other.fields
+        return False
+
+    def __hash__(self) -> int:
+        return hash((self.__class__, tuple(self.fields)))
+
+    def __iter__(self) -> Iterator[tuple[str, IntoDType]]:  # pragma: no cover
+        for fld in self.fields:
+            yield fld.name, fld.dtype
+
+    def __reversed__(self) -> Iterator[tuple[str, IntoDType]]:
+        for fld in reversed(self.fields):
+            yield fld.name, fld.dtype
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        return f"{class_name}({dict(self)})"
+
+    def to_schema(self) -> OrderedDict[str, IntoDType]:
+        """Return Struct dtype as a schema dict."""
+        return OrderedDict(self)
+
+
+class List(NestedType):
+    """Variable length list type.
+
+    Examples:
+       >>> import pandas as pd
+       >>> import pyarrow as pa
+       >>> import narwhals as nw
+       >>> s_native = pd.Series(
+       ...     [["narwhal", "orca"], ["beluga", "vaquita"]],
+       ...     dtype=pd.ArrowDtype(pa.large_list(pa.large_string())),
+       ... )
+       >>> nw.from_native(s_native, series_only=True).dtype
+       List(String)
+    """
+
+    __slots__ = ("inner",)
+    inner: IntoDType
+    """The DType of the values within each list."""
+
+    def __init__(self, inner: IntoDType) -> None:
+        self.inner = inner
+
+    def __eq__(self, other: DType | type[DType]) -> bool:  # type: ignore[override]
+        """Check if this List is equivalent to another DType.
+
+        Examples:
+            >>> import narwhals as nw
+            >>> nw.List(nw.Int64) == nw.List(nw.Int64)
+            True
+            >>> nw.List(nw.Int64) == nw.List(nw.Float32)
+            False
+
+            If a parent type is not specific about its inner type, we infer it as equal
+
+            >>> nw.List(nw.Int64) == nw.List
+            True
+        """
+        if type(other) is DTypeClass and issubclass(other, self.__class__):
+            return True
+        if isinstance(other, self.__class__):
+            return self.inner == other.inner
+        return False
+
+    def __hash__(self) -> int:
+        return hash((self.__class__, self.inner))
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        return f"{class_name}({self.inner!r})"
+
+
+class Array(NestedType):
+    """Fixed length list type.
+
+    Arguments:
+        inner: The datatype of the values within each array.
+        shape: The shape of the arrays.
+
+    Examples:
+        >>> import polars as pl
+        >>> import narwhals as nw
+        >>> s_native = pl.Series([[1, 2], [3, 4], [5, 6]], dtype=pl.Array(pl.Int32, 2))
+        >>> nw.from_native(s_native, series_only=True).dtype
+        Array(Int32, shape=(2,))
+    """
+
+    __slots__ = ("inner", "shape", "size")
+    inner: IntoDType
+    """The DType of the values within each array."""
+    size: int
+    """The size of the Array."""
+    shape: tuple[int, ...]
+    """The shape of the arrays."""
+
+    def __init__(self, inner: IntoDType, shape: int | tuple[int, ...]) -> None:
+        inner_shape: tuple[int, ...] = inner.shape if isinstance(inner, Array) else ()
+        if isinstance(shape, int):
+            self.inner = inner
+            self.size = shape
+            self.shape = (shape, *inner_shape)
+
+        elif isinstance(shape, tuple) and len(shape) != 0 and isinstance(shape[0], int):
+            if len(shape) > 1:
+                inner = Array(inner, shape[1:])
+
+            self.inner = inner
+            self.size = shape[0]
+            self.shape = shape + inner_shape
+
+        else:
+            msg = f"invalid input for shape: {shape!r}"
+            raise TypeError(msg)
+
+    def __eq__(self, other: DType | type[DType]) -> bool:  # type: ignore[override]
+        """Check if this Array is equivalent to another DType.
+
+        Examples:
+            >>> import narwhals as nw
+            >>> nw.Array(nw.Int64, 2) == nw.Array(nw.Int64, 2)
+            True
+            >>> nw.Array(nw.Int64, 2) == nw.Array(nw.String, 2)
+            False
+            >>> nw.Array(nw.Int64, 2) == nw.Array(nw.Int64, 4)
+            False
+
+            If a parent type is not specific about its inner type, we infer it as equal
+
+            >>> nw.Array(nw.Int64, 2) == nw.Array
+            True
+        """
+        if type(other) is DTypeClass and issubclass(other, self.__class__):
+            return True
+        if isinstance(other, self.__class__):
+            if self.shape != other.shape:
+                return False
+            return self.inner == other.inner
+        return False
+
+    def __hash__(self) -> int:
+        return hash((self.__class__, self.inner, self.shape))
+
+    def __repr__(self) -> str:
+        # Get leaf type
+        dtype_ = self
+        for _ in self.shape:
+            dtype_ = dtype_.inner  # type: ignore[assignment]
+
+        class_name = self.__class__.__name__
+        return f"{class_name}({dtype_!r}, shape={self.shape})"
+
+
+class Date(TemporalType):
+    """Data type representing a calendar date.
+
+    Examples:
+        >>> from datetime import date, timedelta
+        >>> import pyarrow as pa
+        >>> import narwhals as nw
+        >>> s_native = pa.chunked_array(
+        ...     [[date(2024, 12, 1) + timedelta(days=d) for d in range(4)]]
+        ... )
+        >>> nw.from_native(s_native, series_only=True).dtype
+        Date
+    """
+
+
+class Time(TemporalType):
+    """Data type representing the time of day.
+
+    Examples:
+       >>> import polars as pl
+       >>> import pyarrow as pa
+       >>> import narwhals as nw
+       >>> import duckdb
+       >>> from datetime import time
+       >>> data = [time(9, 0), time(9, 1, 10), time(9, 2)]
+       >>> ser_pl = pl.Series(data)
+       >>> ser_pa = pa.chunked_array([pa.array(data, type=pa.time64("ns"))])
+       >>> rel = duckdb.sql(
+       ...     " SELECT * FROM (VALUES (TIME '12:00:00'), (TIME '14:30:15')) df(t)"
+       ... )
+
+       >>> nw.from_native(ser_pl, series_only=True).dtype
+       Time
+       >>> nw.from_native(ser_pa, series_only=True).dtype
+       Time
+       >>> nw.from_native(rel).collect_schema()["t"]
+       Time
+    """
+
+
+class Binary(DType):
+    """Binary type.
+
+    Examples:
+        >>> import polars as pl
+        >>> import narwhals as nw
+        >>> import pyarrow as pa
+        >>> import duckdb
+        >>> data = [b"test1", b"test2"]
+        >>> ser_pl = pl.Series(data, dtype=pl.Binary)
+        >>> ser_pa = pa.chunked_array([pa.array(data, type=pa.binary())])
+        >>> rel = duckdb.sql(
+        ...     "SELECT * FROM (VALUES (BLOB 'test1'), (BLOB 'test2')) AS df(t)"
+        ... )
+
+        >>> nw.from_native(ser_pl, series_only=True).dtype
+        Binary
+        >>> nw.from_native(ser_pa, series_only=True).dtype
+        Binary
+        >>> nw.from_native(rel).collect_schema()["t"]
+        Binary
+    """

.venv_haddock/lib/python3.12/site-packages/narwhals/exceptions.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Collection, Iterable
+
+
+class NarwhalsError(ValueError):
+    """Base class for all Narwhals exceptions."""
+
+
+class FormattedKeyError(KeyError):
+    """KeyError with formatted error message.
+
+    Python's `KeyError` has special casing around formatting
+    (see https://bugs.python.org/issue2651). Use this class when the error
+    message has newlines and other special format characters.
+    Needed by https://github.com/tensorflow/tensorflow/issues/36857.
+    """
+
+    message: str
+
+    def __init__(self, message: str) -> None:
+        self.message = message
+
+    def __str__(self) -> str:
+        return self.message
+
+
+class ColumnNotFoundError(FormattedKeyError, NarwhalsError):
+    """Exception raised when column name isn't present."""
+
+    message: str
+
+    def __init__(self, message: str) -> None:
+        self.message = message
+        super().__init__(self.message)
+
+    @classmethod
+    def from_missing_and_available_column_names(
+        cls, missing_columns: Iterable[str], available_columns: Collection[str], /
+    ) -> ColumnNotFoundError:
+        message = (
+            f"The following columns were not found: {sorted(missing_columns)}"
+            f"\n\nHint: Did you mean one of these columns: {list(available_columns)}?"
+        )
+        return ColumnNotFoundError(message)
+
+    @classmethod
+    def from_available_column_names(
+        cls, available_columns: Collection[str]
+    ) -> ColumnNotFoundError:
+        message = (
+            "The selected columns were not found."
+            f"\n\nHint: Did you mean one of these columns: {list(available_columns)}?"
+        )
+        return ColumnNotFoundError(message)
+
+
+class ComputeError(NarwhalsError):
+    """Exception raised when the underlying computation could not be evaluated."""
+
+
+class ShapeError(NarwhalsError):
+    """Exception raised when trying to perform operations on data structures with incompatible shapes."""
+
+
+class MultiOutputExpressionError(NarwhalsError):
+    """Exception raised when using multi-output expression in unsupported context."""
+
+
+class DuplicateError(NarwhalsError):
+    """Exception when duplicate column names are encountered."""
+
+
+class InvalidOperationError(NarwhalsError):
+    """Exception raised during invalid operations."""
+
+
+class InvalidIntoExprError(TypeError, NarwhalsError):
+    """Exception raised when object can't be converted to expression."""
+
+    message: str
+
+    def __init__(self, message: str) -> None:
+        self.message = message
+        super().__init__(self.message)
+
+    @classmethod
+    def from_invalid_type(cls: type, invalid_type: type) -> InvalidIntoExprError:
+        message = (
+            f"Expected an object which can be converted into an expression, got {invalid_type}\n\n"
+            "Hint:\n"
+            "- if you were trying to select a column which does not have a string\n"
+            "  column name, then you should explicitly use `nw.col`.\n"
+            "  For example, `df.select(nw.col(0))` if you have a column named `0`.\n"
+            "- if you were trying to create a new literal column, then you \n"
+            "  should explicitly use `nw.lit`.\n"
+            "  For example, `df.select(nw.lit(0))` if you want to create a new\n"
+            "  column with literal value `0`."
+        )
+        return InvalidIntoExprError(message)
+
+
+class UnsupportedDTypeError(NarwhalsError):
+    """Exception raised when trying to convert to a DType which is not supported by the given backend."""
+
+
+class NarwhalsUnstableWarning(UserWarning):
+    """Warning issued when a method or function is considered unstable in the stable api."""
+
+
+class PerformanceWarning(Warning): ...

.venv_haddock/lib/python3.12/site-packages/narwhals/expr_cat.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Generic, TypeVar
+
+from narwhals._expression_parsing import ExprKind, ExprNode
+
+if TYPE_CHECKING:
+    from narwhals.expr import Expr
+
+ExprT = TypeVar("ExprT", bound="Expr")
+
+
+class ExprCatNamespace(Generic[ExprT]):
+    def __init__(self, expr: ExprT) -> None:
+        self._expr = expr
+
+    def get_categories(self) -> ExprT:
+        """Get unique categories from column.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame(
+            ...     {"fruits": ["apple", "mango", "mango"]},
+            ...     schema={"fruits": pl.Categorical},
+            ... )
+            >>> df = nw.from_native(df_native)
+            >>> df.select(nw.col("fruits").cat.get_categories()).to_native()
+            shape: (2, 1)
+            ┌────────┐
+            │ fruits │
+            │ ---    │
+            │ str    │
+            ╞════════╡
+            │ apple  │
+            │ mango  │
+            └────────┘
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.FILTRATION, "cat.get_categories")
+        )

.venv_haddock/lib/python3.12/site-packages/narwhals/expr_dt.py

@@ -0,0 +1,738 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Generic, TypeVar
+
+from narwhals._expression_parsing import ExprKind, ExprNode
+
+if TYPE_CHECKING:
+    from narwhals.expr import Expr
+    from narwhals.typing import TimeUnit
+
+ExprT = TypeVar("ExprT", bound="Expr")
+
+
+class ExprDateTimeNamespace(Generic[ExprT]):
+    def __init__(self, expr: ExprT) -> None:
+        self._expr = expr
+
+    def date(self) -> ExprT:
+        """Extract the date from underlying DateTime representation.
+
+        Raises:
+            NotImplementedError: If pandas default backend is being used.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame(
+            ...     {"a": [datetime(2012, 1, 7, 10), datetime(2027, 12, 13)]}
+            ... )
+            >>> df = nw.from_native(df_native)
+            >>> df.select(nw.col("a").dt.date()).to_native()
+            shape: (2, 1)
+            ┌────────────┐
+            │ a          │
+            │ ---        │
+            │ date       │
+            ╞════════════╡
+            │ 2012-01-07 │
+            │ 2027-12-13 │
+            └────────────┘
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "dt.date"))
+
+    def year(self) -> ExprT:
+        """Extract year from underlying DateTime representation.
+
+        Returns the year number in the calendar date.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> df_native = pd.DataFrame(
+            ...     {"a": [datetime(1978, 6, 1), datetime(2065, 1, 1)]}
+            ... )
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(nw.col("a").dt.year().alias("year"))
+            ┌──────────────────┐
+            |Narwhals DataFrame|
+            |------------------|
+            |           a  year|
+            |0 1978-06-01  1978|
+            |1 2065-01-01  2065|
+            └──────────────────┘
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "dt.year"))
+
+    def month(self) -> ExprT:
+        """Extract month from underlying DateTime representation.
+
+        Returns the month number starting from 1. The return value ranges from 1 to 12.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> df_native = pa.table({"a": [datetime(1978, 6, 1), datetime(2065, 1, 1)]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(nw.col("a").dt.month().alias("month")).to_native()
+            pyarrow.Table
+            a: timestamp[us]
+            month: int64
+            ----
+            a: [[1978-06-01 00:00:00.000000,2065-01-01 00:00:00.000000]]
+            month: [[6,1]]
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "dt.month"))
+
+    def day(self) -> ExprT:
+        """Extract day from underlying DateTime representation.
+
+        Returns the day of month starting from 1. The return value ranges from 1 to 31. (The last day of month differs by months.)
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> df_native = pa.table({"a": [datetime(1978, 6, 1), datetime(2065, 1, 1)]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(nw.col("a").dt.day().alias("day")).to_native()
+            pyarrow.Table
+            a: timestamp[us]
+            day: int64
+            ----
+            a: [[1978-06-01 00:00:00.000000,2065-01-01 00:00:00.000000]]
+            day: [[1,1]]
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "dt.day"))
+
+    def hour(self) -> ExprT:
+        """Extract hour from underlying DateTime representation.
+
+        Returns the hour number from 0 to 23.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame(
+            ...     {"a": [datetime(1978, 1, 1, 1), datetime(2065, 1, 1, 10)]}
+            ... )
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(nw.col("a").dt.hour().alias("hour"))
+            ┌──────────────────────────────┐
+            |      Narwhals DataFrame      |
+            |------------------------------|
+            |shape: (2, 2)                 |
+            |┌─────────────────────┬──────┐|
+            |│ a                   ┆ hour │|
+            |│ ---                 ┆ ---  │|
+            |│ datetime[μs]        ┆ i8   │|
+            |╞═════════════════════╪══════╡|
+            |│ 1978-01-01 01:00:00 ┆ 1    │|
+            |│ 2065-01-01 10:00:00 ┆ 10   │|
+            |└─────────────────────┴──────┘|
+            └──────────────────────────────┘
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "dt.hour"))
+
+    def minute(self) -> ExprT:
+        """Extract minutes from underlying DateTime representation.
+
+        Returns the minute number from 0 to 59.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> df_native = pd.DataFrame(
+            ...     {"a": [datetime(1978, 1, 1, 1, 1), datetime(2065, 1, 1, 10, 20)]}
+            ... )
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(nw.col("a").dt.minute().alias("minute")).to_native()
+                                a  minute
+            0 1978-01-01 01:01:00       1
+            1 2065-01-01 10:20:00      20
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "dt.minute"))
+
+    def second(self) -> ExprT:
+        """Extract seconds from underlying DateTime representation.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> df_native = pa.table(
+            ...     {
+            ...         "a": [
+            ...             datetime(1978, 1, 1, 1, 1, 1),
+            ...             datetime(2065, 1, 1, 10, 20, 30),
+            ...         ]
+            ...     }
+            ... )
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(nw.col("a").dt.second().alias("second")).to_native()
+            pyarrow.Table
+            a: timestamp[us]
+            second: int64
+            ----
+            a: [[1978-01-01 01:01:01.000000,2065-01-01 10:20:30.000000]]
+            second: [[1,30]]
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "dt.second"))
+
+    def millisecond(self) -> ExprT:
+        """Extract milliseconds from underlying DateTime representation.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> df_native = pa.table(
+            ...     {
+            ...         "a": [
+            ...             datetime(1978, 1, 1, 1, 1, 1, 0),
+            ...             datetime(2065, 1, 1, 10, 20, 30, 67000),
+            ...         ]
+            ...     }
+            ... )
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(
+            ...     nw.col("a").dt.millisecond().alias("millisecond")
+            ... ).to_native()
+            pyarrow.Table
+            a: timestamp[us]
+            millisecond: int64
+            ----
+            a: [[1978-01-01 01:01:01.000000,2065-01-01 10:20:30.067000]]
+            millisecond: [[0,67]]
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "dt.millisecond"))
+
+    def microsecond(self) -> ExprT:
+        """Extract microseconds from underlying DateTime representation.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> df_native = pa.table(
+            ...     {
+            ...         "a": [
+            ...             datetime(1978, 1, 1, 1, 1, 1, 0),
+            ...             datetime(2065, 1, 1, 10, 20, 30, 67000),
+            ...         ]
+            ...     }
+            ... )
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(
+            ...     nw.col("a").dt.microsecond().alias("microsecond")
+            ... ).to_native()
+            pyarrow.Table
+            a: timestamp[us]
+            microsecond: int64
+            ----
+            a: [[1978-01-01 01:01:01.000000,2065-01-01 10:20:30.067000]]
+            microsecond: [[0,67000]]
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "dt.microsecond"))
+
+    def nanosecond(self) -> ExprT:
+        """Extract Nanoseconds from underlying DateTime representation.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> df_native = pa.table(
+            ...     {
+            ...         "a": [
+            ...             datetime(1978, 1, 1, 1, 1, 1, 0),
+            ...             datetime(2065, 1, 1, 10, 20, 30, 67000),
+            ...         ]
+            ...     }
+            ... )
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(
+            ...     nw.col("a").dt.nanosecond().alias("nanosecond")
+            ... ).to_native()
+            pyarrow.Table
+            a: timestamp[us]
+            nanosecond: int64
+            ----
+            a: [[1978-01-01 01:01:01.000000,2065-01-01 10:20:30.067000]]
+            nanosecond: [[0,67000000]]
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "dt.nanosecond"))
+
+    def ordinal_day(self) -> ExprT:
+        """Get ordinal day.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> df_native = pd.DataFrame(
+            ...     {"a": [datetime(2020, 1, 1), datetime(2020, 8, 3)]}
+            ... )
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(a_ordinal_day=nw.col("a").dt.ordinal_day())
+            ┌───────────────────────────┐
+            |    Narwhals DataFrame     |
+            |---------------------------|
+            |           a  a_ordinal_day|
+            |0 2020-01-01              1|
+            |1 2020-08-03            216|
+            └───────────────────────────┘
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "dt.ordinal_day"))
+
+    def weekday(self) -> ExprT:
+        """Extract the week day from the underlying Date representation.
+
+        Note that Monday = 1 and Sunday = 7.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> df_native = pd.DataFrame(
+            ...     {"a": [datetime(2020, 1, 1), datetime(2020, 8, 3)]}
+            ... )
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(a_week_day=nw.col("a").dt.weekday())
+            ┌────────────────────────┐
+            |   Narwhals DataFrame   |
+            |------------------------|
+            |           a  a_week_day|
+            |0 2020-01-01           3|
+            |1 2020-08-03           1|
+            └────────────────────────┘
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "dt.weekday"))
+
+    def total_minutes(self) -> ExprT:
+        """Get total minutes.
+
+        Notes:
+            The function outputs the total minutes in the int dtype by default,
+            however, pandas may change the dtype to float when there are missing values,
+            consider using `fill_null()` and `cast` in this case.
+
+        Examples:
+            >>> from datetime import timedelta
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame(
+            ...     {"a": [timedelta(minutes=10), timedelta(minutes=20, seconds=40)]}
+            ... )
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(
+            ...     a_total_minutes=nw.col("a").dt.total_minutes()
+            ... ).to_native()
+            shape: (2, 2)
+            ┌──────────────┬─────────────────┐
+            │ a            ┆ a_total_minutes │
+            │ ---          ┆ ---             │
+            │ duration[μs] ┆ i64             │
+            ╞══════════════╪═════════════════╡
+            │ 10m          ┆ 10              │
+            │ 20m 40s      ┆ 20              │
+            └──────────────┴─────────────────┘
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "dt.total_minutes"))
+
+    def total_seconds(self) -> ExprT:
+        """Get total seconds.
+
+        Notes:
+            The function outputs the total seconds in the int dtype by default,
+            however, pandas may change the dtype to float when there are missing values,
+            consider using `fill_null()` and `cast` in this case.
+
+        Examples:
+            >>> from datetime import timedelta
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame(
+            ...     {"a": [timedelta(seconds=10), timedelta(seconds=20, milliseconds=40)]}
+            ... )
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(
+            ...     a_total_seconds=nw.col("a").dt.total_seconds()
+            ... ).to_native()
+            shape: (2, 2)
+            ┌──────────────┬─────────────────┐
+            │ a            ┆ a_total_seconds │
+            │ ---          ┆ ---             │
+            │ duration[μs] ┆ i64             │
+            ╞══════════════╪═════════════════╡
+            │ 10s          ┆ 10              │
+            │ 20s 40ms     ┆ 20              │
+            └──────────────┴─────────────────┘
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "dt.total_seconds"))
+
+    def total_milliseconds(self) -> ExprT:
+        """Get total milliseconds.
+
+        Notes:
+            The function outputs the total milliseconds in the int dtype by default,
+            however, pandas may change the dtype to float when there are missing values,
+            consider using `fill_null()` and `cast` in this case.
+
+        Examples:
+            >>> from datetime import timedelta
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame(
+            ...     {
+            ...         "a": [
+            ...             timedelta(milliseconds=10),
+            ...             timedelta(milliseconds=20, microseconds=40),
+            ...         ]
+            ...     }
+            ... )
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(
+            ...     a_total_milliseconds=nw.col("a").dt.total_milliseconds()
+            ... ).to_native()
+            shape: (2, 2)
+            ┌──────────────┬──────────────────────┐
+            │ a            ┆ a_total_milliseconds │
+            │ ---          ┆ ---                  │
+            │ duration[μs] ┆ i64                  │
+            ╞══════════════╪══════════════════════╡
+            │ 10ms         ┆ 10                   │
+            │ 20040µs      ┆ 20                   │
+            └──────────────┴──────────────────────┘
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "dt.total_milliseconds")
+        )
+
+    def total_microseconds(self) -> ExprT:
+        """Get total microseconds.
+
+        Notes:
+            The function outputs the total microseconds in the int dtype by default,
+            however, pandas may change the dtype to float when there are missing values,
+            consider using `fill_null()` and `cast` in this case.
+
+        Examples:
+            >>> from datetime import timedelta
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> df_native = pa.table(
+            ...     {
+            ...         "a": [
+            ...             timedelta(microseconds=10),
+            ...             timedelta(milliseconds=1, microseconds=200),
+            ...         ]
+            ...     }
+            ... )
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(
+            ...     a_total_microseconds=nw.col("a").dt.total_microseconds()
+            ... ).to_native()
+            pyarrow.Table
+            a: duration[us]
+            a_total_microseconds: int64
+            ----
+            a: [[10,1200]]
+            a_total_microseconds: [[10,1200]]
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "dt.total_microseconds")
+        )
+
+    def total_nanoseconds(self) -> ExprT:
+        """Get total nanoseconds.
+
+        Notes:
+            The function outputs the total nanoseconds in the int dtype by default,
+            however, pandas may change the dtype to float when there are missing values,
+            consider using `fill_null()` and `cast` in this case.
+
+        Examples:
+            >>> from datetime import timedelta
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> df_native = pd.DataFrame(
+            ...     {
+            ...         "a": pd.to_datetime(
+            ...             [
+            ...                 "2024-01-01 00:00:00.000000001",
+            ...                 "2024-01-01 00:00:00.000000002",
+            ...             ]
+            ...         )
+            ...     }
+            ... )
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(
+            ...     a_diff_total_nanoseconds=nw.col("a").diff().dt.total_nanoseconds()
+            ... ).to_native()
+                                          a  a_diff_total_nanoseconds
+            0 2024-01-01 00:00:00.000000001                       NaN
+            1 2024-01-01 00:00:00.000000002                       1.0
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "dt.total_nanoseconds")
+        )
+
+    def to_string(self, format: str) -> ExprT:
+        """Convert a Date/Time/Datetime column into a String column with the given format.
+
+        Arguments:
+            format: Format to format temporal column with.
+
+        Notes:
+            Unfortunately, different libraries interpret format directives a bit
+            differently.
+
+            - Chrono, the library used by Polars, uses `"%.f"` for fractional seconds,
+              whereas pandas and Python stdlib use `".%f"`.
+            - PyArrow interprets `"%S"` as "seconds, including fractional seconds"
+              whereas most other tools interpret it as "just seconds, as 2 digits".
+            ---
+            Therefore, we make the following adjustments.
+
+            - for pandas-like libraries, we replace `"%S.%f"` with `"%S%.f"`.
+            - for PyArrow, we replace `"%S.%f"` with `"%S"`.
+            ---
+            Workarounds like these don't make us happy, and we try to avoid them as
+            much as possible, but here we feel like it's the best compromise.
+
+            If you just want to format a date/datetime Series as a local datetime
+            string, and have it work as consistently as possible across libraries,
+            we suggest using:
+
+            - `"%Y-%m-%dT%H:%M:%S%.f"` for datetimes
+            - `"%Y-%m-%d"` for dates
+            ---
+            Though note that, even then, different tools may return a different number
+            of trailing zeros. Nonetheless, this is probably consistent enough for
+            most applications.
+
+            If you have an application where this is not enough, please open an issue
+            and let us know.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame(
+            ...     {"a": [datetime(2020, 3, 1), datetime(2020, 5, 1)]}
+            ... )
+            >>> df = nw.from_native(df_native)
+            >>> df.select(nw.col("a").dt.to_string("%Y/%m/%d %H:%M:%S"))
+            ┌───────────────────────┐
+            |  Narwhals DataFrame   |
+            |-----------------------|
+            |shape: (2, 1)          |
+            |┌─────────────────────┐|
+            |│ a                   │|
+            |│ ---                 │|
+            |│ str                 │|
+            |╞═════════════════════╡|
+            |│ 2020/03/01 00:00:00 │|
+            |│ 2020/05/01 00:00:00 │|
+            |└─────────────────────┘|
+            └───────────────────────┘
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "dt.to_string", format=format)
+        )
+
+    def replace_time_zone(self, time_zone: str | None) -> ExprT:
+        """Replace time zone.
+
+        Arguments:
+            time_zone: Target time zone.
+
+        Examples:
+            >>> from datetime import datetime, timezone
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> df_native = pd.DataFrame(
+            ...     {
+            ...         "a": [
+            ...             datetime(2024, 1, 1, tzinfo=timezone.utc),
+            ...             datetime(2024, 1, 2, tzinfo=timezone.utc),
+            ...         ]
+            ...     }
+            ... )
+            >>> df = nw.from_native(df_native)
+            >>> df.select(nw.col("a").dt.replace_time_zone("Asia/Kathmandu")).to_native()
+                                      a
+            0 2024-01-01 00:00:00+05:45
+            1 2024-01-02 00:00:00+05:45
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "dt.replace_time_zone", time_zone=time_zone)
+        )
+
+    def convert_time_zone(self, time_zone: str) -> ExprT:
+        """Convert to a new time zone.
+
+        If converting from a time-zone-naive column, then conversion happens
+        as if converting from UTC.
+
+        Arguments:
+            time_zone: Target time zone.
+
+        Examples:
+            >>> from datetime import datetime, timezone
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> df_native = pd.DataFrame(
+            ...     {
+            ...         "a": [
+            ...             datetime(2024, 1, 1, tzinfo=timezone.utc),
+            ...             datetime(2024, 1, 2, tzinfo=timezone.utc),
+            ...         ]
+            ...     }
+            ... )
+            >>> df = nw.from_native(df_native)
+            >>> df.select(nw.col("a").dt.convert_time_zone("Asia/Kathmandu")).to_native()
+                                      a
+            0 2024-01-01 05:45:00+05:45
+            1 2024-01-02 05:45:00+05:45
+        """
+        if time_zone is None:
+            msg = "Target `time_zone` cannot be `None` in `convert_time_zone`. Please use `replace_time_zone(None)` if you want to remove the time zone."
+            raise TypeError(msg)
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "dt.convert_time_zone", time_zone=time_zone)
+        )
+
+    def timestamp(self, time_unit: TimeUnit = "us") -> ExprT:
+        """Return a timestamp in the given time unit.
+
+        Arguments:
+            time_unit: One of
+                - 'ns': nanosecond.
+                - 'us': microsecond.
+                - 'ms': millisecond.
+
+        Examples:
+            >>> from datetime import date
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame({"date": [date(2001, 1, 1), None]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(nw.col("date").dt.timestamp("ms").alias("timestamp_ms"))
+            ┌─────────────────────────────┐
+            |     Narwhals DataFrame      |
+            |-----------------------------|
+            |shape: (2, 2)                |
+            |┌────────────┬──────────────┐|
+            |│ date       ┆ timestamp_ms │|
+            |│ ---        ┆ ---          │|
+            |│ date       ┆ i64          │|
+            |╞════════════╪══════════════╡|
+            |│ 2001-01-01 ┆ 978307200000 │|
+            |│ null       ┆ null         │|
+            |└────────────┴──────────────┘|
+            └─────────────────────────────┘
+        """
+        if time_unit not in {"ns", "us", "ms"}:
+            msg = (
+                "invalid `time_unit`"
+                f"\n\nExpected one of {{'ns', 'us', 'ms'}}, got {time_unit!r}."
+            )
+            raise ValueError(msg)
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "dt.timestamp", time_unit=time_unit)
+        )
+
+    def truncate(self, every: str) -> ExprT:
+        """Divide the date/datetime range into buckets.
+
+        Arguments:
+            every: Length of bucket. Must be of form `<multiple><unit>`,
+                where `multiple` is a positive integer and `unit` is one of
+
+                - 'ns': nanosecond.
+                - 'us': microsecond.
+                - 'ms': millisecond.
+                - 's': second.
+                - 'm': minute.
+                - 'h': hour.
+                - 'd': day.
+                - 'mo': month.
+                - 'q': quarter.
+                - 'y': year.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame({"datetime": [datetime(2021, 3, 1, 12, 34)]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(
+            ...     nw.col("datetime").dt.truncate("1h").alias("datetime_trunc")
+            ... )
+            ┌─────────────────────────────────────────────┐
+            |             Narwhals DataFrame              |
+            |---------------------------------------------|
+            |shape: (1, 2)                                |
+            |┌─────────────────────┬─────────────────────┐|
+            |│ datetime            ┆ datetime_trunc      │|
+            |│ ---                 ┆ ---                 │|
+            |│ datetime[μs]        ┆ datetime[μs]        │|
+            |╞═════════════════════╪═════════════════════╡|
+            |│ 2021-03-01 12:34:00 ┆ 2021-03-01 12:00:00 │|
+            |└─────────────────────┴─────────────────────┘|
+            └─────────────────────────────────────────────┘
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "dt.truncate", every=every)
+        )
+
+    def offset_by(self, by: str) -> ExprT:
+        """Offset this date by a relative time offset.
+
+        Arguments:
+            by: The offset. Must be of form `<multiple><unit>`,
+                where `multiple` is a positive integer and `unit` is one of
+
+                - 'ns': nanosecond.
+                - 'us': microsecond.
+                - 'ms': millisecond.
+                - 's': second.
+                - 'm': minute.
+                - 'h': hour.
+                - 'd': day.
+                - 'mo': month.
+                - 'q': quarter.
+                - 'y': year.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame({"datetime": [datetime(2021, 3, 1, 12, 34)]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(
+            ...     nw.col("datetime").dt.offset_by("1h").alias("datetime_offset_by_1h")
+            ... )
+            ┌───────────────────────────────────────────────┐
+            |              Narwhals DataFrame               |
+            |-----------------------------------------------|
+            |shape: (1, 2)                                  |
+            |┌─────────────────────┬───────────────────────┐|
+            |│ datetime            ┆ datetime_offset_by_1h │|
+            |│ ---                 ┆ ---                   │|
+            |│ datetime[μs]        ┆ datetime[μs]          │|
+            |╞═════════════════════╪═══════════════════════╡|
+            |│ 2021-03-01 12:34:00 ┆ 2021-03-01 13:34:00   │|
+            |└─────────────────────┴───────────────────────┘|
+            └───────────────────────────────────────────────┘
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "dt.offset_by", by=by)
+        )

.venv_haddock/lib/python3.12/site-packages/narwhals/expr_list.py

@@ -0,0 +1,300 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Generic, TypeVar
+
+from narwhals._expression_parsing import ExprKind, ExprNode
+
+if TYPE_CHECKING:
+    from narwhals.expr import Expr
+    from narwhals.typing import NonNestedLiteral
+
+ExprT = TypeVar("ExprT", bound="Expr")
+
+
+class ExprListNamespace(Generic[ExprT]):
+    def __init__(self, expr: ExprT) -> None:
+        self._expr = expr
+
+    def len(self) -> ExprT:
+        """Return the number of elements in each list.
+
+        Null values count towards the total.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame({"a": [[1, 2], [3, 4, None], None, []]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(a_len=nw.col("a").list.len())
+            ┌────────────────────────┐
+            |   Narwhals DataFrame   |
+            |------------------------|
+            |shape: (4, 2)           |
+            |┌──────────────┬───────┐|
+            |│ a            ┆ a_len │|
+            |│ ---          ┆ ---   │|
+            |│ list[i64]    ┆ u32   │|
+            |╞══════════════╪═══════╡|
+            |│ [1, 2]       ┆ 2     │|
+            |│ [3, 4, null] ┆ 3     │|
+            |│ null         ┆ null  │|
+            |│ []           ┆ 0     │|
+            |└──────────────┴───────┘|
+            └────────────────────────┘
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "list.len"))
+
+    def unique(self) -> ExprT:
+        """Get the unique/distinct values in the list.
+
+        Null values are included in the result. The order of unique values is not guaranteed.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame({"a": [[1, 1, 2], [3, 3, None], None, []]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(a_unique=nw.col("a").list.unique())
+            ┌────────────────────────────┐
+            |     Narwhals DataFrame     |
+            |----------------------------|
+            |shape: (4, 2)               |
+            |┌──────────────┬───────────┐|
+            |│ a            ┆ a_unique  │|
+            |│ ---          ┆ ---       │|
+            |│ list[i64]    ┆ list[i64] │|
+            |╞══════════════╪═══════════╡|
+            |│ [1, 1, 2]    ┆ [1, 2]    │|
+            |│ [3, 3, null] ┆ [null, 3] │|
+            |│ null         ┆ null      │|
+            |│ []           ┆ []        │|
+            |└──────────────┴───────────┘|
+            └────────────────────────────┘
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "list.unique"))
+
+    def contains(self, item: NonNestedLiteral) -> ExprT:
+        """Check if sublists contain the given item.
+
+        Arguments:
+            item: Item that will be checked for membership.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame({"a": [[1, 2], None, []]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(a_contains_1=nw.col("a").list.contains(1))
+            ┌────────────────────────────┐
+            |     Narwhals DataFrame     |
+            |----------------------------|
+            |shape: (3, 2)               |
+            |┌───────────┬──────────────┐|
+            |│ a         ┆ a_contains_1 │|
+            |│ ---       ┆ ---          │|
+            |│ list[i64] ┆ bool         │|
+            |╞═══════════╪══════════════╡|
+            |│ [1, 2]    ┆ true         │|
+            |│ null      ┆ null         │|
+            |│ []        ┆ false        │|
+            |└───────────┴──────────────┘|
+            └────────────────────────────┘
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "list.contains", item=item)
+        )
+
+    def get(self, index: int) -> ExprT:
+        """Return the value by index in each list.
+
+        Negative indices are not accepted.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame({"a": [[1, 2], [3, 4, None], [None, 5]]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(a_first=nw.col("a").list.get(0))
+            ┌──────────────────────────┐
+            |    Narwhals DataFrame    |
+            |--------------------------|
+            |shape: (3, 2)             |
+            |┌──────────────┬─────────┐|
+            |│ a            ┆ a_first │|
+            |│ ---          ┆ ---     │|
+            |│ list[i64]    ┆ i64     │|
+            |╞══════════════╪═════════╡|
+            |│ [1, 2]       ┆ 1       │|
+            |│ [3, 4, null] ┆ 3       │|
+            |│ [null, 5]    ┆ null    │|
+            |└──────────────┴─────────┘|
+            └──────────────────────────┘
+        """
+        if not isinstance(index, int):
+            msg = (
+                f"Index must be of type 'int'. Got type '{type(index).__name__}' instead."
+            )
+            raise TypeError(msg)
+
+        if index < 0:
+            msg = f"Index {index} is out of bounds: should be greater than or equal to 0."
+            raise ValueError(msg)
+
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "list.get", index=index)
+        )
+
+    def min(self) -> ExprT:
+        """Compute the min value of the lists in the array.
+
+        Examples:
+            >>> import duckdb
+            >>> import narwhals as nw
+            >>> df_native = duckdb.sql("SELECT * FROM VALUES ([1]), ([3, 4, NULL]) df(a)")
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(a_min=nw.col("a").list.min())
+            ┌────────────────────────┐
+            |   Narwhals LazyFrame   |
+            |------------------------|
+            |┌──────────────┬───────┐|
+            |│      a       │ a_min │|
+            |│   int32[]    │ int32 │|
+            |├──────────────┼───────┤|
+            |│ [1]          │     1 │|
+            |│ [3, 4, NULL] │     3 │|
+            |└──────────────┴───────┘|
+            └────────────────────────┘
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "list.min"))
+
+    def max(self) -> ExprT:
+        """Compute the max value of the lists in the array.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame({"a": [[1], [3, 4, None]]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(a_max=nw.col("a").list.max())
+            ┌────────────────────────┐
+            |   Narwhals DataFrame   |
+            |------------------------|
+            |shape: (2, 2)           |
+            |┌──────────────┬───────┐|
+            |│ a            ┆ a_max │|
+            |│ ---          ┆ ---   │|
+            |│ list[i64]    ┆ i64   │|
+            |╞══════════════╪═══════╡|
+            |│ [1]          ┆ 1     │|
+            |│ [3, 4, null] ┆ 4     │|
+            |└──────────────┴───────┘|
+            └────────────────────────┘
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "list.max"))
+
+    def mean(self) -> ExprT:
+        """Compute the mean value of the lists in the array.
+
+        Examples:
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> df_native = pa.table({"a": [[1], [3, 4, None]]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(a_mean=nw.col("a").list.mean())
+            ┌──────────────────────┐
+            |  Narwhals DataFrame  |
+            |----------------------|
+            |pyarrow.Table         |
+            |a: list<item: int64>  |
+            |  child 0, item: int64|
+            |a_mean: double        |
+            |----                  |
+            |a: [[[1],[3,4,null]]] |
+            |a_mean: [[1,3.5]]     |
+            └──────────────────────┘
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "list.mean"))
+
+    def median(self) -> ExprT:
+        """Compute the median value of the lists in the array.
+
+        Examples:
+            >>> import duckdb
+            >>> import narwhals as nw
+            >>> df_native = duckdb.sql("SELECT * FROM VALUES ([1]), ([3, 4, NULL]) df(a)")
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(a_median=nw.col("a").list.median())
+            ┌───────────────────────────┐
+            |    Narwhals LazyFrame     |
+            |---------------------------|
+            |┌──────────────┬──────────┐|
+            |│      a       │ a_median │|
+            |│   int32[]    │  double  │|
+            |├──────────────┼──────────┤|
+            |│ [1]          │      1.0 │|
+            |│ [3, 4, NULL] │      3.5 │|
+            |└──────────────┴──────────┘|
+            └───────────────────────────┘
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "list.median"))
+
+    def sum(self) -> ExprT:
+        """Compute the sum value of the lists in the array.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame({"a": [[1], [3, 4, None]]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(a_sum=nw.col("a").list.sum())
+            ┌────────────────────────┐
+            |   Narwhals DataFrame   |
+            |------------------------|
+            |shape: (2, 2)           |
+            |┌──────────────┬───────┐|
+            |│ a            ┆ a_sum │|
+            |│ ---          ┆ ---   │|
+            |│ list[i64]    ┆ i64   │|
+            |╞══════════════╪═══════╡|
+            |│ [1]          ┆ 1     │|
+            |│ [3, 4, null] ┆ 7     │|
+            |└──────────────┴───────┘|
+            └────────────────────────┘
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "list.sum"))
+
+    def sort(self, *, descending: bool = False, nulls_last: bool = False) -> ExprT:
+        """Sort the lists of the expression.
+
+        Arguments:
+            descending: Sort in descending order.
+            nulls_last: Place null values last.
+
+        Examples:
+            >>> import duckdb
+            >>> import narwhals as nw
+            >>> df_native = duckdb.sql(
+            ...     "SELECT * FROM VALUES ([2, -1, 1]), ([3, -4, NULL]) df(a)"
+            ... )
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(a_sorted=nw.col("a").list.sort())
+            ┌─────────────────────────────────┐
+            |       Narwhals LazyFrame        |
+            |---------------------------------|
+            |┌───────────────┬───────────────┐|
+            |│       a       │   a_sorted    │|
+            |│    int32[]    │    int32[]    │|
+            |├───────────────┼───────────────┤|
+            |│ [2, -1, 1]    │ [-1, 1, 2]    │|
+            |│ [3, -4, NULL] │ [NULL, -4, 3] │|
+            |└───────────────┴───────────────┘|
+            └─────────────────────────────────┘
+        """
+        return self._expr._append_node(
+            ExprNode(
+                ExprKind.ELEMENTWISE,
+                "list.sort",
+                descending=descending,
+                nulls_last=nulls_last,
+            )
+        )

.venv_haddock/lib/python3.12/site-packages/narwhals/expr_name.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Callable, Generic, TypeVar
+
+from narwhals._expression_parsing import ExprKind, ExprNode
+
+if TYPE_CHECKING:
+    from narwhals.expr import Expr
+
+ExprT = TypeVar("ExprT", bound="Expr")
+
+
+class ExprNameNamespace(Generic[ExprT]):
+    def __init__(self, expr: ExprT) -> None:
+        self._expr = expr
+
+    def keep(self) -> ExprT:
+        r"""Keep the original root name of the expression.
+
+        Notes:
+            For Polars versions prior to 1.32, this will undo any previous renaming operations on the expression.
+
+        Examples:
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> df_native = pd.DataFrame({"foo": [1, 2], "BAR": [4, 5]})
+            >>> df = nw.from_native(df_native)
+            >>> df.select(nw.col("foo").alias("alias_for_foo").name.keep()).columns
+            ['foo']
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "name.keep"))
+
+    def map(self, function: Callable[[str], str]) -> ExprT:
+        r"""Rename the output of an expression by mapping a function over the root name.
+
+        Arguments:
+            function: Function that maps a root name to a new name.
+
+        Notes:
+            For Polars versions prior to 1.32, this will undo any previous renaming operations on the expression.
+
+        Examples:
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> df_native = pd.DataFrame({"foo": [1, 2], "BAR": [4, 5]})
+            >>> df = nw.from_native(df_native)
+            >>> renaming_func = lambda s: s[::-1]  # reverse column name
+            >>> df.select(nw.col("foo", "BAR").name.map(renaming_func)).columns
+            ['oof', 'RAB']
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "name.map", function=function)
+        )
+
+    def prefix(self, prefix: str) -> ExprT:
+        r"""Add a prefix to the root column name of the expression.
+
+        Arguments:
+            prefix: Prefix to add to the root column name.
+
+        Notes:
+            For Polars versions prior to 1.32, this will undo any previous renaming operations on the expression.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame({"foo": [1, 2], "BAR": [4, 5]})
+            >>> df = nw.from_native(df_native)
+            >>> df.select(nw.col("foo", "BAR").name.prefix("with_prefix")).columns
+            ['with_prefixfoo', 'with_prefixBAR']
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "name.prefix", prefix=prefix)
+        )
+
+    def suffix(self, suffix: str) -> ExprT:
+        r"""Add a suffix to the root column name of the expression.
+
+        Arguments:
+            suffix: Suffix to add to the root column name.
+
+        Notes:
+            For Polars versions prior to 1.32, this will undo any previous renaming operations on the expression.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame({"foo": [1, 2], "BAR": [4, 5]})
+            >>> df = nw.from_native(df_native)
+            >>> df.select(nw.col("foo", "BAR").name.suffix("_with_suffix")).columns
+            ['foo_with_suffix', 'BAR_with_suffix']
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "name.suffix", suffix=suffix)
+        )
+
+    def to_lowercase(self) -> ExprT:
+        r"""Make the root column name lowercase.
+
+        Notes:
+            For Polars versions prior to 1.32, this will undo any previous renaming operations on the expression.
+
+        Examples:
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> df_native = pa.table({"foo": [1, 2], "BAR": [4, 5]})
+            >>> df = nw.from_native(df_native)
+            >>> df.select(nw.col("foo", "BAR").name.to_lowercase()).columns
+            ['foo', 'bar']
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "name.to_lowercase")
+        )
+
+    def to_uppercase(self) -> ExprT:
+        r"""Make the root column name uppercase.
+
+        Notes:
+            For Polars versions prior to 1.32, this will undo any previous renaming operations on the expression.
+
+        Examples:
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> df_native = pa.table({"foo": [1, 2], "BAR": [4, 5]})
+            >>> df = nw.from_native(df_native)
+            >>> df.select(nw.col("foo", "BAR").name.to_uppercase()).columns
+            ['FOO', 'BAR']
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "name.to_uppercase")
+        )

.venv_haddock/lib/python3.12/site-packages/narwhals/expr_str.py

@@ -0,0 +1,579 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Generic, TypeVar
+
+from narwhals._expression_parsing import ExprKind, ExprNode
+
+if TYPE_CHECKING:
+    from narwhals.expr import Expr
+    from narwhals.typing import IntoExpr
+
+ExprT = TypeVar("ExprT", bound="Expr")
+
+
+class ExprStringNamespace(Generic[ExprT]):
+    def __init__(self, expr: ExprT) -> None:
+        self._expr = expr
+
+    def len_chars(self) -> ExprT:
+        r"""Return the length of each string as the number of characters.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame({"words": ["foo", "345", None]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(words_len=nw.col("words").str.len_chars())
+            ┌─────────────────────┐
+            | Narwhals DataFrame  |
+            |---------------------|
+            |shape: (3, 2)        |
+            |┌───────┬───────────┐|
+            |│ words ┆ words_len │|
+            |│ ---   ┆ ---       │|
+            |│ str   ┆ u32       │|
+            |╞═══════╪═══════════╡|
+            |│ foo   ┆ 3         │|
+            |│ 345   ┆ 3         │|
+            |│ null  ┆ null      │|
+            |└───────┴───────────┘|
+            └─────────────────────┘
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "str.len_chars"))
+
+    def replace(
+        self, pattern: str, value: str | IntoExpr, *, literal: bool = False, n: int = 1
+    ) -> ExprT:
+        r"""Replace first matching regex/literal substring with a new string value.
+
+        Arguments:
+            pattern: A valid regular expression pattern.
+            value: String that will replace the matched substring.
+            literal: Treat `pattern` as a literal string.
+            n: Number of matches to replace.
+
+        Examples:
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> df_native = pd.DataFrame({"foo": ["123abc", "abc abc123"]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(replaced=nw.col("foo").str.replace("abc", ""))
+            ┌──────────────────────┐
+            |  Narwhals DataFrame  |
+            |----------------------|
+            |          foo replaced|
+            |0      123abc      123|
+            |1  abc abc123   abc123|
+            └──────────────────────┘
+        """
+        return self._expr._append_node(
+            ExprNode(
+                ExprKind.ELEMENTWISE,
+                "str.replace",
+                exprs=(value,),
+                pattern=pattern,
+                literal=literal,
+                n=n,
+                str_as_lit=True,
+            )
+        )
+
+    def replace_all(
+        self, pattern: str, value: IntoExpr, *, literal: bool = False
+    ) -> ExprT:
+        r"""Replace all matching regex/literal substring with a new string value.
+
+        Arguments:
+            pattern: A valid regular expression pattern.
+            value: String that will replace the matched substring.
+            literal: Treat `pattern` as a literal string.
+
+        Examples:
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> df_native = pd.DataFrame({"foo": ["123abc", "abc abc123"]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(replaced=nw.col("foo").str.replace_all("abc", ""))
+            ┌──────────────────────┐
+            |  Narwhals DataFrame  |
+            |----------------------|
+            |          foo replaced|
+            |0      123abc      123|
+            |1  abc abc123      123|
+            └──────────────────────┘
+        """
+        return self._expr._append_node(
+            ExprNode(
+                ExprKind.ELEMENTWISE,
+                "str.replace_all",
+                exprs=(value,),
+                pattern=pattern,
+                literal=literal,
+                str_as_lit=True,
+            )
+        )
+
+    def strip_chars(self, characters: str | None = None) -> ExprT:
+        r"""Remove leading and trailing characters.
+
+        Arguments:
+            characters: The set of characters to be removed. All combinations of this
+                set of characters will be stripped from the start and end of the string.
+                If set to None (default), all leading and trailing whitespace is removed
+                instead.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame({"fruits": ["apple", "\nmango"]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(stripped=nw.col("fruits").str.strip_chars()).to_dict(
+            ...     as_series=False
+            ... )
+            {'fruits': ['apple', '\nmango'], 'stripped': ['apple', 'mango']}
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "str.strip_chars", characters=characters)
+        )
+
+    def starts_with(self, prefix: str) -> ExprT:
+        r"""Check if string values start with a substring.
+
+        Arguments:
+            prefix: prefix substring
+
+        Examples:
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> df_native = pd.DataFrame({"fruits": ["apple", "mango", None]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(has_prefix=nw.col("fruits").str.starts_with("app"))
+            ┌────────────────────┐
+            | Narwhals DataFrame |
+            |--------------------|
+            |  fruits  has_prefix|
+            |0  apple        True|
+            |1  mango       False|
+            |2    NaN       False|
+            └────────────────────┘
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "str.starts_with", prefix=prefix)
+        )
+
+    def ends_with(self, suffix: str) -> ExprT:
+        r"""Check if string values end with a substring.
+
+        Arguments:
+            suffix: suffix substring
+
+        Examples:
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> df_native = pd.DataFrame({"fruits": ["apple", "mango", None]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(has_suffix=nw.col("fruits").str.ends_with("ngo"))
+            ┌────────────────────┐
+            | Narwhals DataFrame |
+            |--------------------|
+            |  fruits  has_suffix|
+            |0  apple       False|
+            |1  mango        True|
+            |2    NaN       False|
+            └────────────────────┘
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "str.ends_with", suffix=suffix)
+        )
+
+    def contains(self, pattern: str | IntoExpr, *, literal: bool = False) -> ExprT:
+        r"""Check if string contains a substring that matches a pattern.
+
+        Arguments:
+            pattern: A Character sequence, valid regular expression pattern, or another
+                Expr.
+            literal: If True, treats the pattern as a literal string.
+                If False, assumes the pattern is a regular expression.
+
+        Warning:
+            Passing an expression as `pattern` is only supported by DuckDB, Ibis, Polars,
+            PySpark and SQLFrame. Other backends, such as pandas and PyArrow, will raise
+            a `TypeError`.
+
+        Examples:
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> df_native = pa.table({"pets": ["cat", "dog", "rabbit and parrot"]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(
+            ...     default_match=nw.col("pets").str.contains("cat|parrot"),
+            ...     case_insensitive_match=nw.col("pets").str.contains("cat|(?i)parrot"),
+            ... ).to_native()
+            pyarrow.Table
+            pets: string
+            default_match: bool
+            case_insensitive_match: bool
+            ----
+            pets: [["cat","dog","rabbit and parrot"]]
+            default_match: [[true,false,true]]
+            case_insensitive_match: [[true,false,true]]
+        """
+        return self._expr._append_node(
+            ExprNode(
+                ExprKind.ELEMENTWISE,
+                "str.contains",
+                exprs=(pattern,),
+                literal=literal,
+                str_as_lit=True,
+            )
+        )
+
+    def slice(self, offset: int, length: int | None = None) -> ExprT:
+        r"""Create subslices of the string values of an expression.
+
+        Arguments:
+            offset: Start index. Negative indexing is supported.
+            length: Length of the slice. If set to `None` (default), the slice is taken to the
+                end of the string.
+
+        Examples:
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> df_native = pd.DataFrame({"s": ["pear", None, "papaya"]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(s_sliced=nw.col("s").str.slice(4, length=3))
+            ┌──────────────────┐
+            |Narwhals DataFrame|
+            |------------------|
+            |        s s_sliced|
+            |0    pear         |
+            |1     NaN      NaN|
+            |2  papaya       ya|
+            └──────────────────┘
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "str.slice", offset=offset, length=length)
+        )
+
+    def split(self, by: str) -> ExprT:
+        r"""Split the string values of an expression by a substring.
+
+        Arguments:
+            by: Substring to split by.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame({"s": ["foo bar", "foo_bar"]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(nw.col("s").str.split("_").alias("s_split"))
+            ┌────────────────────────────┐
+            |     Narwhals DataFrame     |
+            |----------------------------|
+            |shape: (2, 2)               |
+            |┌─────────┬────────────────┐|
+            |│ s       ┆ s_split        │|
+            |│ ---     ┆ ---            │|
+            |│ str     ┆ list[str]      │|
+            |╞═════════╪════════════════╡|
+            |│ foo bar ┆ ["foo bar"]    │|
+            |│ foo_bar ┆ ["foo", "bar"] │|
+            |└─────────┴────────────────┘|
+            └────────────────────────────┘
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "str.split", by=by))
+
+    def head(self, n: int = 5) -> ExprT:
+        r"""Take the first n elements of each string.
+
+        Arguments:
+            n: Number of elements to take. Negative indexing is **not** supported.
+
+        Notes:
+            If the length of the string has fewer than `n` characters, the full string is returned.
+
+        Examples:
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> df_native = pa.table({"lyrics": ["taata", "taatatata", "zukkyun"]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(lyrics_head=nw.col("lyrics").str.head()).to_native()
+            pyarrow.Table
+            lyrics: string
+            lyrics_head: string
+            ----
+            lyrics: [["taata","taatatata","zukkyun"]]
+            lyrics_head: [["taata","taata","zukky"]]
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "str.slice", offset=0, length=n)
+        )
+
+    def tail(self, n: int = 5) -> ExprT:
+        r"""Take the last n elements of each string.
+
+        Arguments:
+            n: Number of elements to take. Negative indexing is **not** supported.
+
+        Notes:
+            If the length of the string has fewer than `n` characters, the full string is returned.
+
+        Examples:
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> df_native = pa.table({"lyrics": ["taata", "taatatata", "zukkyun"]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(lyrics_tail=nw.col("lyrics").str.tail()).to_native()
+            pyarrow.Table
+            lyrics: string
+            lyrics_tail: string
+            ----
+            lyrics: [["taata","taatatata","zukkyun"]]
+            lyrics_tail: [["taata","atata","kkyun"]]
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "str.slice", offset=-n, length=None)
+        )
+
+    def to_datetime(self, format: str | None = None) -> ExprT:
+        """Convert to Datetime dtype.
+
+        Notes:
+            - pandas defaults to nanosecond time unit, Polars to microsecond.
+              Prior to pandas 2.0, nanoseconds were the only time unit supported
+              in pandas, with no ability to set any other one. The ability to
+              set the time unit in pandas, if the version permits, will arrive.
+            - timezone-aware strings are all converted to and parsed as UTC.
+
+        Warning:
+            As different backends auto-infer format in different ways, if `format=None`
+            there is no guarantee that the result will be equal.
+
+        Arguments:
+            format: Format to use for conversion. If set to None (default), the format is
+                inferred from the data.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame({"a": ["2020-01-01", "2020-01-02"]})
+            >>> df = nw.from_native(df_native)
+            >>> df.select(nw.col("a").str.to_datetime(format="%Y-%m-%d"))
+            ┌───────────────────────┐
+            |  Narwhals DataFrame   |
+            |-----------------------|
+            |shape: (2, 1)          |
+            |┌────────────────────���┐|
+            |│ a                   │|
+            |│ ---                 │|
+            |│ datetime[μs]        │|
+            |╞═════════════════════╡|
+            |│ 2020-01-01 00:00:00 │|
+            |│ 2020-01-02 00:00:00 │|
+            |└─────────────────────┘|
+            └───────────────────────┘
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "str.to_datetime", format=format)
+        )
+
+    def to_date(self, format: str | None = None) -> ExprT:
+        """Convert to date dtype.
+
+        Warning:
+            As different backends auto-infer format in different ways, if `format=None`
+            there is no guarantee that the result will be equal.
+
+        Arguments:
+            format: Format to use for conversion. If set to None (default), the format is inferred from the data.
+
+        Examples:
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> df_native = pa.table({"a": ["2020-01-01", "2020-01-02"]})
+            >>> df = nw.from_native(df_native)
+            >>> df.select(nw.col("a").str.to_date(format="%Y-%m-%d"))
+            ┌────────────────────────────┐
+            |     Narwhals DataFrame     |
+            |----------------------------|
+            |pyarrow.Table               |
+            |a: date32[day]              |
+            |----                        |
+            |a: [[2020-01-01,2020-01-02]]|
+            └────────────────────────────┘
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "str.to_date", format=format)
+        )
+
+    def to_uppercase(self) -> ExprT:
+        r"""Transform string to uppercase variant.
+
+        Notes:
+            The PyArrow backend will convert 'ß' to 'ẞ' instead of 'SS'.
+            For more info see [the related issue](https://github.com/apache/arrow/issues/34599).
+            There may be other unicode-edge-case-related variations across implementations.
+
+        Examples:
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> df_native = pd.DataFrame({"fruits": ["apple", None]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(upper_col=nw.col("fruits").str.to_uppercase())
+            ┌──────────────────┐
+            |Narwhals DataFrame|
+            |------------------|
+            |  fruits upper_col|
+            |0  apple     APPLE|
+            |1    NaN       NaN|
+            └──────────────────┘
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "str.to_uppercase"))
+
+    def to_lowercase(self) -> ExprT:
+        r"""Transform string to lowercase variant.
+
+        Examples:
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> df_native = pd.DataFrame({"fruits": ["APPLE", None]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(lower_col=nw.col("fruits").str.to_lowercase())
+            ┌──────────────────┐
+            |Narwhals DataFrame|
+            |------------------|
+            |  fruits lower_col|
+            |0  APPLE     apple|
+            |1    NaN       NaN|
+            └──────────────────┘
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "str.to_lowercase"))
+
+    def to_titlecase(self) -> ExprT:
+        """Modify strings to their titlecase equivalent.
+
+        Notes:
+            This is a form of case transform where the first letter of each word is
+            capitalized, with the rest of the word in lowercase.
+
+            Word boundaries are defined by non-**alphabetic** characters, matching the
+            behavior of [`str.title`](https://docs.python.org/3/library/stdtypes.html#str.title)
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame(
+            ...     {
+            ...         "quotes": [
+            ...             "'e.t. phone home'",
+            ...             "you talkin' to me?",
+            ...             "to infinity,and BEYOND!",
+            ...         ]
+            ...     }
+            ... )
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(quotes_title=nw.col("quotes").str.to_titlecase())
+            ┌─────────────────────────────────────────────────────┐
+            |                 Narwhals DataFrame                  |
+            |-----------------------------------------------------|
+            |shape: (3, 2)                                        |
+            |┌─────────────────────────┬─────────────────────────┐|
+            |│ quotes                  ┆ quotes_title            │|
+            |│ ---                     ┆ ---                     │|
+            |│ str                     ┆ str                     │|
+            |╞═════════════════════════╪═════════════════════════╡|
+            |│ 'e.t. phone home'       ┆ 'E.T. Phone Home'       │|
+            |│ you talkin' to me?      ┆ You Talkin' To Me?      │|
+            |│ to infinity,and BEYOND! ┆ To Infinity,And Beyond! │|
+            |└─────────────────────────┴─────────────────────────┘|
+            └─────────────────────────────────────────────────────┘
+        """
+        return self._expr._append_node(ExprNode(ExprKind.ELEMENTWISE, "str.to_titlecase"))
+
+    def zfill(self, width: int) -> ExprT:
+        """Transform string to zero-padded variant.
+
+        Arguments:
+            width: The desired length of the string after padding. If the length of the
+                string is greater than `width`, no padding is applied.
+                If `width` is less than 0, no padding is applied.
+
+        Examples:
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> df_native = pd.DataFrame({"digits": ["+1", "-1", "1", None]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(zfill_col=nw.col("digits").str.zfill(3))
+            ┌──────────────────┐
+            |Narwhals DataFrame|
+            |------------------|
+            |  digits zfill_col|
+            |0     +1       +01|
+            |1     -1       -01|
+            |2      1       001|
+            |3    NaN       NaN|
+            └──────────────────┘
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "str.zfill", width=width)
+        )
+
+    def pad_start(self, length: int, fill_char: str = " ") -> ExprT:
+        """Pad the start of the string until it reaches the given length.
+
+        Arguments:
+            length: Pad the string until it reaches this length. Strings with
+                length equal to or greater than this value are returned as-is.
+            fill_char: The character to pad the string with.
+
+        Examples:
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> df_native = pd.DataFrame({"a": ["cow", "monkey", "hippopotamus", None]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(padded=nw.col("a").str.pad_start(8, "*"))
+            ┌─────────────────────────────┐
+            |     Narwhals DataFrame      |
+            |-----------------------------|
+            |              a        padded|
+            |0           cow      *****cow|
+            |1        monkey      **monkey|
+            |2  hippopotamus  hippopotamus|
+            |3           NaN           NaN|
+            └─────────────────────────────┘
+        """
+        return self._expr._append_node(
+            ExprNode(
+                ExprKind.ELEMENTWISE, "str.pad_start", length=length, fill_char=fill_char
+            )
+        )
+
+    def pad_end(self, length: int, fill_char: str = " ") -> ExprT:
+        """Pad the end of the string until it reaches the given length.
+
+        Arguments:
+            length: Pad the string until it reaches this length. Strings with
+                length equal to or greater than this value are returned as-is.
+            fill_char: The character to pad the string with.
+
+        Examples:
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> df_native = pd.DataFrame({"a": ["cow", "monkey", "hippopotamus", None]})
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(padded=nw.col("a").str.pad_end(8, "*"))
+            ┌─────────────────────────────┐
+            |     Narwhals DataFrame      |
+            |-----------------------------|
+            |              a        padded|
+            |0           cow      cow*****|
+            |1        monkey      monkey**|
+            |2  hippopotamus  hippopotamus|
+            |3           NaN           NaN|
+            └─────���───────────────────────┘
+        """
+        return self._expr._append_node(
+            ExprNode(
+                ExprKind.ELEMENTWISE, "str.pad_end", length=length, fill_char=fill_char
+            )
+        )

.venv_haddock/lib/python3.12/site-packages/narwhals/expr_struct.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Generic, TypeVar
+
+from narwhals._expression_parsing import ExprKind, ExprNode
+
+if TYPE_CHECKING:
+    from narwhals.expr import Expr
+
+ExprT = TypeVar("ExprT", bound="Expr")
+
+
+class ExprStructNamespace(Generic[ExprT]):
+    def __init__(self, expr: ExprT) -> None:
+        self._expr = expr
+
+    def field(self, name: str) -> ExprT:
+        r"""Retrieve a Struct field as a new expression.
+
+        Arguments:
+            name: Name of the struct field to retrieve.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> df_native = pl.DataFrame(
+            ...     {"user": [{"id": "0", "name": "john"}, {"id": "1", "name": "jane"}]}
+            ... )
+            >>> df = nw.from_native(df_native)
+            >>> df.with_columns(name=nw.col("user").struct.field("name"))
+            ┌───────────────────────┐
+            |  Narwhals DataFrame   |
+            |-----------------------|
+            |shape: (2, 2)          |
+            |┌──────────────┬──────┐|
+            |│ user         ┆ name │|
+            |│ ---          ┆ ---  │|
+            |│ struct[2]    ┆ str  │|
+            |╞══════════════╪══════╡|
+            |│ {"0","john"} ┆ john │|
+            |│ {"1","jane"} ┆ jane │|
+            |└──────────────┴──────┘|
+            └───────────────────────┘
+        """
+        return self._expr._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "struct.field", name=name)
+        )

.venv_haddock/lib/python3.12/site-packages/narwhals/functions.py

@@ -0,0 +1,1829 @@
+from __future__ import annotations
+
+import platform
+import sys
+from collections.abc import Iterable, Mapping, Sequence
+from typing import TYPE_CHECKING, Any
+
+from narwhals._expression_parsing import ExprKind, ExprNode, is_expr, is_series
+from narwhals._utils import (
+    Implementation,
+    Version,
+    deprecate_native_namespace,
+    flatten,
+    is_eager_allowed,
+    is_nested_literal,
+    is_sequence_but_not_str,
+    normalize_path,
+    supports_arrow_c_stream,
+    validate_laziness,
+)
+from narwhals.dependencies import (
+    is_narwhals_series,
+    is_numpy_array,
+    is_numpy_array_2d,
+    is_pyarrow_table,
+)
+from narwhals.exceptions import InvalidOperationError
+from narwhals.expr import Expr
+from narwhals.translate import from_native, to_native
+
+if TYPE_CHECKING:
+    from types import ModuleType
+
+    from typing_extensions import TypeAlias, TypeIs
+
+    from narwhals._native import NativeDataFrame, NativeLazyFrame, NativeSeries
+    from narwhals._translate import IntoArrowTable
+    from narwhals._typing import Backend, EagerAllowed, IntoBackend
+    from narwhals.dataframe import DataFrame, LazyFrame
+    from narwhals.dtypes import DType
+    from narwhals.series import Series
+    from narwhals.typing import (
+        ConcatMethod,
+        CorrelationMethod,
+        FileSource,
+        FrameT,
+        IntoDType,
+        IntoExpr,
+        IntoSchema,
+        NonNestedLiteral,
+        PythonLiteral,
+        _2DArray,
+    )
+
+    _IntoSchema: TypeAlias = "IntoSchema | Sequence[str] | None"
+
+
+def concat(items: Iterable[FrameT], *, how: ConcatMethod = "vertical") -> FrameT:
+    """Concatenate multiple DataFrames, LazyFrames into a single entity.
+
+    Arguments:
+        items: DataFrames, LazyFrames to concatenate.
+        how: concatenating strategy
+
+            - vertical: Concatenate vertically. Column names must match.
+            - horizontal: Concatenate horizontally. If lengths don't match, then
+                missing rows are filled with null values. This is only supported
+                when all inputs are (eager) DataFrames.
+            - diagonal: Finds a union between the column schemas and fills missing column
+                values with null.
+
+    Raises:
+        TypeError: The items to concatenate should either all be eager, or all lazy
+
+    Examples:
+        Let's take an example of vertical concatenation:
+
+        >>> import pandas as pd
+        >>> import polars as pl
+        >>> import pyarrow as pa
+        >>> import narwhals as nw
+
+        Let's look at one case a for vertical concatenation (pandas backed):
+
+        >>> df_pd_1 = nw.from_native(pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]}))
+        >>> df_pd_2 = nw.from_native(pd.DataFrame({"a": [5, 2], "b": [1, 4]}))
+        >>> nw.concat([df_pd_1, df_pd_2], how="vertical")
+        ┌──────────────────┐
+        |Narwhals DataFrame|
+        |------------------|
+        |        a  b      |
+        |     0  1  4      |
+        |     1  2  5      |
+        |     2  3  6      |
+        |     0  5  1      |
+        |     1  2  4      |
+        └──────────────────┘
+
+        Let's look at one case a for horizontal concatenation (polars backed):
+
+        >>> df_pl_1 = nw.from_native(pl.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]}))
+        >>> df_pl_2 = nw.from_native(pl.DataFrame({"c": [5, 2], "d": [1, 4]}))
+        >>> nw.concat([df_pl_1, df_pl_2], how="horizontal")
+        ┌───────────────────────────┐
+        |    Narwhals DataFrame     |
+        |---------------------------|
+        |shape: (3, 4)              |
+        |┌─────┬─────┬──────┬──────┐|
+        |│ a   ┆ b   ┆ c    ┆ d    │|
+        |│ --- ┆ --- ┆ ---  ┆ ---  │|
+        |│ i64 ┆ i64 ┆ i64  ┆ i64  │|
+        |╞═════╪═════╪══════╪══════╡|
+        |│ 1   ┆ 4   ┆ 5    ┆ 1    │|
+        |│ 2   ┆ 5   ┆ 2    ┆ 4    │|
+        |│ 3   ┆ 6   ┆ null ┆ null │|
+        |└─────┴─────┴──────┴──────┘|
+        └───────────────────────────┘
+
+        Let's look at one case a for diagonal concatenation (pyarrow backed):
+
+        >>> df_pa_1 = nw.from_native(pa.table({"a": [1, 2], "b": [3.5, 4.5]}))
+        >>> df_pa_2 = nw.from_native(pa.table({"a": [3, 4], "z": ["x", "y"]}))
+        >>> nw.concat([df_pa_1, df_pa_2], how="diagonal")
+        ┌──────────────────────────┐
+        |    Narwhals DataFrame    |
+        |--------------------------|
+        |pyarrow.Table             |
+        |a: int64                  |
+        |b: double                 |
+        |z: string                 |
+        |----                      |
+        |a: [[1,2],[3,4]]          |
+        |b: [[3.5,4.5],[null,null]]|
+        |z: [[null,null],["x","y"]]|
+        └──────────────────────────┘
+    """
+    from narwhals.dependencies import is_narwhals_lazyframe
+
+    if not items:
+        msg = "No items to concatenate."
+        raise ValueError(msg)
+    items = tuple(items)
+    validate_laziness(items)
+    if how not in {"horizontal", "vertical", "diagonal"}:  # pragma: no cover
+        msg = "Only vertical, horizontal and diagonal concatenations are supported."
+        raise NotImplementedError(msg)
+    first_item = items[0]
+    if is_narwhals_lazyframe(first_item) and how == "horizontal":
+        msg = (
+            "Horizontal concatenation is not supported for LazyFrames.\n\n"
+            "Hint: you may want to use `join` instead."
+        )
+        raise InvalidOperationError(msg)
+    plx = first_item.__narwhals_namespace__()
+    return first_item._with_compliant(
+        plx.concat([df._compliant_frame for df in items], how=how)
+    )
+
+
+def new_series(
+    name: str,
+    values: Any,
+    dtype: IntoDType | None = None,
+    *,
+    backend: IntoBackend[EagerAllowed],
+) -> Series[Any]:
+    """Instantiate Narwhals Series from iterable (e.g. list or array).
+
+    Arguments:
+        name: Name of resulting Series.
+        values: Values of make Series from.
+        dtype: (Narwhals) dtype. If not provided, the native library
+            may auto-infer it from `values`.
+        backend: specifies which eager backend instantiate to.
+
+            `backend` can be specified in various ways
+
+            - As `Implementation.<BACKEND>` with `BACKEND` being `PANDAS`, `PYARROW`,
+                `POLARS`, `MODIN` or `CUDF`.
+            - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`.
+            - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`.
+
+    Examples:
+        >>> import pandas as pd
+        >>> import narwhals as nw
+        >>>
+        >>> values = [4, 1, 2, 3]
+        >>> nw.new_series(name="a", values=values, dtype=nw.Int32, backend=pd)
+        ┌─────────────────────┐
+        |   Narwhals Series   |
+        |---------------------|
+        |0    4               |
+        |1    1               |
+        |2    2               |
+        |3    3               |
+        |Name: a, dtype: int32|
+        └─────────────────────┘
+    """
+    return _new_series_impl(name, values, dtype, backend=backend)
+
+
+def _new_series_impl(
+    name: str,
+    values: Any,
+    dtype: IntoDType | None = None,
+    *,
+    backend: IntoBackend[EagerAllowed],
+) -> Series[Any]:
+    implementation = Implementation.from_backend(backend)
+    if is_eager_allowed(implementation):
+        ns = Version.MAIN.namespace.from_backend(implementation).compliant
+        series = ns._series.from_iterable(values, name=name, context=ns, dtype=dtype)
+        return series.to_narwhals()
+    if implementation is Implementation.UNKNOWN:  # pragma: no cover
+        _native_namespace = implementation.to_native_namespace()
+        try:
+            native_series: NativeSeries = _native_namespace.new_series(
+                name, values, dtype
+            )
+            return from_native(native_series, series_only=True).alias(name)
+        except AttributeError as e:
+            msg = "Unknown namespace is expected to implement `new_series` constructor."
+            raise AttributeError(msg) from e
+    msg = (
+        f"{implementation} support in Narwhals is lazy-only, but `new_series` is an eager-only function.\n\n"
+        "Hint: you may want to use an eager backend and then call `.lazy`, e.g.:\n\n"
+        f"    nw.new_series('a', [1,2,3], backend='pyarrow').to_frame().lazy('{implementation}')"
+    )
+    raise ValueError(msg)
+
+
+@deprecate_native_namespace(warn_version="1.26.0")
+def from_dict(
+    data: Mapping[str, Any],
+    schema: IntoSchema | Mapping[str, DType | None] | None = None,
+    *,
+    backend: IntoBackend[EagerAllowed] | None = None,
+    native_namespace: ModuleType | None = None,  # noqa: ARG001
+) -> DataFrame[Any]:
+    """Instantiate DataFrame from dictionary.
+
+    Indexes (if present, for pandas-like backends) are aligned following
+    the [left-hand-rule](../concepts/pandas_index.md/).
+
+    Notes:
+        For pandas-like dataframes, conversion to schema is applied after dataframe
+        creation.
+
+    Arguments:
+        data: Dictionary to create DataFrame from.
+        schema: The DataFrame schema as Schema or dict of {name: type}. If not
+            specified, the schema will be inferred by the native library. If
+            any `dtype` is `None`, the data type for that column will be inferred
+            by the native library.
+        backend: specifies which eager backend instantiate to. Only
+            necessary if inputs are not Narwhals Series.
+
+            `backend` can be specified in various ways
+
+            - As `Implementation.<BACKEND>` with `BACKEND` being `PANDAS`, `PYARROW`,
+                `POLARS`, `MODIN` or `CUDF`.
+            - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`.
+            - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`.
+        native_namespace: deprecated, same as `backend`.
+
+    Examples:
+        >>> import pandas as pd
+        >>> import narwhals as nw
+        >>> data = {"c": [5, 2], "d": [1, 4]}
+        >>> nw.from_dict(data, backend="pandas")
+        ┌──────────────────┐
+        |Narwhals DataFrame|
+        |------------------|
+        |        c  d      |
+        |     0  5  1      |
+        |     1  2  4      |
+        └──────────────────┘
+    """
+    if backend is None:
+        data, backend = _from_dict_no_backend(data)
+    if schema and data and (diff := set(schema.keys()).symmetric_difference(data.keys())):
+        msg = f"Keys in `schema` and `data` are expected to match, found unmatched keys: {diff}"
+        raise InvalidOperationError(msg)
+    implementation = Implementation.from_backend(backend)
+    if is_eager_allowed(implementation):
+        ns = Version.MAIN.namespace.from_backend(implementation).compliant
+        return ns._dataframe.from_dict(data, schema=schema, context=ns).to_narwhals()
+    if implementation is Implementation.UNKNOWN:  # pragma: no cover
+        _native_namespace = implementation.to_native_namespace()
+        try:
+            # implementation is UNKNOWN, Narwhals extension using this feature should
+            # implement `from_dict` function in the top-level namespace.
+            native_frame: NativeDataFrame = _native_namespace.from_dict(
+                data, schema=schema
+            )
+        except AttributeError as e:
+            msg = "Unknown namespace is expected to implement `from_dict` function."
+            raise AttributeError(msg) from e
+        return from_native(native_frame, eager_only=True)
+    msg = (
+        f"{implementation} support in Narwhals is lazy-only, but `from_dict` is an eager-only function.\n\n"
+        "Hint: you may want to use an eager backend and then call `.lazy`, e.g.:\n\n"
+        f"    nw.from_dict({{'a': [1, 2]}}, backend='pyarrow').lazy('{implementation}')"
+    )
+    raise ValueError(msg)
+
+
+def _from_dict_no_backend(
+    data: Mapping[str, Series[Any] | Any], /
+) -> tuple[dict[str, Series[Any] | Any], ModuleType]:
+    for val in data.values():
+        if is_narwhals_series(val):
+            native_namespace = val.__native_namespace__()
+            break
+    else:
+        msg = "Calling `from_dict` without `backend` is only supported if all input values are already Narwhals Series"
+        raise TypeError(msg)
+    data = {key: to_native(value, pass_through=True) for key, value in data.items()}
+    return data, native_namespace
+
+
+def from_dicts(
+    data: Sequence[Mapping[str, Any]],
+    schema: IntoSchema | Mapping[str, DType | None] | None = None,
+    *,
+    backend: IntoBackend[EagerAllowed],
+) -> DataFrame[Any]:
+    """Instantiate DataFrame from a sequence of dictionaries representing rows.
+
+    Notes:
+        For pandas-like dataframes, conversion to schema is applied after dataframe
+        creation.
+
+    Arguments:
+        data: Sequence with dictionaries mapping column name to value.
+        schema: The DataFrame schema as Schema or dict of {name: type}. If not
+            specified, the schema will be inferred by the native library. If
+            any `dtype` is `None`, the data type for that column will be inferred
+            by the native library.
+        backend: Specifies which eager backend instantiate to.
+
+            `backend` can be specified in various ways
+
+            - As `Implementation.<BACKEND>` with `BACKEND` being `PANDAS`, `PYARROW`,
+                `POLARS`, `MODIN` or `CUDF`.
+            - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`.
+            - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`.
+
+    Tip:
+        If you expect non-uniform keys in `data`, consider passing `schema` for
+        more consistent results, as **inference varies between backends**:
+
+        - pandas uses all rows
+        - polars uses the first 100 rows
+        - pyarrow uses only the first row
+
+    Examples:
+        >>> import polars as pl
+        >>> import narwhals as nw
+        >>> data = [
+        ...     {"item": "apple", "weight": 80, "price": 0.60},
+        ...     {"item": "egg", "weight": 55, "price": 0.40},
+        ... ]
+        >>> nw.DataFrame.from_dicts(data, backend="polars")
+        ┌──────────────────────────┐
+        |    Narwhals DataFrame    |
+        |--------------------------|
+        |shape: (2, 3)             |
+        |┌───────┬────────┬───────┐|
+        |│ item  ┆ weight ┆ price │|
+        |│ ---   ┆ ---    ┆ ---   │|
+        |│ str   ┆ i64    ┆ f64   │|
+        |╞═══════╪════════╪═══════╡|
+        |│ apple ┆ 80     ┆ 0.6   │|
+        |│ egg   ┆ 55     ┆ 0.4   │|
+        |└───────┴────────┴───────┘|
+        └──────────────────────────┘
+    """
+    return Version.MAIN.dataframe.from_dicts(data, schema, backend=backend)
+
+
+def from_numpy(
+    data: _2DArray,
+    schema: IntoSchema | Sequence[str] | None = None,
+    *,
+    backend: IntoBackend[EagerAllowed],
+) -> DataFrame[Any]:
+    """Construct a DataFrame from a NumPy ndarray.
+
+    Notes:
+        Only row orientation is currently supported.
+
+        For pandas-like dataframes, conversion to schema is applied after dataframe
+        creation.
+
+    Arguments:
+        data: Two-dimensional data represented as a NumPy ndarray.
+        schema: The DataFrame schema as Schema, dict of {name: type}, or a sequence of str.
+        backend: specifies which eager backend instantiate to.
+
+            `backend` can be specified in various ways
+
+            - As `Implementation.<BACKEND>` with `BACKEND` being `PANDAS`, `PYARROW`,
+                `POLARS`, `MODIN` or `CUDF`.
+            - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`.
+            - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`.
+
+    Examples:
+        >>> import numpy as np
+        >>> import pyarrow as pa
+        >>> import narwhals as nw
+        >>>
+        >>> arr = np.array([[5, 2, 1], [1, 4, 3]])
+        >>> schema = {"c": nw.Int16(), "d": nw.Float32(), "e": nw.Int8()}
+        >>> nw.from_numpy(arr, schema=schema, backend="pyarrow")
+        ┌──────────────────┐
+        |Narwhals DataFrame|
+        |------------------|
+        |  pyarrow.Table   |
+        |  c: int16        |
+        |  d: float        |
+        |  e: int8         |
+        |  ----            |
+        |  c: [[5,1]]      |
+        |  d: [[2,4]]      |
+        |  e: [[1,3]]      |
+        └──────────────────┘
+    """
+    if not is_numpy_array_2d(data):
+        msg = "`from_numpy` only accepts 2D numpy arrays"
+        raise ValueError(msg)
+    if not _is_into_schema(schema):
+        msg = (
+            "`schema` is expected to be one of the following types: "
+            "IntoSchema | Sequence[str]. "
+            f"Got {type(schema)}."
+        )
+        raise TypeError(msg)
+    implementation = Implementation.from_backend(backend)
+    if is_eager_allowed(implementation):
+        ns = Version.MAIN.namespace.from_backend(implementation).compliant
+        return ns.from_numpy(data, schema).to_narwhals()
+    if implementation is Implementation.UNKNOWN:  # pragma: no cover
+        _native_namespace = implementation.to_native_namespace()
+        try:
+            # implementation is UNKNOWN, Narwhals extension using this feature should
+            # implement `from_numpy` function in the top-level namespace.
+            native_frame: NativeDataFrame = _native_namespace.from_numpy(
+                data, schema=schema
+            )
+        except AttributeError as e:
+            msg = "Unknown namespace is expected to implement `from_numpy` function."
+            raise AttributeError(msg) from e
+        return from_native(native_frame, eager_only=True)
+    msg = (
+        f"{implementation} support in Narwhals is lazy-only, but `from_numpy` is an eager-only function.\n\n"
+        "Hint: you may want to use an eager backend and then call `.lazy`, e.g.:\n\n"
+        f"    nw.from_numpy(arr, backend='pyarrow').lazy('{implementation}')"
+    )
+    raise ValueError(msg)
+
+
+def _is_into_schema(obj: Any) -> TypeIs[_IntoSchema]:
+    from narwhals.schema import Schema
+
+    return (
+        obj is None or isinstance(obj, (Mapping, Schema)) or is_sequence_but_not_str(obj)
+    )
+
+
+def from_arrow(
+    native_frame: IntoArrowTable, *, backend: IntoBackend[EagerAllowed]
+) -> DataFrame[Any]:  # pragma: no cover
+    """Construct a DataFrame from an object which supports the PyCapsule Interface.
+
+    Arguments:
+        native_frame: Object which implements `__arrow_c_stream__`.
+        backend: specifies which eager backend instantiate to.
+
+            `backend` can be specified in various ways
+
+            - As `Implementation.<BACKEND>` with `BACKEND` being `PANDAS`, `PYARROW`,
+                `POLARS`, `MODIN` or `CUDF`.
+            - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`.
+            - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`.
+
+    Examples:
+        >>> import pandas as pd
+        >>> import polars as pl
+        >>> import narwhals as nw
+        >>>
+        >>> df_native = pd.DataFrame({"a": [1, 2], "b": [4.2, 5.1]})
+        >>> nw.from_arrow(df_native, backend="polars")
+        ┌──────────────────┐
+        |Narwhals DataFrame|
+        |------------------|
+        |  shape: (2, 2)   |
+        |  ┌─────┬─────┐   |
+        |  │ a   ┆ b   │   |
+        |  │ --- ┆ --- │   |
+        |  │ i64 ┆ f64 │   |
+        |  ╞═════╪═════╡   |
+        |  │ 1   ┆ 4.2 │   |
+        |  │ 2   ┆ 5.1 │   |
+        |  └─────┴─────┘   |
+        └──────────────────┘
+    """
+    if not (supports_arrow_c_stream(native_frame) or is_pyarrow_table(native_frame)):
+        msg = f"Given object of type {type(native_frame)} does not support PyCapsule interface"
+        raise TypeError(msg)
+    implementation = Implementation.from_backend(backend)
+    if is_eager_allowed(implementation):
+        ns = Version.MAIN.namespace.from_backend(implementation).compliant
+        return ns._dataframe.from_arrow(native_frame, context=ns).to_narwhals()
+    if implementation is Implementation.UNKNOWN:  # pragma: no cover
+        _native_namespace = implementation.to_native_namespace()
+        try:
+            # implementation is UNKNOWN, Narwhals extension using this feature should
+            # implement PyCapsule support
+            native: NativeDataFrame = _native_namespace.DataFrame(native_frame)
+        except AttributeError as e:
+            msg = "Unknown namespace is expected to implement `DataFrame` class which accepts object which supports PyCapsule Interface."
+            raise AttributeError(msg) from e
+        return from_native(native, eager_only=True)
+    msg = (
+        f"{implementation} support in Narwhals is lazy-only, but `from_arrow` is an eager-only function.\n\n"
+        "Hint: you may want to use an eager backend and then call `.lazy`, e.g.:\n\n"
+        f"    nw.from_arrow(df, backend='pyarrow').lazy('{implementation}')"
+    )
+    raise ValueError(msg)
+
+
+def _get_sys_info() -> dict[str, str]:
+    """System information.
+
+    Returns system and Python version information
+
+    Copied from sklearn
+
+    Returns:
+        Dictionary with system info.
+    """
+    python = sys.version.replace("\n", " ")
+
+    blob = (
+        ("python", python),
+        ("executable", sys.executable),
+        ("machine", platform.platform()),
+    )
+
+    return dict(blob)
+
+
+def _get_deps_info() -> dict[str, str]:
+    """Overview of the installed version of main dependencies.
+
+    This function does not import the modules to collect the version numbers
+    but instead relies on standard Python package metadata.
+
+    Returns version information on relevant Python libraries
+
+    This function and show_versions were copied from sklearn and adapted
+
+    Returns:
+        Mapping from dependency to version.
+    """
+    from importlib.metadata import distributions
+
+    extra_names = ("narwhals", "numpy")
+    member_names = Implementation._member_names_
+    exclude = {"PYSPARK_CONNECT", "UNKNOWN"}
+    target_names = tuple(
+        name.lower() for name in (*extra_names, *member_names) if name not in exclude
+    )
+    result = dict.fromkeys(target_names, "")  # Initialize with empty strings
+
+    for dist in distributions():
+        dist_name, dist_version = dist.name.lower(), dist.version
+
+        if dist_name in result:  # exact match
+            result[dist_name] = dist_version
+        else:  # prefix match
+            for target in target_names:
+                if not result[target] and dist_name.startswith(
+                    target
+                ):  # pragma: no cover
+                    result[target] = dist_version
+                    break
+
+    return result
+
+
+def show_versions() -> None:
+    """Print useful debugging information.
+
+    Examples:
+        >>> from narwhals import show_versions
+        >>> show_versions()  # doctest: +SKIP
+    """
+    sys_info = _get_sys_info()
+    deps_info = _get_deps_info()
+
+    print("\nSystem:")  # noqa: T201
+    for k, stat in sys_info.items():
+        print(f"{k:>10}: {stat}")  # noqa: T201
+
+    print("\nPython dependencies:")  # noqa: T201
+    for k, stat in deps_info.items():
+        print(f"{k:>13}: {stat}")  # noqa: T201
+
+
+def _validate_separators(
+    separator: str, native_separators: tuple[str, ...], **kwargs: Any
+) -> None:
+    for native_separator in native_separators:
+        if native_separator in kwargs and kwargs[native_separator] != separator:
+            msg = (
+                f"`separator` and `{native_separator}` do not match: "
+                f"`separator`={separator} and `{native_separator}`={kwargs[native_separator]}."
+            )
+            raise TypeError(msg)
+
+
+def _validate_separator_pyarrow(separator: str, **kwargs: Any) -> Any:
+    if "parse_options" in kwargs:
+        parse_options = kwargs.pop("parse_options")
+        if parse_options.delimiter != separator:
+            msg = (
+                "`separator` and `parse_options.delimiter` do not match: "
+                f"`separator`={separator} and `delimiter`={parse_options.delimiter}."
+            )
+            raise TypeError(msg)
+        return kwargs
+    from pyarrow import csv  # ignore-banned-import
+
+    return {"parse_options": csv.ParseOptions(delimiter=separator)}
+
+
+def read_csv(
+    source: FileSource,
+    *,
+    backend: IntoBackend[EagerAllowed],
+    separator: str = ",",
+    **kwargs: Any,
+) -> DataFrame[Any]:
+    """Read a CSV file into a DataFrame.
+
+    Arguments:
+        source: Path to a file.
+        backend: The eager backend for DataFrame creation.
+            `backend` can be specified in various ways
+
+            - As `Implementation.<BACKEND>` with `BACKEND` being `PANDAS`, `PYARROW`,
+                `POLARS`, `MODIN` or `CUDF`.
+            - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`.
+            - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`.
+        separator: Single byte character to use as separator in the file.
+        kwargs: Extra keyword arguments which are passed to the native CSV reader.
+            For example, you could use
+            `nw.read_csv('file.csv', backend='pandas', engine='pyarrow')`.
+
+    Examples:
+        >>> import narwhals as nw
+        >>> nw.read_csv("file.csv", backend="pandas")  # doctest:+SKIP
+        ┌──────────────────┐
+        |Narwhals DataFrame|
+        |------------------|
+        |        a   b     |
+        |     0  1   4     |
+        |     1  2   5     |
+        └──────────────────┘
+    """
+    impl = Implementation.from_backend(backend)
+    native_namespace = impl.to_native_namespace()
+    native_frame: NativeDataFrame
+    if impl in {Implementation.PANDAS, Implementation.MODIN, Implementation.CUDF}:
+        _validate_separators(separator, ("sep",), **kwargs)
+        native_frame = native_namespace.read_csv(
+            normalize_path(source), sep=separator, **kwargs
+        )
+    elif impl is Implementation.POLARS:
+        native_frame = native_namespace.read_csv(
+            normalize_path(source), separator=separator, **kwargs
+        )
+    elif impl is Implementation.PYARROW:
+        kwargs = _validate_separator_pyarrow(separator, **kwargs)
+        from pyarrow import csv  # ignore-banned-import
+
+        native_frame = csv.read_csv(source, **kwargs)
+    elif impl in {
+        Implementation.PYSPARK,
+        Implementation.DASK,
+        Implementation.DUCKDB,
+        Implementation.IBIS,
+        Implementation.SQLFRAME,
+        Implementation.PYSPARK_CONNECT,
+    }:
+        msg = (
+            f"Expected eager backend, found {impl}.\n\n"
+            f"Hint: use nw.scan_csv(source={source}, backend={backend})"
+        )
+        raise ValueError(msg)
+    else:  # pragma: no cover
+        try:
+            # implementation is UNKNOWN, Narwhals extension using this feature should
+            # implement `read_csv` function in the top-level namespace.
+            native_frame = native_namespace.read_csv(source=source, **kwargs)
+        except AttributeError as e:
+            msg = "Unknown namespace is expected to implement `read_csv` function."
+            raise AttributeError(msg) from e
+    return from_native(native_frame, eager_only=True)
+
+
+def scan_csv(
+    source: FileSource,
+    *,
+    backend: IntoBackend[Backend],
+    separator: str = ",",
+    **kwargs: Any,
+) -> LazyFrame[Any]:
+    """Lazily read from a CSV file.
+
+    For the libraries that do not support lazy dataframes, the function reads
+    a csv file eagerly and then converts the resulting dataframe to a lazyframe.
+
+    Arguments:
+        source: Path to a file.
+        backend: The eager backend for DataFrame creation.
+            `backend` can be specified in various ways
+
+            - As `Implementation.<BACKEND>` with `BACKEND` being `PANDAS`, `PYARROW`,
+                `POLARS`, `MODIN` or `CUDF`.
+            - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`.
+            - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`.
+        separator: Single byte character to use as separator in the file.
+        kwargs: Extra keyword arguments which are passed to the native CSV reader.
+            For example, you could use
+            `nw.scan_csv('file.csv', backend=pd, engine='pyarrow')`.
+
+    Examples:
+        >>> import duckdb
+        >>> import narwhals as nw
+        >>>
+        >>> nw.scan_csv("file.csv", backend="duckdb").to_native()  # doctest:+SKIP
+        ┌─────────┬───────┐
+        │    a    │   b   │
+        │ varchar │ int32 │
+        ├─────────┼───────┤
+        │ x       │     1 │
+        │ y       │     2 │
+        │ z       │     3 │
+        └─────────┴───────┘
+    """
+    implementation = Implementation.from_backend(backend)
+    native_namespace = implementation.to_native_namespace()
+    native_frame: NativeDataFrame | NativeLazyFrame
+    source = normalize_path(source)
+    if implementation is Implementation.POLARS:
+        native_frame = native_namespace.scan_csv(source, separator=separator, **kwargs)
+    elif implementation in {
+        Implementation.PANDAS,
+        Implementation.MODIN,
+        Implementation.CUDF,
+        Implementation.DASK,
+        Implementation.IBIS,
+    }:
+        _validate_separators(separator, ("sep",), **kwargs)
+        native_frame = native_namespace.read_csv(source, sep=separator, **kwargs)
+    elif implementation is Implementation.DUCKDB:
+        _validate_separators(separator, ("delimiter", "delim", "sep"), **kwargs)
+        native_frame = native_namespace.read_csv(source, delimiter=separator, **kwargs)
+    elif implementation is Implementation.PYARROW:
+        kwargs = _validate_separator_pyarrow(separator, **kwargs)
+        from pyarrow import csv  # ignore-banned-import
+
+        native_frame = csv.read_csv(source, **kwargs)
+    elif implementation.is_spark_like():
+        _validate_separators(separator, ("sep", "delimiter"), **kwargs)
+        if (session := kwargs.pop("session", None)) is None:
+            msg = "Spark like backends require a session object to be passed in `kwargs`."
+            raise ValueError(msg)
+        csv_reader = session.read.format("csv")
+        native_frame = (
+            csv_reader.load(source, sep=separator)
+            if (
+                implementation is Implementation.SQLFRAME
+                and implementation._backend_version() < (3, 27, 0)
+            )
+            else csv_reader.options(sep=separator, **kwargs).load(source)
+        )
+    else:  # pragma: no cover
+        try:
+            # implementation is UNKNOWN, Narwhals extension using this feature should
+            # implement `scan_csv` function in the top-level namespace.
+            native_frame = native_namespace.scan_csv(source=source, **kwargs)
+        except AttributeError as e:
+            msg = "Unknown namespace is expected to implement `scan_csv` function."
+            raise AttributeError(msg) from e
+    return from_native(native_frame).lazy()
+
+
+def read_parquet(
+    source: FileSource, *, backend: IntoBackend[EagerAllowed], **kwargs: Any
+) -> DataFrame[Any]:
+    """Read into a DataFrame from a parquet file.
+
+    Arguments:
+        source: Path to a file.
+        backend: The eager backend for DataFrame creation.
+            `backend` can be specified in various ways
+
+            - As `Implementation.<BACKEND>` with `BACKEND` being `PANDAS`, `PYARROW`,
+                `POLARS`, `MODIN` or `CUDF`.
+            - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`.
+            - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`.
+        kwargs: Extra keyword arguments which are passed to the native parquet reader.
+            For example, you could use
+            `nw.read_parquet('file.parquet', backend=pd, engine='pyarrow')`.
+
+    Examples:
+        >>> import pyarrow as pa
+        >>> import narwhals as nw
+        >>>
+        >>> nw.read_parquet("file.parquet", backend="pyarrow")  # doctest:+SKIP
+        ┌──────────────────┐
+        |Narwhals DataFrame|
+        |------------------|
+        |pyarrow.Table     |
+        |a: int64          |
+        |c: double         |
+        |----              |
+        |a: [[1,2]]        |
+        |c: [[0.2,0.1]]    |
+        └──────────────────┘
+    """
+    impl = Implementation.from_backend(backend)
+    native_namespace = impl.to_native_namespace()
+    native_frame: NativeDataFrame
+    if impl in {
+        Implementation.POLARS,
+        Implementation.PANDAS,
+        Implementation.MODIN,
+        Implementation.CUDF,
+    }:
+        source = normalize_path(source)
+        native_frame = native_namespace.read_parquet(source, **kwargs)
+    elif impl is Implementation.PYARROW:
+        import pyarrow.parquet as pq  # ignore-banned-import
+
+        native_frame = pq.read_table(source, **kwargs)  # type: ignore[arg-type]
+    elif impl in {
+        Implementation.PYSPARK,
+        Implementation.DASK,
+        Implementation.DUCKDB,
+        Implementation.IBIS,
+        Implementation.SQLFRAME,
+        Implementation.PYSPARK_CONNECT,
+    }:
+        msg = (
+            f"Expected eager backend, found {impl}.\n\n"
+            f"Hint: use nw.scan_parquet(source={source}, backend={backend})"
+        )
+        raise ValueError(msg)
+    else:  # pragma: no cover
+        try:
+            # implementation is UNKNOWN, Narwhals extension using this feature should
+            # implement `read_parquet` function in the top-level namespace.
+            native_frame = native_namespace.read_parquet(source=source, **kwargs)
+        except AttributeError as e:
+            msg = "Unknown namespace is expected to implement `read_parquet` function."
+            raise AttributeError(msg) from e
+    return from_native(native_frame, eager_only=True)
+
+
+def scan_parquet(
+    source: FileSource, *, backend: IntoBackend[Backend], **kwargs: Any
+) -> LazyFrame[Any]:
+    """Lazily read from a parquet file.
+
+    For the libraries that do not support lazy dataframes, the function reads
+    a parquet file eagerly and then converts the resulting dataframe to a lazyframe.
+
+    Note:
+        Spark like backends require a session object to be passed in `kwargs`.
+
+        For instance:
+
+        ```py
+        import narwhals as nw
+        from sqlframe.duckdb import DuckDBSession
+
+        nw.scan_parquet(source, backend="sqlframe", session=DuckDBSession())
+        ```
+
+    Arguments:
+        source: Path to a file.
+        backend: The eager backend for DataFrame creation.
+            `backend` can be specified in various ways
+
+            - As `Implementation.<BACKEND>` with `BACKEND` being `PANDAS`, `PYARROW`,
+                `POLARS`, `MODIN`, `CUDF`, `PYSPARK` or `SQLFRAME`.
+            - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"`, `"cudf"`,
+                `"pyspark"` or `"sqlframe"`.
+            - Directly as a module `pandas`, `pyarrow`, `polars`, `modin`, `cudf`,
+                `pyspark.sql` or `sqlframe`.
+        kwargs: Extra keyword arguments which are passed to the native parquet reader.
+            For example, you could use
+            `nw.scan_parquet('file.parquet', backend=pd, engine='pyarrow')`.
+
+    Examples:
+        >>> import dask.dataframe as dd
+        >>> from sqlframe.duckdb import DuckDBSession
+        >>> import narwhals as nw
+        >>>
+        >>> nw.scan_parquet("file.parquet", backend="dask").collect()  # doctest:+SKIP
+        ┌──────────────────┐
+        |Narwhals DataFrame|
+        |------------------|
+        |        a   b     |
+        |     0  1   4     |
+        |     1  2   5     |
+        └──────────────────┘
+        >>> nw.scan_parquet(
+        ...     "file.parquet", backend="sqlframe", session=DuckDBSession()
+        ... ).collect()  # doctest:+SKIP
+        ┌──────────────────┐
+        |Narwhals DataFrame|
+        |------------------|
+        |  pyarrow.Table   |
+        |  a: int64        |
+        |  b: int64        |
+        |  ----            |
+        |  a: [[1,2]]      |
+        |  b: [[4,5]]      |
+        └──────────────────┘
+    """
+    implementation = Implementation.from_backend(backend)
+    native_namespace = implementation.to_native_namespace()
+    native_frame: NativeDataFrame | NativeLazyFrame
+    source = normalize_path(source)
+    if implementation is Implementation.POLARS:
+        native_frame = native_namespace.scan_parquet(source, **kwargs)
+    elif implementation in {
+        Implementation.PANDAS,
+        Implementation.MODIN,
+        Implementation.CUDF,
+        Implementation.DASK,
+        Implementation.DUCKDB,
+        Implementation.IBIS,
+    }:
+        native_frame = native_namespace.read_parquet(source, **kwargs)
+    elif implementation is Implementation.PYARROW:
+        import pyarrow.parquet as pq  # ignore-banned-import
+
+        native_frame = pq.read_table(source, **kwargs)
+    elif implementation.is_spark_like():
+        if (session := kwargs.pop("session", None)) is None:
+            msg = "Spark like backends require a session object to be passed in `kwargs`."
+            raise ValueError(msg)
+        pq_reader = session.read.format("parquet")
+        native_frame = (
+            pq_reader.load(source)
+            if (
+                implementation is Implementation.SQLFRAME
+                and implementation._backend_version() < (3, 27, 0)
+            )
+            else pq_reader.options(**kwargs).load(source)
+        )
+
+    else:  # pragma: no cover
+        try:
+            # implementation is UNKNOWN, Narwhals extension using this feature should
+            # implement `scan_parquet` function in the top-level namespace.
+            native_frame = native_namespace.scan_parquet(source=source, **kwargs)
+        except AttributeError as e:
+            msg = "Unknown namespace is expected to implement `scan_parquet` function."
+            raise AttributeError(msg) from e
+    return from_native(native_frame).lazy()
+
+
+def col(*names: str | Iterable[str]) -> Expr:
+    """Creates an expression that references one or more columns by their name(s).
+
+    Arguments:
+        names: Name(s) of the columns to use.
+
+    Examples:
+        >>> import polars as pl
+        >>> import narwhals as nw
+        >>>
+        >>> df_native = pl.DataFrame({"a": [1, 2], "b": [3, 4], "c": ["x", "z"]})
+        >>> nw.from_native(df_native).select(nw.col("a", "b") * nw.col("b"))
+        ┌──────────────────┐
+        |Narwhals DataFrame|
+        |------------------|
+        |  shape: (2, 2)   |
+        |  ┌─────┬─────┐   |
+        |  │ a   ┆ b   │   |
+        |  │ --- ┆ --- │   |
+        |  │ i64 ┆ i64 │   |
+        |  ╞═════╪═════╡   |
+        |  │ 3   ┆ 9   │   |
+        |  │ 8   ┆ 16  │   |
+        |  └─────┴─────┘   |
+        └──────────────────┘
+    """
+    flat_names = flatten(names)
+    return Expr(ExprNode(ExprKind.COL, "col", names=flat_names))
+
+
+def exclude(*names: str | Iterable[str]) -> Expr:
+    """Creates an expression that excludes columns by their name(s).
+
+    Arguments:
+        names: Name(s) of the columns to exclude.
+
+    Examples:
+        >>> import polars as pl
+        >>> import narwhals as nw
+        >>>
+        >>> df_native = pl.DataFrame({"a": [1, 2], "b": [3, 4], "c": ["x", "z"]})
+        >>> nw.from_native(df_native).select(nw.exclude("c", "a"))
+        ┌──────────────────┐
+        |Narwhals DataFrame|
+        |------------------|
+        |  shape: (2, 1)   |
+        |  ┌─────┐         |
+        |  │ b   │         |
+        |  │ --- │         |
+        |  │ i64 │         |
+        |  ╞═════╡         |
+        |  │ 3   │         |
+        |  │ 4   │         |
+        |  └─────┘         |
+        └──────────────────┘
+    """
+    return Expr(ExprNode(ExprKind.EXCLUDE, "exclude", names=frozenset(flatten(names))))
+
+
+def nth(*indices: int | Sequence[int]) -> Expr:
+    """Creates an expression that references one or more columns by their index(es).
+
+    Notes:
+        `nth` is not supported for Polars version<1.0.0. Please use
+        [`narwhals.col`][] instead.
+
+    Arguments:
+        indices: One or more indices representing the columns to retrieve.
+
+    Examples:
+        >>> import pyarrow as pa
+        >>> import narwhals as nw
+        >>>
+        >>> df_native = pa.table({"a": [1, 2], "b": [3, 4], "c": [0.123, 3.14]})
+        >>> nw.from_native(df_native).select(nw.nth(0, 2) * 2)
+        ┌──────────────────┐
+        |Narwhals DataFrame|
+        |------------------|
+        |pyarrow.Table     |
+        |a: int64          |
+        |c: double         |
+        |----              |
+        |a: [[2,4]]        |
+        |c: [[0.246,6.28]] |
+        └──────────────────┘
+    """
+    flat_indices = flatten(indices)
+    return Expr(ExprNode(ExprKind.NTH, "nth", indices=flat_indices))
+
+
+# Add underscore so it doesn't conflict with builtin `all`
+def all_() -> Expr:
+    """Instantiate an expression representing all columns.
+
+    Examples:
+        >>> import pandas as pd
+        >>> import narwhals as nw
+        >>>
+        >>> df_native = pd.DataFrame({"a": [1, 2], "b": [3.14, 0.123]})
+        >>> nw.from_native(df_native).select(nw.all() * 2)
+        ┌──────────────────┐
+        |Narwhals DataFrame|
+        |------------------|
+        |      a      b    |
+        |   0  2  6.280    |
+        |   1  4  0.246    |
+        └──────────────────┘
+    """
+    return Expr(ExprNode(ExprKind.ALL, "all"))
+
+
+# Add underscore so it doesn't conflict with builtin `len`
+def len_() -> Expr:
+    """Return the number of rows.
+
+    Examples:
+        >>> import polars as pl
+        >>> import narwhals as nw
+        >>>
+        >>> df_native = pl.DataFrame({"a": [1, 2], "b": [5, None]})
+        >>> nw.from_native(df_native).select(nw.len())
+        ┌──────────────────┐
+        |Narwhals DataFrame|
+        |------------------|
+        |  shape: (1, 1)   |
+        |  ┌─────┐         |
+        |  │ len │         |
+        |  │ --- │         |
+        |  │ u32 │         |
+        |  ╞═════╡         |
+        |  │ 2   │         |
+        |  └─────┘         |
+        └──────────────────┘
+    """
+    return Expr(ExprNode(ExprKind.AGGREGATION, "len"))
+
+
+def sum(*columns: str) -> Expr:
+    """Sum all values.
+
+    Note:
+        Syntactic sugar for ``nw.col(columns).sum()``
+
+    Arguments:
+        columns: Name(s) of the columns to use in the aggregation function
+
+    Examples:
+        >>> import pandas as pd
+        >>> import narwhals as nw
+        >>>
+        >>> df_native = pd.DataFrame({"a": [1, 2], "b": [-1.4, 6.2]})
+        >>> nw.from_native(df_native).select(nw.sum("a", "b"))
+        ┌──────────────────┐
+        |Narwhals DataFrame|
+        |------------------|
+        |       a    b     |
+        |    0  3  4.8     |
+        └──────────────────┘
+    """
+    return col(*columns).sum()
+
+
+def mean(*columns: str) -> Expr:
+    """Get the mean value.
+
+    Note:
+        Syntactic sugar for ``nw.col(columns).mean()``
+
+    Arguments:
+        columns: Name(s) of the columns to use in the aggregation function
+
+    Examples:
+        >>> import pyarrow as pa
+        >>> import narwhals as nw
+        >>>
+        >>> df_native = pa.table({"a": [1, 8, 3], "b": [3.14, 6.28, 42.1]})
+        >>> nw.from_native(df_native).select(nw.mean("a", "b"))
+        ┌─────────────────────────┐
+        |   Narwhals DataFrame    |
+        |-------------------------|
+        |pyarrow.Table            |
+        |a: double                |
+        |b: double                |
+        |----                     |
+        |a: [[4]]                 |
+        |b: [[17.173333333333336]]|
+        └─────────────────────────┘
+    """
+    return col(*columns).mean()
+
+
+def median(*columns: str) -> Expr:
+    """Get the median value.
+
+    Notes:
+        - Syntactic sugar for ``nw.col(columns).median()``
+        - Results might slightly differ across backends due to differences in the
+            underlying algorithms used to compute the median.
+
+    Arguments:
+        columns: Name(s) of the columns to use in the aggregation function
+
+    Examples:
+        >>> import polars as pl
+        >>> import narwhals as nw
+        >>>
+        >>> df_native = pl.DataFrame({"a": [4, 5, 2]})
+        >>> nw.from_native(df_native).select(nw.median("a"))
+        ┌──────────────────┐
+        |Narwhals DataFrame|
+        |------------------|
+        |  shape: (1, 1)   |
+        |  ┌─────┐         |
+        |  │ a   │         |
+        |  │ --- │         |
+        |  │ f64 │         |
+        |  ╞═════╡         |
+        |  │ 4.0 │         |
+        |  └─────┘         |
+        └──────────────────┘
+    """
+    return col(*columns).median()
+
+
+def min(*columns: str) -> Expr:
+    """Return the minimum value.
+
+    Note:
+       Syntactic sugar for ``nw.col(columns).min()``.
+
+    Arguments:
+        columns: Name(s) of the columns to use in the aggregation function.
+
+    Examples:
+        >>> import pyarrow as pa
+        >>> import narwhals as nw
+        >>>
+        >>> df_native = pa.table({"a": [1, 2], "b": [5, 10]})
+        >>> nw.from_native(df_native).select(nw.min("a", "b"))
+        ┌──────────────────┐
+        |Narwhals DataFrame|
+        |------------------|
+        |  pyarrow.Table   |
+        |  a: int64        |
+        |  b: int64        |
+        |  ----            |
+        |  a: [[1]]        |
+        |  b: [[5]]        |
+        └──────────────────┘
+    """
+    return col(*columns).min()
+
+
+def max(*columns: str) -> Expr:
+    """Return the maximum value.
+
+    Note:
+       Syntactic sugar for ``nw.col(columns).max()``.
+
+    Arguments:
+        columns: Name(s) of the columns to use in the aggregation function.
+
+    Examples:
+        >>> import pandas as pd
+        >>> import narwhals as nw
+        >>>
+        >>> df_native = pd.DataFrame({"a": [1, 2], "b": [5, 10]})
+        >>> nw.from_native(df_native).select(nw.max("a", "b"))
+        ┌──────────────────┐
+        |Narwhals DataFrame|
+        |------------------|
+        |        a   b     |
+        |     0  2  10     |
+        └──────────────────┘
+    """
+    return col(*columns).max()
+
+
+def _expr_with_horizontal_op(name: str, *exprs: IntoExpr, **kwargs: Any) -> Expr:
+    if not exprs:
+        msg = f"At least one expression must be passed to `{name}`"
+        raise ValueError(msg)
+    return Expr(
+        ExprNode(
+            ExprKind.ELEMENTWISE, name, exprs=exprs, **kwargs, allow_multi_output=True
+        )
+    )
+
+
+def corr(a: IntoExpr, b: IntoExpr, method: CorrelationMethod = "pearson") -> Expr:
+    """Compute the Pearson's or Spearman rank correlation between two columns.
+
+    Arguments:
+        a: Column name or Expression
+        b: Column name or Expression
+        method: Correlation method ('pearson' or 'spearman')
+
+    Examples:
+        >>> import polars as pl
+        >>> import narwhals as nw
+        >>>
+        >>> df_native = pl.DataFrame({"a": [1, 2, 3], "b": [0, 3, 2]})
+        >>> nw.from_native(df_native).select(
+        ...     pearson=nw.corr("a", "b", method="pearson"),
+        ...     spearman=nw.corr("a", "b", method="spearman"),
+        ... )
+        ┌───────────────────────┐
+        |  Narwhals DataFrame   |
+        |-----------------------|
+        |shape: (1, 2)          |
+        |┌──────────┬──────────┐|
+        |│ pearson  ┆ spearman │|
+        |│ ---      ┆ ---      │|
+        |│ f64      ┆ f64      │|
+        |╞══════════╪══════════╡|
+        |│ 0.654654 ┆ 0.5      │|
+        |└──────────┴──────────┘|
+        └───────────────────────┘
+    """
+    return Expr(ExprNode(ExprKind.AGGREGATION, "corr", exprs=(a, b), method=method))
+
+
+def sum_horizontal(*exprs: IntoExpr | Iterable[IntoExpr]) -> Expr:
+    """Sum all values horizontally across columns.
+
+    Warning:
+        Unlike Polars, we support horizontal sum over numeric columns only.
+
+    Arguments:
+        exprs: Name(s) of the columns to use in the aggregation function. Accepts
+            expression input.
+
+    Examples:
+        >>> import polars as pl
+        >>> import narwhals as nw
+        >>>
+        >>> df_native = pl.DataFrame({"a": [1, 2, 3], "b": [5, 10, None]})
+        >>> nw.from_native(df_native).with_columns(sum=nw.sum_horizontal("a", "b"))
+        ┌────────────────────┐
+        | Narwhals DataFrame |
+        |--------------------|
+        |shape: (3, 3)       |
+        |┌─────┬──────┬─────┐|
+        |│ a   ┆ b    ┆ sum │|
+        |│ --- ┆ ---  ┆ --- │|
+        |│ i64 ┆ i64  ┆ i64 │|
+        |╞═════╪══════╪═════╡|
+        |│ 1   ┆ 5    ┆ 6   │|
+        |│ 2   ┆ 10   ┆ 12  │|
+        |│ 3   ┆ null ┆ 3   │|
+        |└─────┴──────┴─────┘|
+        └────────────────────┘
+    """
+    return _expr_with_horizontal_op("sum_horizontal", *flatten(exprs))
+
+
+def min_horizontal(*exprs: IntoExpr | Iterable[IntoExpr]) -> Expr:
+    """Get the minimum value horizontally across columns.
+
+    Notes:
+        We support `min_horizontal` over numeric columns only.
+
+    Arguments:
+        exprs: Name(s) of the columns to use in the aggregation function. Accepts
+            expression input.
+
+    Examples:
+        >>> import pyarrow as pa
+        >>> import narwhals as nw
+        >>>
+        >>> df_native = pa.table({"a": [1, 8, 3], "b": [4, 5, None]})
+        >>> nw.from_native(df_native).with_columns(h_min=nw.min_horizontal("a", "b"))
+        ┌──────────────────┐
+        |Narwhals DataFrame|
+        |------------------|
+        | pyarrow.Table    |
+        | a: int64         |
+        | b: int64         |
+        | h_min: int64     |
+        | ----             |
+        | a: [[1,8,3]]     |
+        | b: [[4,5,null]]  |
+        | h_min: [[1,5,3]] |
+        └──────────────────┘
+    """
+    return _expr_with_horizontal_op("min_horizontal", *flatten(exprs))
+
+
+def max_horizontal(*exprs: IntoExpr | Iterable[IntoExpr]) -> Expr:
+    """Get the maximum value horizontally across columns.
+
+    Notes:
+        We support `max_horizontal` over numeric columns only.
+
+    Arguments:
+        exprs: Name(s) of the columns to use in the aggregation function. Accepts
+            expression input.
+
+    Examples:
+        >>> import polars as pl
+        >>> import narwhals as nw
+        >>>
+        >>> df_native = pl.DataFrame({"a": [1, 8, 3], "b": [4, 5, None]})
+        >>> nw.from_native(df_native).with_columns(h_max=nw.max_horizontal("a", "b"))
+        ┌──────────────────────┐
+        |  Narwhals DataFrame  |
+        |----------------------|
+        |shape: (3, 3)         |
+        |┌─────┬──────┬───────┐|
+        |│ a   ┆ b    ┆ h_max │|
+        |│ --- ┆ ---  ┆ ---   │|
+        |│ i64 ┆ i64  ┆ i64   │|
+        |╞═════╪══════╪═══════╡|
+        |│ 1   ┆ 4    ┆ 4     │|
+        |│ 8   ┆ 5    ┆ 8     │|
+        |│ 3   ┆ null ┆ 3     │|
+        |└─────┴──────┴───────┘|
+        └──────────────────────┘
+    """
+    return _expr_with_horizontal_op("max_horizontal", *flatten(exprs))
+
+
+class When:
+    def __init__(self, *predicates: IntoExpr | Iterable[IntoExpr]) -> None:
+        self._predicate = all_horizontal(*flatten(predicates), ignore_nulls=False)
+
+    def then(self, value: IntoExpr | NonNestedLiteral) -> Then:
+        return Then(
+            ExprNode(
+                ExprKind.ELEMENTWISE,
+                "when_then",
+                exprs=(self._predicate, value),
+                allow_multi_output=False,
+            )
+        )
+
+
+class Then(Expr):
+    def otherwise(self, value: IntoExpr | NonNestedLiteral) -> Expr:
+        node = self._nodes[0]
+        return Expr(
+            ExprNode(ExprKind.ELEMENTWISE, "when_then", exprs=(*node.exprs, value))
+        )
+
+
+def when(*predicates: IntoExpr | Iterable[IntoExpr]) -> When:
+    """Start a `when-then-otherwise` expression.
+
+    Expression similar to an `if-else` statement in Python. Always initiated by a
+    `pl.when(<condition>).then(<value if condition>)`, and optionally followed by a
+    `.otherwise(<value if condition is false>)` can be appended at the end. If not
+    appended, and the condition is not `True`, `None` will be returned.
+
+    Info:
+        Chaining multiple `.when(<condition>).then(<value>)` statements is currently
+        not supported.
+        See [Narwhals#668](https://github.com/narwhals-dev/narwhals/issues/668).
+
+    Arguments:
+        predicates: Condition(s) that must be met in order to apply the subsequent
+            statement. Accepts one or more boolean expressions, which are implicitly
+            combined with `&`. String input is parsed as a column name.
+
+    Returns:
+        A "when" object, which `.then` can be called on.
+
+    Examples:
+        >>> import pandas as pd
+        >>> import narwhals as nw
+        >>>
+        >>> data = {"a": [1, 2, 3], "b": [5, 10, 15]}
+        >>> df_native = pd.DataFrame(data)
+        >>> nw.from_native(df_native).with_columns(
+        ...     nw.when(nw.col("a") < 3).then(5).otherwise(6).alias("a_when")
+        ... )
+        ┌──────────────────┐
+        |Narwhals DataFrame|
+        |------------------|
+        |    a   b  a_when |
+        | 0  1   5       5 |
+        | 1  2  10       5 |
+        | 2  3  15       6 |
+        └──────────────────┘
+    """
+    return When(*predicates)
+
+
+def all_horizontal(*exprs: IntoExpr | Iterable[IntoExpr], ignore_nulls: bool) -> Expr:
+    r"""Compute the bitwise AND horizontally across columns.
+
+    Arguments:
+        exprs: Name(s) of the columns to use in the aggregation function. Accepts
+            expression input.
+        ignore_nulls: Whether to ignore nulls:
+
+            - If `True`, null values are ignored. If there are no elements, the result
+              is `True`.
+            - If `False`, Kleene logic is followed. Note that this is not allowed for
+              pandas with classical NumPy dtypes when null values are present.
+
+    Examples:
+        >>> import pyarrow as pa
+        >>> import narwhals as nw
+        >>>
+        >>> data = {
+        ...     "a": [False, False, True, True, False, None],
+        ...     "b": [False, True, True, None, None, None],
+        ... }
+        >>> df_native = pa.table(data)
+        >>> nw.from_native(df_native).select(
+        ...     "a", "b", all=nw.all_horizontal("a", "b", ignore_nulls=False)
+        ... )
+        ┌─────────────────────────────────────────┐
+        |           Narwhals DataFrame            |
+        |-----------------------------------------|
+        |pyarrow.Table                            |
+        |a: bool                                  |
+        |b: bool                                  |
+        |all: bool                                |
+        |----                                     |
+        |a: [[false,false,true,true,false,null]]  |
+        |b: [[false,true,true,null,null,null]]    |
+        |all: [[false,false,true,null,false,null]]|
+        └─────────────────────────────────────────┘
+    """
+    return _expr_with_horizontal_op(
+        "all_horizontal", *flatten(exprs), ignore_nulls=ignore_nulls
+    )
+
+
+def lit(value: PythonLiteral, dtype: IntoDType | None = None) -> Expr:
+    """Return an expression representing a literal value.
+
+    Arguments:
+        value: The value to use as literal. Can be a scalar value, list, tuple, or dict.
+            Lists and tuples are converted to `List` dtype, dicts to `Struct` dtype.
+        dtype: The data type of the literal value. If not provided, the data type will
+            be inferred by the native library. For empty lists/dicts, dtype must be
+            specified explicitly.
+
+    Examples:
+        Scalar literals:
+
+        >>> import pyarrow as pa
+        >>> import narwhals as nw
+        >>>
+        >>> df_nw = nw.from_native(pa.table({"a": [1, 2]}))
+        >>> df_nw.with_columns(nw.lit(3))
+        ┌──────────────────┐
+        |Narwhals DataFrame|
+        |------------------|
+        | pyarrow.Table    |
+        | a: int64         |
+        | literal: int64   |
+        | ----             |
+        | a: [[1,2]]       |
+        | literal: [[3,3]] |
+        └──────────────────┘
+
+        List literals (creates a List column):
+
+        >>> df_nw.with_columns(nw.lit([1, 2, 3]).alias("list_col"))
+        ┌─────────────────────────────┐
+        |     Narwhals DataFrame      |
+        |-----------------------------|
+        |pyarrow.Table                |
+        |a: int64                     |
+        |list_col: list<item: int64>  |
+        |  child 0, item: int64       |
+        |----                         |
+        |a: [[1,2]]                   |
+        |list_col: [[[1,2,3],[1,2,3]]]|
+        └─────────────────────────────┘
+
+        Dict literals (creates a Struct column):
+
+        >>> df_nw.with_columns(nw.lit({"x": 1, "y": 2}).alias("struct_col"))
+        ┌──────────────────────────────────────┐
+        |          Narwhals DataFrame          |
+        |--------------------------------------|
+        |pyarrow.Table                         |
+        |a: int64                              |
+        |struct_col: struct<x: int64, y: int64>|
+        |  child 0, x: int64                   |
+        |  child 1, y: int64                   |
+        |----                                  |
+        |a: [[1,2]]                            |
+        |struct_col: [                         |
+        |  -- is_valid: all not null           |
+        |  -- child 0 type: int64              |
+        |[1,1]                                 |
+        |  -- child 1 type: int64              |
+        |[2,2]]                                |
+        └──────────────────────────────────────┘
+    """
+    if is_numpy_array(value):
+        msg = (
+            "numpy arrays are not supported as literal values. "
+            "Consider using `with_columns` to create a new column from the array."
+        )
+        raise ValueError(msg)
+    if is_nested_literal(value):
+        if not value:
+            if not dtype:
+                msg = "Cannot infer dtype for empty nested structure. Please provide an explicit dtype parameter."
+                raise ValueError(msg)
+        elif isinstance(value, dict):
+            if any(is_nested_literal(v) for v in value.values()):
+                msg = "Nested structures with nested values are not supported."
+                raise NotImplementedError(msg)
+        elif is_nested_literal(value[0]):
+            msg = "Nested structures with nested values are not supported."
+            raise NotImplementedError(msg)
+    return Expr(ExprNode(ExprKind.LITERAL, "lit", value=value, dtype=dtype))
+
+
+def any_horizontal(*exprs: IntoExpr | Iterable[IntoExpr], ignore_nulls: bool) -> Expr:
+    r"""Compute the bitwise OR horizontally across columns.
+
+    Arguments:
+        exprs: Name(s) of the columns to use in the aggregation function. Accepts
+            expression input.
+        ignore_nulls: Whether to ignore nulls:
+
+            - If `True`, null values are ignored. If there are no elements, the result
+              is `False`.
+            - If `False`, Kleene logic is followed. Note that this is not allowed for
+              pandas with classical NumPy dtypes when null values are present.
+
+    Examples:
+        >>> import polars as pl
+        >>> import narwhals as nw
+        >>>
+        >>> data = {
+        ...     "a": [False, False, True, True, False, None],
+        ...     "b": [False, True, True, None, None, None],
+        ... }
+        >>> df_native = pl.DataFrame(data)
+        >>> nw.from_native(df_native).select(
+        ...     "a", "b", any=nw.any_horizontal("a", "b", ignore_nulls=False)
+        ... )
+        ┌─────────────────────────┐
+        |   Narwhals DataFrame    |
+        |-------------------------|
+        |shape: (6, 3)            |
+        |┌───────┬───────┬───────┐|
+        |│ a     ┆ b     ┆ any   │|
+        |│ ---   ┆ ---   ┆ ---   │|
+        |│ bool  ┆ bool  ┆ bool  │|
+        |╞═══════╪═══════╪═══════╡|
+        |│ false ┆ false ┆ false │|
+        |│ false ┆ true  ┆ true  │|
+        |│ true  ┆ true  ┆ true  │|
+        |│ true  ┆ null  ┆ true  │|
+        |│ false ┆ null  ┆ null  │|
+        |│ null  ┆ null  ┆ null  │|
+        |└───────┴───────┴───────┘|
+        └─────────────────────────┘
+    """
+    return _expr_with_horizontal_op(
+        "any_horizontal", *flatten(exprs), ignore_nulls=ignore_nulls
+    )
+
+
+def mean_horizontal(*exprs: IntoExpr | Iterable[IntoExpr]) -> Expr:
+    """Compute the mean of all values horizontally across columns.
+
+    Arguments:
+        exprs: Name(s) of the columns to use in the aggregation function. Accepts
+            expression input.
+
+    Examples:
+        >>> import pyarrow as pa
+        >>> import narwhals as nw
+        >>>
+        >>> data = {"a": [1, 8, 3], "b": [4, 5, None], "c": ["x", "y", "z"]}
+        >>> df_native = pa.table(data)
+
+        We define a dataframe-agnostic function that computes the horizontal mean of "a"
+        and "b" columns:
+
+        >>> nw.from_native(df_native).select(nw.mean_horizontal("a", "b"))
+        ┌──────────────────┐
+        |Narwhals DataFrame|
+        |------------------|
+        | pyarrow.Table    |
+        | a: double        |
+        | ----             |
+        | a: [[2.5,6.5,3]] |
+        └──────────────────┘
+    """
+    return _expr_with_horizontal_op("mean_horizontal", *flatten(exprs))
+
+
+def concat_str(
+    exprs: IntoExpr | Iterable[IntoExpr],
+    *more_exprs: IntoExpr,
+    separator: str = "",
+    ignore_nulls: bool = False,
+) -> Expr:
+    r"""Horizontally concatenate columns into a single string column.
+
+    Arguments:
+        exprs: Columns to concatenate into a single string column. Accepts expression
+            input. Strings are parsed as column names, other non-expression inputs are
+            parsed as literals. Non-`String` columns are cast to `String`.
+        *more_exprs: Additional columns to concatenate into a single string column,
+            specified as positional arguments.
+        separator: String that will be used to separate the values of each column.
+        ignore_nulls: Ignore null values (default is `False`).
+            If set to `False`, null values will be propagated and if the row contains any
+            null values, the output is null.
+
+    Examples:
+        >>> import pandas as pd
+        >>> import narwhals as nw
+        >>>
+        >>> data = {
+        ...     "a": [1, 2, 3],
+        ...     "b": ["dogs", "cats", None],
+        ...     "c": ["play", "swim", "walk"],
+        ... }
+        >>> df_native = pd.DataFrame(data)
+        >>> (
+        ...     nw.from_native(df_native).select(
+        ...         nw.concat_str(
+        ...             [nw.col("a") * 2, nw.col("b"), nw.col("c")], separator=" "
+        ...         ).alias("full_sentence")
+        ...     )
+        ... )
+        ┌──────────────────┐
+        |Narwhals DataFrame|
+        |------------------|
+        |   full_sentence  |
+        | 0   2 dogs play  |
+        | 1   4 cats swim  |
+        | 2           NaN  |
+        └──────────────────┘
+    """
+    flat_exprs = flatten([*flatten([exprs]), *more_exprs])
+    return _expr_with_horizontal_op(
+        "concat_str", *flat_exprs, separator=separator, ignore_nulls=ignore_nulls
+    )
+
+
+def coalesce(
+    exprs: IntoExpr | Iterable[IntoExpr], *more_exprs: IntoExpr | NonNestedLiteral
+) -> Expr:
+    """Folds the columns from left to right, keeping the first non-null value.
+
+    Arguments:
+        exprs: Columns to coalesce, must be a str, nw.Expr, or nw.Series
+            where strings are parsed as column names and both nw.Expr/nw.Series
+            are passed through as-is. Scalar values must be wrapped in `nw.lit`.
+
+        *more_exprs: Additional columns to coalesce, specified as positional arguments.
+
+    Raises:
+        TypeError: If any of the inputs are not a str, nw.Expr, or nw.Series.
+
+    Examples:
+        >>> import polars as pl
+        >>> import narwhals as nw
+        >>> data = [
+        ...     (1, 5, None),
+        ...     (None, 6, None),
+        ...     (None, None, 9),
+        ...     (4, 8, 10),
+        ...     (None, None, None),
+        ... ]
+        >>> df = pl.DataFrame(data, schema=["a", "b", "c"], orient="row")
+        >>> nw.from_native(df).select(nw.coalesce("a", "b", "c", nw.lit(-1)))
+        ┌──────────────────┐
+        |Narwhals DataFrame|
+        |------------------|
+        |  shape: (5, 1)   |
+        |  ┌─────┐         |
+        |  │ a   │         |
+        |  │ --- │         |
+        |  │ i64 │         |
+        |  ╞═════╡         |
+        |  │ 1   │         |
+        |  │ 6   │         |
+        |  │ 9   │         |
+        |  │ 4   │         |
+        |  │ -1  │         |
+        |  └─────┘         |
+        └──────────────────┘
+    """
+    flat_exprs = flatten([*flatten([exprs]), *more_exprs])
+
+    non_exprs = [
+        expr
+        for expr in flat_exprs
+        if not (isinstance(expr, str) or is_expr(expr) or is_series(expr))
+    ]
+    if non_exprs:
+        msg = (
+            f"All arguments to `coalesce` must be of type {str!r}, Expr, or Series."
+            "\nGot the following invalid arguments (type, value):"
+            f"\n    {', '.join(repr((type(e), e)) for e in non_exprs)}"
+        )
+        raise TypeError(msg)
+
+    return Expr(
+        ExprNode(
+            ExprKind.ELEMENTWISE, "coalesce", exprs=flat_exprs, allow_multi_output=True
+        )
+    )
+
+
+def format(f_string: str, *args: IntoExpr) -> Expr:
+    """Format expressions as a string.
+
+    Arguments:
+        f_string: A string that with placeholders.
+        args: Expression(s) that fill the placeholders.
+
+    Examples:
+        >>> import duckdb
+        >>> import narwhals as nw
+        >>> rel = duckdb.sql("select * from values ('a', 1), ('b', 2), ('c', 3) df(a, b)")
+        >>> df = nw.from_native(rel)
+        >>> df.with_columns(formatted=nw.format("foo_{}_bar_{}", nw.col("a"), "b"))
+        ┌─────────────────────────────────┐
+        |       Narwhals LazyFrame        |
+        |---------------------------------|
+        |┌─────────┬───────┬─────────────┐|
+        |│    a    │   b   │  formatted  │|
+        |│ varchar │ int32 │   varchar   │|
+        |├─────────┼───────┼─────────────┤|
+        |│ a       │     1 │ foo_a_bar_1 │|
+        |│ b       │     2 │ foo_b_bar_2 │|
+        |│ c       │     3 │ foo_c_bar_3 │|
+        |└─────────┴───────┴─────────────┘|
+        └─────────────────────────────────┘
+    """
+    if (n_placeholders := f_string.count("{}")) != len(args):
+        msg = f"number of placeholders should equal the number of arguments. Expected {n_placeholders} arguments, got {len(args)}."
+        raise ValueError(msg)
+
+    exprs = []
+    it = iter(args)
+    for i, s in enumerate(f_string.split("{}")):
+        if i > 0:
+            exprs.append(next(it))
+        if len(s) > 0:
+            exprs.append(lit(s))
+    return concat_str(exprs, separator="")

.venv_haddock/lib/python3.12/site-packages/narwhals/group_by.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Generic, TypeVar
+
+from narwhals._expression_parsing import is_scalar_like
+from narwhals._utils import tupleify
+from narwhals.exceptions import InvalidOperationError
+from narwhals.typing import DataFrameT
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator, Sequence
+
+    from narwhals._compliant.typing import CompliantExprAny
+    from narwhals.dataframe import LazyFrame
+    from narwhals.expr import Expr
+
+LazyFrameT = TypeVar("LazyFrameT", bound="LazyFrame[Any]")
+
+
+class GroupBy(Generic[DataFrameT]):
+    def __init__(
+        self,
+        df: DataFrameT,
+        keys: Sequence[str] | Sequence[CompliantExprAny],
+        /,
+        *,
+        drop_null_keys: bool,
+    ) -> None:
+        self._df: DataFrameT = df
+        self._keys = keys
+        self._grouped = self._df._compliant_frame.group_by(
+            self._keys, drop_null_keys=drop_null_keys
+        )
+
+    def agg(self, *aggs: Expr | Iterable[Expr], **named_aggs: Expr) -> DataFrameT:
+        """Compute aggregations for each group of a group by operation.
+
+        Arguments:
+            aggs: Aggregations to compute for each group of the group by operation,
+                specified as positional arguments.
+            named_aggs: Additional aggregations, specified as keyword arguments.
+
+        Examples:
+            Group by one column or by multiple columns and call `agg` to compute
+            the grouped sum of another column.
+
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> df_native = pd.DataFrame(
+            ...     {
+            ...         "a": ["a", "b", "a", "b", "c"],
+            ...         "b": [1, 2, 1, 3, 3],
+            ...         "c": [5, 4, 3, 2, 1],
+            ...     }
+            ... )
+            >>> df = nw.from_native(df_native)
+            >>>
+            >>> df.group_by("a").agg(nw.col("b").sum()).sort("a")
+            ┌──────────────────┐
+            |Narwhals DataFrame|
+            |------------------|
+            |        a  b      |
+            |     0  a  2      |
+            |     1  b  5      |
+            |     2  c  3      |
+            └──────────────────┘
+            >>>
+            >>> df.group_by("a", "b").agg(nw.col("c").sum()).sort("a", "b").to_native()
+               a  b  c
+            0  a  1  8
+            1  b  2  4
+            2  b  3  2
+            3  c  3  1
+        """
+        compliant_aggs = self._df._flatten_and_extract(*aggs, **named_aggs)
+        if not all(is_scalar_like(x) for x in compliant_aggs):
+            msg = (
+                "Found expression which does not aggregate.\n\n"
+                "All expressions passed to GroupBy.agg must aggregate.\n"
+                "For example, `df.group_by('a').agg(nw.col('b').sum())` is valid,\n"
+                "but `df.group_by('a').agg(nw.col('b'))` is not."
+            )
+            raise InvalidOperationError(msg)
+        return self._df._with_compliant(self._grouped.agg(*compliant_aggs))
+
+    def __iter__(self) -> Iterator[tuple[Any, DataFrameT]]:
+        yield from (
+            (tupleify(key), self._df._with_compliant(df))
+            for (key, df) in self._grouped.__iter__()
+        )
+
+
+class LazyGroupBy(Generic[LazyFrameT]):
+    def __init__(
+        self,
+        df: LazyFrameT,
+        keys: Sequence[str] | Sequence[CompliantExprAny],
+        /,
+        *,
+        drop_null_keys: bool,
+    ) -> None:
+        self._df: LazyFrameT = df
+        self._keys = keys
+        self._grouped = self._df._compliant_frame.group_by(
+            self._keys, drop_null_keys=drop_null_keys
+        )
+
+    def agg(self, *aggs: Expr | Iterable[Expr], **named_aggs: Expr) -> LazyFrameT:
+        """Compute aggregations for each group of a group by operation.
+
+        Arguments:
+            aggs: Aggregations to compute for each group of the group by operation,
+                specified as positional arguments.
+            named_aggs: Additional aggregations, specified as keyword arguments.
+
+        Examples:
+            Group by one column or by multiple columns and call `agg` to compute
+            the grouped sum of another column.
+
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> from narwhals.typing import IntoFrameT
+            >>> lf_native = pl.LazyFrame(
+            ...     {
+            ...         "a": ["a", "b", "a", "b", "c"],
+            ...         "b": [1, 2, 1, 3, 3],
+            ...         "c": [5, 4, 3, 2, 1],
+            ...     }
+            ... )
+            >>> lf = nw.from_native(lf_native)
+            >>>
+            >>> nw.to_native(lf.group_by("a").agg(nw.col("b").sum()).sort("a")).collect()
+            shape: (3, 2)
+            ┌─────┬─────┐
+            │ a   ┆ b   │
+            │ --- ┆ --- │
+            │ str ��� i64 │
+            ╞═════╪═════╡
+            │ a   ┆ 2   │
+            │ b   ┆ 5   │
+            │ c   ┆ 3   │
+            └─────┴─────┘
+            >>>
+            >>> lf.group_by("a", "b").agg(nw.sum("c")).sort("a", "b").collect()
+            ┌───────────────────┐
+            |Narwhals DataFrame |
+            |-------------------|
+            |shape: (4, 3)      |
+            |┌─────┬─────┬─────┐|
+            |│ a   ┆ b   ┆ c   │|
+            |│ --- ┆ --- ┆ --- │|
+            |│ str ┆ i64 ┆ i64 │|
+            |╞═════╪═════╪═════╡|
+            |│ a   ┆ 1   ┆ 8   │|
+            |│ b   ┆ 2   ┆ 4   │|
+            |│ b   ┆ 3   ┆ 2   │|
+            |│ c   ┆ 3   ┆ 1   │|
+            |└─────┴─────┴─────┘|
+            └───────────────────┘
+        """
+        compliant_aggs = self._df._flatten_and_extract(*aggs, **named_aggs)
+        if not all(is_scalar_like(x) for x in compliant_aggs):
+            msg = (
+                "Found expression which does not aggregate.\n\n"
+                "All expressions passed to GroupBy.agg must aggregate.\n"
+                "For example, `df.group_by('a').agg(nw.col('b').sum())` is valid,\n"
+                "but `df.group_by('a').agg(nw.col('b'))` is not."
+            )
+            raise InvalidOperationError(msg)
+        return self._df._with_compliant(self._grouped.agg(*compliant_aggs))

.venv_haddock/lib/python3.12/site-packages/narwhals/plugins.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import sys
+from functools import cache
+from typing import TYPE_CHECKING, Any, Protocol, cast
+
+from narwhals._compliant import CompliantNamespace
+from narwhals._typing_compat import TypeVar
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+    from importlib.metadata import EntryPoints
+
+    from typing_extensions import LiteralString, TypeAlias
+
+    from narwhals._compliant.typing import (
+        CompliantDataFrameAny,
+        CompliantFrameAny,
+        CompliantLazyFrameAny,
+        CompliantSeriesAny,
+    )
+    from narwhals.utils import Version
+
+
+__all__ = ["Plugin", "from_native"]
+
+CompliantAny: TypeAlias = (
+    "CompliantDataFrameAny | CompliantLazyFrameAny | CompliantSeriesAny"
+)
+"""A statically-unknown, Compliant object originating from a plugin."""
+
+FrameT = TypeVar(
+    "FrameT",
+    bound="CompliantFrameAny",
+    default="CompliantDataFrameAny | CompliantLazyFrameAny",
+)
+FromNativeR_co = TypeVar(
+    "FromNativeR_co", bound=CompliantAny, covariant=True, default=CompliantAny
+)
+
+
+@cache
+def _discover_entrypoints() -> EntryPoints:
+    from importlib.metadata import entry_points as eps
+
+    group = "narwhals.plugins"
+    if sys.version_info < (3, 10):
+        return cast("EntryPoints", eps().get(group, ()))
+    return eps(group=group)
+
+
+class PluginNamespace(CompliantNamespace[FrameT, Any], Protocol[FrameT, FromNativeR_co]):
+    def from_native(self, data: Any, /) -> FromNativeR_co: ...
+
+
+class Plugin(Protocol[FrameT, FromNativeR_co]):
+    @property
+    def NATIVE_PACKAGE(self) -> LiteralString: ...  # noqa: N802
+
+    def __narwhals_namespace__(
+        self, version: Version
+    ) -> PluginNamespace[FrameT, FromNativeR_co]: ...
+    def is_native(self, native_object: object, /) -> bool: ...
+
+
+@cache
+def _might_be(cls: type, type_: str) -> bool:  # pragma: no cover
+    try:
+        return any(type_ in o.__module__.split(".") for o in cls.mro())
+    except TypeError:
+        return False
+
+
+def _is_native_plugin(native_object: Any, plugin: Plugin) -> bool:
+    pkg = plugin.NATIVE_PACKAGE
+    return (
+        sys.modules.get(pkg) is not None
+        and _might_be(type(native_object), pkg)  # type: ignore[arg-type]
+        and plugin.is_native(native_object)
+    )
+
+
+def _iter_from_native(native_object: Any, version: Version) -> Iterator[CompliantAny]:
+    for entry_point in _discover_entrypoints():
+        plugin: Plugin = entry_point.load()
+        if _is_native_plugin(native_object, plugin):
+            compliant_namespace = plugin.__narwhals_namespace__(version=version)
+            yield compliant_namespace.from_native(native_object)
+
+
+def from_native(native_object: Any, version: Version) -> CompliantAny | None:
+    """Attempt to convert `native_object` to a Compliant object, using any available plugin(s).
+
+    Arguments:
+        native_object: Raw object from user.
+        version: Narwhals API version.
+
+    Returns:
+        If the following conditions are met
+            - at least 1 plugin is installed
+            - at least 1 installed plugin supports `type(native_object)`
+
+        Then for the **first matching plugin**, the result of the call below.
+        This *should* be an object accepted by a Narwhals Dataframe, Lazyframe, or Series:
+
+            plugin: Plugin
+            plugin.__narwhals_namespace__(version).from_native(native_object)
+
+        In all other cases, `None` is returned instead.
+    """
+    return next(_iter_from_native(native_object, version), None)
+
+
+def _show_suggestions(native_object_type: type) -> str | None:
+    if _might_be(native_object_type, "daft"):  # pragma: no cover
+        return (
+            "Hint: it looks like you passed a `daft.DataFrame` but don't have `narwhals-daft` installed.\n"
+            "Please refer to https://github.com/narwhals-dev/narwhals-daft for installation instructions."
+        )
+    return None

.venv_haddock/lib/python3.12/site-packages/narwhals/schema.py

@@ -0,0 +1,365 @@
+"""Schema.
+
+Adapted from Polars implementation at:
+https://github.com/pola-rs/polars/blob/main/py-polars/polars/schema.py.
+"""
+
+from __future__ import annotations
+
+from collections import OrderedDict
+from collections.abc import Mapping
+from functools import partial
+from typing import TYPE_CHECKING, cast
+
+from narwhals._utils import Implementation, Version, qualified_type_name, zip_strict
+from narwhals.dependencies import (
+    get_cudf,
+    is_cudf_dtype,
+    is_pandas_like_dtype,
+    is_polars_data_type,
+    is_polars_schema,
+    is_pyarrow_data_type,
+    is_pyarrow_schema,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from typing import Any, ClassVar
+
+    import polars as pl
+    import pyarrow as pa
+    from typing_extensions import Self
+
+    from narwhals.dtypes import DType
+    from narwhals.typing import (
+        DTypeBackend,
+        IntoArrowSchema,
+        IntoPandasSchema,
+        IntoPolarsSchema,
+    )
+
+
+__all__ = ["Schema"]
+
+
+class Schema(OrderedDict[str, "DType"]):
+    """Ordered mapping of column names to their data type.
+
+    Arguments:
+        schema: The schema definition given by column names and their associated
+            *instantiated* Narwhals data type. Accepts a mapping or an iterable of tuples.
+
+    Examples:
+        Define a schema by passing *instantiated* data types.
+
+        >>> import narwhals as nw
+        >>> schema = nw.Schema({"foo": nw.Int8(), "bar": nw.String()})
+        >>> schema
+        Schema({'foo': Int8, 'bar': String})
+
+        Access the data type associated with a specific column name.
+
+        >>> schema["foo"]
+        Int8
+
+        Access various schema properties using the `names`, `dtypes`, and `len` methods.
+
+        >>> schema.names()
+        ['foo', 'bar']
+        >>> schema.dtypes()
+        [Int8, String]
+        >>> schema.len()
+        2
+    """
+
+    _version: ClassVar[Version] = Version.MAIN
+
+    def __init__(
+        self, schema: Mapping[str, DType] | Iterable[tuple[str, DType]] | None = None
+    ) -> None:
+        schema = schema or {}
+        super().__init__(schema)
+
+    def names(self) -> list[str]:
+        """Get the column names of the schema."""
+        return list(self.keys())
+
+    def dtypes(self) -> list[DType]:
+        """Get the data types of the schema."""
+        return list(self.values())
+
+    def len(self) -> int:
+        """Get the number of columns in the schema."""
+        return len(self)
+
+    @classmethod
+    def from_arrow(cls, schema: IntoArrowSchema, /) -> Self:
+        """Construct a Schema from a pyarrow Schema.
+
+        Arguments:
+            schema: A pyarrow Schema or mapping of column names to pyarrow data types.
+
+        Examples:
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>>
+            >>> mapping = {
+            ...     "a": pa.timestamp("us", "UTC"),
+            ...     "b": pa.date32(),
+            ...     "c": pa.string(),
+            ...     "d": pa.uint8(),
+            ... }
+            >>> native = pa.schema(mapping)
+            >>>
+            >>> nw.Schema.from_arrow(native)
+            Schema({'a': Datetime(time_unit='us', time_zone='UTC'), 'b': Date, 'c': String, 'd': UInt8})
+
+            >>> nw.Schema.from_arrow(mapping) == nw.Schema.from_arrow(native)
+            True
+        """
+        if isinstance(schema, Mapping):
+            if not schema:
+                return cls()
+            import pyarrow as pa  # ignore-banned-import
+
+            schema = pa.schema(schema)
+        from narwhals._arrow.utils import native_to_narwhals_dtype
+
+        return cls(
+            (field.name, native_to_narwhals_dtype(field.type, cls._version))
+            for field in schema
+        )
+
+    @classmethod
+    def from_pandas_like(cls, schema: IntoPandasSchema, /) -> Self:
+        """Construct a Schema from a pandas-like schema representation.
+
+        Arguments:
+            schema: A mapping of column names to pandas-like data types.
+
+        Examples:
+            >>> import numpy as np
+            >>> import pandas as pd
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>>
+            >>> data = {"a": [1], "b": ["a"], "c": [False], "d": [9.2]}
+            >>> native = pd.DataFrame(data).convert_dtypes().dtypes.to_dict()
+            >>>
+            >>> nw.Schema.from_pandas_like(native)
+            Schema({'a': Int64, 'b': String, 'c': Boolean, 'd': Float64})
+            >>>
+            >>> mapping = {
+            ...     "a": pd.DatetimeTZDtype("us", "UTC"),
+            ...     "b": pd.ArrowDtype(pa.date32()),
+            ...     "c": pd.StringDtype("python"),
+            ...     "d": np.dtype("uint8"),
+            ... }
+            >>>
+            >>> nw.Schema.from_pandas_like(mapping)
+            Schema({'a': Datetime(time_unit='us', time_zone='UTC'), 'b': Date, 'c': String, 'd': UInt8})
+        """
+        if not schema:
+            return cls()
+        impl = (
+            Implementation.CUDF
+            if get_cudf() and any(is_cudf_dtype(dtype) for dtype in schema.values())
+            else Implementation.PANDAS
+        )
+        return cls._from_pandas_like(schema, impl)
+
+    @classmethod
+    def from_native(
+        cls, schema: IntoArrowSchema | IntoPolarsSchema | IntoPandasSchema, /
+    ) -> Self:
+        """Construct a Schema from a native schema representation.
+
+        Arguments:
+            schema: A native schema object, or mapping of column names to
+                *instantiated* native data types.
+
+        Examples:
+            >>> import datetime as dt
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>>
+            >>> data = {"a": [1], "b": ["a"], "c": [dt.time(1, 2, 3)], "d": [[2]]}
+            >>> native = pa.table(data).schema
+            >>>
+            >>> nw.Schema.from_native(native)
+            Schema({'a': Int64, 'b': String, 'c': Time, 'd': List(Int64)})
+        """
+        if is_pyarrow_schema(schema):
+            return cls.from_arrow(schema)
+        if is_polars_schema(schema):
+            return cls.from_polars(schema)
+        if isinstance(schema, Mapping):
+            return cls._from_native_mapping(schema) if schema else cls()
+        msg = (
+            f"Expected an arrow, polars, or pandas schema, but got "
+            f"{qualified_type_name(schema)!r}\n\n{schema!r}"
+        )
+        raise TypeError(msg)
+
+    @classmethod
+    def from_polars(cls, schema: IntoPolarsSchema, /) -> Self:
+        """Construct a Schema from a polars Schema.
+
+        Arguments:
+            schema: A polars Schema or mapping of column names to *instantiated*
+                polars data types.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>>
+            >>> mapping = {
+            ...     "a": pl.Datetime(time_zone="UTC"),
+            ...     "b": pl.Date(),
+            ...     "c": pl.String(),
+            ...     "d": pl.UInt8(),
+            ... }
+            >>> native = pl.Schema(mapping)
+            >>>
+            >>> nw.Schema.from_polars(native)
+            Schema({'a': Datetime(time_unit='us', time_zone='UTC'), 'b': Date, 'c': String, 'd': UInt8})
+
+            >>> nw.Schema.from_polars(mapping) == nw.Schema.from_polars(native)
+            True
+        """
+        if not schema:
+            return cls()
+        from narwhals._polars.utils import native_to_narwhals_dtype
+
+        return cls(
+            (name, native_to_narwhals_dtype(dtype, cls._version))
+            for name, dtype in schema.items()
+        )
+
+    def to_arrow(self) -> pa.Schema:
+        """Convert Schema to a pyarrow Schema.
+
+        Examples:
+            >>> import narwhals as nw
+            >>> schema = nw.Schema({"a": nw.Int64(), "b": nw.Datetime("ns")})
+            >>> schema.to_arrow()
+            a: int64
+            b: timestamp[ns]
+        """
+        import pyarrow as pa  # ignore-banned-import
+
+        from narwhals._arrow.utils import narwhals_to_native_dtype
+
+        return pa.schema(
+            (name, narwhals_to_native_dtype(dtype, self._version))
+            for name, dtype in self.items()
+        )
+
+    def to_pandas(
+        self, dtype_backend: DTypeBackend | Iterable[DTypeBackend] = None
+    ) -> dict[str, Any]:
+        """Convert Schema to an ordered mapping of column names to their pandas data type.
+
+        Arguments:
+            dtype_backend: Backend(s) used for the native types. When providing more than
+                one, the length of the iterable must be equal to the length of the schema.
+
+        Examples:
+            >>> import narwhals as nw
+            >>> schema = nw.Schema({"a": nw.Int64(), "b": nw.Datetime("ns")})
+            >>> schema.to_pandas()
+            {'a': 'int64', 'b': 'datetime64[ns]'}
+
+            >>> schema.to_pandas("pyarrow")
+            {'a': 'Int64[pyarrow]', 'b': 'timestamp[ns][pyarrow]'}
+        """
+        from narwhals._pandas_like.utils import narwhals_to_native_dtype
+
+        to_native_dtype = partial(
+            narwhals_to_native_dtype,
+            implementation=Implementation.PANDAS,
+            version=self._version,
+        )
+        if dtype_backend is None or isinstance(dtype_backend, str):
+            return {
+                name: to_native_dtype(dtype=dtype, dtype_backend=dtype_backend)
+                for name, dtype in self.items()
+            }
+        backends = tuple(dtype_backend)
+        if len(backends) != len(self):
+            from itertools import chain, islice, repeat
+
+            n_user, n_actual = len(backends), len(self)
+            suggestion = tuple(
+                islice(chain.from_iterable(islice(repeat(backends), n_actual)), n_actual)
+            )
+            msg = (
+                f"Provided {n_user!r} `dtype_backend`(s), but schema contains {n_actual!r} field(s).\n"
+                "Hint: instead of\n"
+                f"    schema.to_pandas({backends})\n"
+                "you may want to use\n"
+                f"    schema.to_pandas({backends[0]})\n"
+                f"or\n"
+                f"    schema.to_pandas({suggestion})"
+            )
+            raise ValueError(msg)
+        return {
+            name: to_native_dtype(dtype=dtype, dtype_backend=backend)
+            for name, dtype, backend in zip_strict(self.keys(), self.values(), backends)
+        }
+
+    def to_polars(self) -> pl.Schema:
+        """Convert Schema to a polars Schema.
+
+        Examples:
+            >>> import narwhals as nw
+            >>> schema = nw.Schema({"a": nw.Int64(), "b": nw.Datetime("ns")})
+            >>> schema.to_polars()
+            Schema({'a': Int64, 'b': Datetime(time_unit='ns', time_zone=None)})
+        """
+        import polars as pl  # ignore-banned-import
+
+        from narwhals._polars.utils import narwhals_to_native_dtype
+
+        pl_version = Implementation.POLARS._backend_version()
+        schema = (
+            (name, narwhals_to_native_dtype(dtype, self._version))
+            for name, dtype in self.items()
+        )
+        return (
+            pl.Schema(schema)
+            if pl_version >= (1, 0, 0)
+            else cast("pl.Schema", dict(schema))
+        )
+
+    @classmethod
+    def _from_native_mapping(
+        cls,
+        native: Mapping[str, pa.DataType] | Mapping[str, pl.DataType] | IntoPandasSchema,
+        /,
+    ) -> Self:
+        first_item = next(iter(native.items()))
+        first_key, first_dtype = first_item
+        if is_polars_data_type(first_dtype):
+            return cls.from_polars(cast("IntoPolarsSchema", native))
+        if is_pandas_like_dtype(first_dtype):
+            return cls.from_pandas_like(cast("IntoPandasSchema", native))
+        if is_pyarrow_data_type(first_dtype):
+            return cls.from_arrow(cast("IntoArrowSchema", native))
+        msg = (
+            f"Expected an arrow, polars, or pandas dtype, but found "
+            f"`{first_key}: {qualified_type_name(first_dtype)}`\n\n{native!r}"
+        )
+        raise TypeError(msg)
+
+    @classmethod
+    def _from_pandas_like(
+        cls, schema: IntoPandasSchema, implementation: Implementation, /
+    ) -> Self:
+        from narwhals._pandas_like.utils import native_to_narwhals_dtype
+
+        impl = implementation
+        return cls(
+            (name, native_to_narwhals_dtype(dtype, cls._version, impl, allow_object=True))
+            for name, dtype in schema.items()
+        )

.venv_haddock/lib/python3.12/site-packages/narwhals/selectors.py

@@ -0,0 +1,322 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, NoReturn
+
+from narwhals._expression_parsing import ExprKind, ExprNode
+from narwhals._utils import flatten
+from narwhals.expr import Expr
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from datetime import timezone
+
+    from narwhals.dtypes import DType
+    from narwhals.typing import TimeUnit
+
+
+class Selector(Expr):
+    def _to_expr(self) -> Expr:
+        return Expr(*self._nodes)
+
+    def __add__(self, other: Any) -> Expr:  # type: ignore[override]
+        if isinstance(other, Selector):
+            msg = "unsupported operand type(s) for op: ('Selector' + 'Selector')"
+            raise TypeError(msg)
+        return self._to_expr()._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "__add__", exprs=(other,), str_as_lit=True)
+        )
+
+    def __or__(self, other: Any) -> Expr:  # type: ignore[override]
+        if isinstance(other, Selector):
+            return self._append_node(
+                ExprNode(
+                    ExprKind.ELEMENTWISE,
+                    "__or__",
+                    exprs=(other,),
+                    str_as_lit=True,
+                    allow_multi_output=True,
+                )
+            )
+        return self._to_expr()._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "__or__", exprs=(other,), str_as_lit=True)
+        )
+
+    def __and__(self, other: Any) -> Expr:  # type: ignore[override]
+        if isinstance(other, Selector):
+            return self._append_node(
+                ExprNode(
+                    ExprKind.ELEMENTWISE,
+                    "__and__",
+                    exprs=(other,),
+                    str_as_lit=True,
+                    allow_multi_output=True,
+                )
+            )
+        return self._to_expr()._append_node(
+            ExprNode(ExprKind.ELEMENTWISE, "__and__", exprs=(other,), str_as_lit=True)
+        )
+
+    def __rsub__(self, other: Any) -> NoReturn:
+        raise NotImplementedError
+
+    def __rand__(self, other: Any) -> NoReturn:
+        raise NotImplementedError
+
+    def __ror__(self, other: Any) -> NoReturn:
+        raise NotImplementedError
+
+
+def by_dtype(*dtypes: DType | type[DType] | Iterable[DType | type[DType]]) -> Selector:
+    """Select columns based on their dtype.
+
+    Arguments:
+        dtypes: one or data types to select
+
+    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]]
+    """
+    flattened = flatten(dtypes)
+    return Selector(ExprNode(ExprKind.SELECTOR, "selectors.by_dtype", dtypes=flattened))
+
+
+def matches(pattern: str) -> Selector:
+    """Select all columns that match the given regex pattern.
+
+    Arguments:
+        pattern: A valid regular expression pattern.
+
+    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
+    """
+    return Selector(ExprNode(ExprKind.SELECTOR, "selectors.matches", pattern=pattern))
+
+
+def numeric() -> Selector:
+    """Select numeric columns.
+
+    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 │
+        └─────┴─────┘
+    """
+    return Selector(ExprNode(ExprKind.SELECTOR, "selectors.numeric"))
+
+
+def boolean() -> Selector:
+    """Select boolean columns.
+
+    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  │       |
+        |  └───────┘       |
+        └──────────────────┘
+    """
+    return Selector(ExprNode(ExprKind.SELECTOR, "selectors.boolean"))
+
+
+def string() -> Selector:
+    """Select string columns.
+
+    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   │
+        └─────┘
+    """
+    return Selector(ExprNode(ExprKind.SELECTOR, "selectors.string"))
+
+
+def categorical() -> Selector:
+    """Select categorical columns.
+
+    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   │
+        └─────┘
+    """
+    return Selector(ExprNode(ExprKind.SELECTOR, "selectors.categorical"))
+
+
+def all() -> Selector:
+    """Select all columns.
+
+    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
+    """
+    return Selector(ExprNode(ExprKind.SELECTOR, "selectors.all"))
+
+
+def datetime(
+    time_unit: TimeUnit | Iterable[TimeUnit] | None = None,
+    time_zone: str | timezone | Iterable[str | timezone | None] | None = ("*", None),
+) -> Selector:
+    """Select 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.
+
+    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]]
+    """
+    return Selector(
+        ExprNode(
+            ExprKind.SELECTOR,
+            "selectors.datetime",
+            time_unit=time_unit,
+            time_zone=time_zone,
+        )
+    )
+
+
+__all__ = [
+    "all",
+    "boolean",
+    "by_dtype",
+    "categorical",
+    "datetime",
+    "matches",
+    "numeric",
+    "string",
+]

.venv_haddock/lib/python3.12/site-packages/narwhals/series_cat.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import Generic
+
+from narwhals.typing import SeriesT
+
+
+class SeriesCatNamespace(Generic[SeriesT]):
+    def __init__(self, series: SeriesT) -> None:
+        self._narwhals_series = series
+
+    def get_categories(self) -> SeriesT:
+        """Get unique categories from column.
+
+        Examples:
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> s_native = pd.Series(["apple", "mango", "mango"], dtype="category")
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.cat.get_categories().to_native()
+            0    apple
+            1    mango
+            dtype: str
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.cat.get_categories()
+        )

.venv_haddock/lib/python3.12/site-packages/narwhals/series_dt.py

@@ -0,0 +1,647 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Generic
+
+from narwhals.typing import SeriesT
+
+if TYPE_CHECKING:
+    from narwhals.typing import TimeUnit
+
+
+class SeriesDateTimeNamespace(Generic[SeriesT]):
+    def __init__(self, series: SeriesT) -> None:
+        self._narwhals_series = series
+
+    def date(self) -> SeriesT:
+        """Get the date in a datetime series.
+
+        Raises:
+            NotImplementedError: If pandas default backend is being used.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> s_native = pd.Series(
+            ...     [datetime(2012, 1, 7, 10, 20), datetime(2023, 3, 10, 11, 32)]
+            ... ).convert_dtypes(dtype_backend="pyarrow")
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.dt.date().to_native()
+            0    2012-01-07
+            1    2023-03-10
+            dtype: date32[day][pyarrow]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.dt.date()
+        )
+
+    def year(self) -> SeriesT:
+        """Get the year in a datetime series.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> s_native = pl.Series([datetime(2012, 1, 7), datetime(2023, 3, 10)])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.dt.year().to_native()  # doctest: +NORMALIZE_WHITESPACE
+            shape: (2,)
+            Series: '' [i32]
+            [
+                    2012
+                    2023
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.dt.year()
+        )
+
+    def month(self) -> SeriesT:
+        """Gets the month in a datetime series.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> s_native = pl.Series([datetime(2012, 1, 7), datetime(2023, 3, 10)])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.dt.month().to_native()  # doctest: +NORMALIZE_WHITESPACE
+            shape: (2,)
+            Series: '' [i8]
+            [
+                    1
+                    3
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.dt.month()
+        )
+
+    def day(self) -> SeriesT:
+        """Extracts the day in a datetime series.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> s_native = pa.chunked_array(
+            ...     [[datetime(2022, 1, 1), datetime(2022, 1, 5)]]
+            ... )
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.dt.day().to_native()  # doctest: +ELLIPSIS
+            <pyarrow.lib.ChunkedArray object at ...>
+            [
+              [
+                1,
+                5
+              ]
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.dt.day()
+        )
+
+    def hour(self) -> SeriesT:
+        """Extracts the hour in a datetime series.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> s_native = pa.chunked_array(
+            ...     [[datetime(2022, 1, 1, 5, 3), datetime(2022, 1, 5, 9, 12)]]
+            ... )
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.dt.hour().to_native()  # doctest: +ELLIPSIS
+            <pyarrow.lib.ChunkedArray object at ...>
+            [
+              [
+                5,
+                9
+              ]
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.dt.hour()
+        )
+
+    def minute(self) -> SeriesT:
+        """Extracts the minute in a datetime series.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> s_native = pd.Series(
+            ...     [datetime(2022, 1, 1, 5, 3), datetime(2022, 1, 5, 9, 12)]
+            ... )
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.dt.minute().to_native()
+            0     3
+            1    12
+            dtype: int32
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.dt.minute()
+        )
+
+    def second(self) -> SeriesT:
+        """Extracts the seconds in a datetime series.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> s_native = pd.Series(
+            ...     [datetime(2022, 1, 1, 5, 3, 10), datetime(2022, 1, 5, 9, 12, 4)]
+            ... )
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.dt.second().to_native()
+            0    10
+            1     4
+            dtype: int32
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.dt.second()
+        )
+
+    def millisecond(self) -> SeriesT:
+        """Extracts the milliseconds in a datetime series.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> s_native = pd.Series(
+            ...     [
+            ...         datetime(2022, 1, 1, 5, 3, 7, 400000),
+            ...         datetime(2022, 1, 1, 5, 3, 7, 0),
+            ...     ]
+            ... )
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.dt.millisecond().alias("datetime").to_native()
+            0    400
+            1      0
+            Name: datetime, dtype: int32
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.dt.millisecond()
+        )
+
+    def microsecond(self) -> SeriesT:
+        """Extracts the microseconds in a datetime series.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> s_native = pd.Series(
+            ...     [
+            ...         datetime(2022, 1, 1, 5, 3, 7, 400000),
+            ...         datetime(2022, 1, 1, 5, 3, 7, 0),
+            ...     ]
+            ... )
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.dt.microsecond().alias("datetime").to_native()
+            0    400000
+            1         0
+            Name: datetime, dtype: int32
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.dt.microsecond()
+        )
+
+    def nanosecond(self) -> SeriesT:
+        """Extract the nanoseconds in a date series.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> s_native = pd.Series(
+            ...     [
+            ...         datetime(2022, 1, 1, 5, 3, 7, 400000),
+            ...         datetime(2022, 1, 1, 5, 3, 7, 0),
+            ...     ]
+            ... )
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.dt.nanosecond().alias("datetime").to_native()
+            0    400000000
+            1            0
+            Name: datetime, dtype: int32
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.dt.nanosecond()
+        )
+
+    def ordinal_day(self) -> SeriesT:
+        """Get ordinal day.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> s_native = pa.chunked_array(
+            ...     [[datetime(2020, 1, 1), datetime(2020, 8, 3)]]
+            ... )
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.dt.ordinal_day().to_native()  # doctest: +ELLIPSIS
+            <pyarrow.lib.ChunkedArray object at ...>
+            [
+              [
+                1,
+                216
+              ]
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.dt.ordinal_day()
+        )
+
+    def weekday(self) -> SeriesT:
+        """Extract the week day in a datetime series.
+
+        Note that Monday = 1 and Sunday = 7.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> s_native = pa.chunked_array(
+            ...     [[datetime(2020, 1, 1), datetime(2020, 8, 3)]]
+            ... )
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.dt.weekday().to_native()  # doctest: +ELLIPSIS
+            <pyarrow.lib.ChunkedArray object at ...>
+            [
+              [
+                3,
+                1
+              ]
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.dt.weekday()
+        )
+
+    def total_minutes(self) -> SeriesT:
+        """Get total minutes.
+
+        Notes:
+            The function outputs the total minutes in the int dtype by default,
+            however, pandas may change the dtype to float when there are missing values,
+            consider using `fill_null()` in this case.
+
+        Examples:
+            >>> from datetime import timedelta
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> s_native = pl.Series(
+            ...     [timedelta(minutes=10), timedelta(minutes=20, seconds=40)]
+            ... )
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.dt.total_minutes().to_native()  # doctest: +NORMALIZE_WHITESPACE
+            shape: (2,)
+            Series: '' [i64]
+            [
+                    10
+                    20
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.dt.total_minutes()
+        )
+
+    def total_seconds(self) -> SeriesT:
+        """Get total seconds.
+
+        Notes:
+            The function outputs the total seconds in the int dtype by default,
+            however, pandas may change the dtype to float when there are missing values,
+            consider using `fill_null()` in this case.
+
+        Examples:
+            >>> from datetime import timedelta
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> s_native = pl.Series(
+            ...     [timedelta(minutes=10), timedelta(minutes=20, seconds=40)]
+            ... )
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.dt.total_seconds().to_native()  # doctest: +NORMALIZE_WHITESPACE
+            shape: (2,)
+            Series: '' [i64]
+            [
+                    600
+                    1240
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.dt.total_seconds()
+        )
+
+    def total_milliseconds(self) -> SeriesT:
+        """Get total milliseconds.
+
+        Notes:
+            The function outputs the total milliseconds in the int dtype by default,
+            however, pandas may change the dtype to float when there are missing values,
+            consider using `fill_null()` in this case.
+
+        Examples:
+            >>> from datetime import timedelta
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> s_native = pl.Series(
+            ...     [
+            ...         timedelta(milliseconds=10),
+            ...         timedelta(milliseconds=20, microseconds=40),
+            ...     ]
+            ... )
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.dt.total_milliseconds().to_native()  # doctest: +NORMALIZE_WHITESPACE
+            shape: (2,)
+            Series: '' [i64]
+            [
+                    10
+                    20
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.dt.total_milliseconds()
+        )
+
+    def total_microseconds(self) -> SeriesT:
+        """Get total microseconds.
+
+        Notes:
+            The function outputs the total microseconds in the int dtype by default,
+            however, pandas may change the dtype to float when there are missing values,
+            consider using `fill_null()` in this case.
+
+        Examples:
+            >>> from datetime import timedelta
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> s_native = pl.Series(
+            ...     [
+            ...         timedelta(microseconds=10),
+            ...         timedelta(milliseconds=1, microseconds=200),
+            ...     ]
+            ... )
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.dt.total_microseconds().to_native()  # doctest: +NORMALIZE_WHITESPACE
+            shape: (2,)
+            Series: '' [i64]
+            [
+                    10
+                    1200
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.dt.total_microseconds()
+        )
+
+    def total_nanoseconds(self) -> SeriesT:
+        """Get total nanoseconds.
+
+        Notes:
+            The function outputs the total nanoseconds in the int dtype by default,
+            however, pandas may change the dtype to float when there are missing values,
+            consider using `fill_null()` in this case.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> s_native = pl.Series(
+            ...     ["2024-01-01 00:00:00.000000001", "2024-01-01 00:00:00.000000002"]
+            ... ).str.to_datetime(time_unit="ns")
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.diff().dt.total_nanoseconds().to_native()  # doctest: +NORMALIZE_WHITESPACE
+            shape: (2,)
+            Series: '' [i64]
+            [
+                    null
+                    1
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.dt.total_nanoseconds()
+        )
+
+    def to_string(self, format: str) -> SeriesT:
+        """Convert a Date/Time/Datetime series into a String series with the given format.
+
+        Arguments:
+            format: Format string for converting the datetime to string.
+
+        Notes:
+            Unfortunately, different libraries interpret format directives a bit
+            differently.
+
+            - Chrono, the library used by Polars, uses `"%.f"` for fractional seconds,
+              whereas pandas and Python stdlib use `".%f"`.
+            - PyArrow interprets `"%S"` as "seconds, including fractional seconds"
+              whereas most other tools interpret it as "just seconds, as 2 digits".
+            ---
+            Therefore, we make the following adjustments.
+
+            - for pandas-like libraries, we replace `"%S.%f"` with `"%S%.f"`.
+            - for PyArrow, we replace `"%S.%f"` with `"%S"`.
+            ---
+            Workarounds like these don't make us happy, and we try to avoid them as
+            much as possible, but here we feel like it's the best compromise.
+
+            If you just want to format a date/datetime Series as a local datetime
+            string, and have it work as consistently as possible across libraries,
+            we suggest using:
+
+            - `"%Y-%m-%dT%H:%M:%S%.f"` for datetimes
+            - `"%Y-%m-%d"` for dates
+            ---
+            Though note that, even then, different tools may return a different number
+            of trailing zeros. Nonetheless, this is probably consistent enough for
+            most applications.
+
+            If you have an application where this is not enough, please open an issue
+            and let us know.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> s_native = pd.Series([datetime(2020, 3, 1), datetime(2020, 4, 1)])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.dt.to_string("%Y/%m/%d")
+            ┌───────────────┐
+            |Narwhals Series|
+            |---------------|
+            |0    2020/03/01|
+            |1    2020/04/01|
+            |dtype: str     |
+            └───────────────┘
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.dt.to_string(format)
+        )
+
+    def replace_time_zone(self, time_zone: str | None) -> SeriesT:
+        """Replace time zone.
+
+        Arguments:
+            time_zone: Target time zone.
+
+        Examples:
+            >>> from datetime import datetime, timezone
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> s_native = pl.Series(
+            ...     [
+            ...         datetime(2024, 1, 1, tzinfo=timezone.utc),
+            ...         datetime(2024, 1, 2, tzinfo=timezone.utc),
+            ...     ]
+            ... )
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.dt.replace_time_zone(
+            ...     "Asia/Kathmandu"
+            ... ).to_native()  # doctest: +NORMALIZE_WHITESPACE
+            shape: (2,)
+            Series: '' [datetime[μs, Asia/Kathmandu]]
+            [
+                    2024-01-01 00:00:00 +0545
+                    2024-01-02 00:00:00 +0545
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.dt.replace_time_zone(time_zone)
+        )
+
+    def convert_time_zone(self, time_zone: str) -> SeriesT:
+        """Convert time zone.
+
+        If converting from a time-zone-naive column, then conversion happens
+        as if converting from UTC.
+
+        Arguments:
+            time_zone: Target time zone.
+
+        Examples:
+            >>> from datetime import datetime, timezone
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> s_native = pd.Series(
+            ...     [
+            ...         datetime(2024, 1, 1, tzinfo=timezone.utc),
+            ...         datetime(2024, 1, 2, tzinfo=timezone.utc),
+            ...     ]
+            ... )
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.dt.convert_time_zone("Asia/Kathmandu").to_native()
+            0   2024-01-01 05:45:00+05:45
+            1   2024-01-02 05:45:00+05:45
+            dtype: datetime64[us, Asia/Kathmandu]
+        """
+        if time_zone is None:
+            msg = "Target `time_zone` cannot be `None` in `convert_time_zone`. Please use `replace_time_zone(None)` if you want to remove the time zone."
+            raise TypeError(msg)
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.dt.convert_time_zone(time_zone)
+        )
+
+    def timestamp(self, time_unit: TimeUnit) -> SeriesT:
+        """Return a timestamp in the given time unit.
+
+        Arguments:
+            time_unit: One of
+                - 'ns': nanosecond.
+                - 'us': microsecond.
+                - 'ms': millisecond.
+
+        Examples:
+            >>> from datetime import date
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> s_native = pd.Series(
+            ...     [date(2001, 1, 1), None, date(2001, 1, 3)], dtype="datetime64[ns]"
+            ... )
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.dt.timestamp("ms").to_native()
+            0    9.783072e+11
+            1             NaN
+            2    9.784800e+11
+            dtype: float64
+        """
+        if time_unit not in {"ns", "us", "ms"}:
+            msg = (
+                "invalid `time_unit`"
+                f"\n\nExpected one of {{'ns', 'us', 'ms'}}, got {time_unit!r}."
+            )
+            raise ValueError(msg)
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.dt.timestamp(time_unit)
+        )
+
+    def truncate(self, every: str) -> SeriesT:
+        """Divide the date/datetime range into buckets.
+
+        Arguments:
+            every: Length of bucket. Must be of form `<multiple><unit>`,
+                where `multiple` is a positive integer and `unit` is one of
+
+                - 'ns': nanosecond.
+                - 'us': microsecond.
+                - 'ms': millisecond.
+                - 's': second.
+                - 'm': minute.
+                - 'h': hour.
+                - 'd': day.
+                - 'mo': month.
+                - 'q': quarter.
+                - 'y': year.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> s_native = pd.Series([datetime(2021, 3, 1, 12, 34)])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.dt.truncate("1h").to_native()
+            0   2021-03-01 12:00:00
+            dtype: datetime64[us]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.dt.truncate(every)
+        )
+
+    def offset_by(self, by: str) -> SeriesT:
+        """Offset this date by a relative time offset.
+
+        Arguments:
+            by: The offset. Must be of form `<multiple><unit>`,
+                where `multiple` is a positive integer and `unit` is one of
+
+                - 'ns': nanosecond.
+                - 'us': microsecond.
+                - 'ms': millisecond.
+                - 's': second.
+                - 'm': minute.
+                - 'h': hour.
+                - 'd': day.
+                - 'mo': month.
+                - 'q': quarter.
+                - 'y': year.
+
+        Examples:
+            >>> from datetime import datetime
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> s_native = pd.Series([datetime(2021, 3, 1, 12, 34)])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.dt.offset_by("1h").to_native()
+            0   2021-03-01 13:34:00
+            dtype: datetime64[us]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.dt.offset_by(by)
+        )

.venv_haddock/lib/python3.12/site-packages/narwhals/series_list.py

@@ -0,0 +1,247 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Generic
+
+from narwhals.typing import SeriesT
+
+if TYPE_CHECKING:
+    from narwhals.typing import NonNestedLiteral
+
+
+class SeriesListNamespace(Generic[SeriesT]):
+    def __init__(self, series: SeriesT) -> None:
+        self._narwhals_series = series
+
+    def len(self) -> SeriesT:
+        """Return the number of elements in each list.
+
+        Null values count towards the total.
+
+        Examples:
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> s_native = pa.chunked_array([[[1, 2], [3, 4, None], None, []]])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.list.len().to_native()  # doctest: +ELLIPSIS
+            <pyarrow.lib.ChunkedArray object at ...>
+            [
+              [
+                2,
+                3,
+                null,
+                0
+              ]
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.list.len()
+        )
+
+    def unique(self) -> SeriesT:
+        """Get the unique/distinct values in the list.
+
+        Null values are included in the result. The order of unique values is not guaranteed.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> s_native = pl.Series([[1, 1, 2], [3, 3, None], None, []])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.list.unique().to_native()  # doctest: +NORMALIZE_WHITESPACE
+            shape: (4,)
+            Series: '' [list[i64]]
+            [
+               [1, 2]
+               [null, 3]
+               null
+               []
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.list.unique()
+        )
+
+    def contains(self, item: NonNestedLiteral) -> SeriesT:
+        """Check if sublists contain the given item.
+
+        Arguments:
+            item: Item that will be checked for membership.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> s_native = pl.Series([[1, 2], None, []])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.list.contains(1).to_native()  # doctest: +NORMALIZE_WHITESPACE
+            shape: (3,)
+            Series: '' [bool]
+            [
+                    true
+                    null
+                    false
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.list.contains(item)
+        )
+
+    def get(self, index: int) -> SeriesT:
+        """Return the value by index in each list.
+
+        Negative indices are not accepted.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> s_native = pl.Series([[1, 2], [3, 4, None], [None, 5]])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.list.get(1).to_native()  # doctest: +NORMALIZE_WHITESPACE
+            shape: (3,)
+            Series: '' [i64]
+            [
+                    2
+                    4
+                    5
+            ]
+        """
+        if not isinstance(index, int):
+            msg = (
+                f"Index must be of type 'int'. Got type '{type(index).__name__}' instead."
+            )
+            raise TypeError(msg)
+
+        if index < 0:
+            msg = f"Index {index} is out of bounds: should be greater than or equal to 0."
+            raise ValueError(msg)
+
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.list.get(index)
+        )
+
+    def min(self) -> SeriesT:
+        """Compute the min value of the lists in the array.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> s_native = pl.Series([[1], [3, 4, None]])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.list.min().to_native()  # doctest: +NORMALIZE_WHITESPACE
+            shape: (2,)
+            Series: '' [i64]
+            [
+                    1
+                    3
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.list.min()
+        )
+
+    def max(self) -> SeriesT:
+        """Compute the max value of the lists in the array.
+
+        Examples:
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> s_native = pa.chunked_array([[[1], [3, 4, None]]])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.list.max().to_native()  # doctest: +ELLIPSIS
+            <pyarrow.lib.ChunkedArray object at ...>
+            [
+              [
+                1,
+                4
+              ]
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.list.max()
+        )
+
+    def mean(self) -> SeriesT:
+        """Compute the mean value of the lists in the array.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> s_native = pl.Series([[1], [3, 4, None]])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.list.mean().to_native()  # doctest: +NORMALIZE_WHITESPACE
+            shape: (2,)
+            Series: '' [f64]
+            [
+                    1.0
+                    3.5
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.list.mean()
+        )
+
+    def median(self) -> SeriesT:
+        """Compute the median value of the lists in the array.
+
+        Examples:
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> s_native = pa.chunked_array([[[1], [3, 4, None]]])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.list.median().to_native()  # doctest: +ELLIPSIS
+            <pyarrow.lib.ChunkedArray object at ...>
+            [
+              [
+                1,
+                3
+              ]
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.list.median()
+        )
+
+    def sum(self) -> SeriesT:
+        """Compute the sum value of the lists in the array.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> s_native = pl.Series([[1], [3, 4, None]])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.list.sum().to_native()  # doctest: +NORMALIZE_WHITESPACE
+            shape: (2,)
+            Series: '' [i64]
+            [
+                    1
+                    7
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.list.sum()
+        )
+
+    def sort(self, *, descending: bool = False, nulls_last: bool = False) -> SeriesT:
+        """Sort the lists of the series.
+
+        Arguments:
+            descending: Sort in descending order.
+            nulls_last: Place null values last.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> s_native = pl.Series([[2, -1, 1], [3, -4, None]])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.list.sort().to_native()  # doctest: +NORMALIZE_WHITESPACE
+            shape: (2,)
+            Series: '' [list[i64]]
+            [
+                    [-1, 1, 2]
+                    [null, -4, 3]
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.list.sort(
+                descending=descending, nulls_last=nulls_last
+            )
+        )

.venv_haddock/lib/python3.12/site-packages/narwhals/series_str.py

@@ -0,0 +1,519 @@
+from __future__ import annotations
+
+from typing import Any, Generic
+
+from narwhals.dependencies import is_narwhals_series
+from narwhals.typing import SeriesT
+
+
+class SeriesStringNamespace(Generic[SeriesT]):
+    def __init__(self, series: SeriesT) -> None:
+        self._narwhals_series = series
+
+    def len_chars(self) -> SeriesT:
+        r"""Return the length of each string as the number of characters.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> s_native = pl.Series(["foo", "345", None])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.str.len_chars().to_native()  # doctest: +NORMALIZE_WHITESPACE
+            shape: (3,)
+            Series: '' [u32]
+            [
+                    3
+                    3
+                    null
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.str.len_chars()
+        )
+
+    def _extract_compliant(self, arg: Any) -> Any:
+        return arg._compliant_series if is_narwhals_series(arg) else arg
+
+    def replace(
+        self, pattern: str, value: str | SeriesT, *, literal: bool = False, n: int = 1
+    ) -> SeriesT:
+        r"""Replace first matching regex/literal substring with a new string value.
+
+        Arguments:
+            pattern: A valid regular expression pattern.
+            value: String that will replace the matched substring.
+            literal: Treat `pattern` as a literal string.
+            n: Number of matches to replace.
+
+        Examples:
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> s_native = pd.Series(["123abc", "abc abc123"])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.str.replace("abc", "").to_native()
+            0        123
+            1     abc123
+            dtype: str
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.str.replace(
+                self._extract_compliant(value), pattern=pattern, literal=literal, n=n
+            )
+        )
+
+    def replace_all(
+        self, pattern: str, value: str | SeriesT, *, literal: bool = False
+    ) -> SeriesT:
+        r"""Replace all matching regex/literal substring with a new string value.
+
+        Arguments:
+            pattern: A valid regular expression pattern.
+            value: String that will replace the matched substring.
+            literal: Treat `pattern` as a literal string.
+
+        Examples:
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> s_native = pd.Series(["123abc", "abc abc123"])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.str.replace_all("abc", "").to_native()
+            0     123
+            1     123
+            dtype: str
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.str.replace_all(
+                self._extract_compliant(value), pattern, literal=literal
+            )
+        )
+
+    def strip_chars(self, characters: str | None = None) -> SeriesT:
+        r"""Remove leading and trailing characters.
+
+        Arguments:
+            characters: The set of characters to be removed. All combinations of this set of characters will be stripped from the start and end of the string. If set to None (default), all leading and trailing whitespace is removed instead.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> s_native = pl.Series(["apple", "\nmango"])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.str.strip_chars().to_native()  # doctest: +NORMALIZE_WHITESPACE
+            shape: (2,)
+            Series: '' [str]
+            [
+                    "apple"
+                    "mango"
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.str.strip_chars(characters)
+        )
+
+    def starts_with(self, prefix: str) -> SeriesT:
+        r"""Check if string values start with a substring.
+
+        Arguments:
+            prefix: prefix substring
+
+        Examples:
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> s_native = pd.Series(["apple", "mango", None])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.str.starts_with("app").to_native()
+            0     True
+            1    False
+            2    False
+            dtype: bool
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.str.starts_with(prefix)
+        )
+
+    def ends_with(self, suffix: str) -> SeriesT:
+        r"""Check if string values end with a substring.
+
+        Arguments:
+            suffix: suffix substring
+
+        Examples:
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> s_native = pd.Series(["apple", "mango", None])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.str.ends_with("ngo").to_native()
+            0    False
+            1     True
+            2    False
+            dtype: bool
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.str.ends_with(suffix)
+        )
+
+    def contains(self, pattern: str | SeriesT, *, literal: bool = False) -> SeriesT:
+        r"""Check if string contains a substring that matches a pattern.
+
+        Arguments:
+            pattern: A Character sequence, valid regular expression pattern, or another
+                Series.
+            literal: If True, treats the pattern as a literal string.
+                If False, assumes the pattern is a regular expression.
+
+        Warning:
+            Passing a Series as `pattern` is only supported by Polars. Other backends
+            will raise a `TypeError`.
+
+        Examples:
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> s_native = pa.chunked_array([["cat", "dog", "rabbit and parrot"]])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.str.contains("cat|parrot").to_native()  # doctest: +ELLIPSIS
+            <pyarrow.lib.ChunkedArray object at ...>
+            [
+              [
+                true,
+                false,
+                true
+              ]
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.str.contains(
+                self._extract_compliant(pattern), literal=literal
+            )
+        )
+
+    def slice(self, offset: int, length: int | None = None) -> SeriesT:
+        r"""Create subslices of the string values of a Series.
+
+        Arguments:
+            offset: Start index. Negative indexing is supported.
+            length: Length of the slice. If set to `None` (default), the slice is taken to the
+                end of the string.
+
+        Examples:
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> s_native = pd.Series(["pear", None, "papaya"])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.str.slice(4, 3).to_native()  # doctest: +NORMALIZE_WHITESPACE
+            0
+            1    NaN
+            2     ya
+            dtype: str
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.str.slice(
+                offset=offset, length=length
+            )
+        )
+
+    def split(self, by: str) -> SeriesT:
+        r"""Split the string values of a Series by a substring.
+
+        Arguments:
+            by: Substring to split by.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> s_native = pl.Series(["foo bar", "foo_bar"])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.str.split("_").to_native()  # doctest: +NORMALIZE_WHITESPACE
+            shape: (2,)
+            Series: '' [list[str]]
+            [
+                    ["foo bar"]
+                    ["foo", "bar"]
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.str.split(by=by)
+        )
+
+    def head(self, n: int = 5) -> SeriesT:
+        r"""Take the first n elements of each string.
+
+        Arguments:
+            n: Number of elements to take. Negative indexing is supported (see note (1.))
+
+        Notes:
+            1. When the `n` input is negative, `head` returns characters up to the n-th from the end of the string.
+            For example, if `n = -3`, then all characters except the last three are returned.
+            2. If the length of the string has fewer than `n` characters, the full string is returned.
+
+        Examples:
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> s_native = pa.chunked_array([["taata", "taatatata", "zukkyun"]])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.str.head().to_native()  # doctest: +ELLIPSIS
+            <pyarrow.lib.ChunkedArray object at ...>
+            [
+              [
+                "taata",
+                "taata",
+                "zukky"
+              ]
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.str.slice(offset=0, length=n)
+        )
+
+    def tail(self, n: int = 5) -> SeriesT:
+        r"""Take the last n elements of each string.
+
+        Arguments:
+            n: Number of elements to take. Negative indexing is supported (see note (1.))
+
+        Notes:
+            1. When the `n` input is negative, `tail` returns characters starting from the n-th from the beginning of
+            the string. For example, if `n = -3`, then all characters except the first three are returned.
+            2. If the length of the string has fewer than `n` characters, the full string is returned.
+
+        Examples:
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> s_native = pa.chunked_array([["taata", "taatatata", "zukkyun"]])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.str.tail().to_native()  # doctest: +ELLIPSIS
+            <pyarrow.lib.ChunkedArray object at ...>
+            [
+              [
+                "taata",
+                "atata",
+                "kkyun"
+              ]
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.str.slice(offset=-n, length=None)
+        )
+
+    def to_uppercase(self) -> SeriesT:
+        r"""Transform string to uppercase variant.
+
+        Notes:
+            The PyArrow backend will convert 'ß' to 'ẞ' instead of 'SS'.
+            For more info see: https://github.com/apache/arrow/issues/34599
+            There may be other unicode-edge-case-related variations across implementations.
+
+        Examples:
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> s_native = pd.Series(["apple", None])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.str.to_uppercase().to_native()
+            0    APPLE
+            1      NaN
+            dtype: str
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.str.to_uppercase()
+        )
+
+    def to_lowercase(self) -> SeriesT:
+        r"""Transform string to lowercase variant.
+
+        Examples:
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> s_native = pd.Series(["APPLE", None])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.str.to_lowercase().to_native()
+            0    apple
+            1      NaN
+            dtype: str
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.str.to_lowercase()
+        )
+
+    def to_datetime(self, format: str | None = None) -> SeriesT:
+        """Parse Series with strings to a Series with Datetime dtype.
+
+        Notes:
+            - pandas defaults to nanosecond time unit, Polars to microsecond.
+              Prior to pandas 2.0, nanoseconds were the only time unit supported
+              in pandas, with no ability to set any other one. The ability to
+              set the time unit in pandas, if the version permits, will arrive.
+            - timezone-aware strings are all converted to and parsed as UTC.
+
+        Warning:
+            As different backends auto-infer format in different ways, if `format=None`
+            there is no guarantee that the result will be equal.
+
+        Arguments:
+            format: Format to use for conversion. If set to None (default), the format is
+                inferred from the data.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> s_native = pl.Series(["2020-01-01", "2020-01-02"])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.str.to_datetime(
+            ...     format="%Y-%m-%d"
+            ... ).to_native()  # doctest: +NORMALIZE_WHITESPACE
+            shape: (2,)
+            Series: '' [datetime[μs]]
+            [
+                    2020-01-01 00:00:00
+                    2020-01-02 00:00:00
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.str.to_datetime(format=format)
+        )
+
+    def to_date(self, format: str | None = None) -> SeriesT:
+        """Convert to date dtype.
+
+        Warning:
+            As different backends auto-infer format in different ways, if `format=None`
+            there is no guarantee that the result will be equal.
+
+        Arguments:
+            format: Format to use for conversion. If set to None (default), the format is
+                inferred from the data.
+
+        Examples:
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> s_native = pa.chunked_array([["2020-01-01", "2020-01-02"]])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.str.to_date(format="%Y-%m-%d").to_native()  # doctest: +ELLIPSIS
+            <pyarrow.lib.ChunkedArray object at ...>
+            [
+              [
+                2020-01-01,
+                2020-01-02
+              ]
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.str.to_date(format=format)
+        )
+
+    def to_titlecase(self) -> SeriesT:
+        """Modify strings to their titlecase equivalent.
+
+        Notes:
+            This is a form of case transform where the first letter of each word is
+            capitalized, with the rest of the word in lowercase.
+
+            Word boundaries are defined by non-**alphabetic** characters, matching the
+            behavior of [`str.title`](https://docs.python.org/3/library/stdtypes.html#str.title)
+
+        Examples:
+            >>> import pyarrow as pa
+            >>> import narwhals as nw
+            >>> s_native = pa.chunked_array(
+            ...     [
+            ...         [
+            ...             "'e.t. phone home'",
+            ...             "you talkin' to me?",
+            ...             "to infinity,and BEYOND!",
+            ...         ]
+            ...     ]
+            ... )
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.str.to_titlecase().to_native()  # doctest: +ELLIPSIS
+            <pyarrow.lib.ChunkedArray object at ...>
+            [
+              [
+                "'E.T. Phone Home'",
+                "You Talkin' To Me?",
+                "To Infinity,And Beyond!"
+              ]
+            ]
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.str.to_titlecase()
+        )
+
+    def zfill(self, width: int) -> SeriesT:
+        r"""Pad strings with zeros on the left.
+
+        Arguments:
+            width: The target width of the string. If the string is shorter than this width, it will be padded with zeros on the left.
+
+        Examples:
+            >>> import pandas as pd
+            >>> import narwhals as nw
+            >>> s_native = pd.Series(["+1", "-23", "456", "123456"])
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.str.zfill(5).to_native()
+            0     +0001
+            1     -0023
+            2     00456
+            3    123456
+            dtype: str
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.str.zfill(width)
+        )
+
+    def pad_start(self, length: int, fill_char: str = " ") -> SeriesT:
+        """Pad the start of the string until it reaches the given length.
+
+        Arguments:
+            length: Pad the string until it reaches this length. Strings with
+                length equal to or greater than this value are returned as-is.
+            fill_char: The character to pad the string with.
+
+        Examples:
+        >>> import pandas as pd
+        >>> import narwhals as nw
+        >>> df_native = pd.DataFrame({"a": ["cow", "monkey", "hippopotamus", None]})
+        >>> df = nw.from_native(df_native)
+        >>> df["a"].str.pad_start(8, "*")
+        ┌───────────────────┐
+        |  Narwhals Series  |
+        |-------------------|
+        |0        *****cow  |
+        |1        **monkey  |
+        |2    hippopotamus  |
+        |3             NaN  |
+        |Name: a, dtype: str|
+        └───────────────────┘
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.str.pad_start(
+                length=length, fill_char=fill_char
+            )
+        )
+
+    def pad_end(self, length: int, fill_char: str = " ") -> SeriesT:
+        """Pad the end of the string until it reaches the given length.
+
+        Arguments:
+            length: Pad the string until it reaches this length. Strings with
+                length equal to or greater than this value are returned as-is.
+            fill_char: The character to pad the string with.
+
+        Examples:
+        >>> import pandas as pd
+        >>> import narwhals as nw
+        >>> df_native = pd.DataFrame({"a": ["cow", "monkey", "hippopotamus", None]})
+        >>> df = nw.from_native(df_native)
+        >>> df["a"].str.pad_end(8, "*")
+        ┌───────────────────┐
+        |  Narwhals Series  |
+        |-------------------|
+        |0        cow*****  |
+        |1        monkey**  |
+        |2    hippopotamus  |
+        |3             NaN  |
+        |Name: a, dtype: str|
+        └───────────────────┘
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.str.pad_end(
+                length=length, fill_char=fill_char
+            )
+        )

.venv_haddock/lib/python3.12/site-packages/narwhals/series_struct.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import Generic
+
+from narwhals.typing import SeriesT
+
+
+class SeriesStructNamespace(Generic[SeriesT]):
+    def __init__(self, series: SeriesT) -> None:
+        self._narwhals_series = series
+
+    def field(self, name: str) -> SeriesT:
+        r"""Retrieve a Struct field as a new expression.
+
+        Arguments:
+            name: Name of the struct field to retrieve.
+
+        Examples:
+            >>> import polars as pl
+            >>> import narwhals as nw
+            >>> s_native = pl.Series(
+            ...     [{"id": "0", "name": "john"}, {"id": "1", "name": "jane"}]
+            ... )
+            >>> s = nw.from_native(s_native, series_only=True)
+            >>> s.struct.field("name").to_list()
+            ['john', 'jane']
+        """
+        return self._narwhals_series._with_compliant(
+            self._narwhals_series._compliant_series.struct.field(name)
+        )

.venv_haddock/lib/python3.12/site-packages/narwhals/sql.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal
+
+from narwhals._duckdb.utils import DeferredTimeZone, narwhals_to_native_dtype
+from narwhals.dataframe import LazyFrame
+from narwhals.translate import from_native
+from narwhals.utils import Version
+
+if TYPE_CHECKING:
+    from narwhals._compliant.typing import CompliantLazyFrameAny
+    from narwhals.typing import IntoSchema
+
+try:
+    import duckdb  # ignore-banned-import
+except ImportError as _exc:  # pragma: no cover
+    msg = (
+        "`narwhals.sql` requires DuckDB to be installed.\n\n"
+        "Hint: run `pip install -U narwhals[sql]`"
+    )
+    raise ModuleNotFoundError(msg) from _exc
+
+CONN = duckdb.connect()
+TZ = DeferredTimeZone(
+    CONN.sql("select value from duckdb_settings() where name = 'TimeZone'")
+)
+
+
+class SQLTable(LazyFrame[duckdb.DuckDBPyRelation]):
+    """A LazyFrame with an additional `to_sql` method."""
+
+    def __init__(
+        self, df: CompliantLazyFrameAny, level: Literal["full", "interchange", "lazy"]
+    ) -> None:
+        super().__init__(df, level=level)
+
+    def to_sql(self, *, pretty: bool = False) -> str:
+        """Convert to SQL query.
+
+        Arguments:
+            pretty: Whether to pretty-print SQL query. If `True`, requires `sqlparse`
+                to be installed.
+
+        Examples:
+            >>> import narwhals as nw
+            >>> from narwhals.sql import table
+            >>> schema = {"date": nw.Date, "price": nw.Int64, "symbol": nw.String}
+            >>> assets = table("assets", schema)
+            >>> result = assets.filter(nw.col("price") > 100)
+            >>> print(result.to_sql())
+            SELECT * FROM main.assets WHERE (price > 100)
+        """
+        sql_query = self.to_native().sql_query()
+        if not pretty:
+            return sql_query
+        try:
+            import sqlparse
+        except ImportError as _exc:  # pragma: no cover
+            msg = (
+                "`SQLTable.to_sql` with `pretty=True`"
+                "requires `sqlparse` to be installed.\n\n"
+                "Hint: run `pip install -U narwhals[sql]`"
+            )
+            raise ModuleNotFoundError(msg) from _exc
+        return sqlparse.format(sql_query, reindent=True, keyword_case="upper")  # type: ignore[no-any-return]
+
+
+def table(name: str, schema: IntoSchema) -> SQLTable:
+    """Generate standalone LazyFrame which you can use to generate SQL.
+
+    Note that this requires DuckDB to be installed.
+
+    Parameters:
+        name: Table name.
+        schema: Table schema.
+
+    Examples:
+        >>> import narwhals as nw
+        >>> from narwhals.sql import table
+        >>> schema = {"date": nw.Date, "price": nw.List(nw.Int64), "symbol": nw.String}
+        >>> table("t", schema)
+        ┌────────────────────────────┐
+        |     Narwhals LazyFrame     |
+        |----------------------------|
+        |┌──────┬─────────┬─────────┐|
+        |│ date │  price  │ symbol  │|
+        |│ date │ int64[] │ varchar │|
+        |└──────┴─────────┴─────────┘|
+        |           0 rows           |
+        └────────────────────────────┘
+    """
+    column_mapping = {
+        col: narwhals_to_native_dtype(dtype, Version.MAIN, TZ)
+        for col, dtype in schema.items()
+    }
+    dtypes = ", ".join(f'"{col}" {dtype}' for col, dtype in column_mapping.items())
+    CONN.sql(f"""
+        CREATE TABLE "{name}"
+        ({dtypes});
+        """)
+    lf = from_native(CONN.table(name))
+    return SQLTable(lf._compliant_frame, level=lf._level)
+
+
+__all__ = ["table"]

.venv_haddock/lib/python3.12/site-packages/narwhals/stable/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from narwhals.stable import v1, v2
+
+__all__ = ["v1", "v2"]

.venv_haddock/lib/python3.12/site-packages/narwhals/stable/v1/__init__.py

@@ -0,0 +1,1156 @@
+from __future__ import annotations
+
+from functools import wraps
+from typing import TYPE_CHECKING, Any, Callable, Final, Literal, cast, overload
+
+import narwhals as nw
+from narwhals import exceptions, functions as nw_f
+from narwhals._exceptions import issue_warning
+from narwhals._expression_parsing import ExprKind, ExprNode, is_expr
+from narwhals._typing_compat import TypeVar, assert_never
+from narwhals._utils import (
+    Implementation,
+    Version,
+    deprecate_native_namespace,
+    generate_temporary_column_name,
+    inherit_doc,
+    is_ordered_categorical,
+    maybe_align_index,
+    maybe_convert_dtypes,
+    maybe_get_index,
+    maybe_reset_index,
+    maybe_set_index,
+    validate_strict_and_pass_though,
+)
+from narwhals.dataframe import DataFrame as NwDataFrame, LazyFrame as NwLazyFrame
+from narwhals.exceptions import InvalidIntoExprError, NarwhalsUnstableWarning
+from narwhals.expr import Expr as NwExpr
+from narwhals.functions import _new_series_impl, concat, show_versions
+from narwhals.schema import Schema as NwSchema
+from narwhals.series import Series as NwSeries
+from narwhals.stable.v1 import dependencies, dtypes, selectors
+from narwhals.stable.v1.dtypes import (
+    Array,
+    Binary,
+    Boolean,
+    Categorical,
+    Date,
+    Datetime,
+    Decimal,
+    Duration,
+    Enum,
+    Field,
+    Float32,
+    Float64,
+    Int8,
+    Int16,
+    Int32,
+    Int64,
+    Int128,
+    List,
+    Object,
+    String,
+    Struct,
+    Time,
+    UInt8,
+    UInt16,
+    UInt32,
+    UInt64,
+    UInt128,
+    Unknown,
+)
+from narwhals.stable.v1.typing import (
+    DataFrameT,
+    IntoDataFrameT,
+    IntoFrame,
+    IntoLazyFrameT,
+    IntoSeries,
+    IntoSeriesT,
+    LazyFrameT,
+    SeriesT,
+)
+from narwhals.translate import _from_native_impl, get_native_namespace, to_py_scalar
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Mapping, Sequence
+    from types import ModuleType
+
+    from typing_extensions import ParamSpec, Self, Unpack
+
+    from narwhals._expression_parsing import ExprMetadata
+    from narwhals._translate import (
+        AllowAnyStrictV1 as AllowAnyStrict,
+        AllowAnyV1 as AllowAny,
+        AllowLazyStrictV1 as AllowLazyStrict,
+        AllowLazyV1 as AllowLazy,
+        AllowSeriesStrictV1 as AllowSeriesStrict,
+        AllowSeriesV1 as AllowSeries,
+        ExcludeSeriesStrictV1 as ExcludeSeriesStrict,
+        ExcludeSeriesV1 as ExcludeSeries,
+        IntoArrowTable,
+        OnlyEagerOrInterchange,
+        OnlyEagerOrInterchangeStrict,
+        OnlySeriesStrictV1 as OnlySeriesStrict,
+        OnlySeriesV1 as OnlySeries,
+        PassThroughUnknownV1 as PassThroughUnknown,
+        StrictUnknownV1 as StrictUnknown,
+    )
+    from narwhals._typing import (
+        Arrow,
+        Backend,
+        EagerAllowed,
+        IntoBackend,
+        LazyAllowed,
+        Pandas,
+        Polars,
+    )
+    from narwhals.dataframe import MultiColSelector, MultiIndexSelector
+    from narwhals.dtypes import DType
+    from narwhals.typing import (
+        FileSource,
+        IntoDType,
+        IntoExpr,
+        IntoSchema,
+        NonNestedLiteral,
+        PythonLiteral,
+        SingleColSelector,
+        SingleIndexSelector,
+        _1DArray,
+        _2DArray,
+    )
+
+    T = TypeVar("T", default=Any)
+    P = ParamSpec("P")
+    R = TypeVar("R")
+
+
+# NOTE legit
+class DataFrame(NwDataFrame[IntoDataFrameT]):  # type: ignore[type-var]
+    _version = Version.V1
+
+    @inherit_doc(NwDataFrame)
+    def __init__(self, df: Any, *, level: Literal["full", "lazy", "interchange"]) -> None:
+        assert df._version is Version.V1  # noqa: S101
+        super().__init__(df, level=level)
+
+    # We need to override any method which don't return Self so that type
+    # annotations are correct.
+
+    @classmethod
+    def from_arrow(
+        cls, native_frame: IntoArrowTable, *, backend: IntoBackend[EagerAllowed]
+    ) -> DataFrame[Any]:
+        result = super().from_arrow(native_frame, backend=backend)
+        return cast("DataFrame[Any]", result)
+
+    @classmethod
+    def from_dict(
+        cls,
+        data: Mapping[str, Any],
+        schema: IntoSchema | Mapping[str, DType | None] | None = None,
+        *,
+        backend: IntoBackend[EagerAllowed] | None = None,
+    ) -> DataFrame[Any]:
+        result = super().from_dict(data, schema, backend=backend)
+        return cast("DataFrame[Any]", result)
+
+    @classmethod
+    def from_dicts(
+        cls,
+        data: Sequence[Any],
+        schema: IntoSchema | Mapping[str, DType | None] | None = None,
+        *,
+        backend: IntoBackend[EagerAllowed],
+    ) -> DataFrame[Any]:
+        result = super().from_dicts(data, schema, backend=backend)
+        return cast("DataFrame[Any]", result)
+
+    @classmethod
+    def from_numpy(
+        cls,
+        data: _2DArray,
+        schema: Mapping[str, DType] | Schema | Sequence[str] | None = None,
+        *,
+        backend: IntoBackend[EagerAllowed],
+    ) -> DataFrame[Any]:
+        result = super().from_numpy(data, schema, backend=backend)
+        return cast("DataFrame[Any]", result)
+
+    @property
+    def _series(self) -> type[Series[Any]]:
+        return cast("type[Series[Any]]", Series)
+
+    @property
+    def _lazyframe(self) -> type[LazyFrame[Any]]:
+        return cast("type[LazyFrame[Any]]", LazyFrame)
+
+    @overload
+    def __getitem__(self, item: tuple[SingleIndexSelector, SingleColSelector]) -> Any: ...
+
+    @overload
+    def __getitem__(  # type: ignore[overload-overlap]
+        self, item: str | tuple[MultiIndexSelector, SingleColSelector]
+    ) -> Series[Any]: ...
+
+    @overload
+    def __getitem__(
+        self,
+        item: (
+            SingleIndexSelector
+            | MultiIndexSelector
+            | MultiColSelector
+            | tuple[SingleIndexSelector, MultiColSelector]
+            | tuple[MultiIndexSelector, MultiColSelector]
+        ),
+    ) -> Self: ...
+    def __getitem__(
+        self,
+        item: (
+            SingleIndexSelector
+            | SingleColSelector
+            | MultiColSelector
+            | MultiIndexSelector
+            | tuple[SingleIndexSelector, SingleColSelector]
+            | tuple[SingleIndexSelector, MultiColSelector]
+            | tuple[MultiIndexSelector, SingleColSelector]
+            | tuple[MultiIndexSelector, MultiColSelector]
+        ),
+    ) -> Series[Any] | Self | Any:
+        return super().__getitem__(item)
+
+    def get_column(self, name: str) -> Series:
+        # Type checkers complain that `nw.Series` is not assignable to `nw.v1.stable.Series`.
+        # However the return type actually is `nw.v1.stable.Series`, check `tests/v1_test.py`.
+        return super().get_column(name)  # type: ignore[return-value]
+
+    def lazy(
+        self,
+        backend: IntoBackend[LazyAllowed] | None = None,
+        *,
+        session: Any | None = None,
+    ) -> LazyFrame[Any]:
+        return _stableify(super().lazy(backend=backend, session=session))
+
+    @overload  # type: ignore[override]
+    def to_dict(self, *, as_series: Literal[True] = ...) -> dict[str, Series[Any]]: ...
+    @overload
+    def to_dict(self, *, as_series: Literal[False]) -> dict[str, list[Any]]: ...
+    @overload
+    def to_dict(
+        self, *, as_series: bool = True
+    ) -> dict[str, Series[Any]] | dict[str, list[Any]]: ...
+    def to_dict(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, *, as_series: bool = True
+    ) -> dict[str, Series[Any]] | dict[str, list[Any]]:
+        # Type checkers complain that `nw.Series` is not assignable to `nw.v1.stable.Series`.
+        # However the return type actually is `nw.v1.stable.Series`, check `tests/v1_test.py::test_to_dict_as_series`.
+        return super().to_dict(as_series=as_series)  # type: ignore[return-value]
+
+    def is_duplicated(self) -> Series[Any]:
+        return _stableify(super().is_duplicated())
+
+    def is_unique(self) -> Series[Any]:
+        return _stableify(super().is_unique())
+
+    def _l1_norm(self) -> Self:
+        # Private, just used to test the stable API.
+        return self.select(all()._l1_norm())
+
+
+class LazyFrame(NwLazyFrame[IntoLazyFrameT]):
+    _version = Version.V1
+
+    @inherit_doc(NwLazyFrame)
+    def __init__(self, df: Any, *, level: Literal["full", "lazy", "interchange"]) -> None:
+        assert df._version is Version.V1  # noqa: S101
+        super().__init__(df, level=level)
+
+    @property
+    def _dataframe(self) -> type[DataFrame[Any]]:
+        return DataFrame
+
+    def _validate_metadata(self, metadata: ExprMetadata) -> None:
+        # After v1, we raise for order-dependent operations.
+        pass
+
+    def collect(
+        self, backend: IntoBackend[Polars | Pandas | Arrow] | None = None, **kwargs: Any
+    ) -> DataFrame[Any]:
+        return _stableify(super().collect(backend=backend, **kwargs))
+
+    def _l1_norm(self) -> Self:
+        # Private, just used to test the stable API.
+        return self.select(all()._l1_norm())
+
+    def tail(self, n: int = 5) -> Self:
+        r"""Get the last `n` rows."""
+        return super().tail(n)
+
+    def gather_every(self, n: int, offset: int = 0) -> Self:
+        r"""Take every nth row in the DataFrame and return as a new DataFrame.
+
+        Arguments:
+            n: Gather every *n*-th row.
+            offset: Starting index.
+        """
+        return self._with_compliant(
+            self._compliant_frame.gather_every(n=n, offset=offset)  # type: ignore[attr-defined]
+        )
+
+    def with_row_index(
+        self, name: str = "index", *, order_by: str | Sequence[str] | None = None
+    ) -> Self:
+        order_by_ = [order_by] if isinstance(order_by, str) else order_by
+        return self._with_compliant(
+            self._compliant_frame.with_row_index(
+                name=name,
+                order_by=order_by_,  # type: ignore[arg-type]
+            )
+        )
+
+
+class Series(NwSeries[IntoSeriesT]):
+    _version = Version.V1
+
+    @inherit_doc(NwSeries)
+    def __init__(
+        self, series: Any, *, level: Literal["full", "lazy", "interchange"]
+    ) -> None:
+        assert series._version is Version.V1  # noqa: S101
+        super().__init__(series, level=level)
+
+    # We need to override any method which don't return Self so that type
+    # annotations are correct.
+
+    @classmethod
+    def from_numpy(
+        cls,
+        name: str,
+        values: _1DArray,
+        dtype: IntoDType | None = None,
+        *,
+        backend: IntoBackend[EagerAllowed],
+    ) -> Series[Any]:
+        result = super().from_numpy(name, values, dtype, backend=backend)
+        return cast("Series[Any]", result)
+
+    @classmethod
+    def from_iterable(
+        cls,
+        name: str,
+        values: Iterable[Any],
+        dtype: IntoDType | None = None,
+        *,
+        backend: IntoBackend[EagerAllowed],
+    ) -> Series[Any]:
+        result = super().from_iterable(name, values, dtype, backend=backend)
+        return cast("Series[Any]", result)
+
+    @property
+    def _dataframe(self) -> type[DataFrame[Any]]:
+        return DataFrame
+
+    def to_frame(self) -> DataFrame[Any]:
+        return _stableify(super().to_frame())
+
+    def value_counts(
+        self,
+        *,
+        sort: bool = False,
+        parallel: bool = False,
+        name: str | None = None,
+        normalize: bool = False,
+    ) -> DataFrame[Any]:
+        return _stableify(
+            super().value_counts(
+                sort=sort, parallel=parallel, name=name, normalize=normalize
+            )
+        )
+
+    def hist(
+        self,
+        bins: list[float] | None = None,
+        *,
+        bin_count: int | None = None,
+        include_breakpoint: bool = True,
+    ) -> DataFrame[Any]:
+        msg = (
+            "`Series.hist` is being called from the stable API although considered "
+            "an unstable feature."
+        )
+        issue_warning(msg, NarwhalsUnstableWarning)
+        return _stableify(
+            super().hist(
+                bins=bins, bin_count=bin_count, include_breakpoint=include_breakpoint
+            )
+        )
+
+    def any_value(self, *, ignore_nulls: bool = False) -> PythonLiteral:
+        msg = (
+            "`Series.any_value` is being called from the stable API although considered "
+            "an unstable feature."
+        )
+        issue_warning(msg, NarwhalsUnstableWarning)
+        return super().any_value(ignore_nulls=ignore_nulls)
+
+
+class Expr(NwExpr):
+    def _l1_norm(self) -> Self:
+        return super()._taxicab_norm()
+
+    def head(self, n: int = 10) -> Self:
+        r"""Get the first `n` rows."""
+        return self._append_node(ExprNode(ExprKind.ORDERABLE_FILTRATION, "head", n=n))
+
+    def tail(self, n: int = 10) -> Self:
+        r"""Get the last `n` rows."""
+        return self._append_node(ExprNode(ExprKind.ORDERABLE_FILTRATION, "tail", n=n))
+
+    def gather_every(self, n: int, offset: int = 0) -> Self:
+        r"""Take every nth value in the Series and return as new Series.
+
+        Arguments:
+            n: Gather every *n*-th row.
+            offset: Starting index.
+        """
+        return self._append_node(
+            ExprNode(ExprKind.ORDERABLE_FILTRATION, "gather_every", n=n, offset=offset)
+        )
+
+    def unique(self, *, maintain_order: bool | None = None) -> Self:
+        """Return unique values of this expression."""
+        if maintain_order is not None:
+            msg = (
+                "`maintain_order` has no effect and is only kept around for backwards-compatibility. "
+                "You can safely remove this argument."
+            )
+            issue_warning(msg, UserWarning)
+        return self._append_node(ExprNode(ExprKind.FILTRATION, "unique"))
+
+    def sort(self, *, descending: bool = False, nulls_last: bool = False) -> Self:
+        """Sort this column. Place null values first."""
+        return self._append_node(
+            ExprNode(
+                ExprKind.WINDOW, "sort", descending=descending, nulls_last=nulls_last
+            )
+        )
+
+    def arg_max(self) -> Self:
+        """Returns the index of the maximum value."""
+        return self._append_node(ExprNode(ExprKind.ORDERABLE_AGGREGATION, "arg_max"))
+
+    def arg_min(self) -> Self:
+        """Returns the index of the minimum value."""
+        return self._append_node(ExprNode(ExprKind.ORDERABLE_AGGREGATION, "arg_min"))
+
+    def arg_true(self) -> Self:
+        """Find elements where boolean expression is True."""
+        return self._append_node(ExprNode(ExprKind.ORDERABLE_FILTRATION, "arg_true"))
+
+    def first(self) -> Self:  # type: ignore[override]
+        """Get the first value."""
+        return self._append_node(ExprNode(ExprKind.ORDERABLE_AGGREGATION, "first"))
+
+    def last(self) -> Self:  # type: ignore[override]
+        """Get the last value."""
+        return self._append_node(ExprNode(ExprKind.ORDERABLE_AGGREGATION, "last"))
+
+    def sample(
+        self,
+        n: int | None = None,
+        *,
+        fraction: float | None = None,
+        with_replacement: bool = False,
+        seed: int | None = None,
+    ) -> Self:
+        """Sample randomly from this expression.
+
+        Arguments:
+            n: Number of items to return. Cannot be used with fraction.
+            fraction: Fraction of items to return. Cannot be used with n.
+            with_replacement: Allow values to be sampled more than once.
+            seed: Seed for the random number generator. If set to None (default), a random
+                seed is generated for each sample operation.
+        """
+        return self._append_node(
+            ExprNode(
+                ExprKind.FILTRATION,
+                "sample",
+                n=n,
+                fraction=fraction,
+                with_replacement=with_replacement,
+                seed=seed,
+            )
+        )
+
+    def any_value(self, *, ignore_nulls: bool = False) -> Self:
+        msg = (
+            "`Expr.any_value` is being called from the stable API although considered "
+            "an unstable feature."
+        )
+        issue_warning(msg, NarwhalsUnstableWarning)
+        return self._append_node(
+            ExprNode(ExprKind.AGGREGATION, "any_value", ignore_nulls=ignore_nulls)
+        )
+
+
+class Schema(NwSchema):
+    _version = Version.V1
+
+    @inherit_doc(NwSchema)
+    def __init__(
+        self, schema: Mapping[str, DType] | Iterable[tuple[str, DType]] | None = None
+    ) -> None:
+        super().__init__(schema)
+
+
+@overload
+def _stableify(obj: NwDataFrame[IntoDataFrameT]) -> DataFrame[IntoDataFrameT]: ...  # type: ignore[type-var]
+@overload
+def _stableify(obj: NwLazyFrame[IntoLazyFrameT]) -> LazyFrame[IntoLazyFrameT]: ...
+@overload
+def _stableify(obj: NwSeries[IntoSeriesT]) -> Series[IntoSeriesT]: ...
+@overload
+def _stableify(obj: NwExpr) -> Expr: ...
+
+
+def _stableify(
+    obj: NwDataFrame[IntoDataFrameT]  # type: ignore[type-var]
+    | NwLazyFrame[IntoLazyFrameT]
+    | NwSeries[IntoSeriesT]
+    | NwExpr,
+) -> DataFrame[IntoDataFrameT] | LazyFrame[IntoLazyFrameT] | Series[IntoSeriesT] | Expr:
+    if isinstance(obj, NwDataFrame):
+        return DataFrame(obj._compliant_frame._with_version(Version.V1), level=obj._level)
+    if isinstance(obj, NwLazyFrame):
+        return LazyFrame(obj._compliant_frame._with_version(Version.V1), level=obj._level)
+    if isinstance(obj, NwSeries):
+        return Series(obj._compliant_series._with_version(Version.V1), level=obj._level)
+    if isinstance(obj, NwExpr):
+        return Expr(*obj._nodes)
+    assert_never(obj)
+
+
+@overload
+def from_native(native_object: SeriesT, **kwds: Unpack[OnlySeries]) -> SeriesT: ...
+@overload
+def from_native(native_object: SeriesT, **kwds: Unpack[OnlySeriesStrict]) -> SeriesT: ...
+@overload
+def from_native(native_object: SeriesT, **kwds: Unpack[AllowSeries]) -> SeriesT: ...
+@overload
+def from_native(native_object: SeriesT, **kwds: Unpack[AllowSeriesStrict]) -> SeriesT: ...
+@overload
+def from_native(
+    native_object: DataFrameT, **kwds: Unpack[ExcludeSeries]
+) -> DataFrameT: ...
+@overload
+def from_native(
+    native_object: DataFrameT, **kwds: Unpack[ExcludeSeriesStrict]
+) -> DataFrameT: ...
+@overload
+def from_native(native_object: LazyFrameT, **kwds: Unpack[AllowLazy]) -> LazyFrameT: ...
+@overload
+def from_native(
+    native_object: LazyFrameT, **kwds: Unpack[AllowLazyStrict]
+) -> LazyFrameT: ...
+@overload
+def from_native(
+    native_object: IntoDataFrameT, **kwds: Unpack[OnlyEagerOrInterchange]
+) -> DataFrame[IntoDataFrameT]: ...
+@overload
+def from_native(
+    native_object: IntoDataFrameT, **kwds: Unpack[OnlyEagerOrInterchangeStrict]
+) -> DataFrame[IntoDataFrameT]: ...
+@overload
+def from_native(
+    native_object: IntoDataFrameT, **kwds: Unpack[ExcludeSeries]
+) -> DataFrame[IntoDataFrameT]: ...
+@overload
+def from_native(
+    native_object: IntoDataFrameT, **kwds: Unpack[ExcludeSeriesStrict]
+) -> DataFrame[IntoDataFrameT]: ...
+@overload
+def from_native(
+    native_object: IntoSeriesT, **kwds: Unpack[OnlySeries]
+) -> Series[IntoSeriesT]: ...
+@overload
+def from_native(
+    native_object: IntoSeriesT, **kwds: Unpack[OnlySeriesStrict]
+) -> Series[IntoSeriesT]: ...
+@overload
+def from_native(
+    native_object: IntoDataFrameT | IntoSeriesT, **kwds: Unpack[AllowSeries]
+) -> DataFrame[IntoDataFrameT] | Series[IntoSeriesT]: ...
+@overload
+def from_native(
+    native_object: IntoDataFrameT | IntoSeriesT, **kwds: Unpack[AllowSeriesStrict]
+) -> DataFrame[IntoDataFrameT] | Series[IntoSeriesT]: ...
+@overload
+def from_native(
+    native_object: IntoLazyFrameT, **kwds: Unpack[AllowLazy]
+) -> LazyFrame[IntoLazyFrameT]: ...
+@overload
+def from_native(
+    native_object: IntoLazyFrameT, **kwds: Unpack[AllowLazyStrict]
+) -> LazyFrame[IntoLazyFrameT]: ...
+@overload
+def from_native(
+    native_object: IntoDataFrameT | IntoLazyFrameT | IntoSeriesT, **kwds: Unpack[AllowAny]
+) -> DataFrame[IntoDataFrameT] | LazyFrame[IntoLazyFrameT] | Series[IntoSeriesT]: ...
+@overload
+def from_native(
+    native_object: IntoDataFrameT | IntoLazyFrameT | IntoSeriesT,
+    **kwds: Unpack[AllowAnyStrict],
+) -> DataFrame[IntoDataFrameT] | LazyFrame[IntoLazyFrameT] | Series[IntoSeriesT]: ...
+@overload
+def from_native(native_object: T, **kwds: Unpack[PassThroughUnknown]) -> T: ...
+@overload
+def from_native(native_object: T, **kwds: Unpack[StrictUnknown]) -> T: ...
+
+
+# All params passed in as variables
+@overload
+def from_native(
+    native_object: Any,
+    *,
+    pass_through: bool,
+    eager_only: bool,
+    eager_or_interchange_only: bool = False,
+    series_only: bool,
+    allow_series: bool | None,
+) -> Any: ...
+
+
+def from_native(
+    native_object: IntoDataFrameT
+    | IntoLazyFrameT
+    | IntoFrame
+    | IntoSeriesT
+    | IntoSeries
+    | T,
+    *,
+    strict: bool | None = None,
+    pass_through: bool | None = None,
+    eager_only: bool = False,
+    eager_or_interchange_only: bool = False,
+    series_only: bool = False,
+    allow_series: bool | None = None,
+    **kwds: Any,
+) -> LazyFrame[IntoLazyFrameT] | DataFrame[IntoDataFrameT] | Series[IntoSeriesT] | T:
+    """Convert `native_object` to Narwhals Dataframe, Lazyframe, or Series.
+
+    See `narwhals.from_native` for full docstring. Note that `native_namespace` is
+    an is the same as `backend` but only accepts module types - for new code, we
+    recommend using `backend`, as that's available beyond just `narwhals.stable.v1`.
+    """
+    # Early returns
+    if isinstance(native_object, (DataFrame, LazyFrame)) and not series_only:
+        return native_object
+    if isinstance(native_object, Series) and (series_only or allow_series):
+        return native_object
+
+    pass_through = validate_strict_and_pass_though(
+        strict, pass_through, pass_through_default=False
+    )
+    if kwds:
+        msg = f"from_native() got an unexpected keyword argument {next(iter(kwds))!r}"
+        raise TypeError(msg)
+
+    return _from_native_impl(  # type: ignore[no-any-return]
+        native_object,
+        pass_through=pass_through,
+        eager_only=eager_only,
+        eager_or_interchange_only=eager_or_interchange_only,
+        series_only=series_only,
+        allow_series=allow_series,
+        version=Version.V1,
+    )
+
+
+@overload
+def to_native(
+    narwhals_object: DataFrame[IntoDataFrameT], *, strict: Literal[True] = ...
+) -> IntoDataFrameT: ...
+@overload
+def to_native(
+    narwhals_object: LazyFrame[IntoLazyFrameT], *, strict: Literal[True] = ...
+) -> IntoLazyFrameT: ...
+@overload
+def to_native(
+    narwhals_object: Series[IntoSeriesT], *, strict: Literal[True] = ...
+) -> IntoSeriesT: ...
+@overload
+def to_native(narwhals_object: Any, *, strict: bool) -> Any: ...
+@overload
+def to_native(
+    narwhals_object: DataFrame[IntoDataFrameT], *, pass_through: Literal[False] = ...
+) -> IntoDataFrameT: ...
+@overload
+def to_native(
+    narwhals_object: LazyFrame[IntoLazyFrameT], *, pass_through: Literal[False] = ...
+) -> IntoLazyFrameT: ...
+@overload
+def to_native(
+    narwhals_object: Series[IntoSeriesT], *, pass_through: Literal[False] = ...
+) -> IntoSeriesT: ...
+@overload
+def to_native(narwhals_object: Any, *, pass_through: bool) -> Any: ...
+
+
+def to_native(
+    narwhals_object: DataFrame[IntoDataFrameT]
+    | LazyFrame[IntoLazyFrameT]
+    | Series[IntoSeriesT],
+    *,
+    strict: bool | None = None,
+    pass_through: bool | None = None,
+) -> IntoLazyFrameT | IntoDataFrameT | IntoSeriesT | Any:
+    """Convert Narwhals object to native one.
+
+    See `narwhals.to_native` for full docstring. Note that `native_namespace` is
+    an is the same as `backend` but only accepts module types - for new code, we
+    recommend using `backend`, as that's available beyond just `narwhals.stable.v1`.
+    """
+    from narwhals._utils import validate_strict_and_pass_though
+
+    pass_through = validate_strict_and_pass_though(
+        strict, pass_through, pass_through_default=False
+    )
+    return nw.to_native(narwhals_object, pass_through=pass_through)
+
+
+def narwhalify(
+    func: Callable[..., Any] | None = None,
+    *,
+    strict: bool | None = None,
+    pass_through: bool | None = None,
+    eager_only: bool = False,
+    eager_or_interchange_only: bool = False,
+    series_only: bool = False,
+    allow_series: bool | None = True,
+) -> Callable[..., Any]:
+    """Decorate function so it becomes dataframe-agnostic.
+
+    See `narwhals.narwhalify` for full docstring. Note that `native_namespace` is
+    an is the same as `backend` but only accepts module types - for new code, we
+    recommend using `backend`, as that's available beyond just `narwhals.stable.v1`.
+    """
+    pass_through = validate_strict_and_pass_though(
+        strict, pass_through, pass_through_default=True
+    )
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            args_nw = [
+                from_native(
+                    arg,
+                    pass_through=pass_through,
+                    eager_only=eager_only,
+                    eager_or_interchange_only=eager_or_interchange_only,
+                    series_only=series_only,
+                    allow_series=allow_series,
+                )
+                for arg in args
+            ]
+
+            kwargs_nw = {
+                name: from_native(
+                    value,
+                    pass_through=pass_through,
+                    eager_only=eager_only,
+                    eager_or_interchange_only=eager_or_interchange_only,
+                    series_only=series_only,
+                    allow_series=allow_series,
+                )
+                for name, value in kwargs.items()
+            }
+
+            backends = {
+                b()
+                for v in (*args_nw, *kwargs_nw.values())
+                if (b := getattr(v, "__native_namespace__", None))
+            }
+
+            if backends.__len__() > 1:
+                msg = "Found multiple backends. Make sure that all dataframe/series inputs come from the same backend."
+                raise ValueError(msg)
+
+            result = func(*args_nw, **kwargs_nw)
+
+            return to_native(result, pass_through=pass_through)
+
+        return wrapper
+
+    if func is None:
+        return decorator
+    # If func is not None, it means the decorator is used without arguments
+    return decorator(func)
+
+
+def all() -> Expr:
+    return _stableify(nw.all())
+
+
+def col(*names: str | Iterable[str]) -> Expr:
+    return _stableify(nw.col(*names))
+
+
+def exclude(*names: str | Iterable[str]) -> Expr:
+    return _stableify(nw.exclude(*names))
+
+
+def nth(*indices: int | Sequence[int]) -> Expr:
+    return _stableify(nw.nth(*indices))
+
+
+def len() -> Expr:
+    return _stableify(nw.len())
+
+
+def lit(value: NonNestedLiteral, dtype: IntoDType | None = None) -> Expr:
+    return _stableify(nw.lit(value, dtype))
+
+
+def min(*columns: str) -> Expr:
+    return _stableify(nw.min(*columns))
+
+
+def max(*columns: str) -> Expr:
+    return _stableify(nw.max(*columns))
+
+
+def mean(*columns: str) -> Expr:
+    return _stableify(nw.mean(*columns))
+
+
+def median(*columns: str) -> Expr:
+    return _stableify(nw.median(*columns))
+
+
+def sum(*columns: str) -> Expr:
+    return _stableify(nw.sum(*columns))
+
+
+def sum_horizontal(*exprs: IntoExpr | Iterable[IntoExpr]) -> Expr:
+    return _stableify(nw.sum_horizontal(*exprs))
+
+
+def all_horizontal(
+    *exprs: IntoExpr | Iterable[IntoExpr], ignore_nulls: bool = False
+) -> Expr:
+    return _stableify(nw.all_horizontal(*exprs, ignore_nulls=ignore_nulls))
+
+
+def any_horizontal(
+    *exprs: IntoExpr | Iterable[IntoExpr], ignore_nulls: bool = False
+) -> Expr:
+    return _stableify(nw.any_horizontal(*exprs, ignore_nulls=ignore_nulls))
+
+
+def mean_horizontal(*exprs: IntoExpr | Iterable[IntoExpr]) -> Expr:
+    return _stableify(nw.mean_horizontal(*exprs))
+
+
+def min_horizontal(*exprs: IntoExpr | Iterable[IntoExpr]) -> Expr:
+    return _stableify(nw.min_horizontal(*exprs))
+
+
+def max_horizontal(*exprs: IntoExpr | Iterable[IntoExpr]) -> Expr:
+    return _stableify(nw.max_horizontal(*exprs))
+
+
+def concat_str(
+    exprs: IntoExpr | Iterable[IntoExpr],
+    *more_exprs: IntoExpr,
+    separator: str = "",
+    ignore_nulls: bool = False,
+) -> Expr:
+    return _stableify(
+        nw.concat_str(exprs, *more_exprs, separator=separator, ignore_nulls=ignore_nulls)
+    )
+
+
+def format(f_string: str, *args: IntoExpr) -> Expr:
+    """Format expressions as a string."""
+    return _stableify(nw.format(f_string, *args))
+
+
+def coalesce(exprs: IntoExpr | Iterable[IntoExpr], *more_exprs: IntoExpr) -> Expr:
+    return _stableify(nw.coalesce(exprs, *more_exprs))
+
+
+def get_level(
+    obj: DataFrame[Any] | LazyFrame[Any] | Series[IntoSeriesT],
+) -> Literal["full", "lazy", "interchange"]:
+    """Level of support Narwhals has for current object.
+
+    Arguments:
+        obj: Dataframe or Series.
+
+    Returns:
+        This can be one of
+
+            - 'full': full Narwhals API support
+            - 'lazy': only lazy operations are supported. This excludes anything
+              which involves iterating over rows in Python.
+            - 'interchange': only metadata operations are supported (`df.schema`)
+    """
+    return obj._level
+
+
+class When(nw_f.When):
+    @classmethod
+    def from_when(cls, when: nw_f.When) -> When:
+        return cls(when._predicate)
+
+    def then(self, value: IntoExpr | NonNestedLiteral | _1DArray) -> Then:
+        return Then.from_then(super().then(value))
+
+
+class Then(nw_f.Then, Expr):
+    @classmethod
+    def from_then(cls, then: nw_f.Then) -> Then:
+        return cls(*then._nodes)
+
+    def otherwise(self, value: IntoExpr | NonNestedLiteral | _1DArray) -> Expr:
+        return _stableify(super().otherwise(value))
+
+
+def when(*predicates: IntoExpr | Iterable[IntoExpr]) -> When:
+    return When.from_when(nw_f.when(*predicates))
+
+
+@deprecate_native_namespace(required=True)
+def new_series(
+    name: str,
+    values: Any,
+    dtype: IntoDType | None = None,
+    *,
+    backend: IntoBackend[EagerAllowed] | None = None,
+    native_namespace: ModuleType | None = None,  # noqa: ARG001
+) -> Series[Any]:
+    """Instantiate Narwhals Series from iterable (e.g. list or array).
+
+    See `narwhals.new_series` for full docstring. Note that `native_namespace` is
+    an is the same as `backend` but only accepts module types - for new code, we
+    recommend using `backend`, as that's available beyond just `narwhals.stable.v1`.
+    """
+    backend = cast("IntoBackend[EagerAllowed]", backend)
+    return _stableify(_new_series_impl(name, values, dtype, backend=backend))
+
+
+@deprecate_native_namespace(required=True)
+def from_arrow(
+    native_frame: IntoArrowTable,
+    *,
+    backend: IntoBackend[EagerAllowed] | None = None,
+    native_namespace: ModuleType | None = None,  # noqa: ARG001
+) -> DataFrame[Any]:
+    """Construct a DataFrame from an object which supports the PyCapsule Interface.
+
+    See `narwhals.from_arrow` for full docstring. Note that `native_namespace` is
+    an is the same as `backend` but only accepts module types - for new code, we
+    recommend using `backend`, as that's available beyond just `narwhals.stable.v1`.
+    """
+    backend = cast("IntoBackend[EagerAllowed]", backend)
+    return _stableify(nw_f.from_arrow(native_frame, backend=backend))
+
+
+@deprecate_native_namespace()
+def from_dict(
+    data: Mapping[str, Any],
+    schema: Mapping[str, DType] | Schema | None = None,
+    *,
+    backend: IntoBackend[EagerAllowed] | None = None,
+    native_namespace: ModuleType | None = None,  # noqa: ARG001
+) -> DataFrame[Any]:
+    """Instantiate DataFrame from dictionary.
+
+    See `narwhals.from_dict` for full docstring. Note that `native_namespace` is
+    an is the same as `backend` but only accepts module types - for new code, we
+    recommend using `backend`, as that's available beyond just `narwhals.stable.v1`.
+    """
+    return _stableify(nw_f.from_dict(data, schema, backend=backend))
+
+
+from_dicts: Final = DataFrame.from_dicts
+
+
+@deprecate_native_namespace(required=True)
+def from_numpy(
+    data: _2DArray,
+    schema: Mapping[str, DType] | Schema | Sequence[str] | None = None,
+    *,
+    backend: IntoBackend[EagerAllowed] | None = None,
+    native_namespace: ModuleType | None = None,  # noqa: ARG001
+) -> DataFrame[Any]:
+    """Construct a DataFrame from a NumPy ndarray.
+
+    See `narwhals.from_numpy` for full docstring. Note that `native_namespace` is
+    an is the same as `backend` but only accepts module types - for new code, we
+    recommend using `backend`, as that's available beyond just `narwhals.stable.v1`.
+    """
+    backend = cast("IntoBackend[EagerAllowed]", backend)
+    return _stableify(nw_f.from_numpy(data, schema, backend=backend))
+
+
+@deprecate_native_namespace(required=True)
+def read_csv(
+    source: FileSource,
+    *,
+    backend: IntoBackend[EagerAllowed] | None = None,
+    native_namespace: ModuleType | None = None,  # noqa: ARG001
+    **kwargs: Any,
+) -> DataFrame[Any]:
+    """Read a CSV file into a DataFrame.
+
+    See `narwhals.read_csv` for full docstring. Note that `native_namespace` is
+    an is the same as `backend` but only accepts module types - for new code, we
+    recommend using `backend`, as that's available beyond just `narwhals.stable.v1`.
+    """
+    backend = cast("IntoBackend[EagerAllowed]", backend)
+    return _stableify(nw_f.read_csv(source, backend=backend, **kwargs))
+
+
+@deprecate_native_namespace(required=True)
+def scan_csv(
+    source: FileSource,
+    *,
+    backend: IntoBackend[Backend] | None = None,
+    native_namespace: ModuleType | None = None,  # noqa: ARG001
+    **kwargs: Any,
+) -> LazyFrame[Any]:
+    """Lazily read from a CSV file.
+
+    See `narwhals.scan_csv` for full docstring. Note that `native_namespace` is
+    an is the same as `backend` but only accepts module types - for new code, we
+    recommend using `backend`, as that's available beyond just `narwhals.stable.v1`.
+    """
+    backend = cast("IntoBackend[Backend]", backend)
+    return _stableify(nw_f.scan_csv(source, backend=backend, **kwargs))
+
+
+@deprecate_native_namespace(required=True)
+def read_parquet(
+    source: FileSource,
+    *,
+    backend: IntoBackend[EagerAllowed] | None = None,
+    native_namespace: ModuleType | None = None,  # noqa: ARG001
+    **kwargs: Any,
+) -> DataFrame[Any]:
+    """Read into a DataFrame from a parquet file.
+
+    See `narwhals.read_parquet` for full docstring. Note that `native_namespace` is
+    an is the same as `backend` but only accepts module types - for new code, we
+    recommend using `backend`, as that's available beyond just `narwhals.stable.v1`.
+    """
+    backend = cast("IntoBackend[EagerAllowed]", backend)
+    return _stableify(nw_f.read_parquet(source, backend=backend, **kwargs))
+
+
+@deprecate_native_namespace(required=True)
+def scan_parquet(
+    source: FileSource,
+    *,
+    backend: IntoBackend[Backend] | None = None,
+    native_namespace: ModuleType | None = None,  # noqa: ARG001
+    **kwargs: Any,
+) -> LazyFrame[Any]:
+    """Lazily read from a parquet file.
+
+    See `narwhals.scan_parquet` for full docstring. Note that `native_namespace` is
+    an is the same as `backend` but only accepts module types - for new code, we
+    recommend using `backend`, as that's available beyond just `narwhals.stable.v1`.
+    """
+    backend = cast("IntoBackend[Backend]", backend)
+    return _stableify(nw_f.scan_parquet(source, backend=backend, **kwargs))
+
+
+__all__ = [
+    "Array",
+    "Binary",
+    "Boolean",
+    "Categorical",
+    "DataFrame",
+    "Date",
+    "Datetime",
+    "Decimal",
+    "Duration",
+    "Enum",
+    "Expr",
+    "Field",
+    "Float32",
+    "Float64",
+    "Implementation",
+    "Int8",
+    "Int16",
+    "Int32",
+    "Int64",
+    "Int128",
+    "InvalidIntoExprError",
+    "LazyFrame",
+    "List",
+    "Object",
+    "Schema",
+    "Series",
+    "String",
+    "Struct",
+    "Time",
+    "UInt8",
+    "UInt16",
+    "UInt32",
+    "UInt64",
+    "UInt128",
+    "Unknown",
+    "all",
+    "all_horizontal",
+    "any_horizontal",
+    "coalesce",
+    "col",
+    "concat",
+    "concat_str",
+    "dependencies",
+    "dtypes",
+    "exceptions",
+    "exclude",
+    "format",
+    "from_arrow",
+    "from_dict",
+    "from_dicts",
+    "from_native",
+    "from_numpy",
+    "generate_temporary_column_name",
+    "get_level",
+    "get_native_namespace",
+    "is_expr",
+    "is_ordered_categorical",
+    "len",
+    "lit",
+    "max",
+    "max_horizontal",
+    "maybe_align_index",
+    "maybe_convert_dtypes",
+    "maybe_get_index",
+    "maybe_reset_index",
+    "maybe_set_index",
+    "mean",
+    "mean_horizontal",
+    "median",
+    "min",
+    "min_horizontal",
+    "narwhalify",
+    "new_series",
+    "nth",
+    "read_csv",
+    "read_parquet",
+    "scan_csv",
+    "scan_parquet",
+    "selectors",
+    "show_versions",
+    "sum",
+    "sum_horizontal",
+    "to_native",
+    "to_py_scalar",
+    "when",
+]