diff --git a/.asf.yaml b/.asf.yaml
index f27975c84..cb0520c17 100644
--- a/.asf.yaml
+++ b/.asf.yaml
@@ -16,24 +16,31 @@
 # under the License.
 
 notifications:
-  commits:      commits@arrow.apache.org
-  issues:       github@arrow.apache.org
-  pullrequests: github@arrow.apache.org
+  commits:      commits@datafusion.apache.org
+  issues:       github@datafusion.apache.org
+  pullrequests: github@datafusion.apache.org
   jira_options: link label worklog
 github:
-  description: "Apache Arrow DataFusion Python Bindings"
-  homepage: https://arrow.apache.org/datafusion
+  description: "Apache DataFusion Python Bindings"
+  homepage: https://datafusion.apache.org/python
   enabled_merge_buttons:
     squash: true
     merge: false
     rebase: false
   features:
     issues: true
+  protected_branches:
+    main:
+      required_status_checks:
+        # require branches to be up-to-date before merging
+        strict: true
+        # don't require any jobs to pass
+        contexts: []
 
 staging:
   whoami: asf-staging
-  subdir: datafusion-python
+  subdir: python
   
 publish:
   whoami: asf-site
-  subdir: datafusion-python
+  subdir: python
diff --git a/.cargo/config.toml b/.cargo/config.toml
new file mode 100644
index 000000000..af951327f
--- /dev/null
+++ b/.cargo/config.toml
@@ -0,0 +1,5 @@
+[target.x86_64-apple-darwin]
+rustflags = ["-C", "link-arg=-undefined", "-C", "link-arg=dynamic_lookup"]
+
+[target.aarch64-apple-darwin]
+rustflags = ["-C", "link-arg=-undefined", "-C", "link-arg=dynamic_lookup"]
diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 000000000..411e60291
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,12 @@
+.cargo
+.github
+.pytest_cache
+ci
+conda
+dev
+docs
+examples
+parquet
+target
+testing
+venv
\ No newline at end of file
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index fc8910766..455a0dc1a 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -15,34 +15,248 @@
 # specific language governing permissions and limitations
 # under the License.
 
-name: Python Release Build
+# Reusable workflow for running building
+# This ensures the same tests run for both debug (PRs) and release (main/tags) builds
+
+name: Build
+
 on:
-  pull_request:
-    branches: ["main"]
-  push:
-    tags: ["*-rc*"]
-    branches: ["branch-*"]
+  workflow_call:
+    inputs:
+      build_mode:
+        description: 'Build mode: debug or release'
+        required: true
+        type: string
+      run_wheels:
+        description: 'Whether to build distribution wheels'
+        required: false
+        type: boolean
+        default: false
+
+env:
+  CARGO_TERM_COLOR: always
+  RUST_BACKTRACE: 1
 
 jobs:
+  # ============================================
+  # Linting Jobs
+  # ============================================
+  lint-rust:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: "nightly"
+          components: rustfmt
+
+      - name: Cache Cargo
+        uses: Swatinem/rust-cache@v2
+
+      - name: Check formatting
+        run: cargo +nightly fmt --all -- --check
+
+  lint-python:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Install Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - uses: astral-sh/setup-uv@v6
+        with:
+          enable-cache: true
+
+      - name: Install dependencies
+        run: uv sync --dev --no-install-package datafusion
+
+      - name: Run Ruff
+        run: |
+          uv run --no-project ruff check --output-format=github python/
+          uv run --no-project ruff format --check python/
+
+      - name: Run codespell
+        run: |
+          uv run --no-project codespell --toml pyproject.toml
+
+  lint-toml:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Install taplo
+        uses: taiki-e/install-action@v2
+        with:
+          tool: taplo-cli
+
+      # if you encounter an error, try running 'taplo format' to fix the formatting automatically.
+      - name: Check Cargo.toml formatting
+        run: taplo format --check
+
+  check-crates-patch:
+    if: inputs.build_mode == 'release'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Ensure [patch.crates-io] is empty
+        run: python3 dev/check_crates_patch.py
+
   generate-license:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@v6
+
+      - uses: astral-sh/setup-uv@v6
+        with:
+          enable-cache: true
+
+      - name: Install cargo-license
+        uses: taiki-e/install-action@v2
         with:
-          profile: minimal
-          toolchain: stable
-          override: true
+          tool: cargo-license
+
       - name: Generate license file
-        run: python ./dev/create_license.py
-      - uses: actions/upload-artifact@v3
+        run: uv run --no-project python ./dev/create_license.py
+
+      - uses: actions/upload-artifact@v6
         with:
           name: python-wheel-license
           path: LICENSE.txt
 
+  # ============================================
+  # Build - Linux x86_64
+  # ============================================
+  build-manylinux-x86_64:
+    needs: [generate-license, lint-rust, lint-python]
+    name: ManyLinux x86_64
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - run: rm LICENSE.txt
+      - name: Download LICENSE.txt
+        uses: actions/download-artifact@v7
+        with:
+          name: python-wheel-license
+          path: .
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache Cargo
+        uses: Swatinem/rust-cache@v2
+        with:
+          key: ${{ inputs.build_mode }}
+
+      - uses: astral-sh/setup-uv@v6
+        with:
+          enable-cache: true
+
+      - name: Build (release mode)
+        uses: PyO3/maturin-action@v1
+        if: inputs.build_mode == 'release'
+        with:
+          target: x86_64-unknown-linux-gnu
+          manylinux: "2_28"
+          args: --release --strip --features protoc,substrait --out dist
+          rustup-components: rust-std
+
+      - name: Build (debug mode)
+        uses: PyO3/maturin-action@v1
+        if: inputs.build_mode == 'debug'
+        with:
+          target: x86_64-unknown-linux-gnu
+          manylinux: "2_28"
+          args: --features protoc,substrait --out dist
+          rustup-components: rust-std
+
+      - name: Build FFI test library
+        uses: PyO3/maturin-action@v1
+        with:
+          target: x86_64-unknown-linux-gnu
+          manylinux: "2_28"
+          working-directory: examples/datafusion-ffi-example
+          args: --out dist
+          rustup-components: rust-std
+
+      - name: Archive wheels
+        uses: actions/upload-artifact@v6
+        with:
+          name: dist-manylinux-x86_64
+          path: dist/*
+
+      - name: Archive FFI test wheel
+        uses: actions/upload-artifact@v6
+        with:
+          name: test-ffi-manylinux-x86_64
+          path: examples/datafusion-ffi-example/dist/*
+
+  # ============================================
+  # Build - Linux ARM64
+  # ============================================
+  build-manylinux-aarch64:
+    needs: [generate-license, lint-rust, lint-python]
+    name: ManyLinux arm64
+    runs-on: ubuntu-24.04-arm
+    steps:
+      - uses: actions/checkout@v6
+
+      - run: rm LICENSE.txt
+      - name: Download LICENSE.txt
+        uses: actions/download-artifact@v7
+        with:
+          name: python-wheel-license
+          path: .
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache Cargo
+        uses: Swatinem/rust-cache@v2
+        with:
+          key: ${{ inputs.build_mode }}
+
+      - uses: astral-sh/setup-uv@v6
+        with:
+          enable-cache: true
+
+      - name: Build (release mode)
+        uses: PyO3/maturin-action@v1
+        if: inputs.build_mode == 'release'
+        with:
+          target: aarch64-unknown-linux-gnu
+          manylinux: "2_28"
+          args: --release --strip --features protoc,substrait --out dist
+          rustup-components: rust-std
+
+      - name: Build (debug mode)
+        uses: PyO3/maturin-action@v1
+        if: inputs.build_mode == 'debug'
+        with:
+          target: aarch64-unknown-linux-gnu
+          manylinux: "2_28"
+          args: --features protoc,substrait --out dist
+          rustup-components: rust-std
+
+      - name: Archive wheels
+        uses: actions/upload-artifact@v6
+        if: inputs.build_mode == 'release'
+        with:
+          name: dist-manylinux-aarch64
+          path: dist/*
+
+  # ============================================
+  # Build - macOS arm64 / Windows
+  # ============================================
   build-python-mac-win:
-    needs: [generate-license]
-    name: Mac/Win
+    needs: [generate-license, lint-rust, lint-python]
+    name: macOS arm64 & Windows
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
@@ -50,82 +264,136 @@ jobs:
         python-version: ["3.10"]
         os: [macos-latest, windows-latest]
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
 
-      - uses: actions/setup-python@v4
-        with:
-          python-version: ${{ matrix.python-version }}
-
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
+      - uses: dtolnay/rust-toolchain@stable
 
       - run: rm LICENSE.txt
       - name: Download LICENSE.txt
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v7
         with:
           name: python-wheel-license
           path: .
 
-      - name: Build Python package
-        run: maturin build --release --strip
+      - name: Cache Cargo
+        uses: Swatinem/rust-cache@v2
+        with:
+          key: ${{ inputs.build_mode }}
+
+      - uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+
+      - name: Install Protoc
+        uses: arduino/setup-protoc@v3
+        with:
+          version: "27.4"
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Install dependencies
+        run: uv sync --dev --no-install-package datafusion
+
+      # Run clippy BEFORE maturin so we can avoid rebuilding. The features must match
+      # exactly the features used by maturin. Linux maturin builds need to happen in a
+      # container so only run this for our mac runner.
+      - name: Run Clippy
+        if: matrix.os != 'windows-latest'
+        run: cargo clippy --no-deps --all-targets --features substrait -- -D warnings
+
+      - name: Build Python package (release mode)
+        if: inputs.build_mode == 'release'
+        run: uv run --no-project maturin build --release --strip --features substrait
+
+      - name: Build Python package (debug mode)
+        if: inputs.build_mode != 'release'
+        run: uv run --no-project maturin build --features substrait
 
       - name: List Windows wheels
         if: matrix.os == 'windows-latest'
         run: dir target\wheels\
+        # since the runner is dynamic shellcheck (from actionlint) can't infer this is powershell
+        # so we specify it explicitly
+        shell: powershell
 
       - name: List Mac wheels
         if: matrix.os != 'windows-latest'
         run: find target/wheels/
 
       - name: Archive wheels
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v6
+        if: inputs.build_mode == 'release'
         with:
-          name: dist
+          name: dist-${{ matrix.os  }}
           path: target/wheels/*
 
-  build-manylinux:
-    needs: [generate-license]
-    name: Manylinux
-    runs-on: ubuntu-latest
+  # ============================================
+  # Build - macOS x86_64 (release only)
+  # ============================================
+  build-macos-x86_64:
+    if: inputs.build_mode == 'release'
+    needs: [generate-license, lint-rust, lint-python]
+    runs-on: macos-15-intel
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10"]
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
+
+      - uses: dtolnay/rust-toolchain@stable
+
       - run: rm LICENSE.txt
       - name: Download LICENSE.txt
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v7
         with:
           name: python-wheel-license
           path: .
-      - run: cat LICENSE.txt
+
+      - name: Cache Cargo
+        uses: Swatinem/rust-cache@v2
+        with:
+          key: ${{ inputs.build_mode }}
+
+      - uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+
       - name: Install Protoc
-        uses: arduino/setup-protoc@v1
+        uses: arduino/setup-protoc@v3
         with:
-          version: '3.x'
+          version: "27.4"
           repo-token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Build wheels
-        uses: PyO3/maturin-action@v1
-        with:
-          env:
-            RUST_BACKTRACE: 1
-          rust-toolchain: nightly
-          target: x86_64
-          manylinux: auto
-          args: --release --manylinux 2014
+
+      - name: Install dependencies
+        run: uv sync --dev --no-install-package datafusion
+
+      - name: Build (release mode)
+        run: |
+          uv run --no-project maturin build --release --strip --features substrait
+
+      - name: List Mac wheels
+        run: find target/wheels/
+
       - name: Archive wheels
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v6
         with:
-          name: dist
+          name: dist-macos-aarch64
           path: target/wheels/*
 
+  # ============================================
+  # Build - Source Distribution
+  # ============================================
+
   build-sdist:
     needs: [generate-license]
     name: Source distribution
+    if: inputs.build_mode == 'release'
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
       - run: rm LICENSE.txt
       - name: Download LICENSE.txt
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v7
         with:
           name: python-wheel-license
           path: .
@@ -135,22 +403,132 @@ jobs:
         with:
           rust-toolchain: stable
           manylinux: auto
-          args: --release --sdist --out dist
-      - name: Archive wheels
-        uses: actions/upload-artifact@v3
+          rustup-components: rust-std rustfmt
+          args: --release --sdist --out dist --features protoc,substrait
+      - name: Assert sdist build does not generate wheels
+        run: |
+          if [ "$(ls -A target/wheels)" ]; then
+            echo "Error: Sdist build generated wheels"
+            exit 1
+          else
+            echo "Directory is clean"
+          fi
+        shell: bash
+
+  # ============================================
+  # Build - Source Distribution
+  # ============================================
+
+  merge-build-artifacts:
+    runs-on: ubuntu-latest
+    name: Merge build artifacts
+    if: inputs.build_mode == 'release'
+    needs:
+      - build-python-mac-win
+      - build-macos-x86_64
+      - build-manylinux-x86_64
+      - build-manylinux-aarch64
+      - build-sdist
+    steps:
+      - name: Merge Build Artifacts
+        uses: actions/upload-artifact/merge@v6
         with:
           name: dist
-          path: target/wheels/*
+          pattern: dist-*
+
+  # ============================================
+  # Build - Documentation
+  # ============================================
+  # Documentation build job that runs after wheels are built
+  build-docs:
+    name: Build docs
+    runs-on: ubuntu-latest
+    needs: [build-manylinux-x86_64]  # Only need the Linux wheel for docs
+    # Only run docs on main branch pushes, tags, or PRs
+    if: github.event_name == 'push' || github.event_name == 'pull_request'
+    steps:
+      - name: Set target branch
+        if: github.event_name == 'push' && (github.ref == 'refs/heads/main' || github.ref_type == 'tag')
+        id: target-branch
+        run: |
+          set -x
+          if test '${{ github.ref }}' = 'refs/heads/main'; then
+            echo "value=asf-staging" >> "$GITHUB_OUTPUT"
+          elif test '${{ github.ref_type }}' = 'tag'; then
+            echo "value=asf-site" >> "$GITHUB_OUTPUT"
+          else
+            echo "Unsupported input: ${{ github.ref }} / ${{ github.ref_type }}"
+            exit 1
+          fi
+
+      - name: Checkout docs sources
+        uses: actions/checkout@v6
+
+      - name: Checkout docs target branch
+        if: github.event_name == 'push' && (github.ref == 'refs/heads/main' || github.ref_type == 'tag')
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          ref: ${{ steps.target-branch.outputs.value }}
+          path: docs-target
+
+      - name: Setup Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.10"
+
+      - name: Install dependencies
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+
+      # Download the Linux wheel built in the previous job
+      - name: Download pre-built Linux wheel
+        uses: actions/download-artifact@v7
+        with:
+          name: dist-manylinux-x86_64
+          path: wheels/
+
+      # Install from the pre-built wheels
+      - name: Install from pre-built wheels
+        run: |
+          set -x
+          uv venv
+          # Install documentation dependencies
+          uv sync --dev --no-install-package datafusion --group docs
+          # Install all pre-built wheels
+          WHEELS=$(find wheels/ -name "*.whl")
+          if [ -n "$WHEELS" ]; then
+            echo "Installing wheels:"
+            echo "$WHEELS"
+            uv pip install wheels/*.whl
+          else
+            echo "ERROR: No wheels found!"
+            exit 1
+          fi
+
+      - name: Build docs
+        run: |
+          set -x
+          cd docs
+          curl -O https://gist.githubusercontent.com/ritchie46/cac6b337ea52281aa23c049250a4ff03/raw/89a957ff3919d90e6ef2d34235e6bf22304f3366/pokemon.csv
+          curl -O https://d37ci6vzurychx.cloudfront.net/trip-data/yellow_tripdata_2021-01.parquet
+          uv run --no-project make html
 
-  # NOTE: PyPI publish needs to be done manually for now after release passed the vote
-  # release:
-  #   name: Publish in PyPI
-  #   needs: [build-manylinux, build-python-mac-win]
-  #   runs-on: ubuntu-latest
-  #   steps:
-  #     - uses: actions/download-artifact@v3
-  #     - name: Publish to PyPI
-  #       uses: pypa/gh-action-pypi-publish@master
-  #       with:
-  #         user: __token__
-  #         password: ${{ secrets.pypi_password }}
+      - name: Copy & push the generated HTML
+        if: github.event_name == 'push' && (github.ref == 'refs/heads/main' || github.ref_type == 'tag')
+        run: |
+          set -x
+          cd docs-target
+          # delete anything but: 1) '.'; 2) '..'; 3) .git/
+          find ./ | grep -vE "^./$|^../$|^./.git" | xargs rm -rf
+          cp ../.asf.yaml .
+          cp -r ../docs/build/html/* .
+          git status --porcelain
+          if [ "$(git status --porcelain)" != "" ]; then
+            git config user.name "github-actions[bot]"
+            git config user.email "github-actions[bot]@users.noreply.github.com"
+            git add --all
+            git commit -m 'Publish built docs triggered by ${{ github.sha }}'
+            git push || git push --force
+          fi
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 000000000..ab284b522
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,41 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# CI workflow for pull requests - runs tests in DEBUG mode for faster feedback
+
+name: CI
+
+on:
+  pull_request:
+    branches: ["main"]
+
+concurrency:
+  group: ${{ github.repository }}-${{ github.head_ref || github.sha }}-${{ github.workflow }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    uses: ./.github/workflows/build.yml
+    with:
+      build_mode: debug
+      run_wheels: false
+    secrets: inherit
+
+  test:
+    needs: build
+    uses: ./.github/workflows/test.yml
+    secrets: inherit
diff --git a/.github/workflows/dev.yml b/.github/workflows/dev.yml
index 05cf8ce68..2c8ecbc5e 100644
--- a/.github/workflows/dev.yml
+++ b/.github/workflows/dev.yml
@@ -25,10 +25,10 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6
       - name: Setup Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v6
         with:
-          python-version: "3.10"
+          python-version: "3.14"
       - name: Audit licenses
         run: ./dev/release/run-rat.sh .
diff --git a/.github/workflows/docs.yaml b/.github/workflows/docs.yaml
deleted file mode 100644
index b1c9ffc12..000000000
--- a/.github/workflows/docs.yaml
+++ /dev/null
@@ -1,75 +0,0 @@
-on:
-  push:
-    branches:
-      - master
-    tags-ignore:
-      - "**-rc**"
-
-name: Deploy DataFusion Python site
-
-jobs:
-  build-docs:
-    name: Build docs
-    runs-on: ubuntu-latest
-    steps:
-      - name: Set target branch
-        id: target-branch
-        run: |
-          set -x
-          if test '${{ github.ref }}' = 'refs/heads/main'; then
-            echo "value=asf-staging" >> $GITHUB_OUTPUT
-          elif test '${{ github.ref_type }}' = 'tag'; then
-            echo "value=asf-site" >> $GITHUB_OUTPUT
-          else
-            echo "Unsupported input: ${{ github.ref }} / ${{ github.ref_type }}"
-            exit 1
-          fi
-      - name: Checkout docs sources
-        uses: actions/checkout@v3
-      - name: Checkout docs target branch
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-          ref: ${{ steps.target-branch.outputs.value }}
-          path: docs-target
-      - name: Setup Python
-        uses: actions/setup-python@v4
-        with:
-          python-version: "3.10"
-
-      - name: Install dependencies
-        run: |
-          set -x
-          python3 -m venv venv
-          source venv/bin/activate
-          pip install -r requirements-310.txt
-          pip install -r docs/requirements.txt
-      - name: Build Datafusion
-        run: |
-          set -x
-          source venv/bin/activate
-          maturin develop
-
-      - name: Build docs
-        run: |
-          set -x
-          source venv/bin/activate
-          cd docs
-          make html
-
-      - name: Copy & push the generated HTML
-        run: |
-          set -x
-          cd docs-target
-          # delete anything but: 1) '.'; 2) '..'; 3) .git/
-          find ./ | grep -vE "^./$|^../$|^./.git" | xargs rm -rf
-          cp ../.asf.yaml .
-          cp -r ../docs/build/html/* .
-          git status --porcelain
-          if [ "$(git status --porcelain)" != "" ]; then
-            git config user.name "github-actions[bot]"
-            git config user.email "github-actions[bot]@users.noreply.github.com"
-            git add --all
-            git commit -m 'Publish built docs triggered by ${{ github.sha }}'
-            git push || git push --force
-          fi
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 000000000..bddc89eac
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,49 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# Release workflow - runs tests in RELEASE mode and builds distribution wheels
+# Triggered on:
+#   - Merges to main
+#   - Release candidate tags (*-rc*)
+#   - Release tags (e.g., 45.0.0)
+
+name: Release Build
+
+on:
+  push:
+    branches:
+      - "main"
+    tags:
+      - "*-rc*"      # Release candidates (e.g., 45.0.0-rc1)
+      - "[0-9]+.*"   # Release tags (e.g., 45.0.0)
+
+concurrency:
+  group: ${{ github.repository }}-${{ github.head_ref || github.sha }}-${{ github.workflow }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    uses: ./.github/workflows/build.yml
+    with:
+      build_mode: release
+      run_wheels: true
+    secrets: inherit
+
+  test:
+    needs: build
+    uses: ./.github/workflows/test.yml
+    secrets: inherit
diff --git a/.github/workflows/take.yml b/.github/workflows/take.yml
new file mode 100644
index 000000000..86dc190ad
--- /dev/null
+++ b/.github/workflows/take.yml
@@ -0,0 +1,41 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+name: Assign the issue via a `take` comment
+on:
+  issue_comment:
+    types: created
+
+permissions:
+  issues: write
+
+jobs:
+  issue_assign:
+    runs-on: ubuntu-latest
+    if: (!github.event.issue.pull_request) && github.event.comment.body == 'take'
+    concurrency:
+      group: ${{ github.actor }}-issue-assign
+    steps:
+      - run: |
+          CODE=$(curl -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" -LI https://api.github.com/repos/${{ github.repository }}/issues/${{ github.event.issue.number }}/assignees/${{ github.event.comment.user.login }} -o /dev/null -w '%{http_code}\n' -s)
+          if [ "$CODE" -eq "204" ]
+          then
+            echo "Assigning issue ${{ github.event.issue.number }} to ${{ github.event.comment.user.login }}"
+            curl -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" -d '{"assignees": ["${{ github.event.comment.user.login }}"]}' https://api.github.com/repos/${{ github.repository }}/issues/${{ github.event.issue.number }}/assignees
+          else
+            echo "Cannot assign issue ${{ github.event.issue.number }} to ${{ github.event.comment.user.login }}"
+          fi
\ No newline at end of file
diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml
deleted file mode 100644
index 164b09e15..000000000
--- a/.github/workflows/test.yaml
+++ /dev/null
@@ -1,115 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-name: Python test
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-
-concurrency:
-  group: ${{ github.repository }}-${{ github.head_ref || github.sha }}-${{ github.workflow }}
-  cancel-in-progress: true
-
-jobs:
-  test-matrix:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        python-version:
-          - "3.10"
-        toolchain:
-          - "stable"
-          - "beta"
-          # we are not that much eager in walking on the edge yet
-          # - nightly
-        # build stable for only 3.7
-        include:
-          - python-version: "3.7"
-            toolchain: "stable"
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Setup Rust Toolchain
-        uses: actions-rs/toolchain@v1
-        id: rust-toolchain
-        with:
-          toolchain: ${{ matrix.toolchain }}
-          override: true
-
-      - name: Install Protoc
-        uses: arduino/setup-protoc@v1
-        with:
-          version: '3.x'
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Setup Python
-        uses: actions/setup-python@v4
-        with:
-          python-version: ${{ matrix.python-version }}
-
-      - name: Cache Cargo
-        uses: actions/cache@v3
-        with:
-          path: ~/.cargo
-          key: cargo-cache-${{ steps.rust-toolchain.outputs.rustc_hash }}-${{ hashFiles('Cargo.lock') }}
-
-      - name: Check Formatting
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.python-version == '3.10' && matrix.toolchain == 'stable' }}
-        with:
-          command: fmt
-          args: -- --check
-
-      - name: Run Clippy
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.python-version == '3.10' && matrix.toolchain == 'stable' }}
-        with:
-          command: clippy
-          args: --all-targets --all-features -- -D clippy::all -A clippy::redundant_closure
-
-      - name: Create Virtualenv (3.10)
-        if: ${{ matrix.python-version == '3.10' }}
-        run: |
-          python -m venv venv
-          source venv/bin/activate
-          pip install -r requirements-310.txt
-
-      - name: Create Virtualenv (3.7)
-        if: ${{ matrix.python-version == '3.7' }}
-        run: |
-          python -m venv venv
-          source venv/bin/activate
-          pip install -r requirements-37.txt
-
-      - name: Run Python Linters
-        if: ${{ matrix.python-version == '3.10' && matrix.toolchain == 'stable' }}
-        run: |
-          source venv/bin/activate
-          flake8 --exclude venv --ignore=E501,W503
-          black --line-length 79 --diff --check .
-
-      - name: Run tests
-        env:
-          RUST_BACKTRACE: 1
-        run: |
-          git submodule update --init
-          source venv/bin/activate
-          pip install -e . -vv
-          pytest -v .
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
new file mode 100644
index 000000000..692563019
--- /dev/null
+++ b/.github/workflows/test.yml
@@ -0,0 +1,133 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# Reusable workflow for running tests
+# This ensures the same tests run for both debug (PRs) and release (main/tags) builds
+
+name: Test
+
+on:
+  workflow_call:
+
+jobs:
+  test-matrix:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version:
+          - "3.10"
+          - "3.11"
+          - "3.12"
+          - "3.13"
+          - "3.14"
+        toolchain:
+          - "stable"
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Verify example datafusion version
+        run: |
+          MAIN_VERSION=$(grep -A 1 "name = \"datafusion-common\"" Cargo.lock | grep "version = " | head -1 | sed 's/.*version = "\(.*\)"/\1/')
+          EXAMPLE_VERSION=$(grep -A 1 "name = \"datafusion-common\"" examples/datafusion-ffi-example/Cargo.lock | grep "version = " | head -1 | sed 's/.*version = "\(.*\)"/\1/')
+          echo "Main crate datafusion version: $MAIN_VERSION"
+          echo "FFI example datafusion version: $EXAMPLE_VERSION"
+
+          if [ "$MAIN_VERSION" != "$EXAMPLE_VERSION" ]; then
+            echo "❌ Error: FFI example datafusion versions don't match!"
+            exit 1
+          fi
+
+      - name: Setup Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Cache Cargo
+        uses: actions/cache@v5
+        with:
+          path: ~/.cargo
+          key: cargo-cache-${{ matrix.toolchain }}-${{ hashFiles('Cargo.lock') }}
+
+      - name: Install dependencies
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+
+      # Download the Linux wheel built in the build workflow
+      - name: Download pre-built Linux wheel
+        uses: actions/download-artifact@v7
+        with:
+          name: dist-manylinux-x86_64
+          path: wheels/
+
+      # Download the FFI test wheel
+      - name: Download pre-built FFI test wheel
+        uses: actions/download-artifact@v7
+        with:
+          name: test-ffi-manylinux-x86_64
+          path: wheels/
+
+      # Install from the pre-built wheels
+      - name: Install from pre-built wheels
+        run: |
+          set -x
+          uv venv
+          # Install development dependencies
+          uv sync --dev --no-install-package datafusion
+          # Install all pre-built wheels
+          WHEELS=$(find wheels/ -name "*.whl")
+          if [ -n "$WHEELS" ]; then
+            echo "Installing wheels:"
+            echo "$WHEELS"
+            uv pip install wheels/*.whl
+          else
+            echo "ERROR: No wheels found!"
+            exit 1
+          fi
+
+      - name: Run tests
+        env:
+          RUST_BACKTRACE: 1
+        run: |
+          git submodule update --init
+          uv run --no-project pytest -v --import-mode=importlib
+
+      - name: FFI unit tests
+        run: |
+          cd examples/datafusion-ffi-example
+          uv run --no-project pytest python/tests/_test*.py
+
+      - name: Cache the generated dataset
+        id: cache-tpch-dataset
+        uses: actions/cache@v5
+        with:
+          path: benchmarks/tpch/data
+          key: tpch-data-2.18.0
+
+      - name: Run dbgen to create 1 Gb dataset
+        if: ${{ steps.cache-tpch-dataset.outputs.cache-hit != 'true' }}
+        run: |
+          cd benchmarks/tpch
+          RUN_IN_CI=TRUE ./tpch-gen.sh 1
+
+      - name: Run TPC-H examples
+        run: |
+          cd examples/tpch
+          uv run --no-project python convert_data_to_parquet.py
+          uv run --no-project pytest _tests.py
diff --git a/.github/workflows/verify-release-candidate.yml b/.github/workflows/verify-release-candidate.yml
new file mode 100644
index 000000000..a10a4faa9
--- /dev/null
+++ b/.github/workflows/verify-release-candidate.yml
@@ -0,0 +1,78 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+name: Verify Release Candidate
+
+# NOTE: This workflow is intended to be run manually via workflow_dispatch.
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: Version number (e.g., 52.0.0)
+        required: true
+        type: string
+      rc_number:
+        description: Release candidate number (e.g., 0)
+        required: true
+        type: string
+
+concurrency:
+  group: ${{ github.repository }}-${{ github.ref }}-${{ github.workflow }}
+  cancel-in-progress: true
+
+jobs:
+  verify:
+    name: Verify RC (${{ matrix.os }}-${{ matrix.arch }})
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # Linux
+          - os: linux
+            arch: x64
+            runner: ubuntu-latest
+          - os: linux
+            arch: arm64
+            runner: ubuntu-24.04-arm
+
+          # macOS
+          - os: macos
+            arch: arm64
+            runner: macos-latest
+          - os: macos
+            arch: x64
+            runner: macos-15-intel
+
+          # Windows
+          - os: windows
+            arch: x64
+            runner: windows-latest
+    runs-on: ${{ matrix.runner }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Set up protoc
+        uses: arduino/setup-protoc@v3
+        with:
+          version: "27.4"
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Run release candidate verification
+        shell: bash
+        run: ./dev/release/verify-release-candidate.sh "${{ inputs.version }}" "${{ inputs.rc_number }}"
diff --git a/.gitignore b/.gitignore
index 4e4450082..614d82327 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,22 +4,35 @@ target
 /docs/temp
 /docs/build
 .DS_Store
+.vscode
 
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
 *$py.class
 
+# Python dist ignore
+dist
+
 # C extensions
 *.so
 
+# Python dist
+dist
+
 # pyenv
 #   For a library or package, you might want to ignore these files since the code is
 #   intended to run in multiple environments; otherwise, check them in:
 .python-version
 venv
+.venv
 
 apache-rat-*.jar
 *rat.txt
 .env
-CHANGELOG.md.bak
\ No newline at end of file
+CHANGELOG.md.bak
+
+docs/mdbook/book
+
+.pyo3_build_config
+
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 3c6805322..8ae6a4e32 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -16,37 +16,42 @@
 # under the License.
 
 repos:
-      - repo: https://github.com/psf/black
-        rev: 22.3.0
+      - repo: https://github.com/rhysd/actionlint
+        rev: v1.7.6
         hooks:
-              - id: black
-                files: datafusion/.*
-                # Explicitly specify the pyproject.toml at the repo root, not per-project.
-                args: ["--config", "pyproject.toml", "--line-length", "79", "--diff", "--check", "."]
-      - repo: https://github.com/PyCQA/flake8
-        rev: 5.0.4
+          - id: actionlint-docker
+      - repo: https://github.com/astral-sh/ruff-pre-commit
+        # Ruff version.
+        rev: v0.15.1
         hooks:
-              - id: flake8
-                files: datafusion/.*$
-                types: [file]
-                types_or: [python]
-                additional_dependencies: ["flake8-force"]
+          # Run the linter.
+          - id: ruff
+          # Run the formatter.
+          - id: ruff-format
       - repo: local
         hooks:
           - id: rust-fmt
             name: Rust fmt
             description: Run cargo fmt on files included in the commit. rustfmt should be installed before-hand.
-            entry: cargo fmt --all --
+            entry: cargo +nightly fmt --all --
             pass_filenames: true
             types: [file, rust]
             language: system
           - id: rust-clippy
             name: Rust clippy
             description: Run cargo clippy on files included in the commit. clippy should be installed before-hand.
-            entry: cargo clippy --all-targets --all-features -- -Dclippy::all -Aclippy::redundant_closure
+            entry: cargo clippy --all-targets --all-features -- -Dclippy::all -D warnings -Aclippy::redundant_closure
             pass_filenames: false
             types: [file, rust]
             language: system
 
+      - repo: https://github.com/codespell-project/codespell
+        rev: v2.4.1
+        hooks:
+          - id: codespell
+            args: [ --toml, "pyproject.toml"]
+            additional_dependencies:
+              - tomli
+
 default_language_version:
       python: python3
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0cf05413a..ae40911d8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -17,279 +17,6 @@
   under the License.
 -->
 
-# Changelog
+# DataFusion Python Changelog
 
-## [20.0.0](https://github.com/apache/arrow-datafusion-python/tree/20.0.0) (2023-03-17)
-
-[Full Changelog](https://github.com/apache/arrow-datafusion-python/compare/0.8.0...20.0.0)
-
-**Implemented enhancements:**
-
-- Empty relation bindings [#208](https://github.com/apache/arrow-datafusion-python/pull/208) (jdye64)
-- wrap display_name and canonical_name functions [#214](https://github.com/apache/arrow-datafusion-python/pull/214) (jdye64)
-- Add PyAlias bindings [#216](https://github.com/apache/arrow-datafusion-python/pull/216) (jdye64)
-- Add bindings for scalar_variable [#218](https://github.com/apache/arrow-datafusion-python/pull/218) (jdye64)
-- Bindings for LIKE type expressions [#220](https://github.com/apache/arrow-datafusion-python/pull/220) (jdye64)
-- Bool expr bindings [#223](https://github.com/apache/arrow-datafusion-python/pull/223) (jdye64)
-- Between bindings [#229](https://github.com/apache/arrow-datafusion-python/pull/229) (jdye64)
-- Add bindings for GetIndexedField [#227](https://github.com/apache/arrow-datafusion-python/pull/227) (jdye64)
-- Add bindings for case, cast, and trycast [#232](https://github.com/apache/arrow-datafusion-python/pull/232) (jdye64)
-- add remaining expr bindings [#233](https://github.com/apache/arrow-datafusion-python/pull/233) (jdye64)
-- feature: Additional export methods [#236](https://github.com/apache/arrow-datafusion-python/pull/236) (simicd)
-- Add Python wrapper for LogicalPlan::Union [#240](https://github.com/apache/arrow-datafusion-python/pull/240) (iajoiner)
-- feature: Create dataframe from pandas, polars, dictionary, list or pyarrow Table [#242](https://github.com/apache/arrow-datafusion-python/pull/242) (simicd)
-- Add Python wrappers for `LogicalPlan::Join` and `LogicalPlan::CrossJoin` [#246](https://github.com/apache/arrow-datafusion-python/pull/246) (iajoiner)
-- feature: Set table name from ctx functions [#260](https://github.com/apache/arrow-datafusion-python/pull/260) (simicd)
-- Explain bindings [#264](https://github.com/apache/arrow-datafusion-python/pull/264) (jdye64)
-- Extension bindings [#266](https://github.com/apache/arrow-datafusion-python/pull/266) (jdye64)
-- Subquery alias bindings [#269](https://github.com/apache/arrow-datafusion-python/pull/269) (jdye64)
-- Create memory table [#271](https://github.com/apache/arrow-datafusion-python/pull/271) (jdye64)
-- Create view bindings [#273](https://github.com/apache/arrow-datafusion-python/pull/273) (jdye64)
-- Re-export Datafusion dependencies [#277](https://github.com/apache/arrow-datafusion-python/pull/277) (jdye64)
-- Distinct bindings [#275](https://github.com/apache/arrow-datafusion-python/pull/275) (jdye64)
-- Drop table bindings [#283](https://github.com/apache/arrow-datafusion-python/pull/283) (jdye64)
-- Bindings for LogicalPlan::Repartition [#285](https://github.com/apache/arrow-datafusion-python/pull/285) (jdye64)
-- Expand Rust return type support for Arrow DataTypes in ScalarValue [#287](https://github.com/apache/arrow-datafusion-python/pull/287) (jdye64)
-
-**Documentation updates:**
-
-- docs: Example of calling Python UDF & UDAF in SQL [#258](https://github.com/apache/arrow-datafusion-python/pull/258) (simicd)
-
-**Merged pull requests:**
-
-- Minor docs updates [#210](https://github.com/apache/arrow-datafusion-python/pull/210) (andygrove)
-- Empty relation bindings [#208](https://github.com/apache/arrow-datafusion-python/pull/208) (jdye64)
-- wrap display_name and canonical_name functions [#214](https://github.com/apache/arrow-datafusion-python/pull/214) (jdye64)
-- Add PyAlias bindings [#216](https://github.com/apache/arrow-datafusion-python/pull/216) (jdye64)
-- Add bindings for scalar_variable [#218](https://github.com/apache/arrow-datafusion-python/pull/218) (jdye64)
-- Bindings for LIKE type expressions [#220](https://github.com/apache/arrow-datafusion-python/pull/220) (jdye64)
-- Bool expr bindings [#223](https://github.com/apache/arrow-datafusion-python/pull/223) (jdye64)
-- Between bindings [#229](https://github.com/apache/arrow-datafusion-python/pull/229) (jdye64)
-- Add bindings for GetIndexedField [#227](https://github.com/apache/arrow-datafusion-python/pull/227) (jdye64)
-- Add bindings for case, cast, and trycast [#232](https://github.com/apache/arrow-datafusion-python/pull/232) (jdye64)
-- add remaining expr bindings [#233](https://github.com/apache/arrow-datafusion-python/pull/233) (jdye64)
-- Pre-commit hooks [#228](https://github.com/apache/arrow-datafusion-python/pull/228) (jdye64)
-- Implement new release process [#149](https://github.com/apache/arrow-datafusion-python/pull/149) (andygrove)
-- feature: Additional export methods [#236](https://github.com/apache/arrow-datafusion-python/pull/236) (simicd)
-- Add Python wrapper for LogicalPlan::Union [#240](https://github.com/apache/arrow-datafusion-python/pull/240) (iajoiner)
-- feature: Create dataframe from pandas, polars, dictionary, list or pyarrow Table [#242](https://github.com/apache/arrow-datafusion-python/pull/242) (simicd)
-- Fix release instructions [#238](https://github.com/apache/arrow-datafusion-python/pull/238) (andygrove)
-- Add Python wrappers for `LogicalPlan::Join` and `LogicalPlan::CrossJoin` [#246](https://github.com/apache/arrow-datafusion-python/pull/246) (iajoiner)
-- docs: Example of calling Python UDF & UDAF in SQL [#258](https://github.com/apache/arrow-datafusion-python/pull/258) (simicd)
-- feature: Set table name from ctx functions [#260](https://github.com/apache/arrow-datafusion-python/pull/260) (simicd)
-- Upgrade to DataFusion 19 [#262](https://github.com/apache/arrow-datafusion-python/pull/262) (andygrove)
-- Explain bindings [#264](https://github.com/apache/arrow-datafusion-python/pull/264) (jdye64)
-- Extension bindings [#266](https://github.com/apache/arrow-datafusion-python/pull/266) (jdye64)
-- Subquery alias bindings [#269](https://github.com/apache/arrow-datafusion-python/pull/269) (jdye64)
-- Create memory table [#271](https://github.com/apache/arrow-datafusion-python/pull/271) (jdye64)
-- Create view bindings [#273](https://github.com/apache/arrow-datafusion-python/pull/273) (jdye64)
-- Re-export Datafusion dependencies [#277](https://github.com/apache/arrow-datafusion-python/pull/277) (jdye64)
-- Distinct bindings [#275](https://github.com/apache/arrow-datafusion-python/pull/275) (jdye64)
-- build(deps): bump actions/checkout from 2 to 3 [#244](https://github.com/apache/arrow-datafusion-python/pull/244) (dependabot[bot])
-- build(deps): bump actions/upload-artifact from 2 to 3 [#245](https://github.com/apache/arrow-datafusion-python/pull/245) (dependabot[bot])
-- build(deps): bump actions/download-artifact from 2 to 3 [#243](https://github.com/apache/arrow-datafusion-python/pull/243) (dependabot[bot])
-- Use DataFusion 20 [#278](https://github.com/apache/arrow-datafusion-python/pull/278) (andygrove)
-- Drop table bindings [#283](https://github.com/apache/arrow-datafusion-python/pull/283) (jdye64)
-- Bindings for LogicalPlan::Repartition [#285](https://github.com/apache/arrow-datafusion-python/pull/285) (jdye64)
-- Expand Rust return type support for Arrow DataTypes in ScalarValue [#287](https://github.com/apache/arrow-datafusion-python/pull/287) (jdye64)
-
-## [0.8.0](https://github.com/apache/arrow-datafusion-python/tree/0.8.0) (2023-02-22)
-
-[Full Changelog](https://github.com/apache/arrow-datafusion-python/compare/0.8.0-rc1...0.8.0)
-
-**Implemented enhancements:**
-
-- Add support for cuDF physical execution engine [\#202](https://github.com/apache/arrow-datafusion-python/issues/202)
-- Make it easier to create a Pandas dataframe from DataFusion query results [\#139](https://github.com/apache/arrow-datafusion-python/issues/139)
-
-**Fixed bugs:**
-
-- Build error: could not compile `thiserror` due to 2 previous errors [\#69](https://github.com/apache/arrow-datafusion-python/issues/69)
-
-**Closed issues:**
-
-- Integrate with the new `object_store` crate [\#22](https://github.com/apache/arrow-datafusion-python/issues/22)
-
-**Merged pull requests:**
-
-- Update README in preparation for 0.8 release [\#206](https://github.com/apache/arrow-datafusion-python/pull/206) ([andygrove](https://github.com/andygrove))
-- Add support for cudf as a physical execution engine [\#205](https://github.com/apache/arrow-datafusion-python/pull/205) ([jdye64](https://github.com/jdye64))
-- Run `maturin develop` instead of `cargo build` in verification script [\#200](https://github.com/apache/arrow-datafusion-python/pull/200) ([andygrove](https://github.com/andygrove))
-- Add tests for recently added functionality [\#199](https://github.com/apache/arrow-datafusion-python/pull/199) ([andygrove](https://github.com/andygrove))
-- Implement `to_pandas()` [\#197](https://github.com/apache/arrow-datafusion-python/pull/197) ([simicd](https://github.com/simicd))
-- Add Python wrapper for LogicalPlan::Sort [\#196](https://github.com/apache/arrow-datafusion-python/pull/196) ([andygrove](https://github.com/andygrove))
-- Add Python wrapper for LogicalPlan::Aggregate [\#195](https://github.com/apache/arrow-datafusion-python/pull/195) ([andygrove](https://github.com/andygrove))
-- Add Python wrapper for LogicalPlan::Limit [\#193](https://github.com/apache/arrow-datafusion-python/pull/193) ([andygrove](https://github.com/andygrove))
-- Add Python wrapper for LogicalPlan::Filter [\#192](https://github.com/apache/arrow-datafusion-python/pull/192) ([andygrove](https://github.com/andygrove))
-- Add experimental support for executing SQL with Polars and Pandas [\#190](https://github.com/apache/arrow-datafusion-python/pull/190) ([andygrove](https://github.com/andygrove))
-- Update changelog for 0.8 release [\#188](https://github.com/apache/arrow-datafusion-python/pull/188) ([andygrove](https://github.com/andygrove))
-- Add ability to execute ExecutionPlan and get a stream of RecordBatch [\#186](https://github.com/apache/arrow-datafusion-python/pull/186) ([andygrove](https://github.com/andygrove))
-- Dffield bindings [\#185](https://github.com/apache/arrow-datafusion-python/pull/185) ([jdye64](https://github.com/jdye64))
-- Add bindings for DFSchema [\#183](https://github.com/apache/arrow-datafusion-python/pull/183) ([jdye64](https://github.com/jdye64))
-- test: Window functions [\#182](https://github.com/apache/arrow-datafusion-python/pull/182) ([simicd](https://github.com/simicd))
-- Add bindings for Projection [\#180](https://github.com/apache/arrow-datafusion-python/pull/180) ([jdye64](https://github.com/jdye64))
-- Table scan bindings [\#178](https://github.com/apache/arrow-datafusion-python/pull/178) ([jdye64](https://github.com/jdye64))
-- Make session configurable [\#176](https://github.com/apache/arrow-datafusion-python/pull/176) ([andygrove](https://github.com/andygrove))
-- Upgrade to DataFusion 18.0.0 [\#175](https://github.com/apache/arrow-datafusion-python/pull/175) ([andygrove](https://github.com/andygrove))
-- Use latest DataFusion rev in preparation for DF 18 release [\#174](https://github.com/apache/arrow-datafusion-python/pull/174) ([andygrove](https://github.com/andygrove))
-- Arrow type bindings [\#173](https://github.com/apache/arrow-datafusion-python/pull/173) ([jdye64](https://github.com/jdye64))
-- Pyo3 bump [\#171](https://github.com/apache/arrow-datafusion-python/pull/171) ([jdye64](https://github.com/jdye64))
-- feature: Add additional aggregation functions [\#170](https://github.com/apache/arrow-datafusion-python/pull/170) ([simicd](https://github.com/simicd))
-- Make from\_substrait\_plan return DataFrame instead of LogicalPlan [\#164](https://github.com/apache/arrow-datafusion-python/pull/164) ([andygrove](https://github.com/andygrove))
-- feature: Implement count method [\#163](https://github.com/apache/arrow-datafusion-python/pull/163) ([simicd](https://github.com/simicd))
-- CI Fixes [\#162](https://github.com/apache/arrow-datafusion-python/pull/162) ([jdye64](https://github.com/jdye64))
-- Upgrade to DataFusion 17 [\#160](https://github.com/apache/arrow-datafusion-python/pull/160) ([andygrove](https://github.com/andygrove))
-- feature: Improve string representation of datafusion classes [\#159](https://github.com/apache/arrow-datafusion-python/pull/159) ([simicd](https://github.com/simicd))
-- Make PyExecutionPlan.plan public [\#156](https://github.com/apache/arrow-datafusion-python/pull/156) ([andygrove](https://github.com/andygrove))
-- Expose methods on logical and execution plans [\#155](https://github.com/apache/arrow-datafusion-python/pull/155) ([andygrove](https://github.com/andygrove))
-- Fix clippy for new Rust version [\#154](https://github.com/apache/arrow-datafusion-python/pull/154) ([andygrove](https://github.com/andygrove))
-- Add DataFrame methods for accessing plans [\#153](https://github.com/apache/arrow-datafusion-python/pull/153) ([andygrove](https://github.com/andygrove))
-- Use DataFusion rev 5238e8c97f998b4d2cb9fab85fb182f325a1a7fb [\#150](https://github.com/apache/arrow-datafusion-python/pull/150) ([andygrove](https://github.com/andygrove))
-- build\(deps\): bump async-trait from 0.1.61 to 0.1.62 [\#148](https://github.com/apache/arrow-datafusion-python/pull/148) ([dependabot[bot]](https://github.com/apps/dependabot))
-- Rename default branch from master to main [\#147](https://github.com/apache/arrow-datafusion-python/pull/147) ([andygrove](https://github.com/andygrove))
-- Substrait bindings [\#145](https://github.com/apache/arrow-datafusion-python/pull/145) ([jdye64](https://github.com/jdye64))
-- build\(deps\): bump uuid from 0.8.2 to 1.2.2 [\#143](https://github.com/apache/arrow-datafusion-python/pull/143) ([dependabot[bot]](https://github.com/apps/dependabot))
-- Prepare for 0.8.0 release [\#141](https://github.com/apache/arrow-datafusion-python/pull/141) ([andygrove](https://github.com/andygrove))
-- Improve README and add more examples [\#137](https://github.com/apache/arrow-datafusion-python/pull/137) ([andygrove](https://github.com/andygrove))
-- test: Expand tests for built-in functions [\#129](https://github.com/apache/arrow-datafusion-python/pull/129) ([simicd](https://github.com/simicd))
-- build\(deps\): bump object\_store from 0.5.2 to 0.5.3 [\#126](https://github.com/apache/arrow-datafusion-python/pull/126) ([dependabot[bot]](https://github.com/apps/dependabot))
-- build\(deps\): bump mimalloc from 0.1.32 to 0.1.34 [\#125](https://github.com/apache/arrow-datafusion-python/pull/125) ([dependabot[bot]](https://github.com/apps/dependabot))
-- Introduce conda directory containing datafusion-dev.yaml conda enviro… [\#124](https://github.com/apache/arrow-datafusion-python/pull/124) ([jdye64](https://github.com/jdye64))
-- build\(deps\): bump bzip2 from 0.4.3 to 0.4.4 [\#121](https://github.com/apache/arrow-datafusion-python/pull/121) ([dependabot[bot]](https://github.com/apps/dependabot))
-- build\(deps\): bump tokio from 1.23.0 to 1.24.1 [\#119](https://github.com/apache/arrow-datafusion-python/pull/119) ([dependabot[bot]](https://github.com/apps/dependabot))
-- build\(deps\): bump async-trait from 0.1.60 to 0.1.61 [\#118](https://github.com/apache/arrow-datafusion-python/pull/118) ([dependabot[bot]](https://github.com/apps/dependabot))
-- Upgrade to DataFusion 16.0.0 [\#115](https://github.com/apache/arrow-datafusion-python/pull/115) ([andygrove](https://github.com/andygrove))
-- Bump async-trait from 0.1.57 to 0.1.60 [\#114](https://github.com/apache/arrow-datafusion-python/pull/114) ([dependabot[bot]](https://github.com/apps/dependabot))
-- Bump object\_store from 0.5.1 to 0.5.2 [\#112](https://github.com/apache/arrow-datafusion-python/pull/112) ([dependabot[bot]](https://github.com/apps/dependabot))
-- Bump tokio from 1.21.2 to 1.23.0 [\#109](https://github.com/apache/arrow-datafusion-python/pull/109) ([dependabot[bot]](https://github.com/apps/dependabot))
-- Add entries for publishing production \(asf-site\) and staging docs [\#107](https://github.com/apache/arrow-datafusion-python/pull/107) ([martin-g](https://github.com/martin-g))
-- Add a workflow that builds the docs and deploys them at staged or production [\#104](https://github.com/apache/arrow-datafusion-python/pull/104) ([martin-g](https://github.com/martin-g))
-- Upgrade to DataFusion 15.0.0 [\#103](https://github.com/apache/arrow-datafusion-python/pull/103) ([andygrove](https://github.com/andygrove))
-- build\(deps\): bump futures from 0.3.24 to 0.3.25 [\#102](https://github.com/apache/arrow-datafusion-python/pull/102) ([dependabot[bot]](https://github.com/apps/dependabot))
-- build\(deps\): bump pyo3 from 0.17.2 to 0.17.3 [\#101](https://github.com/apache/arrow-datafusion-python/pull/101) ([dependabot[bot]](https://github.com/apps/dependabot))
-- build\(deps\): bump mimalloc from 0.1.30 to 0.1.32 [\#98](https://github.com/apache/arrow-datafusion-python/pull/98) ([dependabot[bot]](https://github.com/apps/dependabot))
-- build\(deps\): bump rand from 0.7.3 to 0.8.5 [\#97](https://github.com/apache/arrow-datafusion-python/pull/97) ([dependabot[bot]](https://github.com/apps/dependabot))
-- Fix GitHub actions warnings [\#95](https://github.com/apache/arrow-datafusion-python/pull/95) ([martin-g](https://github.com/martin-g))
-- Fixes \#81 - Add CI workflow for source distribution [\#93](https://github.com/apache/arrow-datafusion-python/pull/93) ([martin-g](https://github.com/martin-g))
-- post-release updates [\#91](https://github.com/apache/arrow-datafusion-python/pull/91) ([andygrove](https://github.com/andygrove))
-- Build for manylinux 2014 [\#88](https://github.com/apache/arrow-datafusion-python/pull/88) ([martin-g](https://github.com/martin-g))
-- update release readme tag [\#86](https://github.com/apache/arrow-datafusion-python/pull/86) ([Jimexist](https://github.com/Jimexist))
-- Upgrade Maturin to 0.14.2 [\#85](https://github.com/apache/arrow-datafusion-python/pull/85) ([martin-g](https://github.com/martin-g))
-- Update release instructions [\#83](https://github.com/apache/arrow-datafusion-python/pull/83) ([andygrove](https://github.com/andygrove))
-- \[Functions\] - Add python function binding to `functions` [\#73](https://github.com/apache/arrow-datafusion-python/pull/73) ([francis-du](https://github.com/francis-du))
-
-## [0.8.0-rc1](https://github.com/apache/arrow-datafusion-python/tree/0.8.0-rc1) (2023-02-17)
-
-[Full Changelog](https://github.com/apache/arrow-datafusion-python/compare/0.7.0-rc2...0.8.0-rc1)
-
-**Implemented enhancements:**
-
-- Add bindings for datafusion\_common::DFField [\#184](https://github.com/apache/arrow-datafusion-python/issues/184)
-- Add bindings for DFSchema/DFSchemaRef [\#181](https://github.com/apache/arrow-datafusion-python/issues/181)
-- Add bindings for datafusion\_expr Projection [\#179](https://github.com/apache/arrow-datafusion-python/issues/179)
-- Add bindings for `TableScan` struct from `datafusion_expr::TableScan` [\#177](https://github.com/apache/arrow-datafusion-python/issues/177)
-- Add a "mapping" struct for types [\#172](https://github.com/apache/arrow-datafusion-python/issues/172)
-- Improve string representation of datafusion classes \(dataframe, context, expression, ...\) [\#158](https://github.com/apache/arrow-datafusion-python/issues/158)
-- Add DataFrame count method [\#151](https://github.com/apache/arrow-datafusion-python/issues/151)
-- \[REQUEST\] Github Actions Improvements [\#146](https://github.com/apache/arrow-datafusion-python/issues/146)
-- Change default branch name from master to main [\#144](https://github.com/apache/arrow-datafusion-python/issues/144)
-- Bump pyo3 to 0.18.0 [\#140](https://github.com/apache/arrow-datafusion-python/issues/140)
-- Add script for Python linting [\#134](https://github.com/apache/arrow-datafusion-python/issues/134)
-- Add Python bindings for substrait module [\#132](https://github.com/apache/arrow-datafusion-python/issues/132)
-- Expand unit tests for built-in functions [\#128](https://github.com/apache/arrow-datafusion-python/issues/128)
-- support creating arrow-datafusion-python conda environment [\#122](https://github.com/apache/arrow-datafusion-python/issues/122)
-- Build Python source distribution in GitHub workflow [\#81](https://github.com/apache/arrow-datafusion-python/issues/81)
-- EPIC: Add all functions to python binding `functions` [\#72](https://github.com/apache/arrow-datafusion-python/issues/72)
-
-**Fixed bugs:**
-
-- Build is broken [\#161](https://github.com/apache/arrow-datafusion-python/issues/161)
-- Out of memory when sorting [\#157](https://github.com/apache/arrow-datafusion-python/issues/157)
-- window\_lead test appears to be non-deterministic [\#135](https://github.com/apache/arrow-datafusion-python/issues/135)
-- Reading csv does not work [\#130](https://github.com/apache/arrow-datafusion-python/issues/130)
-- Github actions produce a lot of warnings [\#94](https://github.com/apache/arrow-datafusion-python/issues/94)
-- ASF source release tarball has wrong directory name [\#90](https://github.com/apache/arrow-datafusion-python/issues/90)
-- Python Release Build failing after upgrading to maturin 14.2 [\#87](https://github.com/apache/arrow-datafusion-python/issues/87)
-- Maturin build hangs on Linux ARM64 [\#84](https://github.com/apache/arrow-datafusion-python/issues/84)
-- Cannot install on Mac M1 from source tarball from testpypi [\#82](https://github.com/apache/arrow-datafusion-python/issues/82)
-- ImportPathMismatchError when running pytest locally [\#77](https://github.com/apache/arrow-datafusion-python/issues/77)
-
-**Closed issues:**
-
-- Publish documentation for Python bindings [\#39](https://github.com/apache/arrow-datafusion-python/issues/39)
-- Add Python binding for `approx_median` [\#32](https://github.com/apache/arrow-datafusion-python/issues/32)
-- Release version 0.7.0 [\#7](https://github.com/apache/arrow-datafusion-python/issues/7)
-
-## [0.7.0-rc2](https://github.com/apache/arrow-datafusion-python/tree/0.7.0-rc2) (2022-11-26)
-
-[Full Changelog](https://github.com/apache/arrow-datafusion-python/compare/0.7.0...0.7.0-rc2)
-
-
-## [Unreleased](https://github.com/datafusion-contrib/datafusion-python/tree/HEAD)
-
-[Full Changelog](https://github.com/datafusion-contrib/datafusion-python/compare/0.5.1...HEAD)
-
-**Merged pull requests:**
-
-- use \_\_getitem\_\_ for df column selection [\#41](https://github.com/datafusion-contrib/datafusion-python/pull/41) ([Jimexist](https://github.com/Jimexist))
-- fix demo in readme [\#40](https://github.com/datafusion-contrib/datafusion-python/pull/40) ([Jimexist](https://github.com/Jimexist))
-- Implement select_columns [\#39](https://github.com/datafusion-contrib/datafusion-python/pull/39) ([andygrove](https://github.com/andygrove))
-- update readme and changelog [\#38](https://github.com/datafusion-contrib/datafusion-python/pull/38) ([Jimexist](https://github.com/Jimexist))
-- Add PyDataFrame.explain [\#36](https://github.com/datafusion-contrib/datafusion-python/pull/36) ([andygrove](https://github.com/andygrove))
-- Release 0.5.0 [\#34](https://github.com/datafusion-contrib/datafusion-python/pull/34) ([Jimexist](https://github.com/Jimexist))
-- disable nightly in workflow [\#33](https://github.com/datafusion-contrib/datafusion-python/pull/33) ([Jimexist](https://github.com/Jimexist))
-- update requirements to 37 and 310, update readme [\#32](https://github.com/datafusion-contrib/datafusion-python/pull/32) ([Jimexist](https://github.com/Jimexist))
-- Add custom global allocator [\#30](https://github.com/datafusion-contrib/datafusion-python/pull/30) ([matthewmturner](https://github.com/matthewmturner))
-- Remove pandas dependency [\#25](https://github.com/datafusion-contrib/datafusion-python/pull/25) ([matthewmturner](https://github.com/matthewmturner))
-- upgrade datafusion and pyo3 [\#20](https://github.com/datafusion-contrib/datafusion-python/pull/20) ([Jimexist](https://github.com/Jimexist))
-- update maturin 0.12+ [\#17](https://github.com/datafusion-contrib/datafusion-python/pull/17) ([Jimexist](https://github.com/Jimexist))
-- Update README.md [\#16](https://github.com/datafusion-contrib/datafusion-python/pull/16) ([Jimexist](https://github.com/Jimexist))
-- apply cargo clippy --fix [\#15](https://github.com/datafusion-contrib/datafusion-python/pull/15) ([Jimexist](https://github.com/Jimexist))
-- update test workflow to include rust clippy and check [\#14](https://github.com/datafusion-contrib/datafusion-python/pull/14) ([Jimexist](https://github.com/Jimexist))
-- use maturin 0.12.6 [\#13](https://github.com/datafusion-contrib/datafusion-python/pull/13) ([Jimexist](https://github.com/Jimexist))
-- apply cargo fmt [\#12](https://github.com/datafusion-contrib/datafusion-python/pull/12) ([Jimexist](https://github.com/Jimexist))
-- use stable not nightly [\#11](https://github.com/datafusion-contrib/datafusion-python/pull/11) ([Jimexist](https://github.com/Jimexist))
-- ci: test against more compilers, setup clippy and fix clippy lints [\#9](https://github.com/datafusion-contrib/datafusion-python/pull/9) ([cpcloud](https://github.com/cpcloud))
-- Fix use of importlib.metadata and unify requirements.txt [\#8](https://github.com/datafusion-contrib/datafusion-python/pull/8) ([cpcloud](https://github.com/cpcloud))
-- Ship the Cargo.lock file in the source distribution [\#7](https://github.com/datafusion-contrib/datafusion-python/pull/7) ([cpcloud](https://github.com/cpcloud))
-- add \_\_version\_\_ attribute to datafusion object [\#3](https://github.com/datafusion-contrib/datafusion-python/pull/3) ([tfeda](https://github.com/tfeda))
-- fix ci by fixing directories [\#2](https://github.com/datafusion-contrib/datafusion-python/pull/2) ([Jimexist](https://github.com/Jimexist))
-- setup workflow [\#1](https://github.com/datafusion-contrib/datafusion-python/pull/1) ([Jimexist](https://github.com/Jimexist))
-
-## [0.5.1](https://github.com/datafusion-contrib/datafusion-python/tree/0.5.1) (2022-03-15)
-
-[Full Changelog](https://github.com/datafusion-contrib/datafusion-python/compare/0.5.1-rc1...0.5.1)
-
-## [0.5.1-rc1](https://github.com/datafusion-contrib/datafusion-python/tree/0.5.1-rc1) (2022-03-15)
-
-[Full Changelog](https://github.com/datafusion-contrib/datafusion-python/compare/0.5.0...0.5.1-rc1)
-
-## [0.5.0](https://github.com/datafusion-contrib/datafusion-python/tree/0.5.0) (2022-03-10)
-
-[Full Changelog](https://github.com/datafusion-contrib/datafusion-python/compare/0.5.0-rc2...0.5.0)
-
-## [0.5.0-rc2](https://github.com/datafusion-contrib/datafusion-python/tree/0.5.0-rc2) (2022-03-10)
-
-[Full Changelog](https://github.com/datafusion-contrib/datafusion-python/compare/0.5.0-rc1...0.5.0-rc2)
-
-**Closed issues:**
-
-- Add support for Ballista [\#37](https://github.com/datafusion-contrib/datafusion-python/issues/37)
-- Implement DataFrame.explain [\#35](https://github.com/datafusion-contrib/datafusion-python/issues/35)
-
-## [0.5.0-rc1](https://github.com/datafusion-contrib/datafusion-python/tree/0.5.0-rc1) (2022-03-09)
-
-[Full Changelog](https://github.com/datafusion-contrib/datafusion-python/compare/4c98b8e9c3c3f8e2e6a8f2d1ffcfefda344c4680...0.5.0-rc1)
-
-**Closed issues:**
-
-- Investigate exposing additional optimizations [\#28](https://github.com/datafusion-contrib/datafusion-python/issues/28)
-- Use custom allocator in Python build [\#27](https://github.com/datafusion-contrib/datafusion-python/issues/27)
-- Why is pandas a requirement? [\#24](https://github.com/datafusion-contrib/datafusion-python/issues/24)
-- Unable to build [\#18](https://github.com/datafusion-contrib/datafusion-python/issues/18)
-- Setup CI against multiple Python version [\#6](https://github.com/datafusion-contrib/datafusion-python/issues/6)
-
-\* _This Changelog was automatically generated by [github_changelog_generator](https://github.com/github-changelog-generator/github-changelog-generator)_
-
-
-\* *This Changelog was automatically generated by [github_changelog_generator](https://github.com/github-changelog-generator/github-changelog-generator)*
+The changelogs have now moved [here](./dev/changelog).
diff --git a/Cargo.lock b/Cargo.lock
index 23f1486b4..40b1ba7f1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,37 +1,80 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
-name = "adler"
-version = "1.0.2"
+name = "abi_stable"
+version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+checksum = "69d6512d3eb05ffe5004c59c206de7f99c34951504056ce23fc953842f12c445"
+dependencies = [
+ "abi_stable_derive",
+ "abi_stable_shared",
+ "const_panic",
+ "core_extensions",
+ "crossbeam-channel",
+ "generational-arena",
+ "libloading",
+ "lock_api",
+ "parking_lot",
+ "paste",
+ "repr_offset",
+ "rustc_version",
+ "serde",
+ "serde_derive",
+ "serde_json",
+]
 
 [[package]]
-name = "adler32"
-version = "1.2.0"
+name = "abi_stable_derive"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7178468b407a4ee10e881bc7a328a65e739f0863615cca4429d43916b05e898"
+dependencies = [
+ "abi_stable_shared",
+ "as_derive_utils",
+ "core_extensions",
+ "proc-macro2",
+ "quote",
+ "rustc_version",
+ "syn 1.0.109",
+ "typed-arena",
+]
+
+[[package]]
+name = "abi_stable_shared"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2b5df7688c123e63f4d4d649cba63f2967ba7f7861b1664fca3f77d3dad2b63"
+dependencies = [
+ "core_extensions",
+]
+
+[[package]]
+name = "adler2"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aae1277d39aeec15cb388266ecc24b11c80469deae6067e17a1a7aa9e5c1f234"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
 [[package]]
 name = "ahash"
-version = "0.8.3"
+version = "0.8.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c99f64d1e06488f620f932677e24bc6e2897582980441ae90a671415bd7ec2f"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
 dependencies = [
  "cfg-if",
  "const-random",
- "getrandom",
+ "getrandom 0.3.4",
  "once_cell",
  "version_check",
+ "zerocopy",
 ]
 
 [[package]]
 name = "aho-corasick"
-version = "0.7.20"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc936419f96fa211c1b9166887b38e5e40b19958e5b895be7c1f93adec7071ac"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
 dependencies = [
  "memchr",
 ]
@@ -51,6 +94,12 @@ dependencies = [
  "alloc-no-stdlib",
 ]
 
+[[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+
 [[package]]
 name = "android_system_properties"
 version = "0.1.5"
@@ -62,56 +111,75 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.69"
+version = "1.0.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "224afbd727c3d6e4b90103ece64b8d1b67fbb1973b1046c2281eed3f3803f800"
+checksum = "5f0e0fee31ef5ed1ba1316088939cea399010ed7731dba877ed44aeb407a75ea"
 
 [[package]]
 name = "apache-avro"
-version = "0.14.0"
+version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cf4144857f9e4d7dd6cc4ba4c78efd2a46bad682b029bd0d91e76a021af1b2a"
+checksum = "36fa98bc79671c7981272d91a8753a928ff6a1cd8e4f20a44c45bd5d313840bf"
 dependencies = [
- "byteorder",
+ "bigdecimal",
+ "bon",
+ "bzip2",
  "crc32fast",
  "digest",
- "lazy_static",
- "libflate",
+ "liblzma",
  "log",
+ "miniz_oxide",
  "num-bigint",
  "quad-rand",
  "rand",
- "regex",
+ "regex-lite",
  "serde",
+ "serde_bytes",
  "serde_json",
  "snap",
  "strum",
  "strum_macros",
  "thiserror",
- "typed-builder",
  "uuid",
- "zerocopy",
+ "zstd",
+]
+
+[[package]]
+name = "ar_archive_writer"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7eb93bbb63b9c227414f6eb3a0adfddca591a8ce1e9b60661bb08969b87e340b"
+dependencies = [
+ "object",
+]
+
+[[package]]
+name = "arc-swap"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9f3647c145568cec02c42054e07bdf9a5a698e15b466fb2341bfc393cd24aa5"
+dependencies = [
+ "rustversion",
 ]
 
 [[package]]
 name = "arrayref"
-version = "0.3.6"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544"
+checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
 
 [[package]]
 name = "arrayvec"
-version = "0.7.2"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
 [[package]]
 name = "arrow"
-version = "34.0.0"
+version = "58.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f410d3907b6b3647b9e7bca4551274b2e3d716aa940afb67b7287257401da921"
+checksum = "602268ce9f569f282cedb9a9f6bac569b680af47b9b077d515900c03c5d190da"
 dependencies = [
- "ahash",
  "arrow-arith",
  "arrow-array",
  "arrow-buffer",
@@ -121,121 +189,129 @@ dependencies = [
  "arrow-ipc",
  "arrow-json",
  "arrow-ord",
+ "arrow-pyarrow",
  "arrow-row",
  "arrow-schema",
  "arrow-select",
  "arrow-string",
- "comfy-table",
- "pyo3",
 ]
 
 [[package]]
 name = "arrow-arith"
-version = "34.0.0"
+version = "58.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f87391cf46473c9bc53dab68cb8872c3a81d4dfd1703f1c8aa397dba9880a043"
+checksum = "cd53c6bf277dea91f136ae8e3a5d7041b44b5e489e244e637d00ae302051f56f"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
  "arrow-data",
  "arrow-schema",
  "chrono",
- "half",
- "num",
+ "num-traits",
 ]
 
 [[package]]
 name = "arrow-array"
-version = "34.0.0"
+version = "58.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d35d5475e65c57cffba06d0022e3006b677515f99b54af33a7cd54f6cdd4a5b5"
+checksum = "e53796e07a6525edaf7dc28b540d477a934aff14af97967ad1d5550878969b9e"
 dependencies = [
  "ahash",
  "arrow-buffer",
  "arrow-data",
  "arrow-schema",
  "chrono",
+ "chrono-tz",
  "half",
- "hashbrown 0.13.2",
- "num",
+ "hashbrown 0.16.1",
+ "num-complex",
+ "num-integer",
+ "num-traits",
 ]
 
 [[package]]
 name = "arrow-buffer"
-version = "34.0.0"
+version = "58.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68b4ec72eda7c0207727df96cf200f539749d736b21f3e782ece113e18c1a0a7"
+checksum = "f2c1a85bb2e94ee10b76531d8bc3ce9b7b4c0d508cabfb17d477f63f2617bd20"
 dependencies = [
+ "bytes",
  "half",
- "num",
+ "num-bigint",
+ "num-traits",
 ]
 
 [[package]]
 name = "arrow-cast"
-version = "34.0.0"
+version = "58.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a7285272c9897321dfdba59de29f5b05aeafd3cdedf104a941256d155f6d304"
+checksum = "89fb245db6b0e234ed8e15b644edb8664673fefe630575e94e62cd9d489a8a26"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
  "arrow-data",
+ "arrow-ord",
  "arrow-schema",
  "arrow-select",
+ "atoi",
+ "base64",
  "chrono",
+ "comfy-table",
+ "half",
  "lexical-core",
- "num",
+ "num-traits",
+ "ryu",
 ]
 
 [[package]]
 name = "arrow-csv"
-version = "34.0.0"
+version = "58.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "981ee4e7f6a120da04e00d0b39182e1eeacccb59c8da74511de753c56b7fddf7"
+checksum = "d374882fb465a194462527c0c15a93aa19a554cf690a6b77a26b2a02539937a7"
 dependencies = [
  "arrow-array",
- "arrow-buffer",
  "arrow-cast",
- "arrow-data",
  "arrow-schema",
  "chrono",
  "csv",
  "csv-core",
- "lazy_static",
- "lexical-core",
  "regex",
 ]
 
 [[package]]
 name = "arrow-data"
-version = "34.0.0"
+version = "58.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27cc673ee6989ea6e4b4e8c7d461f7e06026a096c8f0b1a7288885ff71ae1e56"
+checksum = "189d210bc4244c715fa3ed9e6e22864673cccb73d5da28c2723fb2e527329b33"
 dependencies = [
  "arrow-buffer",
  "arrow-schema",
  "half",
- "num",
+ "num-integer",
+ "num-traits",
 ]
 
 [[package]]
 name = "arrow-ipc"
-version = "34.0.0"
+version = "58.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e37b8b69d9e59116b6b538e8514e0ec63a30f08b617ce800d31cb44e3ef64c1a"
+checksum = "7968c2e5210c41f4909b2ef76f6e05e172b99021c2def5edf3cc48fdd39d1d6c"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
- "arrow-cast",
  "arrow-data",
  "arrow-schema",
+ "arrow-select",
  "flatbuffers",
+ "lz4_flex",
+ "zstd",
 ]
 
 [[package]]
 name = "arrow-json"
-version = "34.0.0"
+version = "58.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80c3fa0bed7cfebf6d18e46b733f9cb8a1cb43ce8e6539055ca3e1e48a426266"
+checksum = "92111dba5bf900f443488e01f00d8c4ddc2f47f5c50039d18120287b580baa22"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -245,134 +321,197 @@ dependencies = [
  "chrono",
  "half",
  "indexmap",
+ "itoa",
  "lexical-core",
- "num",
+ "memchr",
+ "num-traits",
+ "ryu",
+ "serde_core",
  "serde_json",
+ "simdutf8",
 ]
 
 [[package]]
 name = "arrow-ord"
-version = "34.0.0"
+version = "58.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d247dce7bed6a8d6a3c6debfa707a3a2f694383f0c692a39d736a593eae5ef94"
+checksum = "211136cb253577ee1a6665f741a13136d4e563f64f5093ffd6fb837af90b9495"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
  "arrow-data",
  "arrow-schema",
  "arrow-select",
- "num",
+]
+
+[[package]]
+name = "arrow-pyarrow"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "205437da4c0877c756c81bfe847a621d0a740cd00a155109d65510a1a62ebcd9"
+dependencies = [
+ "arrow-array",
+ "arrow-data",
+ "arrow-schema",
+ "pyo3",
 ]
 
 [[package]]
 name = "arrow-row"
-version = "34.0.0"
+version = "58.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d609c0181f963cea5c70fddf9a388595b5be441f3aa1d1cdbf728ca834bbd3a"
+checksum = "8e0f20145f9f5ea3fe383e2ba7a7487bf19be36aa9dbf5dd6a1f92f657179663"
 dependencies = [
- "ahash",
  "arrow-array",
  "arrow-buffer",
  "arrow-data",
  "arrow-schema",
  "half",
- "hashbrown 0.13.2",
 ]
 
 [[package]]
 name = "arrow-schema"
-version = "34.0.0"
+version = "58.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64951898473bfb8e22293e83a44f02874d2257514d49cd95f9aa4afcff183fbc"
+checksum = "1b47e0ca91cc438d2c7879fe95e0bca5329fff28649e30a88c6f760b1faeddcb"
 dependencies = [
  "bitflags",
+ "serde_core",
+ "serde_json",
 ]
 
 [[package]]
 name = "arrow-select"
-version = "34.0.0"
+version = "58.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a513d89c2e1ac22b28380900036cf1f3992c6443efc5e079de631dcf83c6888"
+checksum = "750a7d1dda177735f5e82a314485b6915c7cccdbb278262ac44090f4aba4a325"
 dependencies = [
+ "ahash",
  "arrow-array",
  "arrow-buffer",
  "arrow-data",
  "arrow-schema",
- "num",
+ "num-traits",
 ]
 
 [[package]]
 name = "arrow-string"
-version = "34.0.0"
+version = "58.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5288979b2705dae1114c864d73150629add9153b9b8f1d7ee3963db94c372ba5"
+checksum = "e1eab1208bc4fe55d768cdc9b9f3d9df5a794cdb3ee2586bf89f9b30dc31ad8c"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
  "arrow-data",
  "arrow-schema",
  "arrow-select",
+ "memchr",
+ "num-traits",
  "regex",
  "regex-syntax",
 ]
 
+[[package]]
+name = "as_derive_utils"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff3c96645900a44cf11941c111bd08a6573b0e2f9f69bc9264b179d8fae753c4"
+dependencies = [
+ "core_extensions",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "async-compression"
-version = "0.3.15"
+version = "0.4.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "942c7cd7ae39e91bde4820d74132e9862e62c2f386c3aa90ccf55949f5bad63a"
+checksum = "7d67d43201f4d20c78bcda740c142ca52482d81da80681533d33bf3f0596c8e2"
 dependencies = [
- "bzip2",
- "flate2",
- "futures-core",
- "futures-io",
- "memchr",
+ "compression-codecs",
+ "compression-core",
  "pin-project-lite",
  "tokio",
- "xz2",
- "zstd 0.11.2+zstd.1.5.2",
- "zstd-safe 5.0.2+zstd.1.5.2",
+]
+
+[[package]]
+name = "async-ffi"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4de21c0feef7e5a556e51af767c953f0501f7f300ba785cc99c47bdc8081a50"
+dependencies = [
+ "abi_stable",
 ]
 
 [[package]]
 name = "async-recursion"
-version = "1.0.2"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b015a331cc64ebd1774ba119538573603427eaace0a1950c423ab971f903796"
+checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "async-trait"
-version = "0.1.66"
+version = "0.1.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b84f9ebcc6c1f5b8cb160f6990096a5c127f423fcb6e1ccc46c370cbdfb75dfc"
+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "atoi"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f28d99ec8bfea296261ca1af174f24225171fea9664ba9003cbebee704810528"
+dependencies = [
+ "num-traits",
 ]
 
+[[package]]
+name = "atomic-waker"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
+
 [[package]]
 name = "autocfg"
-version = "1.1.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
 name = "base64"
-version = "0.21.0"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "bigdecimal"
+version = "0.4.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4a4ddaa51a5bc52a6948f74c06d20aaaddb71924eab79b8c97a8c556e942d6a"
+checksum = "4d6867f1565b3aad85681f1015055b087fcfd840d6aeee6eee7f2da317603695"
+dependencies = [
+ "autocfg",
+ "libm",
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+ "serde",
+]
 
 [[package]]
 name = "bitflags"
-version = "1.3.2"
+version = "2.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
 
 [[package]]
 name = "blake2"
@@ -385,16 +524,16 @@ dependencies = [
 
 [[package]]
 name = "blake3"
-version = "1.3.3"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42ae2468a89544a466886840aa467a25b766499f4f04bf7d9fcd10ecee9fccef"
+checksum = "2468ef7d57b3fb7e16b576e8377cdbde2320c60e1491e961d11da40fc4f02a2d"
 dependencies = [
  "arrayref",
  "arrayvec",
  "cc",
  "cfg-if",
  "constant_time_eq",
- "digest",
+ "cpufeatures",
 ]
 
 [[package]]
@@ -406,11 +545,36 @@ dependencies = [
  "generic-array",
 ]
 
+[[package]]
+name = "bon"
+version = "3.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d13a61f2963b88eef9c1be03df65d42f6996dfeac1054870d950fcf66686f83"
+dependencies = [
+ "bon-macros",
+ "rustversion",
+]
+
+[[package]]
+name = "bon-macros"
+version = "3.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d314cc62af2b6b0c65780555abb4d02a03dd3b799cd42419044f0c38d99738c0"
+dependencies = [
+ "darling",
+ "ident_case",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn 2.0.117",
+]
+
 [[package]]
 name = "brotli"
-version = "3.3.4"
+version = "8.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1a0b1dbcc8ae29329621f8d4f0d835787c1c38bb1401979b49d13b0b305ff68"
+checksum = "4bd8b9603c7aa97359dbd97ecf258968c95f3adddd6db2f7e7a5bef101c84560"
 dependencies = [
  "alloc-no-stdlib",
  "alloc-stdlib",
@@ -419,9 +583,9 @@ dependencies = [
 
 [[package]]
 name = "brotli-decompressor"
-version = "2.3.4"
+version = "5.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b6561fd3f895a11e8f72af2cb7d22e08366bebc2b6b57f7744c4bda27034744"
+checksum = "874bb8112abecc98cbd6d81ea4fa7e94fb9449648c93cc89aa40c81c24d7de03"
 dependencies = [
  "alloc-no-stdlib",
  "alloc-stdlib",
@@ -429,236 +593,306 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.12.0"
+version = "3.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d261e256854913907f67ed06efbc3338dfe6179796deefc1ff763fc1aee5535"
+checksum = "5c6f81257d10a0f602a294ae4182251151ff97dbb504ef9afcdda4a64b24d9b4"
 
 [[package]]
 name = "byteorder"
-version = "1.4.3"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "bytes"
-version = "1.4.0"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89b2fd2a0dcf38d7971e2194b6b6eebab45ae01067456a7fd93d5547a61b70be"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
 
 [[package]]
 name = "bzip2"
-version = "0.4.4"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdb116a6ef3f6c3698828873ad02c3014b3c85cadb88496095628e3ef1e347f8"
+checksum = "f3a53fac24f34a81bc9954b5d6cfce0c21e18ec6959f44f56e8e90e4bb7c346c"
 dependencies = [
- "bzip2-sys",
- "libc",
+ "libbz2-rs-sys",
 ]
 
 [[package]]
-name = "bzip2-sys"
-version = "0.1.11+1.0.8"
+name = "cc"
+version = "1.2.56"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "736a955f3fa7875102d57c82b8cac37ec45224a07fd32d58f9f7a186b6cd4cdc"
+checksum = "aebf35691d1bfb0ac386a69bac2fde4dd276fb618cf8bf4f5318fe285e821bb2"
 dependencies = [
- "cc",
+ "find-msvc-tools",
+ "jobserver",
  "libc",
- "pkg-config",
+ "shlex",
 ]
 
 [[package]]
-name = "cc"
-version = "1.0.79"
+name = "cfg-if"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
-dependencies = [
- "jobserver",
-]
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
-name = "cfg-if"
-version = "1.0.0"
+name = "cfg_aliases"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
 [[package]]
 name = "chrono"
-version = "0.4.24"
+version = "0.4.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e3c5919066adf22df73762e50cffcde3a758f2a848b113b586d1f86728b673b"
+checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0"
 dependencies = [
  "iana-time-zone",
- "js-sys",
- "num-integer",
  "num-traits",
  "serde",
- "time",
- "wasm-bindgen",
- "winapi",
+ "windows-link",
 ]
 
 [[package]]
-name = "codespan-reporting"
-version = "0.11.1"
+name = "chrono-tz"
+version = "0.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
+checksum = "a6139a8597ed92cf816dfb33f5dd6cf0bb93a6adc938f11039f371bc5bcd26c3"
 dependencies = [
- "termcolor",
- "unicode-width",
+ "chrono",
+ "phf",
+]
+
+[[package]]
+name = "cmake"
+version = "0.1.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75443c44cd6b379beb8c5b45d85d0773baf31cce901fe7bb252f4eff3008ef7d"
+dependencies = [
+ "cc",
 ]
 
 [[package]]
 name = "comfy-table"
-version = "6.1.4"
+version = "7.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e7b787b0dc42e8111badfdbe4c3059158ccb2db8780352fa1b01e8ccf45cc4d"
+checksum = "958c5d6ecf1f214b4c2bbbbf6ab9523a864bd136dcf71a7e8904799acfe1ad47"
 dependencies = [
- "strum",
- "strum_macros",
+ "unicode-segmentation",
  "unicode-width",
 ]
 
+[[package]]
+name = "compression-codecs"
+version = "0.4.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb7b51a7d9c967fc26773061ba86150f19c50c0d65c887cb1fbe295fd16619b7"
+dependencies = [
+ "bzip2",
+ "compression-core",
+ "flate2",
+ "liblzma",
+ "memchr",
+ "zstd",
+ "zstd-safe",
+]
+
+[[package]]
+name = "compression-core"
+version = "0.4.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75984efb6ed102a0d42db99afb6c1948f0380d1d91808d5529916e6c08b49d8d"
+
 [[package]]
 name = "const-random"
-version = "0.1.15"
+version = "0.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "368a7a772ead6ce7e1de82bfb04c485f3db8ec744f72925af5735e29a22cc18e"
+checksum = "87e00182fe74b066627d63b85fd550ac2998d4b0bd86bfed477a0ae4c7c71359"
 dependencies = [
  "const-random-macro",
- "proc-macro-hack",
 ]
 
 [[package]]
 name = "const-random-macro"
-version = "0.1.15"
+version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d7d6ab3c3a2282db210df5f02c4dab6e0a7057af0fb7ebd4070f30fe05c0ddb"
+checksum = "f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.17",
  "once_cell",
- "proc-macro-hack",
  "tiny-keccak",
 ]
 
+[[package]]
+name = "const_panic"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e262cdaac42494e3ae34c43969f9cdeb7da178bdb4b66fa6a1ea2edb4c8ae652"
+dependencies = [
+ "typewit",
+]
+
 [[package]]
 name = "constant_time_eq"
-version = "0.2.5"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b"
+
+[[package]]
+name = "core-foundation"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13418e745008f7349ec7e449155f419a61b92b58a99cc3616942b926825ec76b"
+checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
 
 [[package]]
 name = "core-foundation-sys"
-version = "0.8.3"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "core_extensions"
+version = "1.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42bb5e5d0269fd4f739ea6cedaf29c16d81c27a7ce7582008e90eb50dcd57003"
+dependencies = [
+ "core_extensions_proc_macros",
+]
+
+[[package]]
+name = "core_extensions_proc_macros"
+version = "1.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
+checksum = "533d38ecd2709b7608fb8e18e4504deb99e9a72879e6aa66373a76d8dc4259ea"
 
 [[package]]
 name = "cpufeatures"
-version = "0.2.5"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28d997bd5e24a5928dd43e46dc529867e207907fe0b239c3477d924f7f2ca320"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "crc32fast"
-version = "1.3.2"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
 dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
 [[package]]
 name = "crunchy"
-version = "0.2.2"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
 
 [[package]]
 name = "crypto-common"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
 dependencies = [
  "generic-array",
  "typenum",
 ]
 
+[[package]]
+name = "cstr"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68523903c8ae5aacfa32a0d9ae60cadeb764e1da14ee0d26b1f3089f13a54636"
+dependencies = [
+ "proc-macro2",
+ "quote",
+]
+
 [[package]]
 name = "csv"
-version = "1.2.1"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b015497079b9a9d69c02ad25de6c0a6edef051ea6360a327d0bd05802ef64ad"
+checksum = "52cd9d68cf7efc6ddfaaee42e7288d3a99d613d4b50f76ce9827ae0c6e14f938"
 dependencies = [
  "csv-core",
  "itoa",
  "ryu",
- "serde",
+ "serde_core",
 ]
 
 [[package]]
 name = "csv-core"
-version = "0.1.10"
+version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90"
+checksum = "704a3c26996a80471189265814dbc2c257598b96b8a7feae2d31ace646bb9782"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
-name = "cxx"
-version = "1.0.92"
+name = "darling"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a140f260e6f3f79013b8bfc65e7ce630c9ab4388c6a89c71e07226f49487b72"
+checksum = "25ae13da2f202d56bd7f91c25fba009e7717a1e4a1cc98a76d844b65ae912e9d"
 dependencies = [
- "cc",
- "cxxbridge-flags",
- "cxxbridge-macro",
- "link-cplusplus",
+ "darling_core",
+ "darling_macro",
 ]
 
 [[package]]
-name = "cxx-build"
-version = "1.0.92"
+name = "darling_core"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da6383f459341ea689374bf0a42979739dc421874f112ff26f829b8040b8e613"
+checksum = "9865a50f7c335f53564bb694ef660825eb8610e0a53d3e11bf1b0d3df31e03b0"
 dependencies = [
- "cc",
- "codespan-reporting",
- "once_cell",
+ "ident_case",
  "proc-macro2",
  "quote",
- "scratch",
- "syn",
+ "strsim",
+ "syn 2.0.117",
 ]
 
 [[package]]
-name = "cxxbridge-flags"
-version = "1.0.92"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90201c1a650e95ccff1c8c0bb5a343213bdd317c6e600a93075bca2eff54ec97"
-
-[[package]]
-name = "cxxbridge-macro"
-version = "1.0.92"
+name = "darling_macro"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b75aed41bb2e6367cae39e6326ef817a851db13c13e4f3263714ca3cfb8de56"
+checksum = "ac3984ec7bd6cfa798e62b4a642426a5be0e68f9401cfc2a01e3fa9ea2fcdb8d"
 dependencies = [
- "proc-macro2",
+ "darling_core",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "dashmap"
-version = "5.4.0"
+version = "6.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "907076dfda823b0b36d2a1bb5f90c96660a5bbcd7729e10727f07858f22c4edc"
+checksum = "5041cc499144891f3790297212f32a74fb938e5136a14943f338ef9e0ae276cf"
 dependencies = [
  "cfg-if",
- "hashbrown 0.12.3",
+ "crossbeam-utils",
+ "hashbrown 0.14.5",
  "lock_api",
  "once_cell",
  "parking_lot_core",
@@ -666,81 +900,309 @@ dependencies = [
 
 [[package]]
 name = "datafusion"
-version = "20.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c467c5802cb75ecb0acffa2121d8361a8903fef05b21fd1ca12a55797df8a75"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
 dependencies = [
- "ahash",
- "apache-avro",
  "arrow",
- "async-compression",
+ "arrow-schema",
  "async-trait",
  "bytes",
  "bzip2",
  "chrono",
- "dashmap",
+ "datafusion-catalog",
+ "datafusion-catalog-listing",
  "datafusion-common",
+ "datafusion-common-runtime",
+ "datafusion-datasource",
+ "datafusion-datasource-arrow",
+ "datafusion-datasource-avro",
+ "datafusion-datasource-csv",
+ "datafusion-datasource-json",
+ "datafusion-datasource-parquet",
  "datafusion-execution",
  "datafusion-expr",
+ "datafusion-expr-common",
+ "datafusion-functions",
+ "datafusion-functions-aggregate",
+ "datafusion-functions-nested",
+ "datafusion-functions-table",
+ "datafusion-functions-window",
  "datafusion-optimizer",
  "datafusion-physical-expr",
- "datafusion-row",
+ "datafusion-physical-expr-adapter",
+ "datafusion-physical-expr-common",
+ "datafusion-physical-optimizer",
+ "datafusion-physical-plan",
+ "datafusion-session",
  "datafusion-sql",
  "flate2",
  "futures",
- "glob",
- "hashbrown 0.13.2",
- "indexmap",
  "itertools",
- "lazy_static",
+ "liblzma",
  "log",
- "num-traits",
- "num_cpus",
  "object_store",
  "parking_lot",
  "parquet",
- "paste",
- "percent-encoding",
- "pin-project-lite",
  "rand",
- "smallvec",
+ "regex",
  "sqlparser",
  "tempfile",
  "tokio",
- "tokio-stream",
- "tokio-util",
  "url",
  "uuid",
- "xz2",
- "zstd 0.12.3+zstd.1.5.2",
+ "zstd",
+]
+
+[[package]]
+name = "datafusion-catalog"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "async-trait",
+ "dashmap",
+ "datafusion-common",
+ "datafusion-common-runtime",
+ "datafusion-datasource",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-physical-expr",
+ "datafusion-physical-plan",
+ "datafusion-session",
+ "futures",
+ "itertools",
+ "log",
+ "object_store",
+ "parking_lot",
+ "tokio",
+]
+
+[[package]]
+name = "datafusion-catalog-listing"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "async-trait",
+ "datafusion-catalog",
+ "datafusion-common",
+ "datafusion-datasource",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-physical-expr",
+ "datafusion-physical-expr-adapter",
+ "datafusion-physical-expr-common",
+ "datafusion-physical-plan",
+ "futures",
+ "itertools",
+ "log",
+ "object_store",
 ]
 
 [[package]]
 name = "datafusion-common"
-version = "20.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5c60e0a92bae06c6a55c4618947ae0837f833929b8d52ade1d50cf8b5f3b381"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
 dependencies = [
+ "ahash",
  "apache-avro",
  "arrow",
+ "arrow-ipc",
  "chrono",
- "num_cpus",
+ "half",
+ "hashbrown 0.16.1",
+ "indexmap",
+ "itertools",
+ "libc",
+ "log",
  "object_store",
  "parquet",
- "pyo3",
+ "paste",
+ "recursive",
  "sqlparser",
+ "tokio",
+ "web-time",
+]
+
+[[package]]
+name = "datafusion-common-runtime"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "futures",
+ "log",
+ "tokio",
+]
+
+[[package]]
+name = "datafusion-datasource"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "async-compression",
+ "async-trait",
+ "bytes",
+ "bzip2",
+ "chrono",
+ "datafusion-common",
+ "datafusion-common-runtime",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-physical-expr",
+ "datafusion-physical-expr-adapter",
+ "datafusion-physical-expr-common",
+ "datafusion-physical-plan",
+ "datafusion-session",
+ "flate2",
+ "futures",
+ "glob",
+ "itertools",
+ "liblzma",
+ "log",
+ "object_store",
+ "rand",
+ "tokio",
+ "tokio-util",
+ "url",
+ "zstd",
+]
+
+[[package]]
+name = "datafusion-datasource-arrow"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "arrow-ipc",
+ "async-trait",
+ "bytes",
+ "datafusion-common",
+ "datafusion-common-runtime",
+ "datafusion-datasource",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-physical-expr-common",
+ "datafusion-physical-plan",
+ "datafusion-session",
+ "futures",
+ "itertools",
+ "object_store",
+ "tokio",
 ]
 
+[[package]]
+name = "datafusion-datasource-avro"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "apache-avro",
+ "arrow",
+ "async-trait",
+ "bytes",
+ "datafusion-common",
+ "datafusion-datasource",
+ "datafusion-physical-expr-common",
+ "datafusion-physical-plan",
+ "datafusion-session",
+ "futures",
+ "num-traits",
+ "object_store",
+]
+
+[[package]]
+name = "datafusion-datasource-csv"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "async-trait",
+ "bytes",
+ "datafusion-common",
+ "datafusion-common-runtime",
+ "datafusion-datasource",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-physical-expr-common",
+ "datafusion-physical-plan",
+ "datafusion-session",
+ "futures",
+ "object_store",
+ "regex",
+ "tokio",
+]
+
+[[package]]
+name = "datafusion-datasource-json"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "async-trait",
+ "bytes",
+ "datafusion-common",
+ "datafusion-common-runtime",
+ "datafusion-datasource",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-physical-expr-common",
+ "datafusion-physical-plan",
+ "datafusion-session",
+ "futures",
+ "object_store",
+ "serde_json",
+ "tokio",
+ "tokio-stream",
+]
+
+[[package]]
+name = "datafusion-datasource-parquet"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "async-trait",
+ "bytes",
+ "datafusion-common",
+ "datafusion-common-runtime",
+ "datafusion-datasource",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-functions-aggregate-common",
+ "datafusion-physical-expr",
+ "datafusion-physical-expr-adapter",
+ "datafusion-physical-expr-common",
+ "datafusion-physical-plan",
+ "datafusion-pruning",
+ "datafusion-session",
+ "futures",
+ "itertools",
+ "log",
+ "object_store",
+ "parking_lot",
+ "parquet",
+ "tokio",
+]
+
+[[package]]
+name = "datafusion-doc"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+
 [[package]]
 name = "datafusion-execution"
-version = "20.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96eab4ef369c3972a4f99418ba8673aa0cf818aa4b892d44c35b473edce8e021"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
 dependencies = [
+ "arrow",
+ "arrow-buffer",
+ "async-trait",
+ "chrono",
  "dashmap",
  "datafusion-common",
  "datafusion-expr",
- "hashbrown 0.13.2",
+ "datafusion-physical-expr-common",
+ "futures",
  "log",
  "object_store",
  "parking_lot",
@@ -751,60 +1213,91 @@ dependencies = [
 
 [[package]]
 name = "datafusion-expr"
-version = "20.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0533db37a619a045a4fd37dabc2d99a85f10127d7f100d75914c194e9e36ed7"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
 dependencies = [
- "ahash",
  "arrow",
+ "async-trait",
+ "chrono",
  "datafusion-common",
- "log",
+ "datafusion-doc",
+ "datafusion-expr-common",
+ "datafusion-functions-aggregate-common",
+ "datafusion-functions-window-common",
+ "datafusion-physical-expr-common",
+ "indexmap",
+ "itertools",
+ "paste",
+ "recursive",
+ "serde_json",
  "sqlparser",
 ]
 
 [[package]]
-name = "datafusion-optimizer"
-version = "20.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3dbb8f467d31c3efebd372854e35cf1ca1572f163d0f031e2c6f8d78b317a43b"
+name = "datafusion-expr-common"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "datafusion-common",
+ "indexmap",
+ "itertools",
+ "paste",
+]
+
+[[package]]
+name = "datafusion-ffi"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
 dependencies = [
+ "abi_stable",
  "arrow",
+ "arrow-schema",
+ "async-ffi",
  "async-trait",
- "chrono",
+ "datafusion-catalog",
  "datafusion-common",
+ "datafusion-datasource",
+ "datafusion-execution",
  "datafusion-expr",
+ "datafusion-functions-aggregate-common",
  "datafusion-physical-expr",
- "hashbrown 0.13.2",
- "itertools",
+ "datafusion-physical-expr-common",
+ "datafusion-physical-plan",
+ "datafusion-proto",
+ "datafusion-proto-common",
+ "datafusion-session",
+ "futures",
  "log",
- "regex-syntax",
+ "prost",
+ "semver",
+ "tokio",
 ]
 
 [[package]]
-name = "datafusion-physical-expr"
-version = "20.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ceb003f6c0cdc25d2e9e92f8ee0322faca2a8f94f03d070b5ca15224c5503a3c"
+name = "datafusion-functions"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
 dependencies = [
- "ahash",
  "arrow",
  "arrow-buffer",
- "arrow-schema",
+ "base64",
  "blake2",
  "blake3",
  "chrono",
+ "chrono-tz",
  "datafusion-common",
+ "datafusion-doc",
+ "datafusion-execution",
  "datafusion-expr",
- "datafusion-row",
- "half",
- "hashbrown 0.13.2",
- "indexmap",
+ "datafusion-expr-common",
+ "datafusion-macros",
+ "hex",
  "itertools",
- "lazy_static",
+ "log",
  "md-5",
+ "memchr",
  "num-traits",
- "paste",
- "petgraph",
  "rand",
  "regex",
  "sha2",
@@ -813,75 +1306,371 @@ dependencies = [
 ]
 
 [[package]]
-name = "datafusion-python"
-version = "20.0.0"
+name = "datafusion-functions-aggregate"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
 dependencies = [
+ "ahash",
+ "arrow",
+ "datafusion-common",
+ "datafusion-doc",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-functions-aggregate-common",
+ "datafusion-macros",
+ "datafusion-physical-expr",
+ "datafusion-physical-expr-common",
+ "half",
+ "log",
+ "num-traits",
+ "paste",
+]
+
+[[package]]
+name = "datafusion-functions-aggregate-common"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "ahash",
+ "arrow",
+ "datafusion-common",
+ "datafusion-expr-common",
+ "datafusion-physical-expr-common",
+]
+
+[[package]]
+name = "datafusion-functions-nested"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "arrow-ord",
+ "datafusion-common",
+ "datafusion-doc",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-expr-common",
+ "datafusion-functions",
+ "datafusion-functions-aggregate",
+ "datafusion-functions-aggregate-common",
+ "datafusion-macros",
+ "datafusion-physical-expr-common",
+ "hashbrown 0.16.1",
+ "itertools",
+ "itoa",
+ "log",
+ "paste",
+]
+
+[[package]]
+name = "datafusion-functions-table"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
  "async-trait",
- "datafusion",
+ "datafusion-catalog",
  "datafusion-common",
  "datafusion-expr",
- "datafusion-optimizer",
- "datafusion-sql",
+ "datafusion-physical-plan",
+ "parking_lot",
+ "paste",
+]
+
+[[package]]
+name = "datafusion-functions-window"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "datafusion-common",
+ "datafusion-doc",
+ "datafusion-expr",
+ "datafusion-functions-window-common",
+ "datafusion-macros",
+ "datafusion-physical-expr",
+ "datafusion-physical-expr-common",
+ "log",
+ "paste",
+]
+
+[[package]]
+name = "datafusion-functions-window-common"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "datafusion-common",
+ "datafusion-physical-expr-common",
+]
+
+[[package]]
+name = "datafusion-macros"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "datafusion-doc",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "datafusion-optimizer"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "chrono",
+ "datafusion-common",
+ "datafusion-expr",
+ "datafusion-expr-common",
+ "datafusion-physical-expr",
+ "indexmap",
+ "itertools",
+ "log",
+ "recursive",
+ "regex",
+ "regex-syntax",
+]
+
+[[package]]
+name = "datafusion-physical-expr"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "ahash",
+ "arrow",
+ "datafusion-common",
+ "datafusion-expr",
+ "datafusion-expr-common",
+ "datafusion-functions-aggregate-common",
+ "datafusion-physical-expr-common",
+ "half",
+ "hashbrown 0.16.1",
+ "indexmap",
+ "itertools",
+ "parking_lot",
+ "paste",
+ "petgraph",
+ "recursive",
+ "tokio",
+]
+
+[[package]]
+name = "datafusion-physical-expr-adapter"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "datafusion-common",
+ "datafusion-expr",
+ "datafusion-functions",
+ "datafusion-physical-expr",
+ "datafusion-physical-expr-common",
+ "itertools",
+]
+
+[[package]]
+name = "datafusion-physical-expr-common"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "ahash",
+ "arrow",
+ "chrono",
+ "datafusion-common",
+ "datafusion-expr-common",
+ "hashbrown 0.16.1",
+ "indexmap",
+ "itertools",
+ "parking_lot",
+]
+
+[[package]]
+name = "datafusion-physical-optimizer"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "datafusion-common",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-expr-common",
+ "datafusion-physical-expr",
+ "datafusion-physical-expr-common",
+ "datafusion-physical-plan",
+ "datafusion-pruning",
+ "itertools",
+ "recursive",
+]
+
+[[package]]
+name = "datafusion-physical-plan"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "ahash",
+ "arrow",
+ "arrow-ord",
+ "arrow-schema",
+ "async-trait",
+ "datafusion-common",
+ "datafusion-common-runtime",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-functions",
+ "datafusion-functions-aggregate-common",
+ "datafusion-functions-window-common",
+ "datafusion-physical-expr",
+ "datafusion-physical-expr-common",
+ "futures",
+ "half",
+ "hashbrown 0.16.1",
+ "indexmap",
+ "itertools",
+ "log",
+ "num-traits",
+ "parking_lot",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "datafusion-proto"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "chrono",
+ "datafusion-catalog",
+ "datafusion-catalog-listing",
+ "datafusion-common",
+ "datafusion-datasource",
+ "datafusion-datasource-arrow",
+ "datafusion-datasource-csv",
+ "datafusion-datasource-json",
+ "datafusion-datasource-parquet",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-functions-table",
+ "datafusion-physical-expr",
+ "datafusion-physical-expr-common",
+ "datafusion-physical-plan",
+ "datafusion-proto-common",
+ "object_store",
+ "prost",
+ "rand",
+]
+
+[[package]]
+name = "datafusion-proto-common"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "datafusion-common",
+ "prost",
+]
+
+[[package]]
+name = "datafusion-pruning"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "datafusion-common",
+ "datafusion-datasource",
+ "datafusion-expr-common",
+ "datafusion-physical-expr",
+ "datafusion-physical-expr-common",
+ "datafusion-physical-plan",
+ "itertools",
+ "log",
+]
+
+[[package]]
+name = "datafusion-python"
+version = "52.0.0"
+dependencies = [
+ "arrow",
+ "arrow-select",
+ "async-trait",
+ "cstr",
+ "datafusion",
+ "datafusion-ffi",
+ "datafusion-proto",
  "datafusion-substrait",
  "futures",
+ "log",
  "mimalloc",
  "object_store",
  "parking_lot",
+ "prost",
+ "prost-types",
  "pyo3",
- "rand",
- "regex-syntax",
+ "pyo3-async-runtimes",
+ "pyo3-build-config",
+ "pyo3-log",
+ "serde_json",
  "tokio",
+ "url",
  "uuid",
 ]
 
 [[package]]
-name = "datafusion-row"
-version = "20.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba0b4478a205b767f6d98e26730a604562155a8b3cf64fe3600367e741b0f129"
+name = "datafusion-session"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
 dependencies = [
- "arrow",
+ "async-trait",
  "datafusion-common",
- "paste",
- "rand",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-physical-plan",
+ "parking_lot",
 ]
 
 [[package]]
 name = "datafusion-sql"
-version = "20.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a07af4200a9353ebe7bf0d6024894275cdebb303bb534b3a38eb0f532583083d"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
 dependencies = [
- "arrow-schema",
+ "arrow",
+ "bigdecimal",
+ "chrono",
  "datafusion-common",
  "datafusion-expr",
+ "datafusion-functions-nested",
+ "indexmap",
  "log",
+ "recursive",
+ "regex",
  "sqlparser",
 ]
 
 [[package]]
 name = "datafusion-substrait"
-version = "20.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71a9cc3e51c77ada10990e996c15c5bda293b3e4a508f55c2f3993ea6c6a39a7"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
 dependencies = [
  "async-recursion",
+ "async-trait",
  "chrono",
  "datafusion",
+ "half",
  "itertools",
  "object_store",
- "prost 0.11.8",
- "prost-build 0.9.0",
- "prost-types 0.11.8",
+ "pbjson-types",
+ "prost",
  "substrait",
  "tokio",
+ "url",
 ]
 
 [[package]]
 name = "digest"
-version = "0.10.6"
+version = "0.10.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8168378f4e5023e7218c89c891c0fd8ecdb5e5e4f18cb78f38cf245dd021e76f"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
 dependencies = [
  "block-buffer",
  "crypto-common",
@@ -889,73 +1678,67 @@ dependencies = [
 ]
 
 [[package]]
-name = "doc-comment"
-version = "0.3.3"
+name = "displaydoc"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
 
 [[package]]
 name = "dyn-clone"
-version = "1.0.11"
+version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68b0cf012f1230e43cd00ebb729c6bb58707ecfa8ad08b52ef3a4ccd2697fc30"
+checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
 
 [[package]]
 name = "either"
-version = "1.8.1"
+version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcaabb2fef8c910e7f4c7ce9f67a1283a1715879a7c230ca9d6d1ae31f16d91"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
 
 [[package]]
-name = "encoding_rs"
-version = "0.8.32"
+name = "equivalent"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "071a31f4ee85403370b58aca746f01041ede6f0da2730960ad001edc2b71b394"
-dependencies = [
- "cfg-if",
-]
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
 [[package]]
 name = "errno"
-version = "0.2.8"
+version = "0.3.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f639046355ee4f37944e44f60642c6f3a7efa3cf6b78c78a0d989a8ce6c396a1"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
- "errno-dragonfly",
  "libc",
- "winapi",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
-name = "errno-dragonfly"
-version = "0.1.2"
+name = "fastrand"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
-dependencies = [
- "cc",
- "libc",
-]
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
 [[package]]
-name = "fastrand"
-version = "1.9.0"
+name = "find-msvc-tools"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e51093e27b0797c359783294ca4f0a911c270184cb10f85783b118614a1501be"
-dependencies = [
- "instant",
-]
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
 
 [[package]]
 name = "fixedbitset"
-version = "0.4.2"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
+checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
 
 [[package]]
 name = "flatbuffers"
-version = "23.1.21"
+version = "25.12.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77f5399c2c9c50ae9418e522842ad362f61ee48b346ac106807bd355a8a7c619"
+checksum = "35f6839d7b3b98adde531effaf34f0c2badc6f4735d26fe74709d8e513a96ef3"
 dependencies = [
  "bitflags",
  "rustc_version",
@@ -963,12 +1746,13 @@ dependencies = [
 
 [[package]]
 name = "flate2"
-version = "1.0.25"
+version = "1.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8a2db397cb1c8772f31494cb8917e48cd1e64f0fa7efac59fbd741a0a8ce841"
+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
 dependencies = [
  "crc32fast",
  "miniz_oxide",
+ "zlib-rs",
 ]
 
 [[package]]
@@ -977,20 +1761,32 @@ version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
 [[package]]
 name = "form_urlencoded"
-version = "1.1.0"
+version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9c384f161156f5260c24a097c56119f9be8c798586aecc13afbcbe7b7e26bf8"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
 dependencies = [
  "percent-encoding",
 ]
 
 [[package]]
 name = "futures"
-version = "0.3.27"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "531ac96c6ff5fd7c62263c5e3c67a603af4fcaee2e1a0ae5565ba3a11e69e549"
+checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -1003,9 +1799,9 @@ dependencies = [
 
 [[package]]
 name = "futures-channel"
-version = "0.3.27"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "164713a5a0dcc3e7b4b1ed7d3b433cabc18025386f9339346e8daf15963cf7ac"
+checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
 dependencies = [
  "futures-core",
  "futures-sink",
@@ -1013,15 +1809,15 @@ dependencies = [
 
 [[package]]
 name = "futures-core"
-version = "0.3.27"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86d7a0c1aa76363dac491de0ee99faf6941128376f1cf96f07db7603b7de69dd"
+checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
 
 [[package]]
 name = "futures-executor"
-version = "0.3.27"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1997dd9df74cdac935c76252744c1ed5794fac083242ea4fe77ef3ed60ba0f83"
+checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d"
 dependencies = [
  "futures-core",
  "futures-task",
@@ -1030,38 +1826,38 @@ dependencies = [
 
 [[package]]
 name = "futures-io"
-version = "0.3.27"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89d422fa3cbe3b40dca574ab087abb5bc98258ea57eea3fd6f1fa7162c778b91"
+checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
 
 [[package]]
 name = "futures-macro"
-version = "0.3.27"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3eb14ed937631bd8b8b8977f2c198443447a8355b6e3ca599f38c975e5a963b6"
+checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "futures-sink"
-version = "0.3.27"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec93083a4aecafb2a80a885c9de1f0ccae9dbd32c2bb54b0c3a65690e0b8d2f2"
+checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
 
 [[package]]
 name = "futures-task"
-version = "0.3.27"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd65540d33b37b16542a0438c12e6aeead10d4ac5d05bd3f805b8f35ab592879"
+checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
 
 [[package]]
 name = "futures-util"
-version = "0.3.27"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ef6b17e481503ec85211fed8f39d1970f128935ca1f814cd32ac4a6842e84ab"
+checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -1071,15 +1867,23 @@ dependencies = [
  "futures-task",
  "memchr",
  "pin-project-lite",
- "pin-utils",
  "slab",
 ]
 
+[[package]]
+name = "generational-arena"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877e94aff08e743b651baaea359664321055749b398adff8740a7399af7796e7"
+dependencies = [
+ "cfg-if",
+]
+
 [[package]]
 name = "generic-array"
-version = "0.14.6"
+version = "0.14.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bff49e947297f3312447abdca79f45f4738097cc82b06e72054d2223f601f1b9"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
 dependencies = [
  "typenum",
  "version_check",
@@ -1087,32 +1891,61 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.2.8"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "wasi",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "r-efi",
+ "wasip2",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
+checksum = "139ef39800118c7683f2fd3c98c1b23c09ae076556b435f8e9064ae108aaeeec"
 dependencies = [
  "cfg-if",
  "libc",
- "wasi 0.11.0+wasi-snapshot-preview1",
+ "r-efi",
+ "wasip2",
+ "wasip3",
 ]
 
 [[package]]
 name = "glob"
-version = "0.3.1"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
 
 [[package]]
 name = "h2"
-version = "0.3.16"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5be7b54589b581f624f566bf5d8eb2bab1db736c51528720b6bd36b96b55924d"
+checksum = "2f44da3a8150a6703ed5d34e164b875fd14c2cdab9af1252a9a1020bde2bdc54"
 dependencies = [
+ "atomic-waker",
  "bytes",
  "fnv",
  "futures-core",
  "futures-sink",
- "futures-util",
  "http",
  "indexmap",
  "slab",
@@ -1123,258 +1956,379 @@ dependencies = [
 
 [[package]]
 name = "half"
-version = "2.2.1"
+version = "2.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02b4af3693f1b705df946e9fe5631932443781d0aabb423b62fcd4d73f6d2fd0"
+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
 dependencies = [
+ "cfg-if",
  "crunchy",
  "num-traits",
+ "zerocopy",
 ]
 
 [[package]]
 name = "hashbrown"
-version = "0.12.3"
+version = "0.14.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 
 [[package]]
 name = "hashbrown"
-version = "0.13.2"
+version = "0.15.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
 dependencies = [
- "ahash",
+ "foldhash 0.1.5",
 ]
 
 [[package]]
-name = "heck"
-version = "0.3.3"
+name = "hashbrown"
+version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d621efb26863f0e9924c6ac577e8275e5e6b77455db64ffa6c65c904e9e132c"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
 dependencies = [
- "unicode-segmentation",
+ "allocator-api2",
+ "equivalent",
+ "foldhash 0.2.0",
 ]
 
 [[package]]
 name = "heck"
-version = "0.4.1"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
-name = "hermit-abi"
-version = "0.2.6"
+name = "hex"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee512640fe35acbfb4bb779db6f0d80704c2cacfa2e39b601ef3e3f47d1ae4c7"
-dependencies = [
- "libc",
-]
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
 [[package]]
-name = "home"
-version = "0.5.4"
+name = "http"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "747309b4b440c06d57b0b25f2aee03ee9b5e5397d288c60e21fc709bb98a7408"
+checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
 dependencies = [
- "winapi",
+ "bytes",
+ "itoa",
 ]
 
 [[package]]
-name = "http"
-version = "0.2.9"
+name = "http-body"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd6effc99afb63425aff9b05836f029929e345a6148a14b7ecd5ab67af944482"
+checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
 dependencies = [
  "bytes",
- "fnv",
- "itoa",
+ "http",
 ]
 
 [[package]]
-name = "http-body"
-version = "0.4.5"
+name = "http-body-util"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5f38f16d184e36f2408a55281cd658ecbd3ca05cce6d6510a176eca393e26d1"
+checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
 dependencies = [
  "bytes",
+ "futures-core",
  "http",
+ "http-body",
  "pin-project-lite",
 ]
 
 [[package]]
 name = "httparse"
-version = "1.8.0"
+version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
 
 [[package]]
-name = "httpdate"
-version = "1.0.2"
+name = "humantime"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421"
+checksum = "135b12329e5e3ce057a9f972339ea52bc954fe1e9358ef27f95e89716fbc5424"
 
 [[package]]
 name = "hyper"
-version = "0.14.25"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc5e554ff619822309ffd57d8734d77cd5ce6238bc956f037ea06c58238c9899"
+checksum = "2ab2d4f250c3d7b1c9fcdff1cece94ea4e2dfbec68614f7b87cb205f24ca9d11"
 dependencies = [
+ "atomic-waker",
  "bytes",
  "futures-channel",
  "futures-core",
- "futures-util",
  "h2",
  "http",
  "http-body",
  "httparse",
- "httpdate",
  "itoa",
  "pin-project-lite",
- "socket2",
+ "pin-utils",
+ "smallvec",
  "tokio",
- "tower-service",
- "tracing",
  "want",
 ]
 
 [[package]]
 name = "hyper-rustls"
-version = "0.23.2"
+version = "0.27.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1788965e61b367cd03a62950836d5cd41560c3577d90e40e0819373194d1661c"
+checksum = "e3c93eb611681b207e1fe55d5a71ecf91572ec8a6705cdb6857f7d8d5242cf58"
 dependencies = [
  "http",
  "hyper",
+ "hyper-util",
  "rustls",
+ "rustls-native-certs",
+ "rustls-pki-types",
  "tokio",
  "tokio-rustls",
+ "tower-service",
+]
+
+[[package]]
+name = "hyper-util"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0"
+dependencies = [
+ "base64",
+ "bytes",
+ "futures-channel",
+ "futures-util",
+ "http",
+ "http-body",
+ "hyper",
+ "ipnet",
+ "libc",
+ "percent-encoding",
+ "pin-project-lite",
+ "socket2",
+ "tokio",
+ "tower-service",
+ "tracing",
 ]
 
 [[package]]
 name = "iana-time-zone"
-version = "0.1.53"
+version = "0.1.65"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64c122667b287044802d6ce17ee2ddf13207ed924c712de9a66a5814d5b64765"
+checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
 dependencies = [
  "android_system_properties",
  "core-foundation-sys",
  "iana-time-zone-haiku",
  "js-sys",
+ "log",
  "wasm-bindgen",
- "winapi",
+ "windows-core",
 ]
 
 [[package]]
 name = "iana-time-zone-haiku"
-version = "0.1.1"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0703ae284fc167426161c2e3f1da3ea71d94b21bedbcc9494e92b28e334e3dca"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
 dependencies = [
- "cxx",
- "cxx-build",
+ "cc",
 ]
 
 [[package]]
-name = "idna"
-version = "0.3.0"
+name = "icu_collections"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e14ddfc70884202db2244c223200c204c2bda1bc6e0998d11b5e024d657209e6"
+checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
 dependencies = [
- "unicode-bidi",
- "unicode-normalization",
+ "displaydoc",
+ "potential_utf",
+ "yoke",
+ "zerofrom",
+ "zerovec",
 ]
 
 [[package]]
-name = "indexmap"
-version = "1.9.2"
+name = "icu_locale_core"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399"
+checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
 dependencies = [
- "autocfg",
- "hashbrown 0.12.3",
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
 ]
 
 [[package]]
-name = "indoc"
-version = "1.0.9"
+name = "icu_normalizer_data"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa799dd5ed20a7e349f3b4639aa80d74549c81716d9ec4f994c9b5815598306"
+checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
 
 [[package]]
-name = "instant"
-version = "0.1.12"
+name = "icu_properties"
+version = "2.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec"
 dependencies = [
- "cfg-if",
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
 ]
 
 [[package]]
-name = "integer-encoding"
-version = "3.0.4"
+name = "icu_properties_data"
+version = "2.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bb03732005da905c88227371639bf1ad885cc712789c011c31c5fb3ab3ccf02"
+checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af"
 
 [[package]]
-name = "io-lifetimes"
-version = "1.0.6"
+name = "icu_provider"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cfa919a82ea574332e2de6e74b4c36e74d41982b335080fa59d4ef31be20fdf3"
+checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
 dependencies = [
- "libc",
- "windows-sys 0.45.0",
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.16.1",
+ "serde",
+ "serde_core",
 ]
 
+[[package]]
+name = "integer-encoding"
+version = "3.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8bb03732005da905c88227371639bf1ad885cc712789c011c31c5fb3ab3ccf02"
+
 [[package]]
 name = "ipnet"
-version = "2.7.1"
+version = "2.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30e22bd8629359895450b59ea7a776c850561b96a3b1d31321c1949d9e6c9146"
+checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130"
+
+[[package]]
+name = "iri-string"
+version = "0.7.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c91338f0783edbd6195decb37bae672fd3b165faffb89bf7b9e6942f8b1a731a"
+dependencies = [
+ "memchr",
+ "serde",
+]
 
 [[package]]
 name = "itertools"
-version = "0.10.5"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
 dependencies = [
  "either",
 ]
 
 [[package]]
 name = "itoa"
-version = "1.0.6"
+version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "453ad9f582a441959e5f0d088b02ce04cfe8d51a8eaf077f12ac6d3e94164ca6"
+checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
 
 [[package]]
 name = "jobserver"
-version = "0.1.26"
+version = "0.1.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "936cfd212a0155903bcbc060e316fb6cc7cbf2e1907329391ebadc1fe0ce77c2"
+checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
 dependencies = [
+ "getrandom 0.3.4",
  "libc",
 ]
 
 [[package]]
 name = "js-sys"
-version = "0.3.61"
+version = "0.3.85"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "445dde2150c55e483f3d8416706b97ec8e8237c307e5b7b4b8dd15e6af2a0730"
+checksum = "8c942ebf8e95485ca0d52d97da7c5a2c387d0e7f0ba4c35e93bfcaee045955b3"
 dependencies = [
+ "once_cell",
  "wasm-bindgen",
 ]
 
 [[package]]
-name = "lazy_static"
-version = "1.4.0"
+name = "leb128fmt"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
 
 [[package]]
 name = "lexical-core"
-version = "0.8.5"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2cde5de06e8d4c2faabc400238f9ae1c74d5412d03a7bd067645ccbc47070e46"
+checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594"
 dependencies = [
  "lexical-parse-float",
  "lexical-parse-integer",
@@ -1385,363 +2339,312 @@ dependencies = [
 
 [[package]]
 name = "lexical-parse-float"
-version = "0.8.5"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "683b3a5ebd0130b8fb52ba0bdc718cc56815b6a097e28ae5a6997d0ad17dc05f"
+checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56"
 dependencies = [
  "lexical-parse-integer",
  "lexical-util",
- "static_assertions",
 ]
 
 [[package]]
 name = "lexical-parse-integer"
-version = "0.8.6"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d0994485ed0c312f6d965766754ea177d07f9c00c9b82a5ee62ed5b47945ee9"
+checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34"
 dependencies = [
  "lexical-util",
- "static_assertions",
 ]
 
 [[package]]
 name = "lexical-util"
-version = "0.8.5"
+version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5255b9ff16ff898710eb9eb63cb39248ea8a5bb036bea8085b1a767ff6c4e3fc"
-dependencies = [
- "static_assertions",
-]
+checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17"
 
 [[package]]
 name = "lexical-write-float"
-version = "0.8.5"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "accabaa1c4581f05a3923d1b4cfd124c329352288b7b9da09e766b0668116862"
+checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361"
 dependencies = [
  "lexical-util",
  "lexical-write-integer",
- "static_assertions",
 ]
 
 [[package]]
 name = "lexical-write-integer"
-version = "0.8.5"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1b6f3d1f4422866b68192d62f77bc5c700bee84f3069f2469d7bc8c77852446"
+checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df"
 dependencies = [
  "lexical-util",
- "static_assertions",
 ]
 
 [[package]]
-name = "libc"
-version = "0.2.140"
+name = "libbz2-rs-sys"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99227334921fae1a979cf0bfdfcc6b3e5ce376ef57e16fb6fb3ea2ed6095f80c"
+checksum = "2c4a545a15244c7d945065b5d392b2d2d7f21526fba56ce51467b06ed445e8f7"
 
 [[package]]
-name = "libflate"
-version = "1.3.0"
+name = "libc"
+version = "0.2.182"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97822bf791bd4d5b403713886a5fbe8bf49520fe78e323b0dc480ca1a03e50b0"
-dependencies = [
- "adler32",
- "crc32fast",
- "libflate_lz77",
-]
+checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112"
 
 [[package]]
-name = "libflate_lz77"
-version = "1.2.0"
+name = "libloading"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a52d3a8bfc85f250440e4424db7d857e241a3aebbbe301f3eb606ab15c39acbf"
+checksum = "b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f"
 dependencies = [
- "rle-decode-fast",
+ "cfg-if",
+ "winapi",
 ]
 
 [[package]]
-name = "libm"
-version = "0.2.6"
+name = "liblzma"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "348108ab3fba42ec82ff6e9564fc4ca0247bdccdc68dd8af9764bbc79c3c8ffb"
+checksum = "b6033b77c21d1f56deeae8014eb9fbe7bdf1765185a6c508b5ca82eeaed7f899"
+dependencies = [
+ "liblzma-sys",
+]
 
 [[package]]
-name = "libmimalloc-sys"
-version = "0.1.30"
+name = "liblzma-sys"
+version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd8c7cbf8b89019683667e347572e6d55a7df7ea36b0c4ce69961b0cde67b174"
+checksum = "9f2db66f3268487b5033077f266da6777d057949b8f93c8ad82e441df25e6186"
 dependencies = [
  "cc",
  "libc",
+ "pkg-config",
 ]
 
 [[package]]
-name = "link-cplusplus"
-version = "1.0.8"
+name = "libm"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
+
+[[package]]
+name = "libmimalloc-sys"
+version = "0.1.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ecd207c9c713c34f95a097a5b029ac2ce6010530c7b49d7fea24d977dede04f5"
+checksum = "667f4fec20f29dfc6bc7357c582d91796c169ad7e2fce709468aefeb2c099870"
 dependencies = [
  "cc",
+ "libc",
 ]
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.1.4"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f051f77a7c8e6957c0696eac88f26b0117e54f52d3fc682ab19397a8812846a4"
+checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
 
 [[package]]
-name = "lock_api"
-version = "0.4.9"
+name = "litemap"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "435011366fe56583b16cf956f9df0095b405b82d76425bc8981c0e22e60ec4df"
-dependencies = [
- "autocfg",
- "scopeguard",
-]
+checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
 
 [[package]]
-name = "log"
-version = "0.4.17"
+name = "lock_api"
+version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
 dependencies = [
- "cfg-if",
+ "scopeguard",
 ]
 
 [[package]]
-name = "lz4"
-version = "1.24.0"
+name = "log"
+version = "0.4.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e9e2dd86df36ce760a60f6ff6ad526f7ba1f14ba0356f8254fb6905e6494df1"
-dependencies = [
- "libc",
- "lz4-sys",
-]
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
-name = "lz4-sys"
-version = "1.9.4"
+name = "lru-slab"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57d27b317e207b10f69f5e75494119e391a96f48861ae870d1da6edac98ca900"
-dependencies = [
- "cc",
- "libc",
-]
+checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154"
 
 [[package]]
-name = "lzma-sys"
-version = "0.1.20"
+name = "lz4_flex"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fda04ab3764e6cde78b9974eec4f779acaba7c4e84b36eca3cf77c581b85d27"
+checksum = "ab6473172471198271ff72e9379150e9dfd70d8e533e0752a27e515b48dd375e"
 dependencies = [
- "cc",
- "libc",
- "pkg-config",
+ "twox-hash",
 ]
 
 [[package]]
 name = "md-5"
-version = "0.10.5"
+version = "0.10.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6365506850d44bff6e2fbcb5176cf63650e48bd45ef2fe2665ae1570e0f4b9ca"
+checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"
 dependencies = [
+ "cfg-if",
  "digest",
 ]
 
 [[package]]
 name = "memchr"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
-
-[[package]]
-name = "memoffset"
-version = "0.8.0"
+version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d61c719bcfbcf5d62b3a09efa6088de8c54bc0bfcd3ea7ae39fcc186108b8de1"
-dependencies = [
- "autocfg",
-]
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
 
 [[package]]
 name = "mimalloc"
-version = "0.1.34"
+version = "0.1.48"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dcb174b18635f7561a0c6c9fc2ce57218ac7523cf72c50af80e2d79ab8f3ba1"
+checksum = "e1ee66a4b64c74f4ef288bcbb9192ad9c3feaad75193129ac8509af543894fd8"
 dependencies = [
  "libmimalloc-sys",
 ]
 
-[[package]]
-name = "mime"
-version = "0.3.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a60c7ce501c71e03a9c9c0d35b861413ae925bd979cc7a4e30d060069aaac8d"
-
 [[package]]
 name = "miniz_oxide"
-version = "0.6.2"
+version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b275950c28b37e794e8c55d88aeb5e139d0ce23fdbbeda68f8d7174abdf9e8fa"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
 dependencies = [
- "adler",
+ "adler2",
+ "simd-adler32",
 ]
 
 [[package]]
 name = "mio"
-version = "0.8.6"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b9d9a46eff5b4ff64b45a9e316a6d1e0bc719ef429cbec4dc630684212bfdf9"
+checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc"
 dependencies = [
  "libc",
- "log",
- "wasi 0.11.0+wasi-snapshot-preview1",
- "windows-sys 0.45.0",
+ "wasi",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "multimap"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5ce46fe64a9d73be07dcbe690a38ce1b293be448fd8ce1e6c1b8062c9f72c6a"
-
-[[package]]
-name = "num"
-version = "0.4.0"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43db66d1170d347f9a065114077f7dccb00c1b9478c89384490a3425279a4606"
-dependencies = [
- "num-bigint",
- "num-complex",
- "num-integer",
- "num-iter",
- "num-rational",
- "num-traits",
-]
+checksum = "1d87ecb2933e8aeadb3e3a02b828fed80a7528047e68b4f424523a0981a3a084"
 
 [[package]]
 name = "num-bigint"
-version = "0.4.3"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f93ab6289c7b344a8a9f60f88d80aa20032336fe78da341afc91c8a2341fc75f"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
 dependencies = [
- "autocfg",
  "num-integer",
  "num-traits",
+ "serde",
 ]
 
 [[package]]
 name = "num-complex"
-version = "0.4.3"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02e0d21255c828d6f128a1e41534206671e8c3ea0c62f32291e808dc82cff17d"
+checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
 dependencies = [
  "num-traits",
 ]
 
 [[package]]
 name = "num-integer"
-version = "0.1.45"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
-dependencies = [
- "autocfg",
- "num-traits",
-]
-
-[[package]]
-name = "num-iter"
-version = "0.1.43"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d03e6c028c5dc5cac6e2dec0efda81fc887605bb3d884578bb6d6bf7514e252"
-dependencies = [
- "autocfg",
- "num-integer",
- "num-traits",
-]
-
-[[package]]
-name = "num-rational"
-version = "0.4.1"
+version = "0.1.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0638a1c9d0a3c0914158145bc76cff373a75a627e6ecbfb71cbe6f453a5a19b0"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
 dependencies = [
- "autocfg",
- "num-bigint",
- "num-integer",
  "num-traits",
 ]
 
 [[package]]
 name = "num-traits"
-version = "0.2.15"
+version = "0.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
 dependencies = [
  "autocfg",
  "libm",
 ]
 
 [[package]]
-name = "num_cpus"
-version = "1.15.0"
+name = "object"
+version = "0.37.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fac9e2da13b5eb447a6ce3d392f23a29d8694bff781bf03a16cd9ac8697593b"
+checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe"
 dependencies = [
- "hermit-abi",
- "libc",
+ "memchr",
 ]
 
 [[package]]
 name = "object_store"
-version = "0.5.5"
+version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1ea8f683b4f89a64181393742c041520a1a87e9775e6b4c0dd5a3281af05fc6"
+checksum = "c2858065e55c148d294a9f3aae3b0fa9458edadb41a108397094566f4e3c0dfb"
 dependencies = [
  "async-trait",
  "base64",
  "bytes",
  "chrono",
+ "form_urlencoded",
  "futures",
+ "http",
+ "http-body-util",
+ "httparse",
+ "humantime",
+ "hyper",
  "itertools",
+ "md-5",
  "parking_lot",
  "percent-encoding",
  "quick-xml",
  "rand",
  "reqwest",
  "ring",
- "rustls-pemfile",
+ "rustls-pki-types",
  "serde",
  "serde_json",
- "snafu",
+ "serde_urlencoded",
+ "thiserror",
  "tokio",
  "tracing",
  "url",
  "walkdir",
+ "wasm-bindgen-futures",
+ "web-time",
 ]
 
 [[package]]
 name = "once_cell"
-version = "1.17.1"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "openssl-probe"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7e5500299e16ebb147ae15a00a942af264cf3688f47923b8fc2cd5858f23ad3"
+checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
 
 [[package]]
 name = "ordered-float"
-version = "2.10.0"
+version = "2.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7940cf2ca942593318d07fcf2596cdca60a85c9e7fab408a5e21a4f9dcd40d87"
+checksum = "68f19d67e5a2795c94e73e0bb1cc1a7edeb2e28efd39e2e1c9b7a40c1108b11c"
 dependencies = [
  "num-traits",
 ]
 
 [[package]]
 name = "parking_lot"
-version = "0.12.1"
+version = "0.12.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
 dependencies = [
  "lock_api",
  "parking_lot_core",
@@ -1749,27 +2652,26 @@ dependencies = [
 
 [[package]]
 name = "parking_lot_core"
-version = "0.9.7"
+version = "0.9.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9069cbb9f99e3a5083476ccb29ceb1de18b9118cafa53e90c9551235de2b9521"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
 dependencies = [
  "cfg-if",
  "libc",
  "redox_syscall",
  "smallvec",
- "windows-sys 0.45.0",
+ "windows-link",
 ]
 
 [[package]]
 name = "parquet"
-version = "34.0.0"
+version = "58.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ac135ecf63ebb5f53dda0921b0b76d6048b3ef631a5f4760b9e8f863ff00cfa"
+checksum = "3f491d0ef1b510194426ee67ddc18a9b747ef3c42050c19322a2cd2e1666c29b"
 dependencies = [
  "ahash",
  "arrow-array",
  "arrow-buffer",
- "arrow-cast",
  "arrow-data",
  "arrow-ipc",
  "arrow-schema",
@@ -1780,56 +2682,107 @@ dependencies = [
  "chrono",
  "flate2",
  "futures",
- "hashbrown 0.13.2",
- "lz4",
- "num",
+ "half",
+ "hashbrown 0.16.1",
+ "lz4_flex",
  "num-bigint",
+ "num-integer",
+ "num-traits",
+ "object_store",
  "paste",
  "seq-macro",
+ "simdutf8",
  "snap",
  "thrift",
  "tokio",
  "twox-hash",
- "zstd 0.12.3+zstd.1.5.2",
+ "zstd",
 ]
 
 [[package]]
 name = "paste"
-version = "1.0.12"
+version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f746c4065a8fa3fe23974dd82f15431cc8d40779821001404d10d2e79ca7d79"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
 [[package]]
-name = "percent-encoding"
-version = "2.2.0"
+name = "pbjson"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "898bac3fa00d0ba57a4e8289837e965baa2dee8c3749f3b11d45a64b4223d9c3"
+dependencies = [
+ "base64",
+ "serde",
+]
+
+[[package]]
+name = "pbjson-build"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "478c572c3d73181ff3c2539045f6eb99e5491218eae919370993b890cdbdd98e"
+checksum = "af22d08a625a2213a78dbb0ffa253318c5c79ce3133d32d296655a7bdfb02095"
+dependencies = [
+ "heck",
+ "itertools",
+ "prost",
+ "prost-types",
+]
 
 [[package]]
-name = "pest"
-version = "2.5.6"
+name = "pbjson-types"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cbd939b234e95d72bc393d51788aec68aeeb5d51e748ca08ff3aad58cb722f7"
+checksum = "8e748e28374f10a330ee3bb9f29b828c0ac79831a32bab65015ad9b661ead526"
 dependencies = [
- "thiserror",
- "ucd-trie",
+ "bytes",
+ "chrono",
+ "pbjson",
+ "pbjson-build",
+ "prost",
+ "prost-build",
+ "serde",
 ]
 
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
 [[package]]
 name = "petgraph"
-version = "0.6.3"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4dd7d28ee937e54fe3080c91faa1c3a46c06de6252988a7f4592ba2310ef22a4"
+checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455"
 dependencies = [
  "fixedbitset",
+ "hashbrown 0.15.5",
  "indexmap",
+ "serde",
+]
+
+[[package]]
+name = "phf"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "913273894cec178f401a31ec4b656318d95473527be05c0752cc41cdc32be8b7"
+dependencies = [
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06005508882fb681fd97892ecff4b7fd0fee13ef1aa569f8695dae7ab9099981"
+dependencies = [
+ "siphasher",
 ]
 
 [[package]]
 name = "pin-project-lite"
-version = "0.2.9"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0a7ae3ac2f1173085d398531c705756c94a4c56843785df85a60c1a0afac116"
+checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
 
 [[package]]
 name = "pin-utils"
@@ -1839,237 +2792,307 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
 [[package]]
 name = "pkg-config"
-version = "0.3.26"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160"
+checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
 
 [[package]]
-name = "ppv-lite86"
-version = "0.2.17"
+name = "portable-atomic"
+version = "1.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
 
 [[package]]
-name = "proc-macro-hack"
-version = "0.5.20+deprecated"
+name = "potential_utf"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc375e1527247fe1a97d8b7156678dfe7c1af2fc075c9a4db3690ecd2a148068"
+checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
+dependencies = [
+ "zerovec",
+]
 
 [[package]]
-name = "proc-macro2"
-version = "1.0.52"
+name = "ppv-lite86"
+version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d0e1ae9e836cc3beddd63db0df682593d7e2d3d891ae8c9083d2113e1744224"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
 dependencies = [
- "unicode-ident",
+ "zerocopy",
 ]
 
 [[package]]
-name = "prost"
-version = "0.9.0"
+name = "prettyplease"
+version = "0.2.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "444879275cb4fd84958b1a1d5420d15e6fcf7c235fe47f053c9c2a80aceb6001"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
 dependencies = [
- "bytes",
- "prost-derive 0.9.0",
+ "proc-macro2",
+ "syn 2.0.117",
 ]
 
 [[package]]
-name = "prost"
-version = "0.11.8"
+name = "proc-macro2"
+version = "1.0.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e48e50df39172a3e7eb17e14642445da64996989bc212b583015435d39a58537"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
 dependencies = [
- "bytes",
- "prost-derive 0.11.8",
+ "unicode-ident",
 ]
 
 [[package]]
-name = "prost-build"
-version = "0.9.0"
+name = "prost"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62941722fb675d463659e49c4f3fe1fe792ff24fe5bbaa9c08cd3b98a1c354f5"
+checksum = "d2ea70524a2f82d518bce41317d0fae74151505651af45faf1ffbd6fd33f0568"
 dependencies = [
  "bytes",
- "heck 0.3.3",
- "itertools",
- "lazy_static",
- "log",
- "multimap",
- "petgraph",
- "prost 0.9.0",
- "prost-types 0.9.0",
- "regex",
- "tempfile",
- "which",
+ "prost-derive",
 ]
 
 [[package]]
 name = "prost-build"
-version = "0.11.8"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c828f93f5ca4826f97fedcbd3f9a536c16b12cff3dbbb4a007f932bbad95b12"
+checksum = "343d3bd7056eda839b03204e68deff7d1b13aba7af2b2fd16890697274262ee7"
 dependencies = [
- "bytes",
- "heck 0.4.1",
+ "heck",
  "itertools",
- "lazy_static",
  "log",
  "multimap",
  "petgraph",
- "prost 0.11.8",
- "prost-types 0.11.8",
+ "prettyplease",
+ "prost",
+ "prost-types",
  "regex",
+ "syn 2.0.117",
  "tempfile",
- "which",
 ]
 
 [[package]]
 name = "prost-derive"
-version = "0.9.0"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9cc1a3263e07e0bf68e96268f37665207b49560d98739662cdfaae215c720fe"
+checksum = "27c6023962132f4b30eb4c172c91ce92d933da334c59c23cddee82358ddafb0b"
 dependencies = [
  "anyhow",
  "itertools",
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
-name = "prost-derive"
-version = "0.11.8"
+name = "prost-types"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ea9b0f8cbe5e15a8a042d030bd96668db28ecb567ec37d691971ff5731d2b1b"
+checksum = "8991c4cbdb8bc5b11f0b074ffe286c30e523de90fee5ba8132f1399f23cb3dd7"
 dependencies = [
- "anyhow",
- "itertools",
- "proc-macro2",
- "quote",
- "syn",
+ "prost",
 ]
 
 [[package]]
-name = "prost-types"
-version = "0.9.0"
+name = "protobuf-src"
+version = "2.1.1+27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "534b7a0e836e3c482d2693070f982e39e7611da9695d4d1f5a4b186b51faef0a"
+checksum = "6217c3504da19b85a3a4b2e9a5183d635822d83507ba0986624b5c05b83bfc40"
 dependencies = [
- "bytes",
- "prost 0.9.0",
+ "cmake",
 ]
 
 [[package]]
-name = "prost-types"
-version = "0.11.8"
+name = "psm"
+version = "0.1.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "379119666929a1afd7a043aa6cf96fa67a6dce9af60c88095a4686dbce4c9c88"
+checksum = "3852766467df634d74f0b2d7819bf8dc483a0eb2e3b0f50f756f9cfe8b0d18d8"
 dependencies = [
- "prost 0.11.8",
+ "ar_archive_writer",
+ "cc",
 ]
 
 [[package]]
 name = "pyo3"
-version = "0.18.1"
+version = "0.28.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06a3d8e8a46ab2738109347433cb7b96dffda2e4a218b03ef27090238886b147"
+checksum = "cf85e27e86080aafd5a22eae58a162e133a589551542b3e5cee4beb27e54f8e1"
 dependencies = [
- "cfg-if",
- "indoc",
  "libc",
- "memoffset",
- "parking_lot",
+ "once_cell",
+ "portable-atomic",
  "pyo3-build-config",
  "pyo3-ffi",
  "pyo3-macros",
- "unindent",
 ]
 
 [[package]]
-name = "pyo3-build-config"
-version = "0.18.1"
+name = "pyo3-async-runtimes"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75439f995d07ddfad42b192dfcf3bc66a7ecfd8b4a1f5f6f046aa5c2c5d7677d"
+checksum = "9e7364a95bf00e8377bbf9b0f09d7ff9715a29d8fcf93b47d1a967363b973178"
 dependencies = [
+ "futures-channel",
+ "futures-util",
  "once_cell",
+ "pin-project-lite",
+ "pyo3",
+ "tokio",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.28.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8bf94ee265674bf76c09fa430b0e99c26e319c945d96ca0d5a8215f31bf81cf7"
+dependencies = [
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.18.1"
+version = "0.28.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "839526a5c07a17ff44823679b68add4a58004de00512a95b6c1c98a6dcac0ee5"
+checksum = "491aa5fc66d8059dd44a75f4580a2962c1862a1c2945359db36f6c2818b748dc"
 dependencies = [
  "libc",
  "pyo3-build-config",
 ]
 
+[[package]]
+name = "pyo3-log"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26c2ec80932c5c3b2d4fbc578c9b56b2d4502098587edb8bef5b6bfcad43682e"
+dependencies = [
+ "arc-swap",
+ "log",
+ "pyo3",
+]
+
 [[package]]
 name = "pyo3-macros"
-version = "0.18.1"
+version = "0.28.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd44cf207476c6a9760c4653559be4f206efafb924d3e4cbf2721475fc0d6cc5"
+checksum = "f5d671734e9d7a43449f8480f8b38115df67bef8d21f76837fa75ee7aaa5e52e"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.18.1"
+version = "0.28.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc1f43d8e30460f36350d18631ccf85ded64c059829208fe680904c65bcd0a4c"
+checksum = "22faaa1ce6c430a1f71658760497291065e6450d7b5dc2bcf254d49f66ee700a"
 dependencies = [
+ "heck",
  "proc-macro2",
+ "pyo3-build-config",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "quad-rand"
-version = "0.2.1"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "658fa1faf7a4cc5f057c9ee5ef560f717ad9d8dc66d975267f709624d6e1ab88"
+checksum = "5a651516ddc9168ebd67b24afd085a718be02f8858fe406591b013d101ce2f40"
 
 [[package]]
 name = "quick-xml"
-version = "0.27.1"
+version = "0.38.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffc053f057dd768a56f62cd7e434c42c831d296968997e9ac1f76ea7c2d14c41"
+checksum = "b66c2058c55a409d601666cffe35f04333cf1013010882cec174a7467cd4e21c"
 dependencies = [
  "memchr",
  "serde",
 ]
 
+[[package]]
+name = "quinn"
+version = "0.11.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e20a958963c291dc322d98411f541009df2ced7b5a4f2bd52337638cfccf20"
+dependencies = [
+ "bytes",
+ "cfg_aliases",
+ "pin-project-lite",
+ "quinn-proto",
+ "quinn-udp",
+ "rustc-hash",
+ "rustls",
+ "socket2",
+ "thiserror",
+ "tokio",
+ "tracing",
+ "web-time",
+]
+
+[[package]]
+name = "quinn-proto"
+version = "0.11.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1906b49b0c3bc04b5fe5d86a77925ae6524a19b816ae38ce1e426255f1d8a31"
+dependencies = [
+ "bytes",
+ "getrandom 0.3.4",
+ "lru-slab",
+ "rand",
+ "ring",
+ "rustc-hash",
+ "rustls",
+ "rustls-pki-types",
+ "slab",
+ "thiserror",
+ "tinyvec",
+ "tracing",
+ "web-time",
+]
+
+[[package]]
+name = "quinn-udp"
+version = "0.5.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "addec6a0dcad8a8d96a771f815f0eaf55f9d1805756410b39f5fa81332574cbd"
+dependencies = [
+ "cfg_aliases",
+ "libc",
+ "once_cell",
+ "socket2",
+ "tracing",
+ "windows-sys 0.60.2",
+]
+
 [[package]]
 name = "quote"
-version = "1.0.26"
+version = "1.0.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4424af4bf778aae2051a77b60283332f386554255d722233d09fbfc7e30da2fc"
+checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4"
 dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
 [[package]]
 name = "rand"
-version = "0.8.5"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
 dependencies = [
- "libc",
  "rand_chacha",
  "rand_core",
 ]
 
 [[package]]
 name = "rand_chacha"
-version = "0.3.1"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
 dependencies = [
  "ppv-lite86",
  "rand_core",
@@ -2077,178 +3100,238 @@ dependencies = [
 
 [[package]]
 name = "rand_core"
-version = "0.6.4"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
+]
+
+[[package]]
+name = "recursive"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0786a43debb760f491b1bc0269fe5e84155353c67482b9e60d0cfb596054b43e"
+dependencies = [
+ "recursive-proc-macro-impl",
+ "stacker",
+]
+
+[[package]]
+name = "recursive-proc-macro-impl"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+checksum = "76009fbe0614077fc1a2ce255e3a1881a2e3a3527097d5dc6d8212c585e7e38b"
 dependencies = [
- "getrandom",
+ "quote",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "redox_syscall"
-version = "0.2.16"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "regex"
+version = "1.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
+checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
 dependencies = [
- "bitflags",
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
 ]
 
 [[package]]
-name = "regex"
-version = "1.7.1"
+name = "regex-automata"
+version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48aaa5748ba571fb95cd2c85c09f629215d3a6ece942baa100950af03a34f733"
+checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
 dependencies = [
  "aho-corasick",
  "memchr",
  "regex-syntax",
 ]
 
+[[package]]
+name = "regex-lite"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cab834c73d247e67f4fae452806d17d3c7501756d98c8808d7c9c7aa7d18f973"
+
 [[package]]
 name = "regex-syntax"
-version = "0.6.28"
+version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"
+checksum = "a96887878f22d7bad8a3b6dc5b7440e0ada9a245242924394987b21cf2210a4c"
 
 [[package]]
 name = "regress"
-version = "0.4.1"
+version = "0.10.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a92ff21fe8026ce3f2627faaf43606f0b67b014dbc9ccf027181a804f75d92e"
+checksum = "2057b2325e68a893284d1538021ab90279adac1139957ca2a74426c6f118fb48"
 dependencies = [
+ "hashbrown 0.16.1",
  "memchr",
 ]
 
+[[package]]
+name = "repr_offset"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb1070755bd29dffc19d0971cab794e607839ba2ef4b69a9e6fbc8733c1b72ea"
+dependencies = [
+ "tstr",
+]
+
 [[package]]
 name = "reqwest"
-version = "0.11.14"
+version = "0.12.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21eed90ec8570952d53b772ecf8f206aa1ec9a3d76b2521c56c42973f2d91ee9"
+checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147"
 dependencies = [
  "base64",
  "bytes",
- "encoding_rs",
  "futures-core",
  "futures-util",
  "h2",
  "http",
  "http-body",
+ "http-body-util",
  "hyper",
  "hyper-rustls",
- "ipnet",
+ "hyper-util",
  "js-sys",
  "log",
- "mime",
- "once_cell",
  "percent-encoding",
  "pin-project-lite",
+ "quinn",
  "rustls",
- "rustls-pemfile",
+ "rustls-native-certs",
+ "rustls-pki-types",
  "serde",
  "serde_json",
  "serde_urlencoded",
+ "sync_wrapper",
  "tokio",
  "tokio-rustls",
  "tokio-util",
+ "tower",
+ "tower-http",
  "tower-service",
  "url",
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "wasm-streams",
  "web-sys",
- "webpki-roots",
- "winreg",
 ]
 
 [[package]]
 name = "ring"
-version = "0.16.20"
+version = "0.17.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
 dependencies = [
  "cc",
+ "cfg-if",
+ "getrandom 0.2.17",
  "libc",
- "once_cell",
- "spin",
  "untrusted",
- "web-sys",
- "winapi",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
-name = "rle-decode-fast"
-version = "1.0.3"
+name = "rustc-hash"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3582f63211428f83597b51b2ddb88e2a91a9d52d12831f9d08f5e624e8977422"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
 
 [[package]]
 name = "rustc_version"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
-dependencies = [
- "semver 1.0.17",
-]
-
-[[package]]
-name = "rustfmt-wrapper"
-version = "0.2.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed729e3bee08ec2befd593c27e90ca9fdd25efdc83c94c3b82eaef16e4f7406e"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
 dependencies = [
- "serde",
- "tempfile",
- "thiserror",
- "toml",
- "toolchain_find",
+ "semver",
 ]
 
 [[package]]
 name = "rustix"
-version = "0.36.9"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd5c6ff11fecd55b40746d1995a02f2eb375bf8c00d192d521ee09f42bef37bc"
+checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34"
 dependencies = [
  "bitflags",
  "errno",
- "io-lifetimes",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.45.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "rustls"
-version = "0.20.8"
+version = "0.23.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fff78fc74d175294f4e83b28343315ffcfb114b156f0185e9741cb5570f50e2f"
+checksum = "c665f33d38cea657d9614f766881e4d510e0eda4239891eea56b4cadcf01801b"
 dependencies = [
- "log",
+ "once_cell",
  "ring",
- "sct",
- "webpki",
+ "rustls-pki-types",
+ "rustls-webpki",
+ "subtle",
+ "zeroize",
 ]
 
 [[package]]
-name = "rustls-pemfile"
-version = "1.0.2"
+name = "rustls-native-certs"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d194b56d58803a43635bdc398cd17e383d6f71f9182b9a192c127ca42494a59b"
+checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63"
 dependencies = [
- "base64",
+ "openssl-probe",
+ "rustls-pki-types",
+ "schannel",
+ "security-framework",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be040f8b0a225e40375822a563fa9524378b9d63112f53e19ffff34df5d33fdd"
+dependencies = [
+ "web-time",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-webpki"
+version = "0.103.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7df23109aa6c1567d1c575b9952556388da57401e4ace1d15f79eedad0d8f53"
+dependencies = [
+ "ring",
+ "rustls-pki-types",
+ "untrusted",
 ]
 
 [[package]]
 name = "rustversion"
-version = "1.0.12"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f3208ce4d8448b3f3e7d168a73f5e0c43a61e32930de3bceeccedb388b6bf06"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
 
 [[package]]
 name = "ryu"
-version = "1.0.13"
+version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f91339c0467de62360649f8d3e185ca8de4224ff281f66000de5eb2a77a79041"
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
 
 [[package]]
 name = "same-file"
@@ -2259,11 +3342,20 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "schannel"
+version = "0.1.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "schemars"
-version = "0.8.12"
+version = "0.8.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02c613288622e5f0c3fdc5dbd4db1c5fbe752746b1d1a56a0630b78fd00de44f"
+checksum = "3fbf2ae1b8bc8e02df939598064d22402220cd5bbcca1c76f7d6a310974d5615"
 dependencies = [
  "dyn-clone",
  "schemars_derive",
@@ -2273,119 +3365,135 @@ dependencies = [
 
 [[package]]
 name = "schemars_derive"
-version = "0.8.12"
+version = "0.8.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "109da1e6b197438deb6db99952990c7f959572794b80ff93707d55a232545e7c"
+checksum = "32e265784ad618884abaea0600a9adf15393368d840e0222d101a072f3f7534d"
 dependencies = [
  "proc-macro2",
  "quote",
  "serde_derive_internals",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "scopeguard"
-version = "1.1.0"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
-name = "scratch"
-version = "1.0.5"
+name = "security-framework"
+version = "3.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1792db035ce95be60c3f8853017b3999209281c24e2ba5bc8e59bf97a0c590c1"
+checksum = "d17b898a6d6948c3a8ee4372c17cb384f90d2e6e912ef00895b14fd7ab54ec38"
+dependencies = [
+ "bitflags",
+ "core-foundation",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
 
 [[package]]
-name = "sct"
-version = "0.7.0"
+name = "security-framework-sys"
+version = "2.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d53dcdb7c9f8158937a7981b48accfd39a43af418591a5d008c7b22b5e1b7ca4"
+checksum = "321c8673b092a9a42605034a9879d73cb79101ed5fd117bc9a597b89b4e9e61a"
 dependencies = [
- "ring",
- "untrusted",
+ "core-foundation-sys",
+ "libc",
 ]
 
 [[package]]
 name = "semver"
-version = "0.11.0"
+version = "1.0.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f301af10236f6df4160f7c3f04eec6dbc70ace82d23326abad5edee88801c6b6"
+checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
 dependencies = [
- "semver-parser",
+ "serde",
+ "serde_core",
 ]
 
 [[package]]
-name = "semver"
-version = "1.0.17"
+name = "seq-macro"
+version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bebd363326d05ec3e2f532ab7660680f3b02130d780c299bca73469d521bc0ed"
+checksum = "1bc711410fbe7399f390ca1c3b60ad0f53f80e95c5eb935e52268a0e2cd49acc"
 
 [[package]]
-name = "semver-parser"
-version = "0.10.2"
+name = "serde"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00b0bef5b7f9e0df16536d3961cfb6e84331c065b4066afb39768d0e319411f7"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
 dependencies = [
- "pest",
+ "serde_core",
+ "serde_derive",
 ]
 
 [[package]]
-name = "seq-macro"
-version = "0.3.3"
+name = "serde_bytes"
+version = "0.11.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6b44e8fc93a14e66336d230954dda83d18b4605ccace8fe09bc7514a71ad0bc"
+checksum = "a5d440709e79d88e51ac01c4b72fc6cb7314017bb7da9eeff678aa94c10e3ea8"
+dependencies = [
+ "serde",
+ "serde_core",
+]
 
 [[package]]
-name = "serde"
-version = "1.0.156"
+name = "serde_core"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "314b5b092c0ade17c00142951e50ced110ec27cea304b1037c6969246c2469a4"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.156"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7e29c4601e36bcec74a223228dce795f4cd3616341a4af93520ca1a837c087d"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "serde_derive_internals"
-version = "0.26.0"
+version = "0.29.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85bf8229e7920a9f636479437026331ce11aa132b4dde37d121944a44d6e5f3c"
+checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.94"
+version = "1.0.149"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c533a59c9d8a93a09c6ab31f0fd5e5f4dd1b8fc9434804029839884765d04ea"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
 dependencies = [
  "itoa",
- "ryu",
+ "memchr",
  "serde",
+ "serde_core",
+ "zmij",
 ]
 
 [[package]]
 name = "serde_tokenstream"
-version = "0.1.7"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "797ba1d80299b264f3aac68ab5d12e5825a561749db4df7cd7c8083900c5d4e9"
+checksum = "64060d864397305347a78851c51588fd283767e7e7589829e8121d65512340f1"
 dependencies = [
  "proc-macro2",
+ "quote",
  "serde",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -2402,9 +3510,9 @@ dependencies = [
 
 [[package]]
 name = "serde_yaml"
-version = "0.9.19"
+version = "0.9.34+deprecated"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f82e6c8c047aa50a7328632d067bcae6ef38772a79e28daf32f735e0e4f3dd10"
+checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
 dependencies = [
  "indexmap",
  "itoa",
@@ -2415,9 +3523,9 @@ dependencies = [
 
 [[package]]
 name = "sha2"
-version = "0.10.6"
+version = "0.10.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82e6b795fe2e3b1e845bafcb27aa35405c4d47cdfc92af5fc8d3002f76cebdc0"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
 dependencies = [
  "cfg-if",
  "cpufeatures",
@@ -2425,133 +3533,153 @@ dependencies = [
 ]
 
 [[package]]
-name = "slab"
-version = "0.4.8"
+name = "shlex"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6528351c9bc8ab22353f9d776db39a20288e8d6c37ef8cfe3317cf875eecfc2d"
-dependencies = [
- "autocfg",
-]
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
-name = "smallvec"
-version = "1.10.0"
+name = "simd-adler32"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
+checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"
 
 [[package]]
-name = "snafu"
-version = "0.7.4"
+name = "simdutf8"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb0656e7e3ffb70f6c39b3c2a86332bb74aa3c679da781642590f3c1118c5045"
-dependencies = [
- "doc-comment",
- "snafu-derive",
-]
+checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
 
 [[package]]
-name = "snafu-derive"
-version = "0.7.4"
+name = "siphasher"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "475b3bbe5245c26f2d8a6f62d67c1f30eb9fffeccee721c45d162c3ebbdf81b2"
-dependencies = [
- "heck 0.4.1",
- "proc-macro2",
- "quote",
- "syn",
-]
+checksum = "b2aa850e253778c88a04c3d7323b043aeda9d3e30d5971937c1855769763678e"
+
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "snap"
-version = "1.1.0"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e9f0ab6ef7eb7353d9119c170a436d1bf248eea575ac42d19d12f4e34130831"
+checksum = "1b6b67fb9a61334225b5b790716f609cd58395f895b3fe8b328786812a40bc3b"
 
 [[package]]
 name = "socket2"
-version = "0.4.9"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64a4a911eed85daf18834cfaa86a79b7d266ff93ff5ba14005426219480ed662"
+checksum = "86f4aa3ad99f2088c990dfa82d367e19cb29268ed67c574d10d0a4bfe71f07e0"
 dependencies = [
  "libc",
- "winapi",
+ "windows-sys 0.60.2",
 ]
 
-[[package]]
-name = "spin"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
-
 [[package]]
 name = "sqlparser"
-version = "0.32.0"
+version = "0.61.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0366f270dbabb5cc2e4c88427dc4c08bba144f81e32fbd459a013f26a4d16aa0"
+checksum = "dbf5ea8d4d7c808e1af1cbabebca9a2abe603bcefc22294c5b95018d53200cb7"
 dependencies = [
  "log",
+ "recursive",
  "sqlparser_derive",
 ]
 
 [[package]]
 name = "sqlparser_derive"
-version = "0.1.1"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55fe75cb4a364c7f7ae06c7dbbc8d84bddd85d6cdf9975963c3935bc1991761e"
+checksum = "a6dd45d8fc1c79299bfbb7190e42ccbbdf6a5f52e4a6ad98d92357ea965bd289"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
-name = "static_assertions"
-version = "1.1.0"
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
+[[package]]
+name = "stacker"
+version = "0.1.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+checksum = "08d74a23609d509411d10e2176dc2a4346e3b4aea2e7b1869f19fdedbc71c013"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "libc",
+ "psm",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
 name = "strum"
-version = "0.24.1"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "063e6045c0e62079840579a7e47a355ae92f60eb74daaf156fb1e84ba164e63f"
+checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
 
 [[package]]
 name = "strum_macros"
-version = "0.24.3"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e385be0d24f186b4ce2f9982191e7101bb737312ad61c1f2f984f34bcf85d59"
+checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
 dependencies = [
- "heck 0.4.1",
+ "heck",
  "proc-macro2",
  "quote",
- "rustversion",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "substrait"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e977fc98d1e03cf99220bb6bb96f8838ffa5c1306a8c83c1b25aa20817eb6d0"
-dependencies = [
- "heck 0.4.1",
- "prost 0.11.8",
- "prost-build 0.11.8",
- "prost-types 0.11.8",
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62fc4b483a129b9772ccb9c3f7945a472112fdd9140da87f8a4e7f1d44e045d0"
+dependencies = [
+ "heck",
+ "pbjson",
+ "pbjson-build",
+ "pbjson-types",
+ "prettyplease",
+ "prost",
+ "prost-build",
+ "prost-types",
+ "protobuf-src",
+ "regress",
  "schemars",
+ "semver",
  "serde",
  "serde_json",
  "serde_yaml",
+ "syn 2.0.117",
  "typify",
  "walkdir",
 ]
 
 [[package]]
 name = "subtle"
-version = "2.4.1"
+version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bdef32e8150c2a081110b42772ffe7d7c9032b606bc226c8260fd97e0976601"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
 name = "syn"
@@ -2565,51 +3693,73 @@ dependencies = [
 ]
 
 [[package]]
-name = "target-lexicon"
-version = "0.12.6"
+name = "syn"
+version = "2.0.117"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ae9980cab1db3fceee2f6c6f643d5d8de2997c58ee8d25fb0cc8a9e9e7348e5"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
 
 [[package]]
-name = "tempfile"
-version = "3.4.0"
+name = "sync_wrapper"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af18f7ae1acd354b992402e9ec5864359d693cd8a79dcbef59f76891701c1e95"
+checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263"
 dependencies = [
- "cfg-if",
- "fastrand",
- "redox_syscall",
- "rustix",
- "windows-sys 0.42.0",
+ "futures-core",
 ]
 
 [[package]]
-name = "termcolor"
-version = "1.2.0"
+name = "synstructure"
+version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be55cf8942feac5c765c2c993422806843c9a9a45d4d5c407ad6dd2ea95eb9b6"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
 dependencies = [
- "winapi-util",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
+
+[[package]]
+name = "tempfile"
+version = "3.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0136791f7c95b1f6dd99f9cc786b91bb81c3800b639b3478e561ddb7be95e5f1"
+dependencies = [
+ "fastrand",
+ "getrandom 0.4.1",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "thiserror"
-version = "1.0.39"
+version = "2.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5ab016db510546d856297882807df8da66a16fb8c4101cb8b30054b0d5b2d9c"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.39"
+version = "2.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5420d42e90af0c38c3290abcca25b9b3bdf379fc9f55c528f53a269d9c9a267e"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
@@ -2624,30 +3774,29 @@ dependencies = [
 ]
 
 [[package]]
-name = "time"
-version = "0.1.45"
+name = "tiny-keccak"
+version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b797afad3f312d1c66a56d11d0316f916356d11bd158fbc6ca6389ff6bf805a"
+checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
 dependencies = [
- "libc",
- "wasi 0.10.0+wasi-snapshot-preview1",
- "winapi",
+ "crunchy",
 ]
 
 [[package]]
-name = "tiny-keccak"
-version = "2.0.2"
+name = "tinystr"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
+checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
 dependencies = [
- "crunchy",
+ "displaydoc",
+ "zerovec",
 ]
 
 [[package]]
 name = "tinyvec"
-version = "1.6.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
+checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa"
 dependencies = [
  "tinyvec_macros",
 ]
@@ -2660,105 +3809,116 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.26.0"
+version = "1.49.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03201d01c3c27a29c8a5cee5b55a93ddae1ccf6f08f65365c2c918f8c1b76f64"
+checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86"
 dependencies = [
- "autocfg",
  "bytes",
  "libc",
- "memchr",
  "mio",
- "num_cpus",
- "parking_lot",
  "pin-project-lite",
  "socket2",
  "tokio-macros",
- "windows-sys 0.45.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "tokio-macros"
-version = "1.8.2"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d266c00fde287f55d3f1c3e96c500c362a2b8c695076ec180f27918820bc6df8"
+checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "tokio-rustls"
-version = "0.23.4"
+version = "0.26.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c43ee83903113e03984cb9e5cebe6c04a5116269e900e3ddba8f068a62adda59"
+checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
 dependencies = [
  "rustls",
  "tokio",
- "webpki",
 ]
 
 [[package]]
 name = "tokio-stream"
-version = "0.1.12"
+version = "0.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fb52b74f05dbf495a8fba459fdc331812b96aa086d9eb78101fa0d4569c3313"
+checksum = "32da49809aab5c3bc678af03902d4ccddea2a87d028d86392a4b1560c6906c70"
 dependencies = [
  "futures-core",
  "pin-project-lite",
  "tokio",
+ "tokio-util",
 ]
 
 [[package]]
 name = "tokio-util"
-version = "0.7.7"
+version = "0.7.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5427d89453009325de0d8f342c9490009f76e999cb7672d77e46267448f7e6b2"
+checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098"
 dependencies = [
  "bytes",
  "futures-core",
  "futures-sink",
  "pin-project-lite",
  "tokio",
- "tracing",
 ]
 
 [[package]]
-name = "toml"
-version = "0.5.11"
+name = "tower"
+version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"
+checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4"
 dependencies = [
- "serde",
+ "futures-core",
+ "futures-util",
+ "pin-project-lite",
+ "sync_wrapper",
+ "tokio",
+ "tower-layer",
+ "tower-service",
 ]
 
 [[package]]
-name = "toolchain_find"
-version = "0.2.0"
+name = "tower-http"
+version = "0.6.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e85654a10e7a07a47c6f19d93818f3f343e22927f2fa280c84f7c8042743413"
+checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8"
 dependencies = [
- "home",
- "lazy_static",
- "regex",
- "semver 0.11.0",
- "walkdir",
+ "bitflags",
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "iri-string",
+ "pin-project-lite",
+ "tower",
+ "tower-layer",
+ "tower-service",
 ]
 
+[[package]]
+name = "tower-layer"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
+
 [[package]]
 name = "tower-service"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
 
 [[package]]
 name = "tracing"
-version = "0.1.37"
+version = "0.1.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ce8c33a8d48bd45d624a6e523445fd21ec13d3653cd51f681abf67418f54eb8"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
 dependencies = [
- "cfg-if",
  "pin-project-lite",
  "tracing-attributes",
  "tracing-core",
@@ -2766,62 +3926,74 @@ dependencies = [
 
 [[package]]
 name = "tracing-attributes"
-version = "0.1.23"
+version = "0.1.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4017f8f45139870ca7e672686113917c71c7a6e02d4924eda67186083c03081a"
+checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
 name = "tracing-core"
-version = "0.1.30"
+version = "0.1.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24eb03ba0eab1fd845050058ce5e616558e8f8d8fca633e6b163fe25c797213a"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
 dependencies = [
  "once_cell",
 ]
 
 [[package]]
 name = "try-lock"
-version = "0.2.4"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3528ecfd12c466c6f163363caf2d02a71161dd5e1cc6ae7b34207ea2d42d81ed"
+checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 
 [[package]]
-name = "twox-hash"
-version = "1.6.3"
+name = "tstr"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675"
+checksum = "7f8e0294f14baae476d0dd0a2d780b2e24d66e349a9de876f5126777a37bdba7"
 dependencies = [
- "cfg-if",
- "static_assertions",
+ "tstr_proc_macros",
 ]
 
 [[package]]
-name = "typed-builder"
-version = "0.10.0"
+name = "tstr_proc_macros"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89851716b67b937e393b3daa8423e67ddfc4bbbf1654bcf05488e95e0828db0c"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
+checksum = "e78122066b0cb818b8afd08f7ed22f7fdbc3e90815035726f0840d0d26c0747a"
+
+[[package]]
+name = "twox-hash"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ea3136b675547379c4bd395ca6b938e5ad3c3d20fad76e7fe85f9e0d011419c"
+
+[[package]]
+name = "typed-arena"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6af6ae20167a9ece4bcb41af5b80f8a1f1df981f6391189ce00fd257af04126a"
 
 [[package]]
 name = "typenum"
-version = "1.16.0"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
+[[package]]
+name = "typewit"
+version = "1.14.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba"
+checksum = "f8c1ae7cc0fdb8b842d65d127cb981574b0d2b249b74d1c7a2986863dc134f71"
 
 [[package]]
 name = "typify"
-version = "0.0.10"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e8486352f3c946e69f983558cfc09b295250b01e01b381ec67a05a812d01d63"
+checksum = "e6d5bcc6f62eb1fa8aa4098f39b29f93dcb914e17158b76c50360911257aa629"
 dependencies = [
  "typify-impl",
  "typify-macro",
@@ -2829,198 +4001,188 @@ dependencies = [
 
 [[package]]
 name = "typify-impl"
-version = "0.0.10"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7624d0b911df6e2bbf34a236f76281f93b294cdde1d4df1dbdb748e5a7fefa5"
+checksum = "a1eb359f7ffa4f9ebe947fa11a1b2da054564502968db5f317b7e37693cb2240"
 dependencies = [
- "heck 0.4.1",
+ "heck",
  "log",
  "proc-macro2",
  "quote",
  "regress",
- "rustfmt-wrapper",
  "schemars",
+ "semver",
+ "serde",
  "serde_json",
- "syn",
+ "syn 2.0.117",
  "thiserror",
  "unicode-ident",
 ]
 
 [[package]]
 name = "typify-macro"
-version = "0.0.10"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c42802aa033cee7650a4e1509ba7d5848a56f84be7c4b31e4385ee12445e942"
+checksum = "911c32f3c8514b048c1b228361bebb5e6d73aeec01696e8cc0e82e2ffef8ab7a"
 dependencies = [
  "proc-macro2",
  "quote",
  "schemars",
+ "semver",
  "serde",
  "serde_json",
  "serde_tokenstream",
- "syn",
+ "syn 2.0.117",
  "typify-impl",
 ]
 
-[[package]]
-name = "ucd-trie"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e79c4d996edb816c91e4308506774452e55e95c3c9de07b6729e17e15a5ef81"
-
-[[package]]
-name = "unicode-bidi"
-version = "0.3.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "524b68aca1d05e03fdf03fcdce2c6c94b6daf6d16861ddaa7e4f2b6638a9052c"
-
 [[package]]
 name = "unicode-ident"
-version = "1.0.8"
+version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"
-
-[[package]]
-name = "unicode-normalization"
-version = "0.1.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921"
-dependencies = [
- "tinyvec",
-]
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
 
 [[package]]
 name = "unicode-segmentation"
-version = "1.10.1"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1dd624098567895118886609431a7c3b8f516e41d30e0643f03d94592a147e36"
+checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
 
 [[package]]
 name = "unicode-width"
-version = "0.1.10"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
+checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
 
 [[package]]
-name = "unindent"
-version = "0.1.11"
+name = "unicode-xid"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1766d682d402817b5ac4490b3c3002d91dfa0d22812f341609f97b08757359c"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
 [[package]]
 name = "unsafe-libyaml"
-version = "0.2.7"
+version = "0.2.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad2024452afd3874bf539695e04af6732ba06517424dbf958fdb16a01f3bef6c"
+checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
 
 [[package]]
 name = "untrusted"
-version = "0.7.1"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
 [[package]]
 name = "url"
-version = "2.3.1"
+version = "2.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d68c799ae75762b8c3fe375feb6600ef5602c883c5d21eb51c09f22b83c4643"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
 dependencies = [
  "form_urlencoded",
  "idna",
  "percent-encoding",
+ "serde",
 ]
 
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
 [[package]]
 name = "uuid"
-version = "1.3.0"
+version = "1.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1674845326ee10d37ca60470760d4288a6f80f304007d92e5c53bab78c9cfd79"
+checksum = "b672338555252d43fd2240c714dc444b8c6fb0a5c5335e65a07bba7742735ddb"
 dependencies = [
- "getrandom",
- "serde",
+ "getrandom 0.4.1",
+ "js-sys",
+ "serde_core",
+ "wasm-bindgen",
 ]
 
 [[package]]
 name = "version_check"
-version = "0.9.4"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
 name = "walkdir"
-version = "2.3.2"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
 dependencies = [
  "same-file",
- "winapi",
  "winapi-util",
 ]
 
 [[package]]
 name = "want"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0"
+checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
 dependencies = [
- "log",
  "try-lock",
 ]
 
 [[package]]
 name = "wasi"
-version = "0.10.0+wasi-snapshot-preview1"
+version = "0.11.1+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
 
 [[package]]
-name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
+name = "wasip2"
+version = "1.0.2+wasi-0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"
+dependencies = [
+ "wit-bindgen",
+]
 
 [[package]]
-name = "wasm-bindgen"
-version = "0.2.84"
+name = "wasip3"
+version = "0.4.0+wasi-0.3.0-rc-2026-01-06"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31f8dcbc21f30d9b8f2ea926ecb58f6b91192c17e9d33594b3df58b2007ca53b"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
 dependencies = [
- "cfg-if",
- "wasm-bindgen-macro",
+ "wit-bindgen",
 ]
 
 [[package]]
-name = "wasm-bindgen-backend"
-version = "0.2.84"
+name = "wasm-bindgen"
+version = "0.2.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95ce90fd5bcc06af55a641a86428ee4229e44e07033963a2290a8e241607ccb9"
+checksum = "64024a30ec1e37399cf85a7ffefebdb72205ca1c972291c51512360d90bd8566"
 dependencies = [
- "bumpalo",
- "log",
+ "cfg-if",
  "once_cell",
- "proc-macro2",
- "quote",
- "syn",
+ "rustversion",
+ "wasm-bindgen-macro",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.34"
+version = "0.4.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f219e0d211ba40266969f6dbdd90636da12f75bee4fc9d6c23d1260dadb51454"
+checksum = "70a6e77fd0ae8029c9ea0063f87c46fde723e7d887703d74ad2616d792e51e6f"
 dependencies = [
  "cfg-if",
+ "futures-util",
  "js-sys",
+ "once_cell",
  "wasm-bindgen",
  "web-sys",
 ]
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.84"
+version = "0.2.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c21f77c0bedc37fd5dc21f897894a5ca01e7bb159884559461862ae90c0b4c5"
+checksum = "008b239d9c740232e71bd39e8ef6429d27097518b6b30bdf9086833bd5b6d608"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -3028,74 +4190,91 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.84"
+version = "0.2.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2aff81306fcac3c7515ad4e177f521b5c9a15f2b08f4e32d823066102f35a5f6"
+checksum = "5256bae2d58f54820e6490f9839c49780dff84c65aeab9e772f15d5f0e913a55"
 dependencies = [
+ "bumpalo",
  "proc-macro2",
  "quote",
- "syn",
- "wasm-bindgen-backend",
+ "syn 2.0.117",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.84"
+version = "0.2.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f01b580c9ac74c8d8f0c0e4afb04eeef2acf145458e52c03845ee9cd23e3d12"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0046fef7e28c3804e5e38bfa31ea2a0f73905319b677e57ebe37e49358989b5d"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
+dependencies = [
+ "leb128fmt",
+ "wasmparser",
+]
 
 [[package]]
-name = "wasm-streams"
-version = "0.2.3"
+name = "wasm-metadata"
+version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bbae3363c08332cadccd13b67db371814cd214c2524020932f0804b8cf7c078"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
 dependencies = [
- "futures-util",
- "js-sys",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
+ "anyhow",
+ "indexmap",
+ "wasm-encoder",
+ "wasmparser",
 ]
 
 [[package]]
-name = "web-sys"
-version = "0.3.61"
+name = "wasm-streams"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e33b99f4b23ba3eec1a53ac264e35a755f00e966e0065077d6027c0f575b0b97"
+checksum = "15053d8d85c7eccdbefef60f06769760a563c7f0a9d6902a13d35c7800b0ad65"
 dependencies = [
+ "futures-util",
  "js-sys",
  "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
 ]
 
 [[package]]
-name = "webpki"
-version = "0.22.0"
+name = "wasmparser"
+version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f095d78192e208183081cc07bc5515ef55216397af48b873e5edcd72637fa1bd"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
 dependencies = [
- "ring",
- "untrusted",
+ "bitflags",
+ "hashbrown 0.15.5",
+ "indexmap",
+ "semver",
 ]
 
 [[package]]
-name = "webpki-roots"
-version = "0.22.6"
+name = "web-sys"
+version = "0.3.85"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6c71e40d7d2c34a5106301fb632274ca37242cd0c9d3e64dbece371a40a2d87"
+checksum = "312e32e551d92129218ea9a2452120f4aabc03529ef03e4d0d82fb2780608598"
 dependencies = [
- "webpki",
+ "js-sys",
+ "wasm-bindgen",
 ]
 
 [[package]]
-name = "which"
-version = "4.4.0"
+name = "web-time"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2441c784c52b289a054b7201fc93253e288f094e2f4be9058343127c4226a269"
+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
 dependencies = [
- "either",
- "libc",
- "once_cell",
+ "js-sys",
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -3116,11 +4295,11 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
 [[package]]
 name = "winapi-util"
-version = "0.1.5"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "winapi",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3129,171 +4308,463 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
+[[package]]
+name = "windows-core"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows-sys"
-version = "0.42.0"
+version = "0.60.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
 dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
+ "windows-targets 0.53.5",
 ]
 
 [[package]]
 name = "windows-sys"
-version = "0.45.0"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "windows-targets",
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
 ]
 
 [[package]]
 name = "windows-targets"
-version = "0.42.2"
+version = "0.53.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
 dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
+ "windows-link",
+ "windows_aarch64_gnullvm 0.53.1",
+ "windows_aarch64_msvc 0.53.1",
+ "windows_i686_gnu 0.53.1",
+ "windows_i686_gnullvm 0.53.1",
+ "windows_i686_msvc 0.53.1",
+ "windows_x86_64_gnu 0.53.1",
+ "windows_x86_64_gnullvm 0.53.1",
+ "windows_x86_64_msvc 0.53.1",
 ]
 
 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.42.2"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.42.2"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.42.2"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.42.2"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.42.2"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.42.2"
+version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.42.2"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
-name = "winreg"
-version = "0.10.1"
+name = "windows_x86_64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
+
+[[package]]
+name = "wit-bindgen"
+version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80d0f4e272c85def139476380b12f9ac60926689dd2e01d4923222f40580869d"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
 dependencies = [
- "winapi",
+ "wit-bindgen-rust-macro",
 ]
 
 [[package]]
-name = "xz2"
-version = "0.1.7"
+name = "wit-bindgen-core"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
+dependencies = [
+ "anyhow",
+ "heck",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-bindgen-rust"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck",
+ "indexmap",
+ "prettyplease",
+ "syn 2.0.117",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
+
+[[package]]
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
+dependencies = [
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
+]
+
+[[package]]
+name = "wit-component"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
+ "bitflags",
+ "indexmap",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder",
+ "wasm-metadata",
+ "wasmparser",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-parser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser",
+]
+
+[[package]]
+name = "writeable"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
+
+[[package]]
+name = "yoke"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "388c44dc09d76f1536602ead6d325eb532f5c122f17782bd57fb47baeeb767e2"
+checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
 dependencies = [
- "lzma-sys",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "synstructure",
 ]
 
 [[package]]
 name = "zerocopy"
-version = "0.6.1"
+version = "0.8.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "332f188cc1bcf1fe1064b8c58d150f497e697f49774aa846f2dc949d9a25f236"
+checksum = "db6d35d663eadb6c932438e763b262fe1a70987f9ae936e60158176d710cae4a"
 dependencies = [
- "byteorder",
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.3.2"
+version = "0.8.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6505e6815af7de1746a08f69c69606bb45695a17149517680f3b2149713b19a3"
+checksum = "4122cd3169e94605190e77839c9a40d40ed048d305bfdc146e7df40ab0f3e517"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.117",
 ]
 
 [[package]]
-name = "zstd"
-version = "0.11.2+zstd.1.5.2"
+name = "zerofrom"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20cc960326ece64f010d2d2107537f26dc589a6573a316bd5b1dba685fa5fde4"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
 dependencies = [
- "zstd-safe 5.0.2+zstd.1.5.2",
+ "zerofrom-derive",
 ]
 
 [[package]]
-name = "zstd"
-version = "0.12.3+zstd.1.5.2"
+name = "zerofrom-derive"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76eea132fb024e0e13fd9c2f5d5d595d8a967aa72382ac2f9d39fcc95afd0806"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
 dependencies = [
- "zstd-safe 6.0.4+zstd.1.5.4",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "synstructure",
 ]
 
 [[package]]
-name = "zstd-safe"
-version = "5.0.2+zstd.1.5.2"
+name = "zeroize"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"
+
+[[package]]
+name = "zerotrie"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d2a5585e04f9eea4b2a3d1eca508c4dee9592a89ef6f450c11719da0726f4db"
+checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
 dependencies = [
- "libc",
- "zstd-sys",
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "zlib-rs"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c745c48e1007337ed136dc99df34128b9faa6ed542d80a1c673cf55a6d7236c8"
+
+[[package]]
+name = "zmij"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
+
+[[package]]
+name = "zstd"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a"
+dependencies = [
+ "zstd-safe",
 ]
 
 [[package]]
 name = "zstd-safe"
-version = "6.0.4+zstd.1.5.4"
+version = "7.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7afb4b54b8910cf5447638cb54bf4e8a65cbedd783af98b98c62ffe91f185543"
+checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d"
 dependencies = [
- "libc",
  "zstd-sys",
 ]
 
 [[package]]
 name = "zstd-sys"
-version = "2.0.7+zstd.1.5.4"
+version = "2.0.16+zstd.1.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94509c3ba2fe55294d752b79842c530ccfab760192521df74a081a78d2b3c7f5"
+checksum = "91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748"
 dependencies = [
  "cc",
- "libc",
  "pkg-config",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 03dafefe8..b584470d6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -17,44 +17,85 @@
 
 [package]
 name = "datafusion-python"
-version = "20.0.0"
-homepage = "https://github.com/apache/arrow-datafusion-python"
-repository = "https://github.com/apache/arrow-datafusion-python"
-authors = ["Apache Arrow <dev@arrow.apache.org>"]
-description = "Apache Arrow DataFusion DataFrame and SQL Query Engine"
+version = "52.0.0"
+homepage = "https://datafusion.apache.org/python"
+repository = "https://github.com/apache/datafusion-python"
+authors = ["Apache DataFusion <dev@datafusion.apache.org>"]
+description = "Apache DataFusion DataFrame and SQL Query Engine"
 readme = "README.md"
 license = "Apache-2.0"
-edition = "2021"
-rust-version = "1.64"
+edition = "2024"
+rust-version = "1.88"
+include = [
+  "/src",
+  "/datafusion",
+  "/LICENSE.txt",
+  "build.rs",
+  "pyproject.toml",
+  "Cargo.toml",
+  "Cargo.lock",
+]
 
 [features]
 default = ["mimalloc"]
+protoc = ["datafusion-substrait/protoc"]
+substrait = ["dep:datafusion-substrait"]
 
 [dependencies]
-tokio = { version = "1.24", features = ["macros", "rt", "rt-multi-thread", "sync"] }
-rand = "0.8"
-pyo3 = { version = "0.18.1", features = ["extension-module", "abi3", "abi3-py37"] }
-datafusion = { version = "20.0.0", features = ["pyarrow", "avro"]}
-datafusion-common = { version = "20.0.0", features = ["pyarrow"]}
-datafusion-expr = { version = "20.0.0" }
-datafusion-optimizer = { version = "20.0.0" }
-datafusion-sql = { version = "20.0.0" }
-datafusion-substrait = { version = "20.0.0" }
-uuid = { version = "1.2", features = ["v4"] }
-mimalloc = { version = "*", optional = true, default-features = false }
-async-trait = "0.1"
+tokio = { version = "1.49", features = [
+  "macros",
+  "rt",
+  "rt-multi-thread",
+  "sync",
+] }
+pyo3 = { version = "0.28", features = [
+  "extension-module",
+  "abi3",
+  "abi3-py310",
+] }
+pyo3-async-runtimes = { version = "0.28", features = ["tokio-runtime"] }
+pyo3-log = "0.13.3"
+arrow = { version = "58", features = ["pyarrow"] }
+arrow-select = { version = "58" }
+datafusion = { version = "53", features = ["avro", "unicode_expressions"] }
+datafusion-substrait = { version = "53", optional = true }
+datafusion-proto = { version = "53" }
+datafusion-ffi = { version = "53" }
+prost = "0.14.3" # keep in line with `datafusion-substrait`
+serde_json = "1"
+uuid = { version = "1.21", features = ["v4"] }
+mimalloc = { version = "0.1", optional = true, default-features = false, features = [
+  "local_dynamic_tls",
+] }
+async-trait = "0.1.89"
 futures = "0.3"
-object_store = { version = "0.5.3", features = ["aws", "gcp", "azure"] }
+cstr = "0.2"
+object_store = { version = "0.13.1", features = [
+  "aws",
+  "gcp",
+  "azure",
+  "http",
+] }
+url = "2"
+log = "0.4.29"
 parking_lot = "0.12"
-regex-syntax = "0.6.28"
+
+[build-dependencies]
+prost-types = "0.14.3"     # keep in line with `datafusion-substrait`
+pyo3-build-config = "0.28"
 
 [lib]
 name = "datafusion_python"
 crate-type = ["cdylib", "rlib"]
 
-[package.metadata.maturin]
-name = "datafusion._internal"
-
 [profile.release]
 lto = true
 codegen-units = 1
+
+# We cannot publish to crates.io with any patches in the below section. Developers
+# must remove any entries in this section before creating a release candidate.
+[patch.crates-io]
+datafusion = { git = "https://github.com/apache/datafusion.git", rev = "35749607f585b3bf25b66b7d2289c56c18d03e4f" }
+datafusion-substrait = { git = "https://github.com/apache/datafusion.git", rev = "35749607f585b3bf25b66b7d2289c56c18d03e4f" }
+datafusion-proto = { git = "https://github.com/apache/datafusion.git", rev = "35749607f585b3bf25b66b7d2289c56c18d03e4f" }
+datafusion-ffi = { git = "https://github.com/apache/datafusion.git", rev = "35749607f585b3bf25b66b7d2289c56c18d03e4f" }
diff --git a/README.md b/README.md
index 7c29defdc..810ac8710 100644
--- a/README.md
+++ b/README.md
@@ -19,12 +19,19 @@
 
 # DataFusion in Python
 
-[![Python test](https://github.com/apache/arrow-datafusion-python/actions/workflows/test.yaml/badge.svg)](https://github.com/apache/arrow-datafusion-python/actions/workflows/test.yaml)
-[![Python Release Build](https://github.com/apache/arrow-datafusion-python/actions/workflows/build.yml/badge.svg)](https://github.com/apache/arrow-datafusion-python/actions/workflows/build.yml)
+[![Python test](https://github.com/apache/datafusion-python/actions/workflows/test.yaml/badge.svg)](https://github.com/apache/datafusion-python/actions/workflows/test.yaml)
+[![Python Release Build](https://github.com/apache/datafusion-python/actions/workflows/build.yml/badge.svg)](https://github.com/apache/datafusion-python/actions/workflows/build.yml)
 
-This is a Python library that binds to [Apache Arrow](https://arrow.apache.org/) in-memory query engine [DataFusion](https://github.com/apache/arrow-datafusion).
+This is a Python library that binds to [Apache Arrow](https://arrow.apache.org/) in-memory query engine [DataFusion](https://github.com/apache/datafusion).
 
-DataFusion's Python bindings can be used as an end-user tool as well as providing a foundation for building new systems.
+DataFusion's Python bindings can be used as a foundation for building new data systems in Python. Here are some examples:
+
+- [Dask SQL](https://github.com/dask-contrib/dask-sql) uses DataFusion's Python bindings for SQL parsing, query
+  planning, and logical plan optimizations, and then transpiles the logical plan to Dask operations for execution.
+- [DataFusion Ballista](https://github.com/apache/datafusion-ballista) is a distributed SQL query engine that extends
+  DataFusion's Python bindings for distributed use cases.
+- [DataFusion Ray](https://github.com/apache/datafusion-ray) is another distributed query engine that uses
+  DataFusion's Python bindings.
 
 ## Features
 
@@ -35,19 +42,9 @@ DataFusion's Python bindings can be used as an end-user tool as well as providin
 - Serialize and deserialize query plans in Substrait format.
 - Experimental support for transpiling SQL queries to DataFrame calls with Polars, Pandas, and cuDF.
 
-## Comparison with other projects
-
-Here is a comparison with similar projects that may help understand when DataFusion might be suitable and unsuitable
-for your needs:
-
-- [DuckDB](http://www.duckdb.org/) is an open source, in-process analytic database. Like DataFusion, it supports
-  very fast execution, both from its custom file format and directly from Parquet files. Unlike DataFusion, it is
-  written in C/C++ and it is primarily used directly by users as a serverless database and query system rather than
-  as a library for building such database systems.
-
-- [Polars](http://pola.rs/) is one of the fastest DataFrame libraries at the time of writing. Like DataFusion, it
-  is also written in Rust and uses the Apache Arrow memory model, but unlike DataFusion it does not provide full SQL
-  support, nor as many extension points.
+For tips on tuning parallelism, see
+[Maximizing CPU Usage](docs/source/user-guide/configuration.rst#maximizing-cpu-usage)
+in the configuration guide.
 
 ## Example Usage
 
@@ -86,37 +83,115 @@ This produces the following chart:
 
 ![Chart](examples/chart.png)
 
+## Registering a DataFrame as a View
+
+You can use SessionContext's `register_view` method to convert a DataFrame into a view and register it with the context.
+
+```python
+from datafusion import SessionContext, col, literal
+
+# Create a DataFusion context
+ctx = SessionContext()
+
+# Create sample data
+data = {"a": [1, 2, 3, 4, 5], "b": [10, 20, 30, 40, 50]}
+
+# Create a DataFrame from the dictionary
+df = ctx.from_pydict(data, "my_table")
+
+# Filter the DataFrame (for example, keep rows where a > 2)
+df_filtered = df.filter(col("a") > literal(2))
+
+# Register the dataframe as a view with the context
+ctx.register_view("view1", df_filtered)
+
+# Now run a SQL query against the registered view
+df_view = ctx.sql("SELECT * FROM view1")
+
+# Collect the results
+results = df_view.collect()
+
+# Convert results to a list of dictionaries for display
+result_dicts = [batch.to_pydict() for batch in results]
+
+print(result_dicts)
+```
+
+This will output:
+
+```python
+[{'a': [3, 4, 5], 'b': [30, 40, 50]}]
+```
+
+## Configuration
+
+It is possible to configure runtime (memory and disk settings) and configuration settings when creating a context.
+
+```python
+runtime = (
+    RuntimeEnvBuilder()
+    .with_disk_manager_os()
+    .with_fair_spill_pool(10000000)
+)
+config = (
+    SessionConfig()
+    .with_create_default_catalog_and_schema(True)
+    .with_default_catalog_and_schema("foo", "bar")
+    .with_target_partitions(8)
+    .with_information_schema(True)
+    .with_repartition_joins(False)
+    .with_repartition_aggregations(False)
+    .with_repartition_windows(False)
+    .with_parquet_pruning(False)
+    .set("datafusion.execution.parquet.pushdown_filters", "true")
+)
+ctx = SessionContext(config, runtime)
+```
+
+Refer to the [API documentation](https://arrow.apache.org/datafusion-python/#api-reference) for more information.
+
+Printing the context will show the current configuration settings.
+
+```python
+print(ctx)
+```
+
+## Extensions
+
+For information about how to extend DataFusion Python, please see the extensions page of the
+[online documentation](https://datafusion.apache.org/python/).
+
 ## More Examples
 
 See [examples](examples/README.md) for more information.
 
 ### Executing Queries with DataFusion
 
-- [Query a Parquet file using SQL](./examples/sql-parquet.py)
-- [Query a Parquet file using the DataFrame API](./examples/dataframe-parquet.py)
-- [Run a SQL query and store the results in a Pandas DataFrame](./examples/sql-to-pandas.py)
-- [Run a SQL query with a Python user-defined function (UDF)](./examples/sql-using-python-udf.py)
-- [Run a SQL query with a Python user-defined aggregation function (UDAF)](./examples/sql-using-python-udaf.py)
-- [Query PyArrow Data](./examples/query-pyarrow-data.py)
-- [Create dataframe](./examples/import.py)
-- [Export dataframe](./examples/export.py)
+- [Query a Parquet file using SQL](https://github.com/apache/datafusion-python/blob/main/examples/sql-parquet.py)
+- [Query a Parquet file using the DataFrame API](https://github.com/apache/datafusion-python/blob/main/examples/dataframe-parquet.py)
+- [Run a SQL query and store the results in a Pandas DataFrame](https://github.com/apache/datafusion-python/blob/main/examples/sql-to-pandas.py)
+- [Run a SQL query with a Python user-defined function (UDF)](https://github.com/apache/datafusion-python/blob/main/examples/sql-using-python-udf.py)
+- [Run a SQL query with a Python user-defined aggregation function (UDAF)](https://github.com/apache/datafusion-python/blob/main/examples/sql-using-python-udaf.py)
+- [Query PyArrow Data](https://github.com/apache/datafusion-python/blob/main/examples/query-pyarrow-data.py)
+- [Create dataframe](https://github.com/apache/datafusion-python/blob/main/examples/import.py)
+- [Export dataframe](https://github.com/apache/datafusion-python/blob/main/examples/export.py)
 
 ### Running User-Defined Python Code
 
-- [Register a Python UDF with DataFusion](./examples/python-udf.py)
-- [Register a Python UDAF with DataFusion](./examples/python-udaf.py)
+- [Register a Python UDF with DataFusion](https://github.com/apache/datafusion-python/blob/main/examples/python-udf.py)
+- [Register a Python UDAF with DataFusion](https://github.com/apache/datafusion-python/blob/main/examples/python-udaf.py)
 
 ### Substrait Support
 
-- [Serialize query plans using Substrait](./examples/substrait.py)
+- [Serialize query plans using Substrait](https://github.com/apache/datafusion-python/blob/main/examples/substrait.py)
 
-### Executing SQL against DataFrame Libraries (Experimental)
+## How to install
 
-- [Executing SQL on Polars](./examples/sql-on-polars.py)
-- [Executing SQL on Pandas](./examples/sql-on-pandas.py)
-- [Executing SQL on cuDF](./examples/sql-on-cudf.py)
+### uv
 
-## How to install (from pip)
+```bash
+uv add datafusion
+```
 
 ### Pip
 
@@ -142,73 +217,96 @@ You can verify the installation by running:
 
 ## How to develop
 
-This assumes that you have rust and cargo installed. We use the workflow recommended by [pyo3](https://github.com/PyO3/pyo3) and [maturin](https://github.com/PyO3/maturin).
+This assumes that you have rust and cargo installed. We use the workflow recommended by [pyo3](https://github.com/PyO3/pyo3) and [maturin](https://github.com/PyO3/maturin). The Maturin tools used in this workflow can be installed either via `uv` or `pip`. Both approaches should offer the same experience. It is recommended to use `uv` since it has significant performance improvements
+over `pip`.
+
+Currently for protobuf support either [protobuf](https://protobuf.dev/installation/) or cmake must be installed.
 
-The Maturin tools used in this workflow can be installed either via Conda or Pip. Both approaches should offer the same experience. Multiple approaches are only offered to appease developer preference. Bootstrapping for both Conda and Pip are as follows.
+Bootstrap (`uv`):
 
-Bootstrap (Conda):
+By default `uv` will attempt to build the datafusion python package. For our development we prefer to build manually. This means
+that when creating your virtual environment using `uv sync` you need to pass in the additional `--no-install-package datafusion`
+and for `uv run` commands the additional parameter `--no-project`
 
 ```bash
 # fetch this repo
-git clone git@github.com:apache/arrow-datafusion-python.git
-# create the conda environment for dev
-conda env create -f ./conda/environments/datafusion-dev.yaml -n datafusion-dev
-# activate the conda environment
-conda activate datafusion-dev
+git clone git@github.com:apache/datafusion-python.git
+# cd to the repo root
+cd datafusion-python/
+# create the virtual environment
+uv sync --dev --no-install-package datafusion
+# activate the environment
+source .venv/bin/activate
 ```
 
-Bootstrap (Pip):
+Bootstrap (`pip`):
 
 ```bash
 # fetch this repo
-git clone git@github.com:apache/arrow-datafusion-python.git
+git clone git@github.com:apache/datafusion-python.git
+# cd to the repo root
+cd datafusion-python/
 # prepare development environment (used to build wheel / install in development)
-python3 -m venv venv
+python3 -m venv .venv
 # activate the venv
-source venv/bin/activate
+source .venv/bin/activate
 # update pip itself if necessary
 python -m pip install -U pip
-# install dependencies (for Python 3.8+)
-python -m pip install -r requirements-310.txt
+# install dependencies
+python -m pip install -r pyproject.toml
 ```
 
 The tests rely on test data in git submodules.
 
 ```bash
-git submodule init
-git submodule update
+git submodule update --init
 ```
 
 Whenever rust code changes (your changes or via `git pull`):
 
 ```bash
 # make sure you activate the venv using "source venv/bin/activate" first
-maturin develop
+maturin develop --uv
 python -m pytest
 ```
 
+Alternatively if you are using `uv` you can do the following without
+needing to activate the virtual environment:
+
+```bash
+uv run --no-project maturin develop --uv
+uv run --no-project pytest .
+```
+
 ### Running & Installing pre-commit hooks
 
-arrow-datafusion-python takes advantage of (pre-commit)[https://pre-commit.com/] to assist developers in with code linting to help reduce the number of commits that ultimately fail in CI due to linter errors. Using the pre-commit hooks is optional for the developer but certainly helpful for keep PRs clean and concise.
+`datafusion-python` takes advantage of [pre-commit](https://pre-commit.com/) to assist developers with code linting to help reduce
+the number of commits that ultimately fail in CI due to linter errors. Using the pre-commit hooks is optional for the
+developer but certainly helpful for keeping PRs clean and concise.
 
-Our pre-commit hooks can be installed by running `pre-commit install` which will install the configurations in your ARROW_DATAFUSION_PYTHON_ROOT/.github directory and run each time you perform a commit failing to perform the commit if an offending lint is found giving you the opportunity to make changes locally before pushing.
+Our pre-commit hooks can be installed by running `pre-commit install`, which will install the configurations in
+your DATAFUSION_PYTHON_ROOT/.github directory and run each time you perform a commit, failing to complete
+the commit if an offending lint is found allowing you to make changes locally before pushing.
 
-The pre-commit hooks can also be ran ad-hoc without installing them by simply running `pre-commit run --all-files`
+The pre-commit hooks can also be run adhoc without installing them by simply running `pre-commit run --all-files`.
 
-## How to update dependencies
+NOTE: the current `pre-commit` hooks require docker, and cmake. See note on protobuf above.
 
-To change test dependencies, change the `requirements.in` and run
+## Running linters without using pre-commit
 
-```bash
-# install pip-tools (this can be done only once), also consider running in venv
-python -m pip install pip-tools
-python -m piptools compile --generate-hashes -o requirements-310.txt
+There are scripts in `ci/scripts` for running Rust and Python linters.
+
+```shell
+./ci/scripts/python_lint.sh
+./ci/scripts/rust_clippy.sh
+./ci/scripts/rust_fmt.sh
+./ci/scripts/rust_toml_fmt.sh
 ```
 
-To update dependencies, run with `-U`
+## How to update dependencies
+
+To change test dependencies, change the `pyproject.toml` and run
 
 ```bash
-python -m piptools compile -U --generate-hashes -o requirements-310.txt
+uv sync --dev --no-install-package datafusion
 ```
-
-More details [here](https://github.com/jazzband/pip-tools)
diff --git a/benchmarks/db-benchmark/README.md b/benchmarks/db-benchmark/README.md
new file mode 100644
index 000000000..8ce45344d
--- /dev/null
+++ b/benchmarks/db-benchmark/README.md
@@ -0,0 +1,32 @@
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+
+# DataFusion Implementation of db-benchmark
+
+This directory contains scripts for running [db-benchmark](https://github.com/duckdblabs/db-benchmark) with 
+DataFusion's Python bindings.
+
+## Directions
+
+Run the following from root of this project.
+
+```bash
+docker build -t db-benchmark -f benchmarks/db-benchmark/db-benchmark.dockerfile .
+docker run --privileged -it db-benchmark
+```
diff --git a/benchmarks/db-benchmark/db-benchmark.dockerfile b/benchmarks/db-benchmark/db-benchmark.dockerfile
new file mode 100644
index 000000000..af2edd0f4
--- /dev/null
+++ b/benchmarks/db-benchmark/db-benchmark.dockerfile
@@ -0,0 +1,120 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+FROM ubuntu:22.04
+ARG DEBIAN_FRONTEND=noninteractive
+ARG TARGETPLATFORM
+
+# This section is based on https://github.com/duckdblabs/db-benchmark/blob/master/_utils/repro.sh
+
+RUN apt-get -qq update
+RUN apt-get -qq -y upgrade
+RUN apt-get -qq install -y apt-utils
+
+RUN apt-get -qq install -y lsb-release software-properties-common wget curl vim htop git byobu libcurl4-openssl-dev libssl-dev
+RUN apt-get -qq install -y libfreetype6-dev
+RUN apt-get -qq install -y libfribidi-dev
+RUN apt-get -qq install -y libharfbuzz-dev
+RUN apt-get -qq install -y git
+RUN apt-get -qq install -y libxml2-dev
+RUN apt-get -qq install -y make
+RUN apt-get -qq install -y libfontconfig1-dev
+RUN apt-get -qq install -y libicu-dev pandoc zlib1g-dev libgit2-dev libcurl4-openssl-dev libssl-dev libjpeg-dev libpng-dev libtiff-dev
+# apt-key adv --keyserver keyserver.ubuntu.com --recv-keys E298A3A825C0D65DFD57CBB651716619E084DAB9
+RUN add-apt-repository "deb [arch=amd64,i386] https://cloud.r-project.org/bin/linux/ubuntu $(lsb_release -cs)-cran40/"
+
+RUN apt-get -qq install -y r-base-dev virtualenv
+
+RUN cd /usr/local/lib/R && \
+  chmod o+w site-library
+
+RUN cd / && \
+    git clone https://github.com/duckdblabs/db-benchmark.git
+
+WORKDIR /db-benchmark
+
+RUN mkdir -p .R && \
+    echo 'CFLAGS=-O3 -mtune=native' >> .R/Makevars && \
+    echo 'CXXFLAGS=-O3 -mtune=native' >> .R/Makevars
+
+RUN cd pydatatable && \
+  virtualenv py-pydatatable --python=/usr/bin/python3.10
+RUN cd pandas && \
+  virtualenv py-pandas --python=/usr/bin/python3.10
+RUN cd modin && \
+  virtualenv py-modin --python=/usr/bin/python3.10
+
+RUN Rscript -e 'install.packages(c("jsonlite","bit64","devtools","rmarkdown"), dependencies=TRUE, repos="https://cloud.r-project.org")'
+
+SHELL ["/bin/bash", "-c"]
+
+RUN source ./pandas/py-pandas/bin/activate && \
+    python3 -m pip install --upgrade psutil && \
+    python3 -m pip install --upgrade pandas && \
+    deactivate
+
+RUN source ./modin/py-modin/bin/activate && \
+    python3 -m pip install --upgrade modin && \
+    deactivate
+
+RUN source ./pydatatable/py-pydatatable/bin/activate && \
+    python3 -m pip install --upgrade git+https://github.com/h2oai/datatable && \
+    deactivate
+
+## install dplyr
+#RUN Rscript -e 'devtools::install_github(c("tidyverse/readr","tidyverse/dplyr"))'
+
+# install data.table
+RUN Rscript -e 'install.packages("data.table", repos="https://rdatatable.gitlab.io/data.table/")'
+
+## generate data for groupby 0.5GB
+RUN Rscript _data/groupby-datagen.R 1e7 1e2 0 0
+RUN #Rscript _data/groupby-datagen.R 1e8 1e2 0 0
+RUN #Rscript _data/groupby-datagen.R 1e9 1e2 0 0
+
+RUN mkdir data && \
+  mv G1_1e7_1e2_0_0.csv data/
+
+# set only groupby task
+RUN echo "Changing run.conf and _control/data.csv to run only groupby at 0.5GB" && \
+    cp run.conf run.conf.original && \
+    sed -i 's/groupby join groupby2014/groupby/g' run.conf && \
+    sed -i 's/data.table dplyr pandas pydatatable spark dask clickhouse polars arrow duckdb/data.table dplyr duckdb/g' run.conf && \
+    sed -i 's/DO_PUBLISH=true/DO_PUBLISH=false/g' run.conf
+
+## set sizes
+RUN mv _control/data.csv _control/data.csv.original && \
+    echo "task,data,nrow,k,na,sort,active" > _control/data.csv && \
+    echo "groupby,G1_1e7_1e2_0_0,1e7,1e2,0,0,1" >> _control/data.csv
+
+RUN #./dplyr/setup-dplyr.sh
+RUN #./datatable/setup-datatable.sh
+RUN #./duckdb/setup-duckdb.sh
+
+# END OF SETUP
+
+RUN python3 -m pip install --upgrade pandas
+RUN python3 -m pip install --upgrade polars psutil
+RUN python3 -m pip install --upgrade datafusion
+
+# Now add our solution
+RUN rm -rf datafusion-python 2>/dev/null && \
+    mkdir datafusion-python
+ADD benchmarks/db-benchmark/*.py datafusion-python/
+ADD benchmarks/db-benchmark/run-bench.sh .
+
+ENTRYPOINT [ "/db-benchmark/run-bench.sh" ]
\ No newline at end of file
diff --git a/benchmarks/db-benchmark/groupby-datafusion.py b/benchmarks/db-benchmark/groupby-datafusion.py
new file mode 100644
index 000000000..533166695
--- /dev/null
+++ b/benchmarks/db-benchmark/groupby-datafusion.py
@@ -0,0 +1,527 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import gc
+import os
+import timeit
+from pathlib import Path
+
+import datafusion as df
+import pyarrow as pa
+from datafusion import (
+    RuntimeEnvBuilder,
+    SessionConfig,
+    SessionContext,
+    col,
+)
+from datafusion import (
+    functions as f,
+)
+from pyarrow import csv as pacsv
+
+print("# groupby-datafusion.py", flush=True)
+
+exec(Path.open("./_helpers/helpers.py").read())
+
+
+def ans_shape(batches) -> tuple[int, int]:
+    rows, cols = 0, 0
+    for batch in batches:
+        rows += batch.num_rows
+        if cols == 0:
+            cols = batch.num_columns
+        else:
+            assert cols == batch.num_columns
+    return rows, cols
+
+
+def execute(df) -> list:
+    print(df.execution_plan().display_indent())
+    return df.collect()
+
+
+ver = df.__version__
+git = ""
+task = "groupby"
+solution = "datafusion"
+fun = ".groupby"
+cache = "TRUE"
+on_disk = "FALSE"
+
+# experimental - support running with both DataFrame and SQL APIs
+sql = True
+
+data_name = os.environ["SRC_DATANAME"]
+src_grp = "data" / data_name / ".csv"
+print("loading dataset %s" % src_grp, flush=True)
+
+schema = pa.schema(
+    [
+        ("id4", pa.int32()),
+        ("id5", pa.int32()),
+        ("id6", pa.int32()),
+        ("v1", pa.int32()),
+        ("v2", pa.int32()),
+        ("v3", pa.float64()),
+    ]
+)
+
+data = pacsv.read_csv(
+    src_grp,
+    convert_options=pacsv.ConvertOptions(auto_dict_encode=True, column_types=schema),
+)
+print("dataset loaded")
+
+# create a session context with explicit runtime and config settings
+runtime = (
+    RuntimeEnvBuilder()
+    .with_disk_manager_os()
+    .with_fair_spill_pool(64 * 1024 * 1024 * 1024)
+)
+config = (
+    SessionConfig()
+    .with_repartition_joins(enabled=False)
+    .with_repartition_aggregations(enabled=False)
+    .set("datafusion.execution.coalesce_batches", "false")
+)
+ctx = SessionContext(config, runtime)
+print(ctx)
+
+ctx.register_record_batches("x", [data.to_batches()])
+print("registered record batches")
+# cols = ctx.sql("SHOW columns from x")
+# ans.show()
+
+in_rows = data.num_rows
+# print(in_rows, flush=True)
+
+task_init = timeit.default_timer()
+
+question = "sum v1 by id1"  # q1
+gc.collect()
+t_start = timeit.default_timer()
+if sql:
+    df = ctx.sql("SELECT id1, SUM(v1) AS v1 FROM x GROUP BY id1")
+else:
+    df = ctx.table("x").aggregate([f.col("id1")], [f.sum(f.col("v1")).alias("v1")])
+ans = execute(df)
+
+shape = ans_shape(ans)
+print(shape, flush=True)
+t = timeit.default_timer() - t_start
+print(f"q1: {t}")
+m = memory_usage()
+t_start = timeit.default_timer()
+df = ctx.create_dataframe([ans])
+chk = df.aggregate([], [f.sum(col("v1"))]).collect()[0].column(0)[0]
+chkt = timeit.default_timer() - t_start
+write_log(
+    task=task,
+    data=data_name,
+    in_rows=in_rows,
+    question=question,
+    out_rows=shape[0],
+    out_cols=shape[1],
+    solution=solution,
+    version=ver,
+    git=git,
+    fun=fun,
+    run=1,
+    time_sec=t,
+    mem_gb=m,
+    cache=cache,
+    chk=make_chk([chk]),
+    chk_time_sec=chkt,
+    on_disk=on_disk,
+)
+del ans
+gc.collect()
+
+question = "sum v1 by id1:id2"  # q2
+gc.collect()
+t_start = timeit.default_timer()
+if sql:
+    df = ctx.sql("SELECT id1, id2, SUM(v1) AS v1 FROM x GROUP BY id1, id2")
+else:
+    df = ctx.table("x").aggregate(
+        [f.col("id1"), f.col("id2")], [f.sum(f.col("v1")).alias("v1")]
+    )
+ans = execute(df)
+shape = ans_shape(ans)
+print(shape, flush=True)
+t = timeit.default_timer() - t_start
+print(f"q2: {t}")
+m = memory_usage()
+t_start = timeit.default_timer()
+df = ctx.create_dataframe([ans])
+chk = df.aggregate([], [f.sum(col("v1"))]).collect()[0].column(0)[0]
+chkt = timeit.default_timer() - t_start
+write_log(
+    task=task,
+    data=data_name,
+    in_rows=in_rows,
+    question=question,
+    out_rows=shape[0],
+    out_cols=shape[1],
+    solution=solution,
+    version=ver,
+    git=git,
+    fun=fun,
+    run=1,
+    time_sec=t,
+    mem_gb=m,
+    cache=cache,
+    chk=make_chk([chk]),
+    chk_time_sec=chkt,
+    on_disk=on_disk,
+)
+del ans
+gc.collect()
+
+question = "sum v1 mean v3 by id3"  # q3
+gc.collect()
+t_start = timeit.default_timer()
+if sql:
+    df = ctx.sql("SELECT id3, SUM(v1) AS v1, AVG(v3) AS v3 FROM x GROUP BY id3")
+else:
+    df = ctx.table("x").aggregate(
+        [f.col("id3")],
+        [
+            f.sum(f.col("v1")).alias("v1"),
+            f.avg(f.col("v3")).alias("v3"),
+        ],
+    )
+ans = execute(df)
+shape = ans_shape(ans)
+print(shape, flush=True)
+t = timeit.default_timer() - t_start
+print(f"q3: {t}")
+m = memory_usage()
+t_start = timeit.default_timer()
+df = ctx.create_dataframe([ans])
+chk = (
+    df.aggregate([], [f.sum(col("v1")), f.sum(col("v3"))])
+    .collect()[0]
+    .to_pandas()
+    .to_numpy()[0]
+)
+chkt = timeit.default_timer() - t_start
+write_log(
+    task=task,
+    data=data_name,
+    in_rows=in_rows,
+    question=question,
+    out_rows=shape[0],
+    out_cols=shape[1],
+    solution=solution,
+    version=ver,
+    git=git,
+    fun=fun,
+    run=1,
+    time_sec=t,
+    mem_gb=m,
+    cache=cache,
+    chk=make_chk([chk]),
+    chk_time_sec=chkt,
+    on_disk=on_disk,
+)
+del ans
+gc.collect()
+
+question = "mean v1:v3 by id4"  # q4
+gc.collect()
+t_start = timeit.default_timer()
+ans = ctx.sql(
+    "SELECT id4, AVG(v1) AS v1, AVG(v2) AS v2, AVG(v3) AS v3 FROM x GROUP BY id4"
+).collect()
+shape = ans_shape(ans)
+print(shape, flush=True)
+t = timeit.default_timer() - t_start
+print(f"q4: {t}")
+m = memory_usage()
+t_start = timeit.default_timer()
+df = ctx.create_dataframe([ans])
+chk = (
+    df.aggregate([], [f.sum(col("v1")), f.sum(col("v2")), f.sum(col("v3"))])
+    .collect()[0]
+    .to_pandas()
+    .to_numpy()[0]
+)
+chkt = timeit.default_timer() - t_start
+write_log(
+    task=task,
+    data=data_name,
+    in_rows=in_rows,
+    question=question,
+    out_rows=shape[0],
+    out_cols=shape[1],
+    solution=solution,
+    version=ver,
+    git=git,
+    fun=fun,
+    run=1,
+    time_sec=t,
+    mem_gb=m,
+    cache=cache,
+    chk=make_chk([chk]),
+    chk_time_sec=chkt,
+    on_disk=on_disk,
+)
+del ans
+gc.collect()
+
+question = "sum v1:v3 by id6"  # q5
+gc.collect()
+t_start = timeit.default_timer()
+ans = ctx.sql(
+    "SELECT id6, SUM(v1) AS v1, SUM(v2) AS v2, SUM(v3) AS v3 FROM x GROUP BY id6"
+).collect()
+shape = ans_shape(ans)
+print(shape, flush=True)
+t = timeit.default_timer() - t_start
+print(f"q5: {t}")
+m = memory_usage()
+t_start = timeit.default_timer()
+df = ctx.create_dataframe([ans])
+chk = (
+    df.aggregate([], [f.sum(col("v1")), f.sum(col("v2")), f.sum(col("v3"))])
+    .collect()[0]
+    .to_pandas()
+    .to_numpy()[0]
+)
+chkt = timeit.default_timer() - t_start
+write_log(
+    task=task,
+    data=data_name,
+    in_rows=in_rows,
+    question=question,
+    out_rows=shape[0],
+    out_cols=shape[1],
+    solution=solution,
+    version=ver,
+    git=git,
+    fun=fun,
+    run=1,
+    time_sec=t,
+    mem_gb=m,
+    cache=cache,
+    chk=make_chk([chk]),
+    chk_time_sec=chkt,
+    on_disk=on_disk,
+)
+del ans
+gc.collect()
+
+question = "median v3 sd v3 by id4 id5"  # q6
+gc.collect()
+t_start = timeit.default_timer()
+ans = ctx.sql(
+    "SELECT id4, id5, approx_percentile_cont(v3, .5) AS median_v3, stddev(v3) AS stddev_v3 FROM x GROUP BY id4, id5"
+).collect()
+shape = ans_shape(ans)
+print(shape, flush=True)
+t = timeit.default_timer() - t_start
+print(f"q6: {t}")
+m = memory_usage()
+t_start = timeit.default_timer()
+df = ctx.create_dataframe([ans])
+chk = (
+    df.aggregate([], [f.sum(col("median_v3")), f.sum(col("stddev_v3"))])
+    .collect()[0]
+    .to_pandas()
+    .to_numpy()[0]
+)
+chkt = timeit.default_timer() - t_start
+write_log(
+    task=task,
+    data=data_name,
+    in_rows=in_rows,
+    question=question,
+    out_rows=shape[0],
+    out_cols=shape[1],
+    solution=solution,
+    version=ver,
+    git=git,
+    fun=fun,
+    run=1,
+    time_sec=t,
+    mem_gb=m,
+    cache=cache,
+    chk=make_chk([chk]),
+    chk_time_sec=chkt,
+    on_disk=on_disk,
+)
+del ans
+gc.collect()
+
+question = "max v1 - min v2 by id3"  # q7
+gc.collect()
+t_start = timeit.default_timer()
+ans = ctx.sql(
+    "SELECT id3, MAX(v1) - MIN(v2) AS range_v1_v2 FROM x GROUP BY id3"
+).collect()
+shape = ans_shape(ans)
+print(shape, flush=True)
+t = timeit.default_timer() - t_start
+print(f"q7: {t}")
+m = memory_usage()
+t_start = timeit.default_timer()
+df = ctx.create_dataframe([ans])
+chk = df.aggregate([], [f.sum(col("range_v1_v2"))]).collect()[0].column(0)[0]
+chkt = timeit.default_timer() - t_start
+write_log(
+    task=task,
+    data=data_name,
+    in_rows=in_rows,
+    question=question,
+    out_rows=shape[0],
+    out_cols=shape[1],
+    solution=solution,
+    version=ver,
+    git=git,
+    fun=fun,
+    run=1,
+    time_sec=t,
+    mem_gb=m,
+    cache=cache,
+    chk=make_chk([chk]),
+    chk_time_sec=chkt,
+    on_disk=on_disk,
+)
+del ans
+gc.collect()
+
+question = "largest two v3 by id6"  # q8
+gc.collect()
+t_start = timeit.default_timer()
+ans = ctx.sql(
+    "SELECT id6, v3 from (SELECT id6, v3, row_number() OVER (PARTITION BY id6 ORDER BY v3 DESC) AS row FROM x) t WHERE row <= 2"
+).collect()
+shape = ans_shape(ans)
+print(shape, flush=True)
+t = timeit.default_timer() - t_start
+print(f"q8: {t}")
+m = memory_usage()
+t_start = timeit.default_timer()
+df = ctx.create_dataframe([ans])
+chk = df.aggregate([], [f.sum(col("v3"))]).collect()[0].column(0)[0]
+chkt = timeit.default_timer() - t_start
+write_log(
+    task=task,
+    data=data_name,
+    in_rows=in_rows,
+    question=question,
+    out_rows=shape[0],
+    out_cols=shape[1],
+    solution=solution,
+    version=ver,
+    git=git,
+    fun=fun,
+    run=1,
+    time_sec=t,
+    mem_gb=m,
+    cache=cache,
+    chk=make_chk([chk]),
+    chk_time_sec=chkt,
+    on_disk=on_disk,
+)
+del ans
+gc.collect()
+
+question = "regression v1 v2 by id2 id4"  # q9
+gc.collect()
+t_start = timeit.default_timer()
+ans = ctx.sql("SELECT corr(v1, v2) as corr FROM x GROUP BY id2, id4").collect()
+shape = ans_shape(ans)
+print(shape, flush=True)
+t = timeit.default_timer() - t_start
+print(f"q9: {t}")
+m = memory_usage()
+t_start = timeit.default_timer()
+df = ctx.create_dataframe([ans])
+chk = df.aggregate([], [f.sum(col("corr"))]).collect()[0].column(0)[0]
+chkt = timeit.default_timer() - t_start
+write_log(
+    task=task,
+    data=data_name,
+    in_rows=in_rows,
+    question=question,
+    out_rows=shape[0],
+    out_cols=shape[1],
+    solution=solution,
+    version=ver,
+    git=git,
+    fun=fun,
+    run=1,
+    time_sec=t,
+    mem_gb=m,
+    cache=cache,
+    chk=make_chk([chk]),
+    chk_time_sec=chkt,
+    on_disk=on_disk,
+)
+del ans
+gc.collect()
+
+question = "sum v3 count by id1:id6"  # q10
+gc.collect()
+t_start = timeit.default_timer()
+ans = ctx.sql(
+    "SELECT id1, id2, id3, id4, id5, id6, SUM(v3) as v3, COUNT(*) AS cnt FROM x GROUP BY id1, id2, id3, id4, id5, id6"
+).collect()
+shape = ans_shape(ans)
+print(shape, flush=True)
+t = timeit.default_timer() - t_start
+print(f"q10: {t}")
+m = memory_usage()
+t_start = timeit.default_timer()
+df = ctx.create_dataframe([ans])
+chk = (
+    df.aggregate([], [f.sum(col("v3")), f.sum(col("cnt"))])
+    .collect()[0]
+    .to_pandas()
+    .to_numpy()[0]
+)
+chkt = timeit.default_timer() - t_start
+write_log(
+    task=task,
+    data=data_name,
+    in_rows=in_rows,
+    question=question,
+    out_rows=shape[0],
+    out_cols=shape[1],
+    solution=solution,
+    version=ver,
+    git=git,
+    fun=fun,
+    run=1,
+    time_sec=t,
+    mem_gb=m,
+    cache=cache,
+    chk=make_chk([chk]),
+    chk_time_sec=chkt,
+    on_disk=on_disk,
+)
+del ans
+gc.collect()
+
+print(
+    "grouping finished, took %0.fs" % (timeit.default_timer() - task_init),
+    flush=True,
+)
+
+exit(0)
diff --git a/benchmarks/db-benchmark/join-datafusion.py b/benchmarks/db-benchmark/join-datafusion.py
new file mode 100755
index 000000000..3be296c81
--- /dev/null
+++ b/benchmarks/db-benchmark/join-datafusion.py
@@ -0,0 +1,299 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import gc
+import os
+import timeit
+from pathlib import Path
+
+import datafusion as df
+from datafusion import col
+from datafusion import functions as f
+from pyarrow import csv as pacsv
+
+print("# join-datafusion.py", flush=True)
+
+exec(Path.open("./_helpers/helpers.py").read())
+
+
+def ans_shape(batches) -> tuple[int, int]:
+    rows, cols = 0, 0
+    for batch in batches:
+        rows += batch.num_rows
+        if cols == 0:
+            cols = batch.num_columns
+        else:
+            assert cols == batch.num_columns
+    return rows, cols
+
+
+ver = df.__version__
+task = "join"
+git = ""
+solution = "datafusion"
+fun = ".join"
+cache = "TRUE"
+on_disk = "FALSE"
+
+data_name = os.environ["SRC_DATANAME"]
+src_jn_x = "data" / data_name / ".csv"
+y_data_name = join_to_tbls(data_name)
+src_jn_y = [
+    "data" / y_data_name[0] / ".csv",
+    "data" / y_data_name[1] / ".csv",
+    "data" / y_data_name[2] / ".csv",
+]
+if len(src_jn_y) != 3:
+    error_msg = "Something went wrong in preparing files used for join"
+    raise Exception(error_msg)
+
+print(
+    "loading datasets "
+    + data_name
+    + ", "
+    + y_data_name[0]
+    + ", "
+    + y_data_name[1]
+    + ", "
+    + y_data_name[2],
+    flush=True,
+)
+
+ctx = df.SessionContext()
+print(ctx)
+
+# TODO we should be applying projections to these table reads to create relations
+# of different sizes
+
+x_data = pacsv.read_csv(
+    src_jn_x, convert_options=pacsv.ConvertOptions(auto_dict_encode=True)
+)
+ctx.register_record_batches("x", [x_data.to_batches()])
+small_data = pacsv.read_csv(
+    src_jn_y[0], convert_options=pacsv.ConvertOptions(auto_dict_encode=True)
+)
+ctx.register_record_batches("small", [small_data.to_batches()])
+medium_data = pacsv.read_csv(
+    src_jn_y[1], convert_options=pacsv.ConvertOptions(auto_dict_encode=True)
+)
+ctx.register_record_batches("medium", [medium_data.to_batches()])
+large_data = pacsv.read_csv(
+    src_jn_y[2], convert_options=pacsv.ConvertOptions(auto_dict_encode=True)
+)
+ctx.register_record_batches("large", [large_data.to_batches()])
+
+print(x_data.num_rows, flush=True)
+print(small_data.num_rows, flush=True)
+print(medium_data.num_rows, flush=True)
+print(large_data.num_rows, flush=True)
+
+task_init = timeit.default_timer()
+print("joining...", flush=True)
+
+question = "small inner on int"  # q1
+gc.collect()
+t_start = timeit.default_timer()
+ans = ctx.sql(
+    "SELECT x.id1, x.id2, x.id3, x.id4 as xid4, small.id4 as smallid4, x.id5, x.id6, x.v1, small.v2 FROM x INNER JOIN small ON x.id1 = small.id1"
+).collect()
+# ans = ctx.sql("SELECT * FROM x INNER JOIN small ON x.id1 = small.id1").collect()
+# print(set([b.schema for b in ans]))
+shape = ans_shape(ans)
+# print(shape, flush=True)
+t = timeit.default_timer() - t_start
+print(f"q1: {t}")
+t_start = timeit.default_timer()
+df = ctx.create_dataframe([ans])
+chk = df.aggregate([], [f.sum(col("v1"))]).collect()[0].column(0)[0]
+chkt = timeit.default_timer() - t_start
+m = memory_usage()
+write_log(
+    task=task,
+    data=data_name,
+    in_rows=x_data.num_rows,
+    question=question,
+    out_rows=shape[0],
+    out_cols=shape[1],
+    solution=solution,
+    version=ver,
+    git=git,
+    fun=fun,
+    run=1,
+    time_sec=t,
+    mem_gb=m,
+    cache=cache,
+    chk=make_chk([chk]),
+    chk_time_sec=chkt,
+    on_disk=on_disk,
+)
+del ans
+gc.collect()
+
+question = "medium inner on int"  # q2
+gc.collect()
+t_start = timeit.default_timer()
+ans = ctx.sql(
+    "SELECT x.id1 as xid1, medium.id1 as mediumid1, x.id2, x.id3, x.id4 as xid4, medium.id4 as mediumid4, x.id5 as xid5, medium.id5 as mediumid5, x.id6, x.v1, medium.v2 FROM x INNER JOIN medium ON x.id2 = medium.id2"
+).collect()
+shape = ans_shape(ans)
+# print(shape, flush=True)
+t = timeit.default_timer() - t_start
+print(f"q2: {t}")
+t_start = timeit.default_timer()
+df = ctx.create_dataframe([ans])
+chk = df.aggregate([], [f.sum(col("v1")), f.sum(col("v2"))]).collect()[0].column(0)[0]
+chkt = timeit.default_timer() - t_start
+m = memory_usage()
+write_log(
+    task=task,
+    data=data_name,
+    in_rows=x_data.num_rows,
+    question=question,
+    out_rows=shape[0],
+    out_cols=shape[1],
+    solution=solution,
+    version=ver,
+    git=git,
+    fun=fun,
+    run=1,
+    time_sec=t,
+    mem_gb=m,
+    cache=cache,
+    chk=make_chk([chk]),
+    chk_time_sec=chkt,
+    on_disk=on_disk,
+)
+del ans
+gc.collect()
+
+question = "medium outer on int"  # q3
+gc.collect()
+t_start = timeit.default_timer()
+ans = ctx.sql(
+    "SELECT x.id1 as xid1, medium.id1 as mediumid1, x.id2, x.id3, x.id4 as xid4, medium.id4 as mediumid4, x.id5 as xid5, medium.id5 as mediumid5, x.id6, x.v1, medium.v2 FROM x LEFT JOIN medium ON x.id2 = medium.id2"
+).collect()
+shape = ans_shape(ans)
+# print(shape, flush=True)
+t = timeit.default_timer() - t_start
+print(f"q3: {t}")
+t_start = timeit.default_timer()
+df = ctx.create_dataframe([ans])
+chk = df.aggregate([], [f.sum(col("v1")), f.sum(col("v2"))]).collect()[0].column(0)[0]
+chkt = timeit.default_timer() - t_start
+m = memory_usage()
+write_log(
+    task=task,
+    data=data_name,
+    in_rows=x_data.num_rows,
+    question=question,
+    out_rows=shape[0],
+    out_cols=shape[1],
+    solution=solution,
+    version=ver,
+    git=git,
+    fun=fun,
+    run=1,
+    time_sec=t,
+    mem_gb=m,
+    cache=cache,
+    chk=make_chk([chk]),
+    chk_time_sec=chkt,
+    on_disk=on_disk,
+)
+del ans
+gc.collect()
+
+question = "medium inner on factor"  # q4
+gc.collect()
+t_start = timeit.default_timer()
+ans = ctx.sql(
+    "SELECT x.id1 as xid1, medium.id1 as mediumid1, x.id2, x.id3, x.id4 as xid4, medium.id4 as mediumid4, x.id5 as xid5, medium.id5 as mediumid5, x.id6, x.v1, medium.v2 FROM x LEFT JOIN medium ON x.id5 = medium.id5"
+).collect()
+shape = ans_shape(ans)
+# print(shape)
+t = timeit.default_timer() - t_start
+print(f"q4: {t}")
+t_start = timeit.default_timer()
+df = ctx.create_dataframe([ans])
+chk = df.aggregate([], [f.sum(col("v1")), f.sum(col("v2"))]).collect()[0].column(0)[0]
+chkt = timeit.default_timer() - t_start
+m = memory_usage()
+write_log(
+    task=task,
+    data=data_name,
+    in_rows=x_data.num_rows,
+    question=question,
+    out_rows=shape[0],
+    out_cols=shape[1],
+    solution=solution,
+    version=ver,
+    git=git,
+    fun=fun,
+    run=1,
+    time_sec=t,
+    mem_gb=m,
+    cache=cache,
+    chk=make_chk([chk]),
+    chk_time_sec=chkt,
+    on_disk=on_disk,
+)
+del ans
+gc.collect()
+
+question = "big inner on int"  # q5
+gc.collect()
+t_start = timeit.default_timer()
+ans = ctx.sql(
+    "SELECT x.id1 as xid1, large.id1 as largeid1, x.id2 as xid2, large.id2 as largeid2, x.id3, x.id4 as xid4, large.id4 as largeid4, x.id5 as xid5, large.id5 as largeid5, x.id6 as xid6, large.id6 as largeid6, x.v1, large.v2 FROM x LEFT JOIN large ON x.id3 = large.id3"
+).collect()
+shape = ans_shape(ans)
+# print(shape)
+t = timeit.default_timer() - t_start
+print(f"q5: {t}")
+t_start = timeit.default_timer()
+df = ctx.create_dataframe([ans])
+chk = df.aggregate([], [f.sum(col("v1")), f.sum(col("v2"))]).collect()[0].column(0)[0]
+chkt = timeit.default_timer() - t_start
+m = memory_usage()
+write_log(
+    task=task,
+    data=data_name,
+    in_rows=x_data.num_rows,
+    question=question,
+    out_rows=shape[0],
+    out_cols=shape[1],
+    solution=solution,
+    version=ver,
+    git=git,
+    fun=fun,
+    run=1,
+    time_sec=t,
+    mem_gb=m,
+    cache=cache,
+    chk=make_chk([chk]),
+    chk_time_sec=chkt,
+    on_disk=on_disk,
+)
+del ans
+gc.collect()
+
+print(
+    "joining finished, took %0.fs" % (timeit.default_timer() - task_init),
+    flush=True,
+)
+
+exit(0)
diff --git a/benchmarks/db-benchmark/run-bench.sh b/benchmarks/db-benchmark/run-bench.sh
new file mode 100755
index 000000000..36a6087d9
--- /dev/null
+++ b/benchmarks/db-benchmark/run-bench.sh
@@ -0,0 +1,27 @@
+#!/bin/bash
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+set -e
+
+#SRC_DATANAME=G1_1e7_1e2_0_0 python3 /db-benchmark/polars/groupby-polars.py
+SRC_DATANAME=G1_1e7_1e2_0_0 python3 /db-benchmark/datafusion-python/groupby-datafusion.py
+
+# joins need more work still
+#SRC_DATANAME=G1_1e7_1e2_0_0 python3 /db-benchmark/datafusion-python/join-datafusion.py
+#SRC_DATANAME=G1_1e7_1e2_0_0 python3 /db-benchmark/polars/join-polars.py
+
+cat time.csv
diff --git a/benchmarks/max_cpu_usage.py b/benchmarks/max_cpu_usage.py
new file mode 100644
index 000000000..ae73baad6
--- /dev/null
+++ b/benchmarks/max_cpu_usage.py
@@ -0,0 +1,107 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+"""Benchmark script showing how to maximize CPU usage.
+
+This script demonstrates one example of tuning DataFusion for improved parallelism
+and CPU utilization. It uses synthetic in-memory data and performs simple aggregation
+operations to showcase the impact of partitioning configuration.
+
+IMPORTANT: This is a simplified example designed to illustrate partitioning concepts.
+Actual performance in your applications may vary significantly based on many factors:
+
+- Type of table providers (Parquet files, CSV, databases, etc.)
+- I/O operations and storage characteristics (local disk, network, cloud storage)
+- Query complexity and operation types (joins, window functions, complex expressions)
+- Data distribution and size characteristics
+- Memory available and hardware specifications
+- Network latency for distributed data sources
+
+It is strongly recommended that you create similar benchmarks tailored to your specific:
+- Hardware configuration
+- Data sources and formats
+- Typical query patterns and workloads
+- Performance requirements
+
+This will give you more accurate insights into how DataFusion configuration options
+will affect your particular use case.
+"""
+
+from __future__ import annotations
+
+import argparse
+import multiprocessing
+import time
+
+import pyarrow as pa
+from datafusion import SessionConfig, SessionContext, col
+from datafusion import functions as f
+
+
+def main(num_rows: int, partitions: int) -> None:
+    """Run a simple aggregation after repartitioning.
+
+    This function demonstrates basic partitioning concepts using synthetic data.
+    Real-world performance will depend on your specific data sources, query types,
+    and system configuration.
+    """
+    # Create some example data (synthetic in-memory data for demonstration)
+    # Note: Real applications typically work with files, databases, or other
+    # data sources that have different I/O and distribution characteristics
+    array = pa.array(range(num_rows))
+    batch = pa.record_batch([array], names=["a"])
+
+    # Configure the session to use a higher target partition count and
+    # enable automatic repartitioning.
+    config = (
+        SessionConfig()
+        .with_target_partitions(partitions)
+        .with_repartition_joins(enabled=True)
+        .with_repartition_aggregations(enabled=True)
+        .with_repartition_windows(enabled=True)
+    )
+    ctx = SessionContext(config)
+
+    # Register the input data and repartition manually to ensure that all
+    # partitions are used.
+    df = ctx.create_dataframe([[batch]]).repartition(partitions)
+
+    start = time.time()
+    df = df.aggregate([], [f.sum(col("a"))])
+    df.collect()
+    end = time.time()
+
+    print(
+        f"Processed {num_rows} rows using {partitions} partitions in {end - start:.3f}s"
+    )
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--rows",
+        type=int,
+        default=1_000_000,
+        help="Number of rows in the generated dataset",
+    )
+    parser.add_argument(
+        "--partitions",
+        type=int,
+        default=multiprocessing.cpu_count(),
+        help="Target number of partitions to use",
+    )
+    args = parser.parse_args()
+    main(args.rows, args.partitions)
diff --git a/benchmarks/tpch/.gitignore b/benchmarks/tpch/.gitignore
new file mode 100644
index 000000000..4471c6d15
--- /dev/null
+++ b/benchmarks/tpch/.gitignore
@@ -0,0 +1,2 @@
+data
+results.csv
\ No newline at end of file
diff --git a/benchmarks/tpch/README.md b/benchmarks/tpch/README.md
new file mode 100644
index 000000000..a118a7449
--- /dev/null
+++ b/benchmarks/tpch/README.md
@@ -0,0 +1,78 @@
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+
+# DataFusion Python Benchmarks Derived from TPC-H
+
+## Create Release Build
+
+From repo root:
+
+```bash
+maturin develop --release
+```
+
+Note that release builds take a really long time, so you may want to temporarily comment out this section of the 
+root Cargo.toml when frequently building.
+
+```toml
+[profile.release]
+lto = true
+codegen-units = 1
+```
+
+## Generate Data
+
+```bash
+./tpch-gen.sh 1
+```
+
+## Run Benchmarks
+
+```bash
+python tpch.py ./data ./queries
+```
+
+A summary of the benchmark timings will be written to `results.csv`. For example:
+
+```csv
+setup,1.4
+q1,2978.6
+q2,679.7
+q3,2943.7
+q4,2894.9
+q5,3592.3
+q6,1691.4
+q7,3003.9
+q8,3818.7
+q9,4237.9
+q10,2344.7
+q11,526.1
+q12,2284.6
+q13,1009.2
+q14,1738.4
+q15,1942.1
+q16,499.8
+q17,5178.9
+q18,4127.7
+q19,2056.6
+q20,2162.5
+q21,8046.5
+q22,754.9
+total,58513.2
+```
\ No newline at end of file
diff --git a/benchmarks/tpch/create_tables.sql b/benchmarks/tpch/create_tables.sql
new file mode 100644
index 000000000..9f3aeea20
--- /dev/null
+++ b/benchmarks/tpch/create_tables.sql
@@ -0,0 +1,143 @@
+-- Schema derived from TPC-H schema under the terms of the TPC Fair Use Policy.
+-- TPC-H queries are Copyright 1993-2022 Transaction Processing Performance Council.
+
+CREATE EXTERNAL TABLE customer (
+    c_custkey INT NOT NULL,
+    c_name VARCHAR NOT NULL,
+    c_address VARCHAR NOT NULL,
+    c_nationkey INT NOT NULL,
+    c_phone VARCHAR NOT NULL,
+    c_acctbal DECIMAL(15, 2) NOT NULL,
+    c_mktsegment VARCHAR NOT NULL,
+    c_comment VARCHAR NOT NULL,
+    c_extra VARCHAR NOT NULL,
+)
+STORED AS CSV
+OPTIONS (
+    format.delimiter '|',
+    format.has_header true
+)
+LOCATION '$PATH/customer.csv';
+
+CREATE EXTERNAL TABLE lineitem (
+    l_orderkey INT NOT NULL,
+    l_partkey INT NOT NULL,
+    l_suppkey INT NOT NULL,
+    l_linenumber INT NOT NULL,
+    l_quantity DECIMAL(15, 2) NOT NULL,
+    l_extendedprice DECIMAL(15, 2) NOT NULL,
+    l_discount DECIMAL(15, 2) NOT NULL,
+    l_tax DECIMAL(15, 2) NOT NULL,
+    l_returnflag VARCHAR NOT NULL,
+    l_linestatus VARCHAR NOT NULL,
+    l_shipdate DATE NOT NULL,
+    l_commitdate DATE NOT NULL,
+    l_receiptdate DATE NOT NULL,
+    l_shipinstruct VARCHAR NOT NULL,
+    l_shipmode VARCHAR NOT NULL,
+    l_comment VARCHAR NOT NULL,
+    l_extra VARCHAR NOT NULL,
+)
+STORED AS CSV
+OPTIONS (
+    format.delimiter '|',
+    format.has_header true
+)
+LOCATION '$PATH/lineitem.csv';
+
+CREATE EXTERNAL TABLE nation (
+    n_nationkey INT NOT NULL,
+    n_name VARCHAR NOT NULL,
+    n_regionkey INT NOT NULL,
+    n_comment VARCHAR NOT NULL,
+    n_extra VARCHAR NOT NULL,
+)
+STORED AS CSV
+OPTIONS (
+    format.delimiter '|',
+    format.has_header true
+)
+LOCATION '$PATH/nation.csv';
+
+CREATE EXTERNAL TABLE orders (
+    o_orderkey INT NOT NULL,
+    o_custkey INT NOT NULL,
+    o_orderstatus VARCHAR NOT NULL,
+    o_totalprice DECIMAL(15, 2) NOT NULL,
+    o_orderdate DATE NOT NULL,
+    o_orderpriority VARCHAR NOT NULL,
+    o_clerk VARCHAR NOT NULL,
+    o_shippriority INT NULL,
+    o_comment VARCHAR NOT NULL,
+    o_extra VARCHAR NOT NULL,
+)
+STORED AS CSV
+OPTIONS (
+    format.delimiter '|',
+    format.has_header true
+)
+LOCATION '$PATH/orders.csv';
+
+CREATE EXTERNAL TABLE part (
+    p_partkey INT NOT NULL,
+    p_name VARCHAR NOT NULL,
+    p_mfgr VARCHAR NOT NULL,
+    p_brand VARCHAR NOT NULL,
+    p_type VARCHAR NOT NULL,
+    p_size INT NULL,
+    p_container VARCHAR NOT NULL,
+    p_retailprice DECIMAL(15, 2) NOT NULL,
+    p_comment VARCHAR NOT NULL,
+    p_extra VARCHAR NOT NULL,
+)
+STORED AS CSV
+OPTIONS (
+    format.delimiter '|',
+    format.has_header true
+)
+LOCATION '$PATH/part.csv';
+
+CREATE EXTERNAL TABLE partsupp (
+    ps_partkey INT NOT NULL,
+    ps_suppkey INT NOT NULL,
+    ps_availqty INT NOT NULL,
+    ps_supplycost DECIMAL(15, 2) NOT NULL,
+    ps_comment VARCHAR NOT NULL,
+    ps_extra VARCHAR NOT NULL,
+)
+STORED AS CSV
+OPTIONS (
+    format.delimiter '|',
+    format.has_header true
+)
+LOCATION '$PATH/partsupp.csv';
+
+CREATE EXTERNAL TABLE region (
+    r_regionkey INT NOT NULL,
+    r_name VARCHAR NOT NULL,
+    r_comment VARCHAR NOT NULL,
+    r_extra VARCHAR NOT NULL,
+)
+STORED AS CSV
+OPTIONS (
+    format.delimiter '|',
+    format.has_header true
+)
+LOCATION '$PATH/region.csv';
+
+CREATE EXTERNAL TABLE supplier (
+    s_suppkey INT NOT NULL,
+    s_name VARCHAR NOT NULL,
+    s_address VARCHAR NOT NULL,
+    s_nationkey INT NOT NULL,
+    s_phone VARCHAR NOT NULL,
+    s_acctbal DECIMAL(15, 2) NOT NULL,
+    s_comment VARCHAR NOT NULL,
+    s_extra VARCHAR NOT NULL,
+)
+STORED AS CSV
+OPTIONS (
+    format.delimiter '|',
+    format.has_header true
+)
+LOCATION '$PATH/supplier.csv';
\ No newline at end of file
diff --git a/benchmarks/tpch/queries/q1.sql b/benchmarks/tpch/queries/q1.sql
new file mode 100644
index 000000000..e7e8e32b8
--- /dev/null
+++ b/benchmarks/tpch/queries/q1.sql
@@ -0,0 +1,23 @@
+-- Benchmark Query 1 derived from TPC-H query 1 under the terms of the TPC Fair Use Policy.
+-- TPC-H queries are Copyright 1993-2022 Transaction Processing Performance Council.
+select
+	l_returnflag,
+	l_linestatus,
+	sum(l_quantity) as sum_qty,
+	sum(l_extendedprice) as sum_base_price,
+	sum(l_extendedprice * (1 - l_discount)) as sum_disc_price,
+	sum(l_extendedprice * (1 - l_discount) * (1 + l_tax)) as sum_charge,
+	avg(l_quantity) as avg_qty,
+	avg(l_extendedprice) as avg_price,
+	avg(l_discount) as avg_disc,
+	count(*) as count_order
+from
+	lineitem
+where
+	l_shipdate <= date '1998-12-01' - interval '68 days'
+group by
+	l_returnflag,
+	l_linestatus
+order by
+	l_returnflag,
+	l_linestatus;
diff --git a/benchmarks/tpch/queries/q10.sql b/benchmarks/tpch/queries/q10.sql
new file mode 100644
index 000000000..8391f6277
--- /dev/null
+++ b/benchmarks/tpch/queries/q10.sql
@@ -0,0 +1,33 @@
+-- Benchmark Query 10 derived from TPC-H query 10 under the terms of the TPC Fair Use Policy.
+-- TPC-H queries are Copyright 1993-2022 Transaction Processing Performance Council.
+select
+	c_custkey,
+	c_name,
+	sum(l_extendedprice * (1 - l_discount)) as revenue,
+	c_acctbal,
+	n_name,
+	c_address,
+	c_phone,
+	c_comment
+from
+	customer,
+	orders,
+	lineitem,
+	nation
+where
+	c_custkey = o_custkey
+	and l_orderkey = o_orderkey
+	and o_orderdate >= date '1993-07-01'
+	and o_orderdate < date '1993-07-01' + interval '3' month
+	and l_returnflag = 'R'
+	and c_nationkey = n_nationkey
+group by
+	c_custkey,
+	c_name,
+	c_acctbal,
+	c_phone,
+	n_name,
+	c_address,
+	c_comment
+order by
+	revenue desc limit 20;
diff --git a/benchmarks/tpch/queries/q11.sql b/benchmarks/tpch/queries/q11.sql
new file mode 100644
index 000000000..58776d369
--- /dev/null
+++ b/benchmarks/tpch/queries/q11.sql
@@ -0,0 +1,29 @@
+-- Benchmark Query 11 derived from TPC-H query 11 under the terms of the TPC Fair Use Policy.
+-- TPC-H queries are Copyright 1993-2022 Transaction Processing Performance Council.
+select
+	ps_partkey,
+	sum(ps_supplycost * ps_availqty) as value
+from
+	partsupp,
+	supplier,
+	nation
+where
+	ps_suppkey = s_suppkey
+	and s_nationkey = n_nationkey
+	and n_name = 'ALGERIA'
+group by
+	ps_partkey having
+		sum(ps_supplycost * ps_availqty) > (
+			select
+				sum(ps_supplycost * ps_availqty) * 0.0001000000
+			from
+				partsupp,
+				supplier,
+				nation
+			where
+				ps_suppkey = s_suppkey
+				and s_nationkey = n_nationkey
+				and n_name = 'ALGERIA'
+		)
+order by
+	value desc;
diff --git a/benchmarks/tpch/queries/q12.sql b/benchmarks/tpch/queries/q12.sql
new file mode 100644
index 000000000..0b973de98
--- /dev/null
+++ b/benchmarks/tpch/queries/q12.sql
@@ -0,0 +1,30 @@
+-- Benchmark Query 12 derived from TPC-H query 12 under the terms of the TPC Fair Use Policy.
+-- TPC-H queries are Copyright 1993-2022 Transaction Processing Performance Council.
+select
+	l_shipmode,
+	sum(case
+		when o_orderpriority = '1-URGENT'
+			or o_orderpriority = '2-HIGH'
+			then 1
+		else 0
+	end) as high_line_count,
+	sum(case
+		when o_orderpriority <> '1-URGENT'
+			and o_orderpriority <> '2-HIGH'
+			then 1
+		else 0
+	end) as low_line_count
+from
+	orders,
+	lineitem
+where
+	o_orderkey = l_orderkey
+	and l_shipmode in ('FOB', 'SHIP')
+	and l_commitdate < l_receiptdate
+	and l_shipdate < l_commitdate
+	and l_receiptdate >= date '1995-01-01'
+	and l_receiptdate < date '1995-01-01' + interval '1' year
+group by
+	l_shipmode
+order by
+	l_shipmode;
diff --git a/benchmarks/tpch/queries/q13.sql b/benchmarks/tpch/queries/q13.sql
new file mode 100644
index 000000000..145dd6f10
--- /dev/null
+++ b/benchmarks/tpch/queries/q13.sql
@@ -0,0 +1,22 @@
+-- Benchmark Query 13 derived from TPC-H query 13 under the terms of the TPC Fair Use Policy.
+-- TPC-H queries are Copyright 1993-2022 Transaction Processing Performance Council.
+select
+	c_count,
+	count(*) as custdist
+from
+	(
+		select
+			c_custkey,
+			count(o_orderkey)
+		from
+			customer left outer join orders on
+				c_custkey = o_custkey
+				and o_comment not like '%express%requests%'
+		group by
+			c_custkey
+	) as c_orders (c_custkey, c_count)
+group by
+	c_count
+order by
+	custdist desc,
+	c_count desc;
diff --git a/benchmarks/tpch/queries/q14.sql b/benchmarks/tpch/queries/q14.sql
new file mode 100644
index 000000000..1a91a04df
--- /dev/null
+++ b/benchmarks/tpch/queries/q14.sql
@@ -0,0 +1,15 @@
+-- Benchmark Query 14 derived from TPC-H query 14 under the terms of the TPC Fair Use Policy.
+-- TPC-H queries are Copyright 1993-2022 Transaction Processing Performance Council.
+select
+	100.00 * sum(case
+		when p_type like 'PROMO%'
+			then l_extendedprice * (1 - l_discount)
+		else 0
+	end) / sum(l_extendedprice * (1 - l_discount)) as promo_revenue
+from
+	lineitem,
+	part
+where
+	l_partkey = p_partkey
+	and l_shipdate >= date '1995-02-01'
+	and l_shipdate < date '1995-02-01' + interval '1' month;
diff --git a/benchmarks/tpch/queries/q15.sql b/benchmarks/tpch/queries/q15.sql
new file mode 100644
index 000000000..68cc32cb7
--- /dev/null
+++ b/benchmarks/tpch/queries/q15.sql
@@ -0,0 +1,33 @@
+-- Benchmark Query 15 derived from TPC-H query 15 under the terms of the TPC Fair Use Policy.
+-- TPC-H queries are Copyright 1993-2022 Transaction Processing Performance Council.
+create view revenue0 (supplier_no, total_revenue) as
+	select
+		l_suppkey,
+		sum(l_extendedprice * (1 - l_discount))
+	from
+		lineitem
+	where
+		l_shipdate >= date '1996-08-01'
+		and l_shipdate < date '1996-08-01' + interval '3' month
+	group by
+		l_suppkey;
+select
+	s_suppkey,
+	s_name,
+	s_address,
+	s_phone,
+	total_revenue
+from
+	supplier,
+	revenue0
+where
+	s_suppkey = supplier_no
+	and total_revenue = (
+		select
+			max(total_revenue)
+		from
+			revenue0
+	)
+order by
+	s_suppkey;
+drop view revenue0;
diff --git a/benchmarks/tpch/queries/q16.sql b/benchmarks/tpch/queries/q16.sql
new file mode 100644
index 000000000..098b4f3b3
--- /dev/null
+++ b/benchmarks/tpch/queries/q16.sql
@@ -0,0 +1,32 @@
+-- Benchmark Query 16 derived from TPC-H query 16 under the terms of the TPC Fair Use Policy.
+-- TPC-H queries are Copyright 1993-2022 Transaction Processing Performance Council.
+select
+	p_brand,
+	p_type,
+	p_size,
+	count(distinct ps_suppkey) as supplier_cnt
+from
+	partsupp,
+	part
+where
+	p_partkey = ps_partkey
+	and p_brand <> 'Brand#14'
+	and p_type not like 'SMALL PLATED%'
+	and p_size in (14, 6, 5, 31, 49, 15, 41, 47)
+	and ps_suppkey not in (
+		select
+			s_suppkey
+		from
+			supplier
+		where
+			s_comment like '%Customer%Complaints%'
+	)
+group by
+	p_brand,
+	p_type,
+	p_size
+order by
+	supplier_cnt desc,
+	p_brand,
+	p_type,
+	p_size;
diff --git a/benchmarks/tpch/queries/q17.sql b/benchmarks/tpch/queries/q17.sql
new file mode 100644
index 000000000..ed02d7b77
--- /dev/null
+++ b/benchmarks/tpch/queries/q17.sql
@@ -0,0 +1,19 @@
+-- Benchmark Query 17 derived from TPC-H query 17 under the terms of the TPC Fair Use Policy.
+-- TPC-H queries are Copyright 1993-2022 Transaction Processing Performance Council.
+select
+	sum(l_extendedprice) / 7.0 as avg_yearly
+from
+	lineitem,
+	part
+where
+	p_partkey = l_partkey
+	and p_brand = 'Brand#42'
+	and p_container = 'LG BAG'
+	and l_quantity < (
+		select
+			0.2 * avg(l_quantity)
+		from
+			lineitem
+		where
+			l_partkey = p_partkey
+	);
diff --git a/benchmarks/tpch/queries/q18.sql b/benchmarks/tpch/queries/q18.sql
new file mode 100644
index 000000000..cf1f8c89a
--- /dev/null
+++ b/benchmarks/tpch/queries/q18.sql
@@ -0,0 +1,34 @@
+-- Benchmark Query 18 derived from TPC-H query 18 under the terms of the TPC Fair Use Policy.
+-- TPC-H queries are Copyright 1993-2022 Transaction Processing Performance Council.
+select
+	c_name,
+	c_custkey,
+	o_orderkey,
+	o_orderdate,
+	o_totalprice,
+	sum(l_quantity)
+from
+	customer,
+	orders,
+	lineitem
+where
+	o_orderkey in (
+		select
+			l_orderkey
+		from
+			lineitem
+		group by
+			l_orderkey having
+				sum(l_quantity) > 313
+	)
+	and c_custkey = o_custkey
+	and o_orderkey = l_orderkey
+group by
+	c_name,
+	c_custkey,
+	o_orderkey,
+	o_orderdate,
+	o_totalprice
+order by
+	o_totalprice desc,
+	o_orderdate limit 100;
diff --git a/benchmarks/tpch/queries/q19.sql b/benchmarks/tpch/queries/q19.sql
new file mode 100644
index 000000000..3968f0d24
--- /dev/null
+++ b/benchmarks/tpch/queries/q19.sql
@@ -0,0 +1,37 @@
+-- Benchmark Query 19 derived from TPC-H query 19 under the terms of the TPC Fair Use Policy.
+-- TPC-H queries are Copyright 1993-2022 Transaction Processing Performance Council.
+select
+	sum(l_extendedprice* (1 - l_discount)) as revenue
+from
+	lineitem,
+	part
+where
+	(
+		p_partkey = l_partkey
+		and p_brand = 'Brand#21'
+		and p_container in ('SM CASE', 'SM BOX', 'SM PACK', 'SM PKG')
+		and l_quantity >= 8 and l_quantity <= 8 + 10
+		and p_size between 1 and 5
+		and l_shipmode in ('AIR', 'AIR REG')
+		and l_shipinstruct = 'DELIVER IN PERSON'
+	)
+	or
+	(
+		p_partkey = l_partkey
+		and p_brand = 'Brand#13'
+		and p_container in ('MED BAG', 'MED BOX', 'MED PKG', 'MED PACK')
+		and l_quantity >= 20 and l_quantity <= 20 + 10
+		and p_size between 1 and 10
+		and l_shipmode in ('AIR', 'AIR REG')
+		and l_shipinstruct = 'DELIVER IN PERSON'
+	)
+	or
+	(
+		p_partkey = l_partkey
+		and p_brand = 'Brand#52'
+		and p_container in ('LG CASE', 'LG BOX', 'LG PACK', 'LG PKG')
+		and l_quantity >= 30 and l_quantity <= 30 + 10
+		and p_size between 1 and 15
+		and l_shipmode in ('AIR', 'AIR REG')
+		and l_shipinstruct = 'DELIVER IN PERSON'
+	);
diff --git a/benchmarks/tpch/queries/q2.sql b/benchmarks/tpch/queries/q2.sql
new file mode 100644
index 000000000..46ec5d239
--- /dev/null
+++ b/benchmarks/tpch/queries/q2.sql
@@ -0,0 +1,45 @@
+-- Benchmark Query 2 derived from TPC-H query 2 under the terms of the TPC Fair Use Policy.
+-- TPC-H queries are Copyright 1993-2022 Transaction Processing Performance Council.
+select
+	s_acctbal,
+	s_name,
+	n_name,
+	p_partkey,
+	p_mfgr,
+	s_address,
+	s_phone,
+	s_comment
+from
+	part,
+	supplier,
+	partsupp,
+	nation,
+	region
+where
+	p_partkey = ps_partkey
+	and s_suppkey = ps_suppkey
+	and p_size = 48
+	and p_type like '%TIN'
+	and s_nationkey = n_nationkey
+	and n_regionkey = r_regionkey
+	and r_name = 'ASIA'
+	and ps_supplycost = (
+		select
+			min(ps_supplycost)
+		from
+			partsupp,
+			supplier,
+			nation,
+			region
+		where
+			p_partkey = ps_partkey
+			and s_suppkey = ps_suppkey
+			and s_nationkey = n_nationkey
+			and n_regionkey = r_regionkey
+			and r_name = 'ASIA'
+	)
+order by
+	s_acctbal desc,
+	n_name,
+	s_name,
+	p_partkey limit 100;
diff --git a/benchmarks/tpch/queries/q20.sql b/benchmarks/tpch/queries/q20.sql
new file mode 100644
index 000000000..5bb16563b
--- /dev/null
+++ b/benchmarks/tpch/queries/q20.sql
@@ -0,0 +1,39 @@
+-- Benchmark Query 20 derived from TPC-H query 20 under the terms of the TPC Fair Use Policy.
+-- TPC-H queries are Copyright 1993-2022 Transaction Processing Performance Council.
+select
+	s_name,
+	s_address
+from
+	supplier,
+	nation
+where
+	s_suppkey in (
+		select
+			ps_suppkey
+		from
+			partsupp
+		where
+			ps_partkey in (
+				select
+					p_partkey
+				from
+					part
+				where
+					p_name like 'blanched%'
+			)
+			and ps_availqty > (
+				select
+					0.5 * sum(l_quantity)
+				from
+					lineitem
+				where
+					l_partkey = ps_partkey
+					and l_suppkey = ps_suppkey
+					and l_shipdate >= date '1993-01-01'
+					and l_shipdate < date '1993-01-01' + interval '1' year
+			)
+	)
+	and s_nationkey = n_nationkey
+	and n_name = 'KENYA'
+order by
+	s_name;
diff --git a/benchmarks/tpch/queries/q21.sql b/benchmarks/tpch/queries/q21.sql
new file mode 100644
index 000000000..6f84b876e
--- /dev/null
+++ b/benchmarks/tpch/queries/q21.sql
@@ -0,0 +1,41 @@
+-- Benchmark Query 21 derived from TPC-H query 21 under the terms of the TPC Fair Use Policy.
+-- TPC-H queries are Copyright 1993-2022 Transaction Processing Performance Council.
+select
+	s_name,
+	count(*) as numwait
+from
+	supplier,
+	lineitem l1,
+	orders,
+	nation
+where
+	s_suppkey = l1.l_suppkey
+	and o_orderkey = l1.l_orderkey
+	and o_orderstatus = 'F'
+	and l1.l_receiptdate > l1.l_commitdate
+	and exists (
+		select
+			*
+		from
+			lineitem l2
+		where
+			l2.l_orderkey = l1.l_orderkey
+			and l2.l_suppkey <> l1.l_suppkey
+	)
+	and not exists (
+		select
+			*
+		from
+			lineitem l3
+		where
+			l3.l_orderkey = l1.l_orderkey
+			and l3.l_suppkey <> l1.l_suppkey
+			and l3.l_receiptdate > l3.l_commitdate
+	)
+	and s_nationkey = n_nationkey
+	and n_name = 'ARGENTINA'
+group by
+	s_name
+order by
+	numwait desc,
+	s_name limit 100;
diff --git a/benchmarks/tpch/queries/q22.sql b/benchmarks/tpch/queries/q22.sql
new file mode 100644
index 000000000..65ea49b04
--- /dev/null
+++ b/benchmarks/tpch/queries/q22.sql
@@ -0,0 +1,39 @@
+-- Benchmark Query 22 derived from TPC-H query 22 under the terms of the TPC Fair Use Policy.
+-- TPC-H queries are Copyright 1993-2022 Transaction Processing Performance Council.
+select
+	cntrycode,
+	count(*) as numcust,
+	sum(c_acctbal) as totacctbal
+from
+	(
+		select
+			substring(c_phone from 1 for 2) as cntrycode,
+			c_acctbal
+		from
+			customer
+		where
+			substring(c_phone from 1 for 2) in
+				('24', '34', '16', '30', '33', '14', '13')
+			and c_acctbal > (
+				select
+					avg(c_acctbal)
+				from
+					customer
+				where
+					c_acctbal > 0.00
+					and substring(c_phone from 1 for 2) in
+						('24', '34', '16', '30', '33', '14', '13')
+			)
+			and not exists (
+				select
+					*
+				from
+					orders
+				where
+					o_custkey = c_custkey
+			)
+	) as custsale
+group by
+	cntrycode
+order by
+	cntrycode;
diff --git a/benchmarks/tpch/queries/q3.sql b/benchmarks/tpch/queries/q3.sql
new file mode 100644
index 000000000..161f2e1e4
--- /dev/null
+++ b/benchmarks/tpch/queries/q3.sql
@@ -0,0 +1,24 @@
+-- Benchmark Query 3 derived from TPC-H query 3 under the terms of the TPC Fair Use Policy.
+-- TPC-H queries are Copyright 1993-2022 Transaction Processing Performance Council.
+select
+	l_orderkey,
+	sum(l_extendedprice * (1 - l_discount)) as revenue,
+	o_orderdate,
+	o_shippriority
+from
+	customer,
+	orders,
+	lineitem
+where
+	c_mktsegment = 'BUILDING'
+	and c_custkey = o_custkey
+	and l_orderkey = o_orderkey
+	and o_orderdate < date '1995-03-15'
+	and l_shipdate > date '1995-03-15'
+group by
+	l_orderkey,
+	o_orderdate,
+	o_shippriority
+order by
+	revenue desc,
+	o_orderdate limit 10;
diff --git a/benchmarks/tpch/queries/q4.sql b/benchmarks/tpch/queries/q4.sql
new file mode 100644
index 000000000..e444dbfce
--- /dev/null
+++ b/benchmarks/tpch/queries/q4.sql
@@ -0,0 +1,23 @@
+-- Benchmark Query 4 derived from TPC-H query 4 under the terms of the TPC Fair Use Policy.
+-- TPC-H queries are Copyright 1993-2022 Transaction Processing Performance Council.
+select
+	o_orderpriority,
+	count(*) as order_count
+from
+	orders
+where
+	o_orderdate >= date '1995-04-01'
+	and o_orderdate < date '1995-04-01' + interval '3' month
+	and exists (
+		select
+			*
+		from
+			lineitem
+		where
+			l_orderkey = o_orderkey
+			and l_commitdate < l_receiptdate
+	)
+group by
+	o_orderpriority
+order by
+	o_orderpriority;
diff --git a/benchmarks/tpch/queries/q5.sql b/benchmarks/tpch/queries/q5.sql
new file mode 100644
index 000000000..4426bd245
--- /dev/null
+++ b/benchmarks/tpch/queries/q5.sql
@@ -0,0 +1,26 @@
+-- Benchmark Query 5 derived from TPC-H query 5 under the terms of the TPC Fair Use Policy.
+-- TPC-H queries are Copyright 1993-2022 Transaction Processing Performance Council.
+select
+	n_name,
+	sum(l_extendedprice * (1 - l_discount)) as revenue
+from
+	customer,
+	orders,
+	lineitem,
+	supplier,
+	nation,
+	region
+where
+	c_custkey = o_custkey
+	and l_orderkey = o_orderkey
+	and l_suppkey = s_suppkey
+	and c_nationkey = s_nationkey
+	and s_nationkey = n_nationkey
+	and n_regionkey = r_regionkey
+	and r_name = 'AFRICA'
+	and o_orderdate >= date '1994-01-01'
+	and o_orderdate < date '1994-01-01' + interval '1' year
+group by
+	n_name
+order by
+	revenue desc;
diff --git a/benchmarks/tpch/queries/q6.sql b/benchmarks/tpch/queries/q6.sql
new file mode 100644
index 000000000..3d6e51cfe
--- /dev/null
+++ b/benchmarks/tpch/queries/q6.sql
@@ -0,0 +1,11 @@
+-- Benchmark Query 6 derived from TPC-H query 6 under the terms of the TPC Fair Use Policy.
+-- TPC-H queries are Copyright 1993-2022 Transaction Processing Performance Council.
+select
+	sum(l_extendedprice * l_discount) as revenue
+from
+	lineitem
+where
+	l_shipdate >= date '1994-01-01'
+	and l_shipdate < date '1994-01-01' + interval '1' year
+	and l_discount between 0.04 - 0.01 and 0.04 + 0.01
+	and l_quantity < 24;
diff --git a/benchmarks/tpch/queries/q7.sql b/benchmarks/tpch/queries/q7.sql
new file mode 100644
index 000000000..6e36ad616
--- /dev/null
+++ b/benchmarks/tpch/queries/q7.sql
@@ -0,0 +1,41 @@
+-- Benchmark Query 7 derived from TPC-H query 7 under the terms of the TPC Fair Use Policy.
+-- TPC-H queries are Copyright 1993-2022 Transaction Processing Performance Council.
+select
+	supp_nation,
+	cust_nation,
+	l_year,
+	sum(volume) as revenue
+from
+	(
+		select
+			n1.n_name as supp_nation,
+			n2.n_name as cust_nation,
+			extract(year from l_shipdate) as l_year,
+			l_extendedprice * (1 - l_discount) as volume
+		from
+			supplier,
+			lineitem,
+			orders,
+			customer,
+			nation n1,
+			nation n2
+		where
+			s_suppkey = l_suppkey
+			and o_orderkey = l_orderkey
+			and c_custkey = o_custkey
+			and s_nationkey = n1.n_nationkey
+			and c_nationkey = n2.n_nationkey
+			and (
+				(n1.n_name = 'GERMANY' and n2.n_name = 'IRAQ')
+				or (n1.n_name = 'IRAQ' and n2.n_name = 'GERMANY')
+			)
+			and l_shipdate between date '1995-01-01' and date '1996-12-31'
+	) as shipping
+group by
+	supp_nation,
+	cust_nation,
+	l_year
+order by
+	supp_nation,
+	cust_nation,
+	l_year;
diff --git a/benchmarks/tpch/queries/q8.sql b/benchmarks/tpch/queries/q8.sql
new file mode 100644
index 000000000..e28235ed4
--- /dev/null
+++ b/benchmarks/tpch/queries/q8.sql
@@ -0,0 +1,39 @@
+-- Benchmark Query 8 derived from TPC-H query 8 under the terms of the TPC Fair Use Policy.
+-- TPC-H queries are Copyright 1993-2022 Transaction Processing Performance Council.
+select
+	o_year,
+	sum(case
+		when nation = 'IRAQ' then volume
+		else 0
+	end) / sum(volume) as mkt_share
+from
+	(
+		select
+			extract(year from o_orderdate) as o_year,
+			l_extendedprice * (1 - l_discount) as volume,
+			n2.n_name as nation
+		from
+			part,
+			supplier,
+			lineitem,
+			orders,
+			customer,
+			nation n1,
+			nation n2,
+			region
+		where
+			p_partkey = l_partkey
+			and s_suppkey = l_suppkey
+			and l_orderkey = o_orderkey
+			and o_custkey = c_custkey
+			and c_nationkey = n1.n_nationkey
+			and n1.n_regionkey = r_regionkey
+			and r_name = 'MIDDLE EAST'
+			and s_nationkey = n2.n_nationkey
+			and o_orderdate between date '1995-01-01' and date '1996-12-31'
+			and p_type = 'LARGE PLATED STEEL'
+	) as all_nations
+group by
+	o_year
+order by
+	o_year;
diff --git a/benchmarks/tpch/queries/q9.sql b/benchmarks/tpch/queries/q9.sql
new file mode 100644
index 000000000..86ae02482
--- /dev/null
+++ b/benchmarks/tpch/queries/q9.sql
@@ -0,0 +1,34 @@
+-- Benchmark Query 9 derived from TPC-H query 9 under the terms of the TPC Fair Use Policy.
+-- TPC-H queries are Copyright 1993-2022 Transaction Processing Performance Council.
+select
+	nation,
+	o_year,
+	sum(amount) as sum_profit
+from
+	(
+		select
+			n_name as nation,
+			extract(year from o_orderdate) as o_year,
+			l_extendedprice * (1 - l_discount) - ps_supplycost * l_quantity as amount
+		from
+			part,
+			supplier,
+			lineitem,
+			partsupp,
+			orders,
+			nation
+		where
+			s_suppkey = l_suppkey
+			and ps_suppkey = l_suppkey
+			and ps_partkey = l_partkey
+			and p_partkey = l_partkey
+			and o_orderkey = l_orderkey
+			and s_nationkey = n_nationkey
+			and p_name like '%moccasin%'
+	) as profit
+group by
+	nation,
+	o_year
+order by
+	nation,
+	o_year desc;
diff --git a/benchmarks/tpch/tpch-gen.sh b/benchmarks/tpch/tpch-gen.sh
new file mode 100755
index 000000000..139c300a2
--- /dev/null
+++ b/benchmarks/tpch/tpch-gen.sh
@@ -0,0 +1,62 @@
+#!/bin/bash
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+mkdir -p data/answers 2>/dev/null
+
+set -e
+
+# If RUN_IN_CI is set, then do not produce verbose output or use an interactive terminal
+if [[ -z "${RUN_IN_CI}" ]]; then
+  TERMINAL_FLAG="-it"
+  VERBOSE_OUTPUT="-vf"
+else
+  TERMINAL_FLAG=""
+  VERBOSE_OUTPUT="-f"
+fi
+
+#pushd ..
+#. ./dev/build-set-env.sh
+#popd
+
+# Generate data into the ./data directory if it does not already exist
+FILE=./data/supplier.tbl
+if test -f "$FILE"; then
+    echo "$FILE exists."
+else
+  docker run -v `pwd`/data:/data $TERMINAL_FLAG --rm ghcr.io/scalytics/tpch-docker:main $VERBOSE_OUTPUT -s $1
+
+  # workaround for https://github.com/apache/arrow-datafusion/issues/6147
+  mv data/customer.tbl data/customer.csv
+  mv data/lineitem.tbl data/lineitem.csv
+  mv data/nation.tbl data/nation.csv
+  mv data/orders.tbl data/orders.csv
+  mv data/part.tbl data/part.csv
+  mv data/partsupp.tbl data/partsupp.csv
+  mv data/region.tbl data/region.csv
+  mv data/supplier.tbl data/supplier.csv
+
+  ls -l data
+fi
+
+# Copy expected answers (at SF=1) into the ./data/answers directory if it does not already exist
+FILE=./data/answers/q1.out
+if test -f "$FILE"; then
+    echo "$FILE exists."
+else
+  docker run -v `pwd`/data:/data $TERMINAL_FLAG --entrypoint /bin/bash --rm ghcr.io/scalytics/tpch-docker:main -c "cp /opt/tpch/2.18.0_rc2/dbgen/answers/* /data/answers/"
+fi
diff --git a/benchmarks/tpch/tpch.py b/benchmarks/tpch/tpch.py
new file mode 100644
index 000000000..ffee5554c
--- /dev/null
+++ b/benchmarks/tpch/tpch.py
@@ -0,0 +1,99 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import argparse
+import time
+from pathlib import Path
+
+from datafusion import SessionContext
+
+
+def bench(data_path, query_path) -> None:
+    with Path("results.csv").open("w") as results:
+        # register tables
+        start = time.time()
+        total_time_millis = 0
+
+        # create context
+        # runtime = (
+        #     RuntimeEnvBuilder()
+        #     .with_disk_manager_os()
+        #     .with_fair_spill_pool(10000000)
+        # )
+        # config = (
+        #     SessionConfig()
+        #     .with_create_default_catalog_and_schema(True)
+        #     .with_default_catalog_and_schema("datafusion", "tpch")
+        #     .with_information_schema(True)
+        # )
+        # ctx = SessionContext(config, runtime)
+
+        ctx = SessionContext()
+        print("Configuration:\n", ctx)
+
+        # register tables
+        with Path("create_tables.sql").open() as f:
+            sql = ""
+            for line in f.readlines():
+                if line.startswith("--"):
+                    continue
+                sql = sql + line
+                if sql.strip().endswith(";"):
+                    sql = sql.strip().replace("$PATH", data_path)
+                    ctx.sql(sql)
+                    sql = ""
+
+        end = time.time()
+        time_millis = (end - start) * 1000
+        total_time_millis += time_millis
+        print(f"setup,{round(time_millis, 1)}")
+        results.write(f"setup,{round(time_millis, 1)}\n")
+        results.flush()
+
+        # run queries
+        for query in range(1, 23):
+            with Path(f"{query_path}/q{query}.sql").open() as f:
+                text = f.read()
+                tmp = text.split(";")
+                queries = [s.strip() for s in tmp if len(s.strip()) > 0]
+
+                try:
+                    start = time.time()
+                    for sql in queries:
+                        print(sql)
+                        df = ctx.sql(sql)
+                        # result_set = df.collect()
+                        df.show()
+                    end = time.time()
+                    time_millis = (end - start) * 1000
+                    total_time_millis += time_millis
+                    print(f"q{query},{round(time_millis, 1)}")
+                    results.write(f"q{query},{round(time_millis, 1)}\n")
+                    results.flush()
+                except Exception as e:
+                    print("query", query, "failed", e)
+
+        print(f"total,{round(total_time_millis, 1)}")
+        results.write(f"total,{round(total_time_millis, 1)}\n")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("data_path")
+    parser.add_argument("query_path")
+    args = parser.parse_args()
+    bench(args.data_path, args.query_path)
diff --git a/build.rs b/build.rs
new file mode 100644
index 000000000..4878d8b0e
--- /dev/null
+++ b/build.rs
@@ -0,0 +1,20 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+fn main() {
+    pyo3_build_config::add_extension_module_link_args();
+}
diff --git a/datafusion/expr.py b/ci/scripts/python_lint.sh
old mode 100644
new mode 100755
similarity index 90%
rename from datafusion/expr.py
rename to ci/scripts/python_lint.sh
index e914b85d7..3f7310ba7
--- a/datafusion/expr.py
+++ b/ci/scripts/python_lint.sh
@@ -1,3 +1,5 @@
+#!/usr/bin/env bash
+#
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information
@@ -15,9 +17,6 @@
 # specific language governing permissions and limitations
 # under the License.
 
-
-from ._internal import expr
-
-
-def __getattr__(name):
-    return getattr(expr, name)
+set -ex
+ruff format datafusion
+ruff check datafusion
\ No newline at end of file
diff --git a/ci/scripts/rust_fmt.sh b/ci/scripts/rust_fmt.sh
index 9d8325877..05cb6b208 100755
--- a/ci/scripts/rust_fmt.sh
+++ b/ci/scripts/rust_fmt.sh
@@ -18,4 +18,4 @@
 # under the License.
 
 set -ex
-cargo fmt --all -- --check
+cargo +nightly fmt --all -- --check
diff --git a/conda/environments/datafusion-dev.yaml b/conda/environments/datafusion-dev.yaml
deleted file mode 100644
index d9405e4fe..000000000
--- a/conda/environments/datafusion-dev.yaml
+++ /dev/null
@@ -1,44 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-channels:
-- conda-forge
-dependencies:
-- black
-- flake8
-- isort
-- maturin
-- mypy
-- numpy
-- pyarrow
-- pytest
-- toml
-- importlib_metadata
-- python>=3.10
-# Packages useful for building distributions and releasing
-- mamba
-- conda-build
-- anaconda-client
-# Packages for documentation building
-- sphinx
-- pydata-sphinx-theme==0.8.0
-- myst-parser
-- jinja2
-# GPU packages
-- cudf
-- cudatoolkit=11.8
-name: datafusion-dev
diff --git a/conftest.py b/conftest.py
new file mode 100644
index 000000000..1c89f92bc
--- /dev/null
+++ b/conftest.py
@@ -0,0 +1,29 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""Pytest configuration for doctest namespace injection."""
+
+import datafusion as dfn
+import numpy as np
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def _doctest_namespace(doctest_namespace: dict) -> None:
+    """Add common imports to the doctest namespace."""
+    doctest_namespace["dfn"] = dfn
+    doctest_namespace["np"] = np
diff --git a/datafusion/__init__.py b/datafusion/__init__.py
deleted file mode 100644
index bb1beacd9..000000000
--- a/datafusion/__init__.py
+++ /dev/null
@@ -1,219 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-from abc import ABCMeta, abstractmethod
-from typing import List
-
-try:
-    import importlib.metadata as importlib_metadata
-except ImportError:
-    import importlib_metadata
-
-import pyarrow as pa
-
-from ._internal import (
-    AggregateUDF,
-    Config,
-    DataFrame,
-    SessionContext,
-    SessionConfig,
-    RuntimeConfig,
-    ScalarUDF,
-)
-
-from .common import (
-    DFField,
-    DFSchema,
-)
-
-from .expr import (
-    Alias,
-    Analyze,
-    Expr,
-    Filter,
-    Limit,
-    Like,
-    ILike,
-    Projection,
-    SimilarTo,
-    ScalarVariable,
-    Sort,
-    TableScan,
-    GetIndexedField,
-    Not,
-    IsNotNull,
-    IsTrue,
-    IsFalse,
-    IsUnknown,
-    IsNotTrue,
-    IsNotFalse,
-    IsNotUnknown,
-    Negative,
-    ScalarFunction,
-    BuiltinScalarFunction,
-    InList,
-    Exists,
-    Subquery,
-    InSubquery,
-    ScalarSubquery,
-    GroupingSet,
-    Placeholder,
-    Case,
-    Cast,
-    TryCast,
-    Between,
-    Explain,
-    CreateMemoryTable,
-    SubqueryAlias,
-    Extension,
-    CreateView,
-    Distinct,
-    DropTable,
-    Repartition,
-    Partitioning,
-)
-
-__version__ = importlib_metadata.version(__name__)
-
-__all__ = [
-    "Config",
-    "DataFrame",
-    "SessionContext",
-    "SessionConfig",
-    "RuntimeConfig",
-    "Expr",
-    "AggregateUDF",
-    "ScalarUDF",
-    "column",
-    "literal",
-    "TableScan",
-    "Projection",
-    "DFSchema",
-    "DFField",
-    "Analyze",
-    "Sort",
-    "Limit",
-    "Filter",
-    "Like",
-    "ILike",
-    "SimilarTo",
-    "ScalarVariable",
-    "Alias",
-    "GetIndexedField",
-    "Not",
-    "IsNotNull",
-    "IsTrue",
-    "IsFalse",
-    "IsUnknown",
-    "IsNotTrue",
-    "IsNotFalse",
-    "IsNotUnknown",
-    "Negative",
-    "ScalarFunction",
-    "BuiltinScalarFunction",
-    "InList",
-    "Exists",
-    "Subquery",
-    "InSubquery",
-    "ScalarSubquery",
-    "GroupingSet",
-    "Placeholder",
-    "Case",
-    "Cast",
-    "TryCast",
-    "Between",
-    "Explain",
-    "SubqueryAlias",
-    "Extension",
-    "CreateMemoryTable",
-    "CreateView",
-    "Distinct",
-    "DropTable",
-    "Repartition",
-    "Partitioning",
-]
-
-
-class Accumulator(metaclass=ABCMeta):
-    @abstractmethod
-    def state(self) -> List[pa.Scalar]:
-        pass
-
-    @abstractmethod
-    def update(self, values: pa.Array) -> None:
-        pass
-
-    @abstractmethod
-    def merge(self, states: pa.Array) -> None:
-        pass
-
-    @abstractmethod
-    def evaluate(self) -> pa.Scalar:
-        pass
-
-
-def column(value):
-    return Expr.column(value)
-
-
-col = column
-
-
-def literal(value):
-    if not isinstance(value, pa.Scalar):
-        value = pa.scalar(value)
-    return Expr.literal(value)
-
-
-lit = literal
-
-
-def udf(func, input_types, return_type, volatility, name=None):
-    """
-    Create a new User Defined Function
-    """
-    if not callable(func):
-        raise TypeError("`func` argument must be callable")
-    if name is None:
-        name = func.__qualname__.lower()
-    return ScalarUDF(
-        name=name,
-        func=func,
-        input_types=input_types,
-        return_type=return_type,
-        volatility=volatility,
-    )
-
-
-def udaf(accum, input_type, return_type, state_type, volatility, name=None):
-    """
-    Create a new User Defined Aggregate Function
-    """
-    if not issubclass(accum, Accumulator):
-        raise TypeError(
-            "`accum` must implement the abstract base class Accumulator"
-        )
-    if name is None:
-        name = accum.__qualname__.lower()
-    return AggregateUDF(
-        name=name,
-        accumulator=accum,
-        input_type=input_type,
-        return_type=return_type,
-        state_type=state_type,
-        volatility=volatility,
-    )
diff --git a/datafusion/cudf.py b/datafusion/cudf.py
deleted file mode 100644
index d5f02156f..000000000
--- a/datafusion/cudf.py
+++ /dev/null
@@ -1,61 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-import cudf
-import datafusion
-from datafusion.expr import Projection, TableScan, Column
-
-
-class SessionContext:
-    def __init__(self):
-        self.datafusion_ctx = datafusion.SessionContext()
-        self.parquet_tables = {}
-
-    def register_parquet(self, name, path):
-        self.parquet_tables[name] = path
-        self.datafusion_ctx.register_parquet(name, path)
-
-    def to_cudf_expr(self, expr):
-        # get Python wrapper for logical expression
-        expr = expr.to_variant()
-
-        if isinstance(expr, Column):
-            return expr.name()
-        else:
-            raise Exception("unsupported expression: {}".format(expr))
-
-    def to_cudf_df(self, plan):
-        # recurse down first to translate inputs into pandas data frames
-        inputs = [self.to_cudf_df(x) for x in plan.inputs()]
-
-        # get Python wrapper for logical operator node
-        node = plan.to_variant()
-
-        if isinstance(node, Projection):
-            args = [self.to_cudf_expr(expr) for expr in node.projections()]
-            return inputs[0][args]
-        elif isinstance(node, TableScan):
-            return cudf.read_parquet(self.parquet_tables[node.table_name()])
-        else:
-            raise Exception(
-                "unsupported logical operator: {}".format(type(node))
-            )
-
-    def sql(self, sql):
-        datafusion_df = self.datafusion_ctx.sql(sql)
-        plan = datafusion_df.logical_plan()
-        return self.to_cudf_df(plan)
diff --git a/datafusion/pandas.py b/datafusion/pandas.py
deleted file mode 100644
index f8e56512b..000000000
--- a/datafusion/pandas.py
+++ /dev/null
@@ -1,61 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-import pandas as pd
-import datafusion
-from datafusion.expr import Projection, TableScan, Column
-
-
-class SessionContext:
-    def __init__(self):
-        self.datafusion_ctx = datafusion.SessionContext()
-        self.parquet_tables = {}
-
-    def register_parquet(self, name, path):
-        self.parquet_tables[name] = path
-        self.datafusion_ctx.register_parquet(name, path)
-
-    def to_pandas_expr(self, expr):
-        # get Python wrapper for logical expression
-        expr = expr.to_variant()
-
-        if isinstance(expr, Column):
-            return expr.name()
-        else:
-            raise Exception("unsupported expression: {}".format(expr))
-
-    def to_pandas_df(self, plan):
-        # recurse down first to translate inputs into pandas data frames
-        inputs = [self.to_pandas_df(x) for x in plan.inputs()]
-
-        # get Python wrapper for logical operator node
-        node = plan.to_variant()
-
-        if isinstance(node, Projection):
-            args = [self.to_pandas_expr(expr) for expr in node.projections()]
-            return inputs[0][args]
-        elif isinstance(node, TableScan):
-            return pd.read_parquet(self.parquet_tables[node.table_name()])
-        else:
-            raise Exception(
-                "unsupported logical operator: {}".format(type(node))
-            )
-
-    def sql(self, sql):
-        datafusion_df = self.datafusion_ctx.sql(sql)
-        plan = datafusion_df.logical_plan()
-        return self.to_pandas_df(plan)
diff --git a/datafusion/polars.py b/datafusion/polars.py
deleted file mode 100644
index a1bafbef8..000000000
--- a/datafusion/polars.py
+++ /dev/null
@@ -1,84 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-import polars
-import datafusion
-from datafusion.expr import Projection, TableScan, Aggregate
-from datafusion.expr import Column, AggregateFunction
-
-
-class SessionContext:
-    def __init__(self):
-        self.datafusion_ctx = datafusion.SessionContext()
-        self.parquet_tables = {}
-
-    def register_parquet(self, name, path):
-        self.parquet_tables[name] = path
-        self.datafusion_ctx.register_parquet(name, path)
-
-    def to_polars_expr(self, expr):
-        # get Python wrapper for logical expression
-        expr = expr.to_variant()
-
-        if isinstance(expr, Column):
-            return polars.col(expr.name())
-        else:
-            raise Exception("unsupported expression: {}".format(expr))
-
-    def to_polars_df(self, plan):
-        # recurse down first to translate inputs into Polars data frames
-        inputs = [self.to_polars_df(x) for x in plan.inputs()]
-
-        # get Python wrapper for logical operator node
-        node = plan.to_variant()
-
-        if isinstance(node, Projection):
-            args = [self.to_polars_expr(expr) for expr in node.projections()]
-            return inputs[0].select(*args)
-        elif isinstance(node, Aggregate):
-            groupby_expr = [
-                self.to_polars_expr(expr) for expr in node.group_by_exprs()
-            ]
-            aggs = []
-            for expr in node.aggregate_exprs():
-                expr = expr.to_variant()
-                if isinstance(expr, AggregateFunction):
-                    if expr.aggregate_type() == "COUNT":
-                        aggs.append(polars.count().alias("{}".format(expr)))
-                    else:
-                        raise Exception(
-                            "Unsupported aggregate function {}".format(
-                                expr.aggregate_type()
-                            )
-                        )
-                else:
-                    raise Exception(
-                        "Unsupported aggregate function {}".format(expr)
-                    )
-            df = inputs[0].groupby(groupby_expr).agg(aggs)
-            return df
-        elif isinstance(node, TableScan):
-            return polars.read_parquet(self.parquet_tables[node.table_name()])
-        else:
-            raise Exception(
-                "unsupported logical operator: {}".format(type(node))
-            )
-
-    def sql(self, sql):
-        datafusion_df = self.datafusion_ctx.sql(sql)
-        plan = datafusion_df.logical_plan()
-        return self.to_polars_df(plan)
diff --git a/datafusion/substrait.py b/datafusion/substrait.py
deleted file mode 100644
index eff809a0c..000000000
--- a/datafusion/substrait.py
+++ /dev/null
@@ -1,23 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-
-from ._internal import substrait
-
-
-def __getattr__(name):
-    return getattr(substrait, name)
diff --git a/datafusion/tests/test_aggregation.py b/datafusion/tests/test_aggregation.py
deleted file mode 100644
index 2c8c064b1..000000000
--- a/datafusion/tests/test_aggregation.py
+++ /dev/null
@@ -1,127 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-import numpy as np
-import pyarrow as pa
-import pytest
-
-from datafusion import SessionContext, column, lit
-from datafusion import functions as f
-
-
-@pytest.fixture
-def df():
-    ctx = SessionContext()
-
-    # create a RecordBatch and a new DataFrame from it
-    batch = pa.RecordBatch.from_arrays(
-        [
-            pa.array([1, 2, 3]),
-            pa.array([4, 4, 6]),
-            pa.array([9, 8, 5]),
-        ],
-        names=["a", "b", "c"],
-    )
-    return ctx.create_dataframe([[batch]])
-
-
-def test_built_in_aggregation(df):
-    col_a = column("a")
-    col_b = column("b")
-    col_c = column("c")
-
-    agg_df = df.aggregate(
-        [],
-        [
-            f.approx_distinct(col_b),
-            f.approx_median(col_b),
-            f.approx_percentile_cont(col_b, lit(0.5)),
-            f.approx_percentile_cont_with_weight(col_b, lit(0.6), lit(0.5)),
-            f.array_agg(col_b),
-            f.avg(col_a),
-            f.corr(col_a, col_b),
-            f.count(col_a),
-            f.covar(col_a, col_b),
-            f.covar_pop(col_a, col_c),
-            f.covar_samp(col_b, col_c),
-            # f.grouping(col_a),  # No physical plan implemented yet
-            f.max(col_a),
-            f.mean(col_b),
-            f.median(col_b),
-            f.min(col_a),
-            f.sum(col_b),
-            f.stddev(col_a),
-            f.stddev_pop(col_b),
-            f.stddev_samp(col_c),
-            f.var(col_a),
-            f.var_pop(col_b),
-            f.var_samp(col_c),
-        ],
-    )
-    result = agg_df.collect()[0]
-    values_a, values_b, values_c = df.collect()[0]
-
-    assert result.column(0) == pa.array([2], type=pa.uint64())
-    assert result.column(1) == pa.array([4])
-    assert result.column(2) == pa.array([4])
-    assert result.column(3) == pa.array([6])
-    assert result.column(4) == pa.array([[4, 4, 6]])
-    np.testing.assert_array_almost_equal(
-        result.column(5), np.average(values_a)
-    )
-    np.testing.assert_array_almost_equal(
-        result.column(6), np.corrcoef(values_a, values_b)[0][1]
-    )
-    assert result.column(7) == pa.array([len(values_a)])
-    # Sample (co)variance -> ddof=1
-    # Population (co)variance -> ddof=0
-    np.testing.assert_array_almost_equal(
-        result.column(8), np.cov(values_a, values_b, ddof=1)[0][1]
-    )
-    np.testing.assert_array_almost_equal(
-        result.column(9), np.cov(values_a, values_c, ddof=0)[0][1]
-    )
-    np.testing.assert_array_almost_equal(
-        result.column(10), np.cov(values_b, values_c, ddof=1)[0][1]
-    )
-    np.testing.assert_array_almost_equal(result.column(11), np.max(values_a))
-    np.testing.assert_array_almost_equal(result.column(12), np.mean(values_b))
-    np.testing.assert_array_almost_equal(
-        result.column(13), np.median(values_b)
-    )
-    np.testing.assert_array_almost_equal(result.column(14), np.min(values_a))
-    np.testing.assert_array_almost_equal(
-        result.column(15), np.sum(values_b.to_pylist())
-    )
-    np.testing.assert_array_almost_equal(
-        result.column(16), np.std(values_a, ddof=1)
-    )
-    np.testing.assert_array_almost_equal(
-        result.column(17), np.std(values_b, ddof=0)
-    )
-    np.testing.assert_array_almost_equal(
-        result.column(18), np.std(values_c, ddof=1)
-    )
-    np.testing.assert_array_almost_equal(
-        result.column(19), np.var(values_a, ddof=1)
-    )
-    np.testing.assert_array_almost_equal(
-        result.column(20), np.var(values_b, ddof=0)
-    )
-    np.testing.assert_array_almost_equal(
-        result.column(21), np.var(values_c, ddof=1)
-    )
diff --git a/datafusion/tests/test_context.py b/datafusion/tests/test_context.py
deleted file mode 100644
index 1aea21c21..000000000
--- a/datafusion/tests/test_context.py
+++ /dev/null
@@ -1,351 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-import os
-
-import pyarrow as pa
-import pyarrow.dataset as ds
-
-from datafusion import (
-    column,
-    literal,
-    SessionContext,
-    SessionConfig,
-    RuntimeConfig,
-    DataFrame,
-)
-import pytest
-
-
-def test_create_context_no_args():
-    SessionContext()
-
-
-def test_create_context_with_all_valid_args():
-    runtime = (
-        RuntimeConfig().with_disk_manager_os().with_fair_spill_pool(10000000)
-    )
-    config = (
-        SessionConfig()
-        .with_create_default_catalog_and_schema(True)
-        .with_default_catalog_and_schema("foo", "bar")
-        .with_target_partitions(1)
-        .with_information_schema(True)
-        .with_repartition_joins(False)
-        .with_repartition_aggregations(False)
-        .with_repartition_windows(False)
-        .with_parquet_pruning(False)
-    )
-
-    ctx = SessionContext(config, runtime)
-
-    # verify that at least some of the arguments worked
-    ctx.catalog("foo").database("bar")
-    with pytest.raises(KeyError):
-        ctx.catalog("datafusion")
-
-
-def test_register_record_batches(ctx):
-    # create a RecordBatch and register it as memtable
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
-        names=["a", "b"],
-    )
-
-    ctx.register_record_batches("t", [[batch]])
-
-    assert ctx.tables() == {"t"}
-
-    result = ctx.sql("SELECT a+b, a-b FROM t").collect()
-
-    assert result[0].column(0) == pa.array([5, 7, 9])
-    assert result[0].column(1) == pa.array([-3, -3, -3])
-
-
-def test_create_dataframe_registers_unique_table_name(ctx):
-    # create a RecordBatch and register it as memtable
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
-        names=["a", "b"],
-    )
-
-    df = ctx.create_dataframe([[batch]])
-    tables = list(ctx.tables())
-
-    assert df
-    assert len(tables) == 1
-    assert len(tables[0]) == 33
-    assert tables[0].startswith("c")
-    # ensure that the rest of the table name contains
-    # only hexadecimal numbers
-    for c in tables[0][1:]:
-        assert c in "0123456789abcdef"
-
-
-def test_create_dataframe_registers_with_defined_table_name(ctx):
-    # create a RecordBatch and register it as memtable
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
-        names=["a", "b"],
-    )
-
-    df = ctx.create_dataframe([[batch]], name="tbl")
-    tables = list(ctx.tables())
-
-    assert df
-    assert len(tables) == 1
-    assert tables[0] == "tbl"
-
-
-def test_from_arrow_table(ctx):
-    # create a PyArrow table
-    data = {"a": [1, 2, 3], "b": [4, 5, 6]}
-    table = pa.Table.from_pydict(data)
-
-    # convert to DataFrame
-    df = ctx.from_arrow_table(table)
-    tables = list(ctx.tables())
-
-    assert df
-    assert len(tables) == 1
-    assert type(df) == DataFrame
-    assert set(df.schema().names) == {"a", "b"}
-    assert df.collect()[0].num_rows == 3
-
-
-def test_from_arrow_table_with_name(ctx):
-    # create a PyArrow table
-    data = {"a": [1, 2, 3], "b": [4, 5, 6]}
-    table = pa.Table.from_pydict(data)
-
-    # convert to DataFrame with optional name
-    df = ctx.from_arrow_table(table, name="tbl")
-    tables = list(ctx.tables())
-
-    assert df
-    assert tables[0] == "tbl"
-
-
-def test_from_pylist(ctx):
-    # create a dataframe from Python list
-    data = [
-        {"a": 1, "b": 4},
-        {"a": 2, "b": 5},
-        {"a": 3, "b": 6},
-    ]
-
-    df = ctx.from_pylist(data)
-    tables = list(ctx.tables())
-
-    assert df
-    assert len(tables) == 1
-    assert type(df) == DataFrame
-    assert set(df.schema().names) == {"a", "b"}
-    assert df.collect()[0].num_rows == 3
-
-
-def test_from_pydict(ctx):
-    # create a dataframe from Python dictionary
-    data = {"a": [1, 2, 3], "b": [4, 5, 6]}
-
-    df = ctx.from_pydict(data)
-    tables = list(ctx.tables())
-
-    assert df
-    assert len(tables) == 1
-    assert type(df) == DataFrame
-    assert set(df.schema().names) == {"a", "b"}
-    assert df.collect()[0].num_rows == 3
-
-
-def test_from_pandas(ctx):
-    # create a dataframe from pandas dataframe
-    pd = pytest.importorskip("pandas")
-    data = {"a": [1, 2, 3], "b": [4, 5, 6]}
-    pandas_df = pd.DataFrame(data)
-
-    df = ctx.from_pandas(pandas_df)
-    tables = list(ctx.tables())
-
-    assert df
-    assert len(tables) == 1
-    assert type(df) == DataFrame
-    assert set(df.schema().names) == {"a", "b"}
-    assert df.collect()[0].num_rows == 3
-
-
-def test_from_polars(ctx):
-    # create a dataframe from Polars dataframe
-    pd = pytest.importorskip("polars")
-    data = {"a": [1, 2, 3], "b": [4, 5, 6]}
-    polars_df = pd.DataFrame(data)
-
-    df = ctx.from_polars(polars_df)
-    tables = list(ctx.tables())
-
-    assert df
-    assert len(tables) == 1
-    assert type(df) == DataFrame
-    assert set(df.schema().names) == {"a", "b"}
-    assert df.collect()[0].num_rows == 3
-
-
-def test_register_table(ctx, database):
-    default = ctx.catalog()
-    public = default.database("public")
-    assert public.names() == {"csv", "csv1", "csv2"}
-    table = public.table("csv")
-
-    ctx.register_table("csv3", table)
-    assert public.names() == {"csv", "csv1", "csv2", "csv3"}
-
-
-def test_deregister_table(ctx, database):
-    default = ctx.catalog()
-    public = default.database("public")
-    assert public.names() == {"csv", "csv1", "csv2"}
-
-    ctx.deregister_table("csv")
-    assert public.names() == {"csv1", "csv2"}
-
-
-def test_register_dataset(ctx):
-    # create a RecordBatch and register it as a pyarrow.dataset.Dataset
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
-        names=["a", "b"],
-    )
-    dataset = ds.dataset([batch])
-    ctx.register_dataset("t", dataset)
-
-    assert ctx.tables() == {"t"}
-
-    result = ctx.sql("SELECT a+b, a-b FROM t").collect()
-
-    assert result[0].column(0) == pa.array([5, 7, 9])
-    assert result[0].column(1) == pa.array([-3, -3, -3])
-
-
-def test_dataset_filter(ctx, capfd):
-    # create a RecordBatch and register it as a pyarrow.dataset.Dataset
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
-        names=["a", "b"],
-    )
-    dataset = ds.dataset([batch])
-    ctx.register_dataset("t", dataset)
-
-    assert ctx.tables() == {"t"}
-    df = ctx.sql("SELECT a+b, a-b FROM t WHERE a BETWEEN 2 and 3 AND b > 5")
-
-    # Make sure the filter was pushed down in Physical Plan
-    df.explain()
-    captured = capfd.readouterr()
-    assert "filter_expr=(((a >= 2) and (a <= 3)) and (b > 5))" in captured.out
-
-    result = df.collect()
-
-    assert result[0].column(0) == pa.array([9])
-    assert result[0].column(1) == pa.array([-3])
-
-
-def test_dataset_filter_nested_data(ctx):
-    # create Arrow StructArrays to test nested data types
-    data = pa.StructArray.from_arrays(
-        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
-        names=["a", "b"],
-    )
-    batch = pa.RecordBatch.from_arrays(
-        [data],
-        names=["nested_data"],
-    )
-    dataset = ds.dataset([batch])
-    ctx.register_dataset("t", dataset)
-
-    assert ctx.tables() == {"t"}
-
-    df = ctx.table("t")
-
-    # This filter will not be pushed down to DatasetExec since it
-    # isn't supported
-    df = df.select(
-        column("nested_data")["a"] + column("nested_data")["b"],
-        column("nested_data")["a"] - column("nested_data")["b"],
-    ).filter(column("nested_data")["b"] > literal(5))
-
-    result = df.collect()
-
-    assert result[0].column(0) == pa.array([9])
-    assert result[0].column(1) == pa.array([-3])
-
-
-def test_table_exist(ctx):
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
-        names=["a", "b"],
-    )
-    dataset = ds.dataset([batch])
-    ctx.register_dataset("t", dataset)
-
-    assert ctx.table_exist("t") is True
-
-
-def test_read_json(ctx):
-    path = os.path.dirname(os.path.abspath(__file__))
-
-    # Default
-    test_data_path = os.path.join(path, "data_test_context", "data.json")
-    df = ctx.read_json(test_data_path)
-    result = df.collect()
-
-    assert result[0].column(0) == pa.array(["a", "b", "c"])
-    assert result[0].column(1) == pa.array([1, 2, 3])
-
-    # Schema
-    schema = pa.schema(
-        [
-            pa.field("A", pa.string(), nullable=True),
-        ]
-    )
-    df = ctx.read_json(test_data_path, schema=schema)
-    result = df.collect()
-
-    assert result[0].column(0) == pa.array(["a", "b", "c"])
-    assert result[0].schema == schema
-
-    # File extension
-    test_data_path = os.path.join(path, "data_test_context", "data.json")
-    df = ctx.read_json(test_data_path, file_extension=".json")
-    result = df.collect()
-
-    assert result[0].column(0) == pa.array(["a", "b", "c"])
-    assert result[0].column(1) == pa.array([1, 2, 3])
-
-
-def test_read_csv(ctx):
-    csv_df = ctx.read_csv(path="testing/data/csv/aggregate_test_100.csv")
-    csv_df.select(column("c1")).show()
-
-
-def test_read_parquet(ctx):
-    csv_df = ctx.read_parquet(path="parquet/data/alltypes_plain.parquet")
-    csv_df.show()
-
-
-def test_read_avro(ctx):
-    csv_df = ctx.read_avro(path="testing/data/avro/alltypes_plain.avro")
-    csv_df.show()
diff --git a/datafusion/tests/test_dataframe.py b/datafusion/tests/test_dataframe.py
deleted file mode 100644
index 611bcabe4..000000000
--- a/datafusion/tests/test_dataframe.py
+++ /dev/null
@@ -1,609 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-import pyarrow as pa
-import pytest
-
-from datafusion import functions as f
-from datafusion import DataFrame, SessionContext, column, literal, udf
-
-
-@pytest.fixture
-def ctx():
-    return SessionContext()
-
-
-@pytest.fixture
-def df():
-    ctx = SessionContext()
-
-    # create a RecordBatch and a new DataFrame from it
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([1, 2, 3]), pa.array([4, 5, 6]), pa.array([8, 5, 8])],
-        names=["a", "b", "c"],
-    )
-
-    return ctx.create_dataframe([[batch]])
-
-
-@pytest.fixture
-def struct_df():
-    ctx = SessionContext()
-
-    # create a RecordBatch and a new DataFrame from it
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([{"c": 1}, {"c": 2}, {"c": 3}]), pa.array([4, 5, 6])],
-        names=["a", "b"],
-    )
-
-    return ctx.create_dataframe([[batch]])
-
-
-@pytest.fixture
-def aggregate_df():
-    ctx = SessionContext()
-    ctx.register_csv("test", "testing/data/csv/aggregate_test_100.csv")
-    return ctx.sql("select c1, sum(c2) from test group by c1")
-
-
-def test_select(df):
-    df = df.select(
-        column("a") + column("b"),
-        column("a") - column("b"),
-    )
-
-    # execute and collect the first (and only) batch
-    result = df.collect()[0]
-
-    assert result.column(0) == pa.array([5, 7, 9])
-    assert result.column(1) == pa.array([-3, -3, -3])
-
-
-def test_select_columns(df):
-    df = df.select_columns("b", "a")
-
-    # execute and collect the first (and only) batch
-    result = df.collect()[0]
-
-    assert result.column(0) == pa.array([4, 5, 6])
-    assert result.column(1) == pa.array([1, 2, 3])
-
-
-def test_filter(df):
-    df = df.select(
-        column("a") + column("b"),
-        column("a") - column("b"),
-    ).filter(column("a") > literal(2))
-
-    # execute and collect the first (and only) batch
-    result = df.collect()[0]
-
-    assert result.column(0) == pa.array([9])
-    assert result.column(1) == pa.array([-3])
-
-
-def test_sort(df):
-    df = df.sort(column("b").sort(ascending=False))
-
-    table = pa.Table.from_batches(df.collect())
-    expected = {"a": [3, 2, 1], "b": [6, 5, 4], "c": [8, 5, 8]}
-
-    assert table.to_pydict() == expected
-
-
-def test_limit(df):
-    df = df.limit(1)
-
-    # execute and collect the first (and only) batch
-    result = df.collect()[0]
-
-    assert len(result.column(0)) == 1
-    assert len(result.column(1)) == 1
-
-
-def test_with_column(df):
-    df = df.with_column("c", column("a") + column("b"))
-
-    # execute and collect the first (and only) batch
-    result = df.collect()[0]
-
-    assert result.schema.field(0).name == "a"
-    assert result.schema.field(1).name == "b"
-    assert result.schema.field(2).name == "c"
-
-    assert result.column(0) == pa.array([1, 2, 3])
-    assert result.column(1) == pa.array([4, 5, 6])
-    assert result.column(2) == pa.array([5, 7, 9])
-
-
-def test_with_column_renamed(df):
-    df = df.with_column("c", column("a") + column("b")).with_column_renamed(
-        "c", "sum"
-    )
-
-    result = df.collect()[0]
-
-    assert result.schema.field(0).name == "a"
-    assert result.schema.field(1).name == "b"
-    assert result.schema.field(2).name == "sum"
-
-
-def test_udf(df):
-    # is_null is a pa function over arrays
-    is_null = udf(
-        lambda x: x.is_null(),
-        [pa.int64()],
-        pa.bool_(),
-        volatility="immutable",
-    )
-
-    df = df.select(is_null(column("a")))
-    result = df.collect()[0].column(0)
-
-    assert result == pa.array([False, False, False])
-
-
-def test_join():
-    ctx = SessionContext()
-
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
-        names=["a", "b"],
-    )
-    df = ctx.create_dataframe([[batch]])
-
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([1, 2]), pa.array([8, 10])],
-        names=["a", "c"],
-    )
-    df1 = ctx.create_dataframe([[batch]])
-
-    df = df.join(df1, join_keys=(["a"], ["a"]), how="inner")
-    df = df.sort(column("a").sort(ascending=True))
-    table = pa.Table.from_batches(df.collect())
-
-    expected = {"a": [1, 2], "c": [8, 10], "b": [4, 5]}
-    assert table.to_pydict() == expected
-
-
-def test_distinct():
-    ctx = SessionContext()
-
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([1, 2, 3, 1, 2, 3]), pa.array([4, 5, 6, 4, 5, 6])],
-        names=["a", "b"],
-    )
-    df_a = (
-        ctx.create_dataframe([[batch]])
-        .distinct()
-        .sort(column("a").sort(ascending=True))
-    )
-
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
-        names=["a", "b"],
-    )
-    df_b = ctx.create_dataframe([[batch]]).sort(
-        column("a").sort(ascending=True)
-    )
-
-    assert df_a.collect() == df_b.collect()
-
-
-def test_window_functions(df):
-    df = df.select(
-        column("a"),
-        column("b"),
-        column("c"),
-        f.alias(
-            f.window("row_number", [], order_by=[f.order_by(column("c"))]),
-            "row",
-        ),
-        f.alias(
-            f.window("rank", [], order_by=[f.order_by(column("c"))]),
-            "rank",
-        ),
-        f.alias(
-            f.window("dense_rank", [], order_by=[f.order_by(column("c"))]),
-            "dense_rank",
-        ),
-        f.alias(
-            f.window("percent_rank", [], order_by=[f.order_by(column("c"))]),
-            "percent_rank",
-        ),
-        f.alias(
-            f.window("cume_dist", [], order_by=[f.order_by(column("b"))]),
-            "cume_dist",
-        ),
-        f.alias(
-            f.window(
-                "ntile", [literal(2)], order_by=[f.order_by(column("c"))]
-            ),
-            "ntile",
-        ),
-        f.alias(
-            f.window("lag", [column("b")], order_by=[f.order_by(column("b"))]),
-            "previous",
-        ),
-        f.alias(
-            f.window(
-                "lead", [column("b")], order_by=[f.order_by(column("b"))]
-            ),
-            "next",
-        ),
-        f.alias(
-            f.window(
-                "first_value",
-                [column("a")],
-                order_by=[f.order_by(column("b"))],
-            ),
-            "first_value",
-        ),
-        f.alias(
-            f.window(
-                "last_value", [column("b")], order_by=[f.order_by(column("b"))]
-            ),
-            "last_value",
-        ),
-        f.alias(
-            f.window(
-                "nth_value",
-                [column("b"), literal(2)],
-                order_by=[f.order_by(column("b"))],
-            ),
-            "2nd_value",
-        ),
-    )
-
-    table = pa.Table.from_batches(df.collect())
-
-    expected = {
-        "a": [1, 2, 3],
-        "b": [4, 5, 6],
-        "c": [8, 5, 8],
-        "row": [2, 1, 3],
-        "rank": [2, 1, 2],
-        "dense_rank": [2, 1, 2],
-        "percent_rank": [0.5, 0, 0.5],
-        "cume_dist": [0.3333333333333333, 0.6666666666666666, 1.0],
-        "ntile": [1, 1, 2],
-        "next": [5, 6, None],
-        "previous": [None, 4, 5],
-        "first_value": [1, 1, 1],
-        "last_value": [4, 5, 6],
-        "2nd_value": [None, 5, 5],
-    }
-    assert table.sort_by("a").to_pydict() == expected
-
-
-def test_get_dataframe(tmp_path):
-    ctx = SessionContext()
-
-    path = tmp_path / "test.csv"
-    table = pa.Table.from_arrays(
-        [
-            [1, 2, 3, 4],
-            ["a", "b", "c", "d"],
-            [1.1, 2.2, 3.3, 4.4],
-        ],
-        names=["int", "str", "float"],
-    )
-    pa.csv.write_csv(table, path)
-
-    ctx.register_csv("csv", path)
-
-    df = ctx.table("csv")
-    assert isinstance(df, DataFrame)
-
-
-def test_struct_select(struct_df):
-    df = struct_df.select(
-        column("a")["c"] + column("b"),
-        column("a")["c"] - column("b"),
-    )
-
-    # execute and collect the first (and only) batch
-    result = df.collect()[0]
-
-    assert result.column(0) == pa.array([5, 7, 9])
-    assert result.column(1) == pa.array([-3, -3, -3])
-
-
-def test_explain(df):
-    df = df.select(
-        column("a") + column("b"),
-        column("a") - column("b"),
-    )
-    df.explain()
-
-
-def test_logical_plan(aggregate_df):
-    plan = aggregate_df.logical_plan()
-
-    expected = "Projection: test.c1, SUM(test.c2)"
-
-    assert expected == plan.display()
-
-    expected = (
-        "Projection: test.c1, SUM(test.c2)\n"
-        "  Aggregate: groupBy=[[test.c1]], aggr=[[SUM(test.c2)]]\n"
-        "    TableScan: test"
-    )
-
-    assert expected == plan.display_indent()
-
-
-def test_optimized_logical_plan(aggregate_df):
-    plan = aggregate_df.optimized_logical_plan()
-
-    expected = "Aggregate: groupBy=[[test.c1]], aggr=[[SUM(test.c2)]]"
-
-    assert expected == plan.display()
-
-    expected = (
-        "Aggregate: groupBy=[[test.c1]], aggr=[[SUM(test.c2)]]\n"
-        "  TableScan: test projection=[c1, c2]"
-    )
-
-    assert expected == plan.display_indent()
-
-
-def test_execution_plan(aggregate_df):
-    plan = aggregate_df.execution_plan()
-
-    expected = "AggregateExec: mode=FinalPartitioned, gby=[c1@0 as c1], aggr=[SUM(test.c2)]\n"  # noqa: E501
-
-    assert expected == plan.display()
-
-    expected = (
-        "ProjectionExec: expr=[c1@0 as c1, SUM(test.c2)@1 as SUM(test.c2)]\n"
-        "  Aggregate: groupBy=[[test.c1]], aggr=[[SUM(test.c2)]]\n"
-        "    TableScan: test projection=[c1, c2]"
-    )
-
-    indent = plan.display_indent()
-
-    # indent plan will be different for everyone due to absolute path
-    # to filename, so we just check for some expected content
-    assert "AggregateExec:" in indent
-    assert "CoalesceBatchesExec:" in indent
-    assert "RepartitionExec:" in indent
-    assert "CsvExec:" in indent
-
-    ctx = SessionContext()
-    stream = ctx.execute(plan, 0)
-    # get the one and only batch
-    batch = stream.next()
-    assert batch is not None
-    # there should be no more batches
-    batch = stream.next()
-    assert batch is None
-
-
-def test_repartition(df):
-    df.repartition(2)
-
-
-def test_repartition_by_hash(df):
-    df.repartition_by_hash(column("a"), num=2)
-
-
-def test_intersect():
-    ctx = SessionContext()
-
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
-        names=["a", "b"],
-    )
-    df_a = ctx.create_dataframe([[batch]])
-
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([3, 4, 5]), pa.array([6, 7, 8])],
-        names=["a", "b"],
-    )
-    df_b = ctx.create_dataframe([[batch]])
-
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([3]), pa.array([6])],
-        names=["a", "b"],
-    )
-    df_c = ctx.create_dataframe([[batch]]).sort(
-        column("a").sort(ascending=True)
-    )
-
-    df_a_i_b = df_a.intersect(df_b).sort(column("a").sort(ascending=True))
-
-    assert df_c.collect() == df_a_i_b.collect()
-
-
-def test_except_all():
-    ctx = SessionContext()
-
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
-        names=["a", "b"],
-    )
-    df_a = ctx.create_dataframe([[batch]])
-
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([3, 4, 5]), pa.array([6, 7, 8])],
-        names=["a", "b"],
-    )
-    df_b = ctx.create_dataframe([[batch]])
-
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([1, 2]), pa.array([4, 5])],
-        names=["a", "b"],
-    )
-    df_c = ctx.create_dataframe([[batch]]).sort(
-        column("a").sort(ascending=True)
-    )
-
-    df_a_e_b = df_a.except_all(df_b).sort(column("a").sort(ascending=True))
-
-    assert df_c.collect() == df_a_e_b.collect()
-
-
-def test_collect_partitioned():
-    ctx = SessionContext()
-
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
-        names=["a", "b"],
-    )
-
-    assert [[batch]] == ctx.create_dataframe([[batch]]).collect_partitioned()
-
-
-def test_union(ctx):
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
-        names=["a", "b"],
-    )
-    df_a = ctx.create_dataframe([[batch]])
-
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([3, 4, 5]), pa.array([6, 7, 8])],
-        names=["a", "b"],
-    )
-    df_b = ctx.create_dataframe([[batch]])
-
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([1, 2, 3, 3, 4, 5]), pa.array([4, 5, 6, 6, 7, 8])],
-        names=["a", "b"],
-    )
-    df_c = ctx.create_dataframe([[batch]]).sort(
-        column("a").sort(ascending=True)
-    )
-
-    df_a_u_b = df_a.union(df_b).sort(column("a").sort(ascending=True))
-
-    assert df_c.collect() == df_a_u_b.collect()
-
-
-def test_union_distinct(ctx):
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
-        names=["a", "b"],
-    )
-    df_a = ctx.create_dataframe([[batch]])
-
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([3, 4, 5]), pa.array([6, 7, 8])],
-        names=["a", "b"],
-    )
-    df_b = ctx.create_dataframe([[batch]])
-
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([1, 2, 3, 4, 5]), pa.array([4, 5, 6, 7, 8])],
-        names=["a", "b"],
-    )
-    df_c = ctx.create_dataframe([[batch]]).sort(
-        column("a").sort(ascending=True)
-    )
-
-    df_a_u_b = df_a.union(df_b, True).sort(column("a").sort(ascending=True))
-
-    assert df_c.collect() == df_a_u_b.collect()
-    assert df_c.collect() == df_a_u_b.collect()
-
-
-def test_cache(df):
-    assert df.cache().collect() == df.collect()
-
-
-def test_count(df):
-    # Get number of rows
-    assert df.count() == 3
-
-
-def test_to_pandas(df):
-    # Skip test if pandas is not installed
-    pd = pytest.importorskip("pandas")
-
-    # Convert datafusion dataframe to pandas dataframe
-    pandas_df = df.to_pandas()
-    assert type(pandas_df) == pd.DataFrame
-    assert pandas_df.shape == (3, 3)
-    assert set(pandas_df.columns) == {"a", "b", "c"}
-
-
-def test_empty_to_pandas(df):
-    # Skip test if pandas is not installed
-    pd = pytest.importorskip("pandas")
-
-    # Convert empty datafusion dataframe to pandas dataframe
-    pandas_df = df.limit(0).to_pandas()
-    assert type(pandas_df) == pd.DataFrame
-    assert pandas_df.shape == (0, 3)
-    assert set(pandas_df.columns) == {"a", "b", "c"}
-
-
-def test_to_polars(df):
-    # Skip test if polars is not installed
-    pl = pytest.importorskip("polars")
-
-    # Convert datafusion dataframe to polars dataframe
-    polars_df = df.to_polars()
-    assert type(polars_df) == pl.DataFrame
-    assert polars_df.shape == (3, 3)
-    assert set(polars_df.columns) == {"a", "b", "c"}
-
-
-def test_empty_to_polars(df):
-    # Skip test if polars is not installed
-    pl = pytest.importorskip("polars")
-
-    # Convert empty datafusion dataframe to polars dataframe
-    polars_df = df.limit(0).to_polars()
-    assert type(polars_df) == pl.DataFrame
-    assert polars_df.shape == (0, 3)
-    assert set(polars_df.columns) == {"a", "b", "c"}
-
-
-def test_to_arrow_table(df):
-    # Convert datafusion dataframe to pyarrow Table
-    pyarrow_table = df.to_arrow_table()
-    assert type(pyarrow_table) == pa.Table
-    assert pyarrow_table.shape == (3, 3)
-    assert set(pyarrow_table.column_names) == {"a", "b", "c"}
-
-
-def test_empty_to_arrow_table(df):
-    # Convert empty datafusion dataframe to pyarrow Table
-    pyarrow_table = df.limit(0).to_arrow_table()
-    assert type(pyarrow_table) == pa.Table
-    assert pyarrow_table.shape == (0, 3)
-    assert set(pyarrow_table.column_names) == {"a", "b", "c"}
-
-
-def test_to_pylist(df):
-    # Convert datafusion dataframe to Python list
-    pylist = df.to_pylist()
-    assert type(pylist) == list
-    assert pylist == [
-        {"a": 1, "b": 4, "c": 8},
-        {"a": 2, "b": 5, "c": 5},
-        {"a": 3, "b": 6, "c": 8},
-    ]
-
-
-def test_to_pydict(df):
-    # Convert datafusion dataframe to Python dictionary
-    pydict = df.to_pydict()
-    assert type(pydict) == dict
-    assert pydict == {"a": [1, 2, 3], "b": [4, 5, 6], "c": [8, 5, 8]}
diff --git a/datafusion/tests/test_expr.py b/datafusion/tests/test_expr.py
deleted file mode 100644
index 0c4869f27..000000000
--- a/datafusion/tests/test_expr.py
+++ /dev/null
@@ -1,110 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-from datafusion import SessionContext
-from datafusion.expr import Column, Literal, BinaryExpr, AggregateFunction
-from datafusion.expr import (
-    Projection,
-    Filter,
-    Aggregate,
-    Limit,
-    Sort,
-    TableScan,
-)
-import pytest
-
-
-@pytest.fixture
-def test_ctx():
-    ctx = SessionContext()
-    ctx.register_csv("test", "testing/data/csv/aggregate_test_100.csv")
-    return ctx
-
-
-def test_projection(test_ctx):
-    df = test_ctx.sql("select c1, 123, c1 < 123 from test")
-    plan = df.logical_plan()
-
-    plan = plan.to_variant()
-    assert isinstance(plan, Projection)
-
-    expr = plan.projections()
-
-    col1 = expr[0].to_variant()
-    assert isinstance(col1, Column)
-    assert col1.name() == "c1"
-    assert col1.qualified_name() == "test.c1"
-
-    col2 = expr[1].to_variant()
-    assert isinstance(col2, Literal)
-    assert col2.data_type() == "Int64"
-    assert col2.value_i64() == 123
-
-    col3 = expr[2].to_variant()
-    assert isinstance(col3, BinaryExpr)
-    assert isinstance(col3.left().to_variant(), Column)
-    assert col3.op() == "<"
-    assert isinstance(col3.right().to_variant(), Literal)
-
-    plan = plan.input()[0].to_variant()
-    assert isinstance(plan, TableScan)
-
-
-def test_filter(test_ctx):
-    df = test_ctx.sql("select c1 from test WHERE c1 > 5")
-    plan = df.logical_plan()
-
-    plan = plan.to_variant()
-    assert isinstance(plan, Projection)
-
-    plan = plan.input()[0].to_variant()
-    assert isinstance(plan, Filter)
-
-
-def test_limit(test_ctx):
-    df = test_ctx.sql("select c1 from test LIMIT 10")
-    plan = df.logical_plan()
-
-    plan = plan.to_variant()
-    assert isinstance(plan, Limit)
-
-
-def test_aggregate_query(test_ctx):
-    df = test_ctx.sql("select c1, count(*) from test group by c1")
-    plan = df.logical_plan()
-
-    projection = plan.to_variant()
-    assert isinstance(projection, Projection)
-
-    aggregate = projection.input()[0].to_variant()
-    assert isinstance(aggregate, Aggregate)
-
-    col1 = aggregate.group_by_exprs()[0].to_variant()
-    assert isinstance(col1, Column)
-    assert col1.name() == "c1"
-    assert col1.qualified_name() == "test.c1"
-
-    col2 = aggregate.aggregate_exprs()[0].to_variant()
-    assert isinstance(col2, AggregateFunction)
-
-
-def test_sort(test_ctx):
-    df = test_ctx.sql("select c1 from test order by c1")
-    plan = df.logical_plan()
-
-    plan = plan.to_variant()
-    assert isinstance(plan, Sort)
diff --git a/datafusion/tests/test_functions.py b/datafusion/tests/test_functions.py
deleted file mode 100644
index bea580859..000000000
--- a/datafusion/tests/test_functions.py
+++ /dev/null
@@ -1,413 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-import numpy as np
-import pyarrow as pa
-import pytest
-from datetime import datetime
-
-from datafusion import SessionContext, column
-from datafusion import functions as f
-from datafusion import literal
-
-
-@pytest.fixture
-def df():
-    ctx = SessionContext()
-    # create a RecordBatch and a new DataFrame from it
-    batch = pa.RecordBatch.from_arrays(
-        [
-            pa.array(["Hello", "World", "!"]),
-            pa.array([4, 5, 6]),
-            pa.array(["hello ", " world ", " !"]),
-            pa.array(
-                [
-                    datetime(2022, 12, 31),
-                    datetime(2027, 6, 26),
-                    datetime(2020, 7, 2),
-                ]
-            ),
-        ],
-        names=["a", "b", "c", "d"],
-    )
-    return ctx.create_dataframe([[batch]])
-
-
-def test_literal(df):
-    df = df.select(
-        literal(1),
-        literal("1"),
-        literal("OK"),
-        literal(3.14),
-        literal(True),
-        literal(b"hello world"),
-    )
-    result = df.collect()
-    assert len(result) == 1
-    result = result[0]
-    assert result.column(0) == pa.array([1] * 3)
-    assert result.column(1) == pa.array(["1"] * 3)
-    assert result.column(2) == pa.array(["OK"] * 3)
-    assert result.column(3) == pa.array([3.14] * 3)
-    assert result.column(4) == pa.array([True] * 3)
-    assert result.column(5) == pa.array([b"hello world"] * 3)
-
-
-def test_lit_arith(df):
-    """
-    Test literals with arithmetic operations
-    """
-    df = df.select(
-        literal(1) + column("b"), f.concat(column("a"), literal("!"))
-    )
-    result = df.collect()
-    assert len(result) == 1
-    result = result[0]
-    assert result.column(0) == pa.array([5, 6, 7])
-    assert result.column(1) == pa.array(["Hello!", "World!", "!!"])
-
-
-def test_math_functions():
-    ctx = SessionContext()
-    # create a RecordBatch and a new DataFrame from it
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([0.1, -0.7, 0.55])], names=["value"]
-    )
-    df = ctx.create_dataframe([[batch]])
-
-    values = np.array([0.1, -0.7, 0.55])
-    col_v = column("value")
-    df = df.select(
-        f.abs(col_v),
-        f.sin(col_v),
-        f.cos(col_v),
-        f.tan(col_v),
-        f.asin(col_v),
-        f.acos(col_v),
-        f.exp(col_v),
-        f.ln(col_v + literal(pa.scalar(1))),
-        f.log2(col_v + literal(pa.scalar(1))),
-        f.log10(col_v + literal(pa.scalar(1))),
-        f.random(),
-        f.atan(col_v),
-        f.atan2(col_v, literal(pa.scalar(1.1))),
-        f.ceil(col_v),
-        f.floor(col_v),
-        f.power(col_v, literal(pa.scalar(3))),
-        f.pow(col_v, literal(pa.scalar(4))),
-        f.round(col_v),
-        f.sqrt(col_v),
-        f.signum(col_v),
-        f.trunc(col_v),
-    )
-    batches = df.collect()
-    assert len(batches) == 1
-    result = batches[0]
-
-    np.testing.assert_array_almost_equal(result.column(0), np.abs(values))
-    np.testing.assert_array_almost_equal(result.column(1), np.sin(values))
-    np.testing.assert_array_almost_equal(result.column(2), np.cos(values))
-    np.testing.assert_array_almost_equal(result.column(3), np.tan(values))
-    np.testing.assert_array_almost_equal(result.column(4), np.arcsin(values))
-    np.testing.assert_array_almost_equal(result.column(5), np.arccos(values))
-    np.testing.assert_array_almost_equal(result.column(6), np.exp(values))
-    np.testing.assert_array_almost_equal(
-        result.column(7), np.log(values + 1.0)
-    )
-    np.testing.assert_array_almost_equal(
-        result.column(8), np.log2(values + 1.0)
-    )
-    np.testing.assert_array_almost_equal(
-        result.column(9), np.log10(values + 1.0)
-    )
-    np.testing.assert_array_less(result.column(10), np.ones_like(values))
-    np.testing.assert_array_almost_equal(result.column(11), np.arctan(values))
-    np.testing.assert_array_almost_equal(
-        result.column(12), np.arctan2(values, 1.1)
-    )
-    np.testing.assert_array_almost_equal(result.column(13), np.ceil(values))
-    np.testing.assert_array_almost_equal(result.column(14), np.floor(values))
-    np.testing.assert_array_almost_equal(
-        result.column(15), np.power(values, 3)
-    )
-    np.testing.assert_array_almost_equal(
-        result.column(16), np.power(values, 4)
-    )
-    np.testing.assert_array_almost_equal(result.column(17), np.round(values))
-    np.testing.assert_array_almost_equal(result.column(18), np.sqrt(values))
-    np.testing.assert_array_almost_equal(result.column(19), np.sign(values))
-    np.testing.assert_array_almost_equal(result.column(20), np.trunc(values))
-
-
-def test_string_functions(df):
-    df = df.select(
-        f.ascii(column("a")),
-        f.bit_length(column("a")),
-        f.btrim(literal(" World ")),
-        f.character_length(column("a")),
-        f.chr(literal(68)),
-        f.concat_ws("-", column("a"), literal("test")),
-        f.concat(column("a"), literal("?")),
-        f.initcap(column("c")),
-        f.left(column("a"), literal(3)),
-        f.length(column("c")),
-        f.lower(column("a")),
-        f.lpad(column("a"), literal(7)),
-        f.ltrim(column("c")),
-        f.md5(column("a")),
-        f.octet_length(column("a")),
-        f.repeat(column("a"), literal(2)),
-        f.replace(column("a"), literal("l"), literal("?")),
-        f.reverse(column("a")),
-        f.right(column("a"), literal(4)),
-        f.rpad(column("a"), literal(8)),
-        f.rtrim(column("c")),
-        f.split_part(column("a"), literal("l"), literal(1)),
-        f.starts_with(column("a"), literal("Wor")),
-        f.strpos(column("a"), literal("o")),
-        f.substr(column("a"), literal(3)),
-        f.translate(column("a"), literal("or"), literal("ld")),
-        f.trim(column("c")),
-        f.upper(column("c")),
-    )
-    result = df.collect()
-    assert len(result) == 1
-    result = result[0]
-    assert result.column(0) == pa.array(
-        [72, 87, 33], type=pa.int32()
-    )  # H = 72; W = 87; ! = 33
-    assert result.column(1) == pa.array([40, 40, 8], type=pa.int32())
-    assert result.column(2) == pa.array(["World", "World", "World"])
-    assert result.column(3) == pa.array([5, 5, 1], type=pa.int32())
-    assert result.column(4) == pa.array(["D", "D", "D"])
-    assert result.column(5) == pa.array(["Hello-test", "World-test", "!-test"])
-    assert result.column(6) == pa.array(["Hello?", "World?", "!?"])
-    assert result.column(7) == pa.array(["Hello ", " World ", " !"])
-    assert result.column(8) == pa.array(["Hel", "Wor", "!"])
-    assert result.column(9) == pa.array([6, 7, 2], type=pa.int32())
-    assert result.column(10) == pa.array(["hello", "world", "!"])
-    assert result.column(11) == pa.array(["  Hello", "  World", "      !"])
-    assert result.column(12) == pa.array(["hello ", "world ", "!"])
-    assert result.column(13) == pa.array(
-        [
-            "8b1a9953c4611296a827abf8c47804d7",
-            "f5a7924e621e84c9280a9a27e1bcb7f6",
-            "9033e0e305f247c0c3c80d0c7848c8b3",
-        ]
-    )
-    assert result.column(14) == pa.array([5, 5, 1], type=pa.int32())
-    assert result.column(15) == pa.array(["HelloHello", "WorldWorld", "!!"])
-    assert result.column(16) == pa.array(["He??o", "Wor?d", "!"])
-    assert result.column(17) == pa.array(["olleH", "dlroW", "!"])
-    assert result.column(18) == pa.array(["ello", "orld", "!"])
-    assert result.column(19) == pa.array(["Hello   ", "World   ", "!       "])
-    assert result.column(20) == pa.array(["hello", " world", " !"])
-    assert result.column(21) == pa.array(["He", "Wor", "!"])
-    assert result.column(22) == pa.array([False, True, False])
-    assert result.column(23) == pa.array([5, 2, 0], type=pa.int32())
-    assert result.column(24) == pa.array(["llo", "rld", ""])
-    assert result.column(25) == pa.array(["Helll", "Wldld", "!"])
-    assert result.column(26) == pa.array(["hello", "world", "!"])
-    assert result.column(27) == pa.array(["HELLO ", " WORLD ", " !"])
-
-
-def test_hash_functions(df):
-    exprs = [
-        f.digest(column("a"), literal(m))
-        for m in (
-            "md5",
-            "sha224",
-            "sha256",
-            "sha384",
-            "sha512",
-            "blake2s",
-            "blake3",
-        )
-    ]
-    df = df.select(
-        *exprs,
-        f.sha224(column("a")),
-        f.sha256(column("a")),
-        f.sha384(column("a")),
-        f.sha512(column("a")),
-    )
-    result = df.collect()
-    assert len(result) == 1
-    result = result[0]
-    b = bytearray.fromhex
-    assert result.column(0) == pa.array(
-        [
-            b("8B1A9953C4611296A827ABF8C47804D7"),
-            b("F5A7924E621E84C9280A9A27E1BCB7F6"),
-            b("9033E0E305F247C0C3C80D0C7848C8B3"),
-        ]
-    )
-    assert result.column(1) == pa.array(
-        [
-            b("4149DA18AA8BFC2B1E382C6C26556D01A92C261B6436DAD5E3BE3FCC"),
-            b("12972632B6D3B6AA52BD6434552F08C1303D56B817119406466E9236"),
-            b("6641A7E8278BCD49E476E7ACAE158F4105B2952D22AEB2E0B9A231A0"),
-        ]
-    )
-    assert result.column(2) == pa.array(
-        [
-            b(
-                "185F8DB32271FE25F561A6FC938B2E26"
-                "4306EC304EDA518007D1764826381969"
-            ),
-            b(
-                "78AE647DC5544D227130A0682A51E30B"
-                "C7777FBB6D8A8F17007463A3ECD1D524"
-            ),
-            b(
-                "BB7208BC9B5D7C04F1236A82A0093A5E"
-                "33F40423D5BA8D4266F7092C3BA43B62"
-            ),
-        ]
-    )
-    assert result.column(3) == pa.array(
-        [
-            b(
-                "3519FE5AD2C596EFE3E276A6F351B8FC"
-                "0B03DB861782490D45F7598EBD0AB5FD"
-                "5520ED102F38C4A5EC834E98668035FC"
-            ),
-            b(
-                "ED7CED84875773603AF90402E42C65F3"
-                "B48A5E77F84ADC7A19E8F3E8D3101010"
-                "22F552AEC70E9E1087B225930C1D260A"
-            ),
-            b(
-                "1D0EC8C84EE9521E21F06774DE232367"
-                "B64DE628474CB5B2E372B699A1F55AE3"
-                "35CC37193EF823E33324DFD9A70738A6"
-            ),
-        ]
-    )
-    assert result.column(4) == pa.array(
-        [
-            b(
-                "3615F80C9D293ED7402687F94B22D58E"
-                "529B8CC7916F8FAC7FDDF7FBD5AF4CF7"
-                "77D3D795A7A00A16BF7E7F3FB9561EE9"
-                "BAAE480DA9FE7A18769E71886B03F315"
-            ),
-            b(
-                "8EA77393A42AB8FA92500FB077A9509C"
-                "C32BC95E72712EFA116EDAF2EDFAE34F"
-                "BB682EFDD6C5DD13C117E08BD4AAEF71"
-                "291D8AACE2F890273081D0677C16DF0F"
-            ),
-            b(
-                "3831A6A6155E509DEE59A7F451EB3532"
-                "4D8F8F2DF6E3708894740F98FDEE2388"
-                "9F4DE5ADB0C5010DFB555CDA77C8AB5D"
-                "C902094C52DE3278F35A75EBC25F093A"
-            ),
-        ]
-    )
-    assert result.column(5) == pa.array(
-        [
-            b(
-                "F73A5FBF881F89B814871F46E26AD3FA"
-                "37CB2921C5E8561618639015B3CCBB71"
-            ),
-            b(
-                "B792A0383FB9E7A189EC150686579532"
-                "854E44B71AC394831DAED169BA85CCC5"
-            ),
-            b(
-                "27988A0E51812297C77A433F63523334"
-                "6AEE29A829DCF4F46E0F58F402C6CFCB"
-            ),
-        ]
-    )
-    assert result.column(6) == pa.array(
-        [
-            b(
-                "FBC2B0516EE8744D293B980779178A35"
-                "08850FDCFE965985782C39601B65794F"
-            ),
-            b(
-                "BF73D18575A736E4037D45F9E316085B"
-                "86C19BE6363DE6AA789E13DEAACC1C4E"
-            ),
-            b(
-                "C8D11B9F7237E4034ADBCD2005735F9B"
-                "C4C597C75AD89F4492BEC8F77D15F7EB"
-            ),
-        ]
-    )
-    assert result.column(7) == result.column(1)  # SHA-224
-    assert result.column(8) == result.column(2)  # SHA-256
-    assert result.column(9) == result.column(3)  # SHA-384
-    assert result.column(10) == result.column(4)  # SHA-512
-
-
-def test_temporal_functions(df):
-    df = df.select(
-        f.date_part(literal("month"), column("d")),
-        f.datepart(literal("year"), column("d")),
-        f.date_trunc(literal("month"), column("d")),
-        f.datetrunc(literal("day"), column("d")),
-        f.date_bin(
-            literal("15 minutes"),
-            column("d"),
-            literal("2001-01-01 00:02:30"),
-        ),
-        f.from_unixtime(literal(1673383974)),
-        f.to_timestamp(literal("2023-09-07 05:06:14.523952")),
-        f.to_timestamp_seconds(literal("2023-09-07 05:06:14.523952")),
-        f.to_timestamp_millis(literal("2023-09-07 05:06:14.523952")),
-        f.to_timestamp_micros(literal("2023-09-07 05:06:14.523952")),
-    )
-    result = df.collect()
-    assert len(result) == 1
-    result = result[0]
-    assert result.column(0) == pa.array([12, 6, 7], type=pa.float64())
-    assert result.column(1) == pa.array([2022, 2027, 2020], type=pa.float64())
-    assert result.column(2) == pa.array(
-        [datetime(2022, 12, 1), datetime(2027, 6, 1), datetime(2020, 7, 1)],
-        type=pa.timestamp("ns"),
-    )
-    assert result.column(3) == pa.array(
-        [datetime(2022, 12, 31), datetime(2027, 6, 26), datetime(2020, 7, 2)],
-        type=pa.timestamp("ns"),
-    )
-    assert result.column(4) == pa.array(
-        [
-            datetime(2022, 12, 30, 23, 47, 30),
-            datetime(2027, 6, 25, 23, 47, 30),
-            datetime(2020, 7, 1, 23, 47, 30),
-        ],
-        type=pa.timestamp("ns"),
-    )
-    assert result.column(5) == pa.array(
-        [datetime(2023, 1, 10, 20, 52, 54)] * 3, type=pa.timestamp("s")
-    )
-    assert result.column(6) == pa.array(
-        [datetime(2023, 9, 7, 5, 6, 14, 523952)] * 3, type=pa.timestamp("ns")
-    )
-    assert result.column(7) == pa.array(
-        [datetime(2023, 9, 7, 5, 6, 14)] * 3, type=pa.timestamp("s")
-    )
-    assert result.column(8) == pa.array(
-        [datetime(2023, 9, 7, 5, 6, 14, 523000)] * 3, type=pa.timestamp("ms")
-    )
-    assert result.column(9) == pa.array(
-        [datetime(2023, 9, 7, 5, 6, 14, 523952)] * 3, type=pa.timestamp("us")
-    )
diff --git a/datafusion/tests/test_sql.py b/datafusion/tests/test_sql.py
deleted file mode 100644
index 638a222dc..000000000
--- a/datafusion/tests/test_sql.py
+++ /dev/null
@@ -1,295 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-import numpy as np
-import pyarrow as pa
-import pyarrow.dataset as ds
-import pytest
-
-from datafusion import udf
-
-from . import generic as helpers
-
-
-def test_no_table(ctx):
-    with pytest.raises(Exception, match="DataFusion error"):
-        ctx.sql("SELECT a FROM b").collect()
-
-
-def test_register_csv(ctx, tmp_path):
-    path = tmp_path / "test.csv"
-
-    table = pa.Table.from_arrays(
-        [
-            [1, 2, 3, 4],
-            ["a", "b", "c", "d"],
-            [1.1, 2.2, 3.3, 4.4],
-        ],
-        names=["int", "str", "float"],
-    )
-    pa.csv.write_csv(table, path)
-
-    ctx.register_csv("csv", path)
-    ctx.register_csv("csv1", str(path))
-    ctx.register_csv(
-        "csv2",
-        path,
-        has_header=True,
-        delimiter=",",
-        schema_infer_max_records=10,
-    )
-    alternative_schema = pa.schema(
-        [
-            ("some_int", pa.int16()),
-            ("some_bytes", pa.string()),
-            ("some_floats", pa.float32()),
-        ]
-    )
-    ctx.register_csv("csv3", path, schema=alternative_schema)
-
-    assert ctx.tables() == {"csv", "csv1", "csv2", "csv3"}
-
-    for table in ["csv", "csv1", "csv2"]:
-        result = ctx.sql(f"SELECT COUNT(int) AS cnt FROM {table}").collect()
-        result = pa.Table.from_batches(result)
-        assert result.to_pydict() == {"cnt": [4]}
-
-    result = ctx.sql("SELECT * FROM csv3").collect()
-    result = pa.Table.from_batches(result)
-    assert result.schema == alternative_schema
-
-    with pytest.raises(
-        ValueError, match="Delimiter must be a single character"
-    ):
-        ctx.register_csv("csv4", path, delimiter="wrong")
-
-
-def test_register_parquet(ctx, tmp_path):
-    path = helpers.write_parquet(tmp_path / "a.parquet", helpers.data())
-    ctx.register_parquet("t", path)
-    assert ctx.tables() == {"t"}
-
-    result = ctx.sql("SELECT COUNT(a) AS cnt FROM t").collect()
-    result = pa.Table.from_batches(result)
-    assert result.to_pydict() == {"cnt": [100]}
-
-
-def test_register_parquet_partitioned(ctx, tmp_path):
-    dir_root = tmp_path / "dataset_parquet_partitioned"
-    dir_root.mkdir(exist_ok=False)
-    (dir_root / "grp=a").mkdir(exist_ok=False)
-    (dir_root / "grp=b").mkdir(exist_ok=False)
-
-    table = pa.Table.from_arrays(
-        [
-            [1, 2, 3, 4],
-            ["a", "b", "c", "d"],
-            [1.1, 2.2, 3.3, 4.4],
-        ],
-        names=["int", "str", "float"],
-    )
-    pa.parquet.write_table(table.slice(0, 3), dir_root / "grp=a/file.parquet")
-    pa.parquet.write_table(table.slice(3, 4), dir_root / "grp=b/file.parquet")
-
-    ctx.register_parquet(
-        "datapp",
-        str(dir_root),
-        table_partition_cols=[("grp", "string")],
-        parquet_pruning=True,
-        file_extension=".parquet",
-    )
-    assert ctx.tables() == {"datapp"}
-
-    result = ctx.sql(
-        "SELECT grp, COUNT(*) AS cnt FROM datapp GROUP BY grp"
-    ).collect()
-    result = pa.Table.from_batches(result)
-
-    rd = result.to_pydict()
-    assert dict(zip(rd["grp"], rd["cnt"])) == {"a": 3, "b": 1}
-
-
-def test_register_dataset(ctx, tmp_path):
-    path = helpers.write_parquet(tmp_path / "a.parquet", helpers.data())
-    dataset = ds.dataset(path, format="parquet")
-
-    ctx.register_dataset("t", dataset)
-    assert ctx.tables() == {"t"}
-
-    result = ctx.sql("SELECT COUNT(a) AS cnt FROM t").collect()
-    result = pa.Table.from_batches(result)
-    assert result.to_pydict() == {"cnt": [100]}
-
-
-def test_execute(ctx, tmp_path):
-    data = [1, 1, 2, 2, 3, 11, 12]
-
-    # single column, "a"
-    path = helpers.write_parquet(tmp_path / "a.parquet", pa.array(data))
-    ctx.register_parquet("t", path)
-
-    assert ctx.tables() == {"t"}
-
-    # count
-    result = ctx.sql(
-        "SELECT COUNT(a) AS cnt FROM t WHERE a IS NOT NULL"
-    ).collect()
-
-    expected = pa.array([7], pa.int64())
-    expected = [pa.RecordBatch.from_arrays([expected], ["cnt"])]
-    assert result == expected
-
-    # where
-    expected = pa.array([2], pa.int64())
-    expected = [pa.RecordBatch.from_arrays([expected], ["cnt"])]
-    result = ctx.sql("SELECT COUNT(a) AS cnt FROM t WHERE a > 10").collect()
-    assert result == expected
-
-    # group by
-    results = ctx.sql(
-        "SELECT CAST(a as int) AS a, COUNT(a) AS cnt FROM t GROUP BY a"
-    ).collect()
-
-    # group by returns batches
-    result_keys = []
-    result_values = []
-    for result in results:
-        pydict = result.to_pydict()
-        result_keys.extend(pydict["a"])
-        result_values.extend(pydict["cnt"])
-
-    result_keys, result_values = (
-        list(t) for t in zip(*sorted(zip(result_keys, result_values)))
-    )
-
-    assert result_keys == [1, 2, 3, 11, 12]
-    assert result_values == [2, 2, 1, 1, 1]
-
-    # order by
-    result = ctx.sql(
-        "SELECT a, CAST(a AS int) AS a_int FROM t ORDER BY a DESC LIMIT 2"
-    ).collect()
-    expected_a = pa.array([50.0219, 50.0152], pa.float64())
-    expected_cast = pa.array([50, 50], pa.int32())
-    expected = [
-        pa.RecordBatch.from_arrays([expected_a, expected_cast], ["a", "a_int"])
-    ]
-    np.testing.assert_equal(expected[0].column(1), expected[0].column(1))
-
-
-def test_cast(ctx, tmp_path):
-    """
-    Verify that we can cast
-    """
-    path = helpers.write_parquet(tmp_path / "a.parquet", helpers.data())
-    ctx.register_parquet("t", path)
-
-    valid_types = [
-        "smallint",
-        "int",
-        "bigint",
-        "float(32)",
-        "float(64)",
-        "float",
-    ]
-
-    select = ", ".join(
-        [f"CAST(9 AS {t}) AS A{i}" for i, t in enumerate(valid_types)]
-    )
-
-    # can execute, which implies that we can cast
-    ctx.sql(f"SELECT {select} FROM t").collect()
-
-
-@pytest.mark.parametrize(
-    ("fn", "input_types", "output_type", "input_values", "expected_values"),
-    [
-        (
-            lambda x: x,
-            [pa.float64()],
-            pa.float64(),
-            [-1.2, None, 1.2],
-            [-1.2, None, 1.2],
-        ),
-        (
-            lambda x: x.is_null(),
-            [pa.float64()],
-            pa.bool_(),
-            [-1.2, None, 1.2],
-            [False, True, False],
-        ),
-    ],
-)
-def test_udf(
-    ctx, tmp_path, fn, input_types, output_type, input_values, expected_values
-):
-    # write to disk
-    path = helpers.write_parquet(
-        tmp_path / "a.parquet", pa.array(input_values)
-    )
-    ctx.register_parquet("t", path)
-
-    func = udf(
-        fn, input_types, output_type, name="func", volatility="immutable"
-    )
-    ctx.register_udf(func)
-
-    batches = ctx.sql("SELECT func(a) AS tt FROM t").collect()
-    result = batches[0].column(0)
-
-    assert result == pa.array(expected_values)
-
-
-_null_mask = np.array([False, True, False])
-
-
-@pytest.mark.parametrize(
-    "arr",
-    [
-        pa.array(["a", "b", "c"], pa.utf8(), _null_mask),
-        pa.array(["a", "b", "c"], pa.large_utf8(), _null_mask),
-        pa.array([b"1", b"2", b"3"], pa.binary(), _null_mask),
-        pa.array([b"1111", b"2222", b"3333"], pa.large_binary(), _null_mask),
-        pa.array([False, True, True], None, _null_mask),
-        pa.array([0, 1, 2], None),
-        helpers.data_binary_other(),
-        helpers.data_date32(),
-        helpers.data_with_nans(),
-        # C data interface missing
-        pytest.param(
-            pa.array([b"1111", b"2222", b"3333"], pa.binary(4), _null_mask),
-            marks=pytest.mark.xfail,
-        ),
-        pytest.param(helpers.data_datetime("s"), marks=pytest.mark.xfail),
-        pytest.param(helpers.data_datetime("ms"), marks=pytest.mark.xfail),
-        pytest.param(helpers.data_datetime("us"), marks=pytest.mark.xfail),
-        pytest.param(helpers.data_datetime("ns"), marks=pytest.mark.xfail),
-        # Not writtable to parquet
-        pytest.param(helpers.data_timedelta("s"), marks=pytest.mark.xfail),
-        pytest.param(helpers.data_timedelta("ms"), marks=pytest.mark.xfail),
-        pytest.param(helpers.data_timedelta("us"), marks=pytest.mark.xfail),
-        pytest.param(helpers.data_timedelta("ns"), marks=pytest.mark.xfail),
-    ],
-)
-def test_simple_select(ctx, tmp_path, arr):
-    path = helpers.write_parquet(tmp_path / "a.parquet", arr)
-    ctx.register_parquet("t", path)
-
-    batches = ctx.sql("SELECT a AS tt FROM t").collect()
-    result = batches[0].column(0)
-
-    np.testing.assert_equal(result, arr)
diff --git a/datafusion/tests/test_substrait.py b/datafusion/tests/test_substrait.py
deleted file mode 100644
index 9a08b760e..000000000
--- a/datafusion/tests/test_substrait.py
+++ /dev/null
@@ -1,55 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-import pyarrow as pa
-
-from datafusion import SessionContext
-from datafusion import substrait as ss
-import pytest
-
-
-@pytest.fixture
-def ctx():
-    return SessionContext()
-
-
-def test_substrait_serialization(ctx):
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
-        names=["a", "b"],
-    )
-
-    ctx.register_record_batches("t", [[batch]])
-
-    assert ctx.tables() == {"t"}
-
-    # For now just make sure the method calls blow up
-    substrait_plan = ss.substrait.serde.serialize_to_plan(
-        "SELECT * FROM t", ctx
-    )
-    substrait_bytes = ss.substrait.serde.serialize_bytes(
-        "SELECT * FROM t", ctx
-    )
-    substrait_plan = ss.substrait.serde.deserialize_bytes(substrait_bytes)
-    logical_plan = ss.substrait.consumer.from_substrait_plan(
-        ctx, substrait_plan
-    )
-
-    # demonstrate how to create a DataFrame from a deserialized logical plan
-    df = ctx.create_dataframe_from_logical_plan(logical_plan)
-
-    substrait_plan = ss.substrait.producer.to_substrait_plan(df.logical_plan())
diff --git a/datafusion/tests/test_udaf.py b/datafusion/tests/test_udaf.py
deleted file mode 100644
index c2b29d199..000000000
--- a/datafusion/tests/test_udaf.py
+++ /dev/null
@@ -1,136 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-from typing import List
-
-import pyarrow as pa
-import pyarrow.compute as pc
-import pytest
-
-from datafusion import Accumulator, SessionContext, column, udaf
-
-
-class Summarize(Accumulator):
-    """
-    Interface of a user-defined accumulation.
-    """
-
-    def __init__(self):
-        self._sum = pa.scalar(0.0)
-
-    def state(self) -> List[pa.Scalar]:
-        return [self._sum]
-
-    def update(self, values: pa.Array) -> None:
-        # Not nice since pyarrow scalars can't be summed yet.
-        # This breaks on `None`
-        self._sum = pa.scalar(self._sum.as_py() + pc.sum(values).as_py())
-
-    def merge(self, states: pa.Array) -> None:
-        # Not nice since pyarrow scalars can't be summed yet.
-        # This breaks on `None`
-        self._sum = pa.scalar(self._sum.as_py() + pc.sum(states).as_py())
-
-    def evaluate(self) -> pa.Scalar:
-        return self._sum
-
-
-class NotSubclassOfAccumulator:
-    pass
-
-
-class MissingMethods(Accumulator):
-    def __init__(self):
-        self._sum = pa.scalar(0)
-
-    def state(self) -> List[pa.Scalar]:
-        return [self._sum]
-
-
-@pytest.fixture
-def df():
-    ctx = SessionContext()
-
-    # create a RecordBatch and a new DataFrame from it
-    batch = pa.RecordBatch.from_arrays(
-        [pa.array([1, 2, 3]), pa.array([4, 4, 6])],
-        names=["a", "b"],
-    )
-    return ctx.create_dataframe([[batch]])
-
-
-@pytest.mark.skip(reason="df.collect() will hang, need more investigations")
-def test_errors(df):
-    with pytest.raises(TypeError):
-        udaf(
-            NotSubclassOfAccumulator,
-            pa.float64(),
-            pa.float64(),
-            [pa.float64()],
-            volatility="immutable",
-        )
-
-    accum = udaf(
-        MissingMethods,
-        pa.int64(),
-        pa.int64(),
-        [pa.int64()],
-        volatility="immutable",
-    )
-    df = df.aggregate([], [accum(column("a"))])
-
-    msg = (
-        "Can't instantiate abstract class MissingMethods with abstract "
-        "methods evaluate, merge, update"
-    )
-    with pytest.raises(Exception, match=msg):
-        df.collect()
-
-
-def test_aggregate(df):
-    summarize = udaf(
-        Summarize,
-        pa.float64(),
-        pa.float64(),
-        [pa.float64()],
-        volatility="immutable",
-    )
-
-    df = df.aggregate([], [summarize(column("a"))])
-
-    # execute and collect the first (and only) batch
-    result = df.collect()[0]
-
-    assert result.column(0) == pa.array([1.0 + 2.0 + 3.0])
-
-
-def test_group_by(df):
-    summarize = udaf(
-        Summarize,
-        pa.float64(),
-        pa.float64(),
-        [pa.float64()],
-        volatility="immutable",
-    )
-
-    df = df.aggregate([column("b")], [summarize(column("a"))])
-
-    batches = df.collect()
-
-    arrays = [batch.column(1) for batch in batches]
-    joined = pa.concat_arrays(arrays)
-    assert joined == pa.array([1.0 + 2.0, 3.0])
diff --git a/dev/changelog/43.0.0.md b/dev/changelog/43.0.0.md
new file mode 100644
index 000000000..bbb766910
--- /dev/null
+++ b/dev/changelog/43.0.0.md
@@ -0,0 +1,73 @@
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+# Apache DataFusion Python 43.0.0 Changelog
+
+This release consists of 26 commits from 7 contributors. See credits at the end of this changelog for more information.
+
+**Implemented enhancements:**
+
+- feat: expose `drop` method [#913](https://github.com/apache/datafusion-python/pull/913) (ion-elgreco)
+- feat: expose `join_on` [#914](https://github.com/apache/datafusion-python/pull/914) (ion-elgreco)
+- feat: add fill_null/nan expressions [#919](https://github.com/apache/datafusion-python/pull/919) (ion-elgreco)
+- feat: add `with_columns` [#909](https://github.com/apache/datafusion-python/pull/909) (ion-elgreco)
+- feat: add `cast` to DataFrame [#916](https://github.com/apache/datafusion-python/pull/916) (ion-elgreco)
+- feat: add `head`, `tail` methods [#915](https://github.com/apache/datafusion-python/pull/915) (ion-elgreco)
+
+**Fixed bugs:**
+
+- fix: remove use of deprecated `make_scalar_function` [#906](https://github.com/apache/datafusion-python/pull/906) (Michael-J-Ward)
+- fix: udwf example [#948](https://github.com/apache/datafusion-python/pull/948) (mesejo)
+
+**Other:**
+
+- Ts/minor updates release process [#903](https://github.com/apache/datafusion-python/pull/903) (timsaucer)
+- build(deps): bump pyo3 from 0.22.3 to 0.22.4 [#910](https://github.com/apache/datafusion-python/pull/910) (dependabot[bot])
+- refactor: `from_arrow` use protocol typehints [#917](https://github.com/apache/datafusion-python/pull/917) (ion-elgreco)
+- Change requires-python version in pyproject.toml [#924](https://github.com/apache/datafusion-python/pull/924) (kosiew)
+- chore: deprecate `select_columns` [#911](https://github.com/apache/datafusion-python/pull/911) (ion-elgreco)
+- build(deps): bump uuid from 1.10.0 to 1.11.0 [#927](https://github.com/apache/datafusion-python/pull/927) (dependabot[bot])
+- Add array_empty scalar function [#931](https://github.com/apache/datafusion-python/pull/931) (kosiew)
+- add `cardinality` function to calculate total distinct elements in an array [#937](https://github.com/apache/datafusion-python/pull/937) (kosiew)
+- Add empty scalar function (alias of array_empty), fix a small typo [#938](https://github.com/apache/datafusion-python/pull/938) (kosiew)
+- README How to develop section now also works on Apple M1 [#940](https://github.com/apache/datafusion-python/pull/940) (drauschenbach)
+- refactor: dataframe `join` params [#912](https://github.com/apache/datafusion-python/pull/912) (ion-elgreco)
+- Upgrade to Datafusion 43 [#905](https://github.com/apache/datafusion-python/pull/905) (Michael-J-Ward)
+- build(deps): bump tokio from 1.40.0 to 1.41.1 [#946](https://github.com/apache/datafusion-python/pull/946) (dependabot[bot])
+- Add list_cat, list_concat, list_repeat [#942](https://github.com/apache/datafusion-python/pull/942) (kosiew)
+- Add foreign table providers [#921](https://github.com/apache/datafusion-python/pull/921) (timsaucer)
+- Add make_list and tests for make_list, make_array [#949](https://github.com/apache/datafusion-python/pull/949) (kosiew)
+- Documentation updates: simplify examples and add section on data sources [#955](https://github.com/apache/datafusion-python/pull/955) (timsaucer)
+- Add datafusion.extract [#959](https://github.com/apache/datafusion-python/pull/959) (kosiew)
+
+## Credits
+
+Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor.
+
+```
+     9	Ion Koutsouris
+     7	kosiew
+     3	Tim Saucer
+     3	dependabot[bot]
+     2	Michael J Ward
+     1	Daniel Mesejo
+     1	David Rauschenbach
+```
+
+Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release.
diff --git a/dev/changelog/44.0.0.md b/dev/changelog/44.0.0.md
new file mode 100644
index 000000000..c5ed4bdb0
--- /dev/null
+++ b/dev/changelog/44.0.0.md
@@ -0,0 +1,58 @@
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+# Apache DataFusion Python 44.0.0 Changelog
+
+This release consists of 12 commits from 5 contributors. See credits at the end of this changelog for more information.
+
+**Implemented enhancements:**
+
+- feat: support enable_url_table config [#980](https://github.com/apache/datafusion-python/pull/980) (chenkovsky)
+- feat: remove DataFusion pyarrow feat [#1000](https://github.com/apache/datafusion-python/pull/1000) (timsaucer)
+
+**Fixed bugs:**
+
+- fix: correct LZ0 to LZO in compression options [#995](https://github.com/apache/datafusion-python/pull/995) (kosiew)
+
+**Other:**
+
+- Add arrow cast [#962](https://github.com/apache/datafusion-python/pull/962) (kosiew)
+- Fix small issues in pyproject.toml [#976](https://github.com/apache/datafusion-python/pull/976) (kylebarron)
+- chore: set validation and type hint for ffi tableprovider [#983](https://github.com/apache/datafusion-python/pull/983) (ion-elgreco)
+- Support async iteration of RecordBatchStream [#975](https://github.com/apache/datafusion-python/pull/975) (kylebarron)
+- Chore/upgrade datafusion 44 [#973](https://github.com/apache/datafusion-python/pull/973) (timsaucer)
+- Default to ZSTD compression when writing Parquet  [#981](https://github.com/apache/datafusion-python/pull/981) (kosiew)
+- Feat/use uv python management [#994](https://github.com/apache/datafusion-python/pull/994) (timsaucer)
+- minor: Update dependencies prior to release [#999](https://github.com/apache/datafusion-python/pull/999) (timsaucer)
+- Apply import ordering in ruff check [#1001](https://github.com/apache/datafusion-python/pull/1001) (timsaucer)
+
+## Credits
+
+Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor.
+
+```
+     5	Tim Saucer
+     3	kosiew
+     2	Kyle Barron
+     1	Chongchen Chen
+     1	Ion Koutsouris
+```
+
+Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release.
+
diff --git a/dev/changelog/45.0.0.md b/dev/changelog/45.0.0.md
new file mode 100644
index 000000000..93659b171
--- /dev/null
+++ b/dev/changelog/45.0.0.md
@@ -0,0 +1,42 @@
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+# Apache DataFusion Python 45.0.0 Changelog
+
+This release consists of 2 commits from 2 contributors. See credits at the end of this changelog for more information.
+
+**Fixed bugs:**
+
+- fix: add to_timestamp_nanos [#1020](https://github.com/apache/datafusion-python/pull/1020) (chenkovsky)
+
+**Other:**
+
+- Chore/upgrade datafusion 45 [#1010](https://github.com/apache/datafusion-python/pull/1010) (kevinjqliu)
+
+## Credits
+
+Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor.
+
+```
+     1	Kevin Liu
+     1	Tim Saucer
+```
+
+Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release.
+
diff --git a/dev/changelog/46.0.0.md b/dev/changelog/46.0.0.md
new file mode 100644
index 000000000..3e5768099
--- /dev/null
+++ b/dev/changelog/46.0.0.md
@@ -0,0 +1,73 @@
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+# Apache DataFusion Python 46.0.0 Changelog
+
+This release consists of 21 commits from 11 contributors. See credits at the end of this changelog for more information.
+
+**Implemented enhancements:**
+
+- feat: reads using global ctx [#982](https://github.com/apache/datafusion-python/pull/982) (ion-elgreco)
+- feat: Implementation of udf and udaf decorator [#1040](https://github.com/apache/datafusion-python/pull/1040) (CrystalZhou0529)
+- feat: expose regex_count function [#1066](https://github.com/apache/datafusion-python/pull/1066) (nirnayroy)
+- feat: Update DataFusion dependency to 46 [#1079](https://github.com/apache/datafusion-python/pull/1079) (timsaucer)
+
+**Fixed bugs:**
+
+- fix: add to_timestamp_nanos [#1020](https://github.com/apache/datafusion-python/pull/1020) (chenkovsky)
+- fix: type checking [#993](https://github.com/apache/datafusion-python/pull/993) (chenkovsky)
+
+**Other:**
+
+- [infra] Fail Clippy on rust build warnings [#1029](https://github.com/apache/datafusion-python/pull/1029) (kevinjqliu)
+- Add user documentation for the FFI approach [#1031](https://github.com/apache/datafusion-python/pull/1031) (timsaucer)
+- build(deps): bump arrow from 54.1.0 to 54.2.0 [#1035](https://github.com/apache/datafusion-python/pull/1035) (dependabot[bot])
+- Chore: Release datafusion-python 45 [#1024](https://github.com/apache/datafusion-python/pull/1024) (timsaucer)
+- Enable Dataframe to be converted into views which can be used in register_table [#1016](https://github.com/apache/datafusion-python/pull/1016) (kosiew)
+- Add ruff check for missing futures import [#1052](https://github.com/apache/datafusion-python/pull/1052) (timsaucer)
+- Enable take comments to assign issues to users [#1058](https://github.com/apache/datafusion-python/pull/1058) (timsaucer)
+- Update python min version to 3.9 [#1043](https://github.com/apache/datafusion-python/pull/1043) (kevinjqliu)
+- feat/improve ruff test coverage [#1055](https://github.com/apache/datafusion-python/pull/1055) (timsaucer)
+- feat/making global context accessible for users [#1060](https://github.com/apache/datafusion-python/pull/1060) (jsai28)
+- Renaming Internal Structs [#1059](https://github.com/apache/datafusion-python/pull/1059) (Spaarsh)
+- test: add pytest asyncio tests [#1063](https://github.com/apache/datafusion-python/pull/1063) (jsai28)
+- Add decorator for udwf [#1061](https://github.com/apache/datafusion-python/pull/1061) (kosiew)
+- Add additional ruff suggestions [#1062](https://github.com/apache/datafusion-python/pull/1062) (Spaarsh)
+- Improve collection during repr and repr_html [#1036](https://github.com/apache/datafusion-python/pull/1036) (timsaucer)
+
+## Credits
+
+Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor.
+
+```
+     7	Tim Saucer
+     2	Kevin Liu
+     2	Spaarsh
+     2	jsai28
+     2	kosiew
+     1	Chen Chongchen
+     1	Chongchen Chen
+     1	Crystal Zhou
+     1	Ion Koutsouris
+     1	Nirnay Roy
+     1	dependabot[bot]
+```
+
+Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release.
+
diff --git a/dev/changelog/47.0.0.md b/dev/changelog/47.0.0.md
new file mode 100644
index 000000000..a7ed90313
--- /dev/null
+++ b/dev/changelog/47.0.0.md
@@ -0,0 +1,64 @@
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+# Apache DataFusion Python 47.0.0 Changelog
+
+This release consists of 23 commits from 5 contributors. See credits at the end of this changelog for more information.
+
+**Implemented enhancements:**
+
+- feat: support unparser [#1088](https://github.com/apache/datafusion-python/pull/1088) (chenkovsky)
+- feat: update datafusion dependency 47 [#1107](https://github.com/apache/datafusion-python/pull/1107) (timsaucer)
+- feat: alias with metadata [#1111](https://github.com/apache/datafusion-python/pull/1111) (chenkovsky)
+- feat: add missing PyLogicalPlan to_variant [#1085](https://github.com/apache/datafusion-python/pull/1085) (chenkovsky)
+- feat: add user defined table function support [#1113](https://github.com/apache/datafusion-python/pull/1113) (timsaucer)
+
+**Fixed bugs:**
+
+- fix: recursive import [#1117](https://github.com/apache/datafusion-python/pull/1117) (chenkovsky)
+
+**Other:**
+
+- Update changelog and version number [#1089](https://github.com/apache/datafusion-python/pull/1089) (timsaucer)
+- Documentation updates: mention correct dataset on basics page [#1081](https://github.com/apache/datafusion-python/pull/1081) (floscha)
+- Add Configurable HTML Table Formatter for DataFusion DataFrames in Python [#1100](https://github.com/apache/datafusion-python/pull/1100) (kosiew)
+- Add DataFrame usage guide with HTML rendering customization options [#1108](https://github.com/apache/datafusion-python/pull/1108) (kosiew)
+- 1075/enhancement/Make col class with __getattr__ [#1076](https://github.com/apache/datafusion-python/pull/1076) (deanm0000)
+- 1064/enhancement/add functions to Expr class [#1074](https://github.com/apache/datafusion-python/pull/1074) (deanm0000)
+- ci: require approving review [#1122](https://github.com/apache/datafusion-python/pull/1122) (timsaucer)
+- Partial fix for 1078: Enhance DataFrame Formatter Configuration with Memory and Display Controls [#1119](https://github.com/apache/datafusion-python/pull/1119) (kosiew)
+- Add fill_null method to DataFrame API for handling missing values [#1019](https://github.com/apache/datafusion-python/pull/1019) (kosiew)
+- minor: reduce error size [#1126](https://github.com/apache/datafusion-python/pull/1126) (timsaucer)
+- Move the udf module to user_defined [#1112](https://github.com/apache/datafusion-python/pull/1112) (timsaucer)
+- add unit tests for expression functions [#1121](https://github.com/apache/datafusion-python/pull/1121) (timsaucer)
+
+## Credits
+
+Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor.
+
+```
+    12	Tim Saucer
+     4	Chen Chongchen
+     4	kosiew
+     2	deanm0000
+     1	Florian Schäfer
+```
+
+Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release.
+
diff --git a/dev/changelog/48.0.0.md b/dev/changelog/48.0.0.md
new file mode 100644
index 000000000..80bc61aca
--- /dev/null
+++ b/dev/changelog/48.0.0.md
@@ -0,0 +1,59 @@
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+# Apache DataFusion Python 48.0.0 Changelog
+
+This release consists of 15 commits from 6 contributors. See credits at the end of this changelog for more information.
+
+**Implemented enhancements:**
+
+- feat: upgrade df48 dependency [#1143](https://github.com/apache/datafusion-python/pull/1143) (timsaucer)
+- feat: Support Parquet writer options [#1123](https://github.com/apache/datafusion-python/pull/1123) (nuno-faria)
+- feat: dataframe string formatter [#1170](https://github.com/apache/datafusion-python/pull/1170) (timsaucer)
+- feat: collect once during display() in jupyter notebooks [#1167](https://github.com/apache/datafusion-python/pull/1167) (timsaucer)
+- feat: python based catalog and schema provider [#1156](https://github.com/apache/datafusion-python/pull/1156) (timsaucer)
+- feat: add FFI support for user defined functions [#1145](https://github.com/apache/datafusion-python/pull/1145) (timsaucer)
+
+**Other:**
+
+- Release DataFusion 47.0.0 [#1130](https://github.com/apache/datafusion-python/pull/1130) (timsaucer)
+- Add a documentation build step in CI [#1139](https://github.com/apache/datafusion-python/pull/1139) (crystalxyz)
+- Add DataFrame API Documentation for DataFusion Python [#1132](https://github.com/apache/datafusion-python/pull/1132) (kosiew)
+- Add Interruptible Query Execution in Jupyter via KeyboardInterrupt Support [#1141](https://github.com/apache/datafusion-python/pull/1141) (kosiew)
+- Support types other than String and Int for partition columns [#1154](https://github.com/apache/datafusion-python/pull/1154) (miclegr)
+- Fix signature of `__arrow_c_stream__` [#1168](https://github.com/apache/datafusion-python/pull/1168) (kylebarron)
+- Consolidate DataFrame Docs: Merge HTML Rendering Section as Subpage [#1161](https://github.com/apache/datafusion-python/pull/1161) (kosiew)
+- Add compression_level support to ParquetWriterOptions and enhance write_parquet to accept full options object [#1169](https://github.com/apache/datafusion-python/pull/1169) (kosiew)
+- Simplify HTML Formatter Style Handling Using Script Injection [#1177](https://github.com/apache/datafusion-python/pull/1177) (kosiew)
+
+## Credits
+
+Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor.
+
+```
+     6	Tim Saucer
+     5	kosiew
+     1	Crystal Zhou
+     1	Kyle Barron
+     1	Michele Gregori
+     1	Nuno Faria
+```
+
+Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release.
+
diff --git a/dev/changelog/49.0.0.md b/dev/changelog/49.0.0.md
new file mode 100644
index 000000000..008bd43bc
--- /dev/null
+++ b/dev/changelog/49.0.0.md
@@ -0,0 +1,61 @@
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+# Apache DataFusion Python 49.0.0 Changelog
+
+This release consists of 16 commits from 7 contributors. See credits at the end of this changelog for more information.
+
+**Fixed bugs:**
+
+- fix(build): Include build.rs in published crates [#1199](https://github.com/apache/datafusion-python/pull/1199) (colinmarc)
+
+**Other:**
+
+- 48.0.0 Release [#1175](https://github.com/apache/datafusion-python/pull/1175) (timsaucer)
+- Update CI rules [#1188](https://github.com/apache/datafusion-python/pull/1188) (timsaucer)
+- Fix Python UDAF Accumulator Interface example to Properly Handle State and Updates with List[Array] Types [#1192](https://github.com/apache/datafusion-python/pull/1192) (kosiew)
+- chore: Upgrade datafusion to version 49 [#1200](https://github.com/apache/datafusion-python/pull/1200) (nuno-faria)
+- Update how to dev instructions [#1179](https://github.com/apache/datafusion-python/pull/1179) (ntjohnson1)
+- build(deps): bump object_store from 0.12.2 to 0.12.3 [#1189](https://github.com/apache/datafusion-python/pull/1189) (dependabot[bot])
+- build(deps): bump uuid from 1.17.0 to 1.18.0 [#1202](https://github.com/apache/datafusion-python/pull/1202) (dependabot[bot])
+- build(deps): bump async-trait from 0.1.88 to 0.1.89 [#1203](https://github.com/apache/datafusion-python/pull/1203) (dependabot[bot])
+- build(deps): bump slab from 0.4.10 to 0.4.11 [#1205](https://github.com/apache/datafusion-python/pull/1205) (dependabot[bot])
+- Improved window and aggregate function signature [#1187](https://github.com/apache/datafusion-python/pull/1187) (timsaucer)
+- Optional improvements in verification instructions [#1183](https://github.com/apache/datafusion-python/pull/1183) (paleolimbot)
+- Improve `show()` output for empty DataFrames [#1208](https://github.com/apache/datafusion-python/pull/1208) (kosiew)
+- build(deps): bump actions/download-artifact from 4 to 5 [#1201](https://github.com/apache/datafusion-python/pull/1201) (dependabot[bot])
+- build(deps): bump url from 2.5.4 to 2.5.7 [#1210](https://github.com/apache/datafusion-python/pull/1210) (dependabot[bot])
+- build(deps): bump actions/checkout from 4 to 5 [#1204](https://github.com/apache/datafusion-python/pull/1204) (dependabot[bot])
+
+## Credits
+
+Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor.
+
+```
+     7	dependabot[bot]
+     3	Tim Saucer
+     2	kosiew
+     1	Colin Marc
+     1	Dewey Dunnington
+     1	Nick
+     1	Nuno Faria
+```
+
+Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release.
+
diff --git a/dev/changelog/50.0.0.md b/dev/changelog/50.0.0.md
new file mode 100644
index 000000000..c3f09d180
--- /dev/null
+++ b/dev/changelog/50.0.0.md
@@ -0,0 +1,60 @@
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+# Apache DataFusion Python 50.0.0 Changelog
+
+This release consists of 12 commits from 7 contributors. See credits at the end of this changelog for more information.
+
+**Implemented enhancements:**
+
+- feat: allow passing a slice to and expression with the [] indexing [#1215](https://github.com/apache/datafusion-python/pull/1215) (timsaucer)
+
+**Documentation updates:**
+
+- docs: fix CaseBuilder documentation example [#1225](https://github.com/apache/datafusion-python/pull/1225) (IndexSeek)
+- docs: update link to user example for custom table provider [#1224](https://github.com/apache/datafusion-python/pull/1224) (IndexSeek)
+- docs: add apache iceberg as datafusion data source [#1240](https://github.com/apache/datafusion-python/pull/1240) (kevinjqliu)
+
+**Other:**
+
+- 49.0.0 release [#1211](https://github.com/apache/datafusion-python/pull/1211) (timsaucer)
+- Update development guide in README.md [#1213](https://github.com/apache/datafusion-python/pull/1213) (YKoustubhRao)
+- Add benchmark script and documentation for maximizing CPU usage in DataFusion Python [#1216](https://github.com/apache/datafusion-python/pull/1216) (kosiew)
+- Fixing a few Typos [#1220](https://github.com/apache/datafusion-python/pull/1220) (ntjohnson1)
+- Set fail on warning for documentation generation [#1218](https://github.com/apache/datafusion-python/pull/1218) (timsaucer)
+- chore: remove redundant error transformation [#1232](https://github.com/apache/datafusion-python/pull/1232) (mesejo)
+- Support string column identifiers for sort/aggregate/window and stricter Expr validation [#1221](https://github.com/apache/datafusion-python/pull/1221) (kosiew)
+- Prepare for DF50 [#1231](https://github.com/apache/datafusion-python/pull/1231) (timsaucer)
+
+## Credits
+
+Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor.
+
+```
+     4	Tim Saucer
+     2	Tyler White
+     2	kosiew
+     1	Daniel Mesejo
+     1	Kevin Liu
+     1	Koustubh Rao
+     1	Nick
+```
+
+Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release.
+
diff --git a/dev/changelog/50.1.0.md b/dev/changelog/50.1.0.md
new file mode 100644
index 000000000..3b9ff84ff
--- /dev/null
+++ b/dev/changelog/50.1.0.md
@@ -0,0 +1,57 @@
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+# Apache DataFusion Python 50.1.0 Changelog
+
+This release consists of 11 commits from 7 contributors. See credits at the end of this changelog for more information.
+
+**Breaking changes:**
+
+- Unify Table representations [#1256](https://github.com/apache/datafusion-python/pull/1256) (timsaucer)
+
+**Implemented enhancements:**
+
+- feat: expose DataFrame.write_table [#1264](https://github.com/apache/datafusion-python/pull/1264) (timsaucer)
+- feat: expose` DataFrame.parse_sql_expr` [#1274](https://github.com/apache/datafusion-python/pull/1274) (milenkovicm)
+
+**Other:**
+
+- Update version number, add changelog [#1249](https://github.com/apache/datafusion-python/pull/1249) (timsaucer)
+- Fix drop() method to handle quoted column names consistently [#1242](https://github.com/apache/datafusion-python/pull/1242) (H0TB0X420)
+- Make Session Context `pyclass` frozen so interior mutability is only managed by rust [#1248](https://github.com/apache/datafusion-python/pull/1248) (ntjohnson1)
+- macos-13 is deprecated [#1259](https://github.com/apache/datafusion-python/pull/1259) (kevinjqliu)
+- Freeze PyO3 wrappers & introduce interior mutability to avoid PyO3 borrow errors [#1253](https://github.com/apache/datafusion-python/pull/1253) (kosiew)
+- chore: update dependencies [#1269](https://github.com/apache/datafusion-python/pull/1269) (timsaucer)
+
+## Credits
+
+Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor.
+
+```
+     4	Tim Saucer
+     2	Siew Kam Onn
+     1	H0TB0X420
+     1	Kevin Liu
+     1	Marko Milenković
+     1	Nick
+     1	kosiew
+```
+
+Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release.
+
diff --git a/dev/changelog/51.0.0.md b/dev/changelog/51.0.0.md
new file mode 100644
index 000000000..cc157eb0d
--- /dev/null
+++ b/dev/changelog/51.0.0.md
@@ -0,0 +1,74 @@
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+# Apache DataFusion Python 51.0.0 Changelog
+
+This release consists of 23 commits from 7 contributors. See credits at the end of this changelog for more information.
+
+**Breaking changes:**
+
+- feat: reduce duplicate fields on join [#1184](https://github.com/apache/datafusion-python/pull/1184) (timsaucer)
+
+**Implemented enhancements:**
+
+- feat: expose `select_exprs` method on DataFrame [#1271](https://github.com/apache/datafusion-python/pull/1271) (milenkovicm)
+- feat: allow DataFrame.filter to accept SQL strings [#1276](https://github.com/apache/datafusion-python/pull/1276) (K-dash)
+- feat: add temporary view option for into_view [#1267](https://github.com/apache/datafusion-python/pull/1267) (timsaucer)
+- feat: support session token parameter for AmazonS3 [#1275](https://github.com/apache/datafusion-python/pull/1275) (GCHQDeveloper028)
+- feat: `with_column` supports SQL expression [#1284](https://github.com/apache/datafusion-python/pull/1284) (milenkovicm)
+- feat: Add SQL expression for `repartition_by_hash` [#1285](https://github.com/apache/datafusion-python/pull/1285) (milenkovicm)
+- feat: Add SQL expression support for `with_columns` [#1286](https://github.com/apache/datafusion-python/pull/1286) (milenkovicm)
+
+**Fixed bugs:**
+
+- fix: use coalesce instead of drop_duplicate_keys for join [#1318](https://github.com/apache/datafusion-python/pull/1318) (mesejo)
+- fix: Inconsistent schemas when converting to pyarrow [#1315](https://github.com/apache/datafusion-python/pull/1315) (nuno-faria)
+
+**Other:**
+
+- Release 50.1 [#1281](https://github.com/apache/datafusion-python/pull/1281) (timsaucer)
+- Update python minimum version to 3.10 [#1296](https://github.com/apache/datafusion-python/pull/1296) (timsaucer)
+- chore: update datafusion minor version [#1297](https://github.com/apache/datafusion-python/pull/1297) (timsaucer)
+- Enable remaining pylints [#1298](https://github.com/apache/datafusion-python/pull/1298) (timsaucer)
+- Add Arrow C streaming, DataFrame iteration, and OOM-safe streaming execution [#1222](https://github.com/apache/datafusion-python/pull/1222) (kosiew)
+- Add PyCapsule Type Support and Type Hint Enhancements for AggregateUDF in DataFusion Python Bindings [#1277](https://github.com/apache/datafusion-python/pull/1277) (kosiew)
+- Add collect_column to dataframe [#1302](https://github.com/apache/datafusion-python/pull/1302) (timsaucer)
+- chore: apply cargo fmt with import organization [#1303](https://github.com/apache/datafusion-python/pull/1303) (timsaucer)
+- Feat/parameterized sql queries [#964](https://github.com/apache/datafusion-python/pull/964) (timsaucer)
+- Upgrade to Datafusion 51 [#1311](https://github.com/apache/datafusion-python/pull/1311) (nuno-faria)
+- minor: resolve build errors after latest merge into main [#1325](https://github.com/apache/datafusion-python/pull/1325) (timsaucer)
+- Update build workflow link [#1330](https://github.com/apache/datafusion-python/pull/1330) (timsaucer)
+- Do not convert pyarrow scalar values to plain python types when passing as `lit` [#1319](https://github.com/apache/datafusion-python/pull/1319) (timsaucer)
+
+## Credits
+
+Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor.
+
+```
+    12	Tim Saucer
+     4	Marko Milenković
+     2	Nuno Faria
+     2	kosiew
+     1	Daniel Mesejo
+     1	GCHQDeveloper028
+     1	𝕂
+```
+
+Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release.
+
diff --git a/dev/changelog/52.0.0.md b/dev/changelog/52.0.0.md
new file mode 100644
index 000000000..3f848bb47
--- /dev/null
+++ b/dev/changelog/52.0.0.md
@@ -0,0 +1,78 @@
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+# Apache DataFusion Python 52.0.0 Changelog
+
+This release consists of 26 commits from 9 contributors. See credits at the end of this changelog for more information.
+
+**Implemented enhancements:**
+
+- feat: add CatalogProviderList support [#1363](https://github.com/apache/datafusion-python/pull/1363) (timsaucer)
+- feat: add support for generating JSON formatted substrait plan [#1376](https://github.com/apache/datafusion-python/pull/1376) (Prathamesh9284)
+- feat: add regexp_instr function [#1382](https://github.com/apache/datafusion-python/pull/1382) (mesejo)
+
+**Fixed bugs:**
+
+- fix: mangled errors [#1377](https://github.com/apache/datafusion-python/pull/1377) (mesejo)
+
+**Documentation updates:**
+
+- docs: Clarify first_value usage in select vs aggregate [#1348](https://github.com/apache/datafusion-python/pull/1348) (AdMub)
+
+**Other:**
+
+- Release 51.0.0 [#1333](https://github.com/apache/datafusion-python/pull/1333) (timsaucer)
+- Use explicit timer in unit test [#1338](https://github.com/apache/datafusion-python/pull/1338) (timsaucer)
+- Add use_fabric_endpoint parameter to MicrosoftAzure class [#1357](https://github.com/apache/datafusion-python/pull/1357) (djouallah)
+- Prepare for DF52 release [#1337](https://github.com/apache/datafusion-python/pull/1337) (timsaucer)
+- build(deps): bump actions/checkout from 5 to 6 [#1310](https://github.com/apache/datafusion-python/pull/1310) (dependabot[bot])
+- build(deps): bump actions/download-artifact from 5 to 7 [#1321](https://github.com/apache/datafusion-python/pull/1321) (dependabot[bot])
+- build(deps): bump actions/upload-artifact from 4 to 6 [#1322](https://github.com/apache/datafusion-python/pull/1322) (dependabot[bot])
+- build(deps): bump actions/cache from 4 to 5 [#1323](https://github.com/apache/datafusion-python/pull/1323) (dependabot[bot])
+- Pass Field information back and forth when using scalar UDFs [#1299](https://github.com/apache/datafusion-python/pull/1299) (timsaucer)
+- Update dependency minor versions to prepare for DF52 release [#1368](https://github.com/apache/datafusion-python/pull/1368) (timsaucer)
+- Improve displayed error by using `DataFusionError`'s `Display` trait [#1370](https://github.com/apache/datafusion-python/pull/1370) (abey79)
+- Enforce DataFrame display memory limits with `max_rows` + `min_rows` constraint (deprecate `repr_rows`) [#1367](https://github.com/apache/datafusion-python/pull/1367) (kosiew)
+- Implement all CSV reader options [#1361](https://github.com/apache/datafusion-python/pull/1361) (timsaucer)
+- chore: add confirmation before tarball is released [#1372](https://github.com/apache/datafusion-python/pull/1372) (milenkovicm)
+- Build in debug mode for PRs [#1375](https://github.com/apache/datafusion-python/pull/1375) (timsaucer)
+- minor: remove ffi test wheel from distribution artifact [#1378](https://github.com/apache/datafusion-python/pull/1378) (timsaucer)
+- chore: update rust 2024 edition [#1371](https://github.com/apache/datafusion-python/pull/1371) (timsaucer)
+- Fix Python UDAF list-of-timestamps return by enforcing list-valued scalars and caching PyArrow types [#1347](https://github.com/apache/datafusion-python/pull/1347) (kosiew)
+- minor: update cargo dependencies [#1383](https://github.com/apache/datafusion-python/pull/1383) (timsaucer)
+- chore: bump Python version for RAT checking [#1386](https://github.com/apache/datafusion-python/pull/1386) (timsaucer)
+
+## Credits
+
+Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor.
+
+```
+    13	Tim Saucer
+     4	dependabot[bot]
+     2	Daniel Mesejo
+     2	kosiew
+     1	Adisa Mubarak (AdMub)
+     1	Antoine Beyeler
+     1	Dhanashri Prathamesh Iranna
+     1	Marko Milenković
+     1	Mimoune
+```
+
+Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release.
+
diff --git a/dev/changelog/pre-43.0.0.md b/dev/changelog/pre-43.0.0.md
new file mode 100644
index 000000000..ae3a2348a
--- /dev/null
+++ b/dev/changelog/pre-43.0.0.md
@@ -0,0 +1,715 @@
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+
+# DataFusion Python Changelog
+
+## [42.0.0](https://github.com/apache/datafusion-python/tree/42.0.0) (2024-10-06)
+
+This release consists of 20 commits from 6 contributors. See credits at the end of this changelog for more information.
+
+**Implemented enhancements:**
+
+- feat: expose between [#868](https://github.com/apache/datafusion-python/pull/868) (mesejo)
+- feat: make register_csv accept a list of paths [#883](https://github.com/apache/datafusion-python/pull/883) (mesejo)
+- feat: expose http object store [#885](https://github.com/apache/datafusion-python/pull/885) (mesejo)
+
+**Fixed bugs:**
+
+- fix: Calling `count` on a pyarrow dataset results in an error [#843](https://github.com/apache/datafusion-python/pull/843) (Michael-J-Ward)
+
+**Other:**
+
+- Upgrade datafusion [#867](https://github.com/apache/datafusion-python/pull/867) (emgeee)
+- Feature/aggregates as windows [#871](https://github.com/apache/datafusion-python/pull/871) (timsaucer)
+- Fix regression on register_udaf [#878](https://github.com/apache/datafusion-python/pull/878) (timsaucer)
+- build(deps): upgrade setup-protoc action and protoc version number [#873](https://github.com/apache/datafusion-python/pull/873) (Michael-J-Ward)
+- build(deps): bump prost-types from 0.13.2 to 0.13.3 [#881](https://github.com/apache/datafusion-python/pull/881) (dependabot[bot])
+- build(deps): bump prost from 0.13.2 to 0.13.3 [#882](https://github.com/apache/datafusion-python/pull/882) (dependabot[bot])
+- chore: remove XFAIL from passing tests [#884](https://github.com/apache/datafusion-python/pull/884) (Michael-J-Ward)
+- Add user defined window function support [#880](https://github.com/apache/datafusion-python/pull/880) (timsaucer)
+- build(deps): bump syn from 2.0.77 to 2.0.79 [#886](https://github.com/apache/datafusion-python/pull/886) (dependabot[bot])
+- fix example of reading parquet from s3 [#896](https://github.com/apache/datafusion-python/pull/896) (sir-sigurd)
+- release-testing [#889](https://github.com/apache/datafusion-python/pull/889) (Michael-J-Ward)
+- chore(bench): fix create_tables.sql for tpch benchmark [#897](https://github.com/apache/datafusion-python/pull/897) (Michael-J-Ward)
+- Add physical and logical plan conversion to and from protobuf [#892](https://github.com/apache/datafusion-python/pull/892) (timsaucer)
+- Feature/instance udfs [#890](https://github.com/apache/datafusion-python/pull/890) (timsaucer)
+- chore(ci): remove Mambaforge variant from CI [#894](https://github.com/apache/datafusion-python/pull/894) (Michael-J-Ward)
+- Use OnceLock to store TokioRuntime [#895](https://github.com/apache/datafusion-python/pull/895) (Michael-J-Ward)
+
+## Credits
+
+Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor.
+
+```
+     7	Michael J Ward
+     5	Tim Saucer
+     3	Daniel Mesejo
+     3	dependabot[bot]
+     1	Matt Green
+     1	Sergey Fedoseev
+```
+
+Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release.
+
+## [41.0.0](https://github.com/apache/datafusion-python/tree/41.0.0) (2024-09-09)
+
+This release consists of 19 commits from 6 contributors. See credits at the end of this changelog for more information.
+
+**Implemented enhancements:**
+
+- feat: enable list of paths for read_csv [#824](https://github.com/apache/datafusion-python/pull/824) (mesejo)
+- feat: better exception and message for table not found [#851](https://github.com/apache/datafusion-python/pull/851) (mesejo)
+- feat: make cast accept built-in Python types [#858](https://github.com/apache/datafusion-python/pull/858) (mesejo)
+
+**Other:**
+
+- chore: Prepare for 40.0.0 release [#801](https://github.com/apache/datafusion-python/pull/801) (andygrove)
+- Add typing-extensions dependency to pyproject [#805](https://github.com/apache/datafusion-python/pull/805) (timsaucer)
+- Upgrade deps to datafusion 41 [#802](https://github.com/apache/datafusion-python/pull/802) (Michael-J-Ward)
+- Fix SessionContext init with only SessionConfig [#827](https://github.com/apache/datafusion-python/pull/827) (jcrist)
+- build(deps): upgrade actions/{upload,download}-artifact@v3 to v4 [#829](https://github.com/apache/datafusion-python/pull/829) (Michael-J-Ward)
+- Run ruff format in CI [#837](https://github.com/apache/datafusion-python/pull/837) (timsaucer)
+- Add PyCapsule support for Arrow import and export [#825](https://github.com/apache/datafusion-python/pull/825) (timsaucer)
+- Feature/expose when function [#836](https://github.com/apache/datafusion-python/pull/836) (timsaucer)
+- Add Window Functions for use with function builder [#808](https://github.com/apache/datafusion-python/pull/808) (timsaucer)
+- chore: fix typos [#844](https://github.com/apache/datafusion-python/pull/844) (mesejo)
+- build(ci): use proper mac runners [#841](https://github.com/apache/datafusion-python/pull/841) (Michael-J-Ward)
+- Set of small features [#839](https://github.com/apache/datafusion-python/pull/839) (timsaucer)
+- chore: fix docstrings, typos [#852](https://github.com/apache/datafusion-python/pull/852) (mesejo)
+- chore: Use datafusion re-exported dependencies [#856](https://github.com/apache/datafusion-python/pull/856) (emgeee)
+- add guidelines on separating python and rust code [#860](https://github.com/apache/datafusion-python/pull/860) (Michael-J-Ward)
+- Update Aggregate functions to take builder parameters [#859](https://github.com/apache/datafusion-python/pull/859) (timsaucer)
+
+## Credits
+
+Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor.
+
+```
+     7  Tim Saucer
+     5  Daniel Mesejo
+     4  Michael J Ward
+     1  Andy Grove
+     1  Jim Crist-Harif
+     1  Matt Green
+```
+
+Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release.
+
+## [40.0.0](https://github.com/apache/datafusion-python/tree/40.0.0) (2024-08-09)
+
+This release consists of 18 commits from 4 contributors. See credits at the end of this changelog for more information.
+
+- Update changelog for 39.0.0 [#742](https://github.com/apache/datafusion-python/pull/742) (andygrove)
+- build(deps): bump uuid from 1.8.0 to 1.9.1 [#744](https://github.com/apache/datafusion-python/pull/744) (dependabot[bot])
+- build(deps): bump mimalloc from 0.1.42 to 0.1.43 [#745](https://github.com/apache/datafusion-python/pull/745) (dependabot[bot])
+- build(deps): bump syn from 2.0.67 to 2.0.68 [#746](https://github.com/apache/datafusion-python/pull/746) (dependabot[bot])
+- Tsaucer/find window fn [#747](https://github.com/apache/datafusion-python/pull/747) (timsaucer)
+- Python wrapper classes for all user interfaces [#750](https://github.com/apache/datafusion-python/pull/750) (timsaucer)
+- Expose array sort [#764](https://github.com/apache/datafusion-python/pull/764) (timsaucer)
+- Upgrade protobuf and remove GH Action googletest-installer [#773](https://github.com/apache/datafusion-python/pull/773) (Michael-J-Ward)
+- Upgrade Datafusion 40 [#771](https://github.com/apache/datafusion-python/pull/771) (Michael-J-Ward)
+- Bugfix: Calling count with None arguments [#768](https://github.com/apache/datafusion-python/pull/768) (timsaucer)
+- Add in user example that compares a two different approaches to UDFs [#770](https://github.com/apache/datafusion-python/pull/770) (timsaucer)
+- Add missing exports for wrapper modules [#782](https://github.com/apache/datafusion-python/pull/782) (timsaucer)
+- Add PyExpr to_variant conversions [#793](https://github.com/apache/datafusion-python/pull/793) (Michael-J-Ward)
+- Add missing expressions to wrapper export [#795](https://github.com/apache/datafusion-python/pull/795) (timsaucer)
+- Doc/cross reference [#791](https://github.com/apache/datafusion-python/pull/791) (timsaucer)
+- Re-Enable `num_centroids` to `approx_percentile_cont` [#798](https://github.com/apache/datafusion-python/pull/798) (Michael-J-Ward)
+- UDAF process all state variables [#799](https://github.com/apache/datafusion-python/pull/799) (timsaucer)
+
+## Credits
+
+Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) per contributor.
+
+```
+     9	Tim Saucer
+     4	Michael J Ward
+     3	dependabot[bot]
+     2	Andy Grove
+```
+
+Thank you also to everyone who contributed in other ways such as filing issues, reviewing PRs, and providing feedback on this release.
+
+## [39.0.0](https://github.com/apache/datafusion-python/tree/39.0.0) (2024-06-25)
+
+**Merged pull requests:**
+
+- ci: add substrait feature to linux builds [#720](https://github.com/apache/datafusion-python/pull/720) (Michael-J-Ward)
+- Docs deploy action [#721](https://github.com/apache/datafusion-python/pull/721) (Michael-J-Ward)
+- update deps [#723](https://github.com/apache/datafusion-python/pull/723) (Michael-J-Ward)
+- Upgrade maturin [#725](https://github.com/apache/datafusion-python/pull/725) (Michael-J-Ward)
+- Upgrade datafusion 39 [#728](https://github.com/apache/datafusion-python/pull/728) (Michael-J-Ward)
+- use ScalarValue::to_pyarrow to convert to python object [#731](https://github.com/apache/datafusion-python/pull/731) (Michael-J-Ward)
+- Pyo3 `Bound<'py, T>` api [#734](https://github.com/apache/datafusion-python/pull/734) (Michael-J-Ward)
+- github test action: drop python 3.7, add python 3.12 [#736](https://github.com/apache/datafusion-python/pull/736) (Michael-J-Ward)
+- Pyarrow filter pushdowns [#735](https://github.com/apache/datafusion-python/pull/735) (Michael-J-Ward)
+- build(deps): bump syn from 2.0.66 to 2.0.67 [#738](https://github.com/apache/datafusion-python/pull/738) (dependabot[bot])
+- Pyo3 refactorings [#740](https://github.com/apache/datafusion-python/pull/740) (Michael-J-Ward)
+- UDAF `sum` workaround [#741](https://github.com/apache/datafusion-python/pull/741) (Michael-J-Ward)
+
+## [38.0.1](https://github.com/apache/datafusion-python/tree/38.0.1) (2024-05-25)
+
+**Implemented enhancements:**
+
+- feat: add python bindings for ends_with function [#693](https://github.com/apache/datafusion-python/pull/693) (richtia)
+- feat: expose `named_struct` in python [#700](https://github.com/apache/datafusion-python/pull/700) (Michael-J-Ward)
+
+**Merged pull requests:**
+
+- Add document about basics of working with expressions [#668](https://github.com/apache/datafusion-python/pull/668) (timsaucer)
+- chore: Update Python release process now that DataFusion is TLP [#674](https://github.com/apache/datafusion-python/pull/674) (andygrove)
+- Fix Docs [#676](https://github.com/apache/datafusion-python/pull/676) (Michael-J-Ward)
+- Add examples from TPC-H [#666](https://github.com/apache/datafusion-python/pull/666) (timsaucer)
+- fix conda nightly builds, attempt 2 [#689](https://github.com/apache/datafusion-python/pull/689) (Michael-J-Ward)
+- Upgrade to datafusion 38 [#691](https://github.com/apache/datafusion-python/pull/691) (Michael-J-Ward)
+- chore: update to maturin's recommended project layout for rust/python… [#695](https://github.com/apache/datafusion-python/pull/695) (Michael-J-Ward)
+- chore: update cargo deps [#698](https://github.com/apache/datafusion-python/pull/698) (Michael-J-Ward)
+- feat: add python bindings for ends_with function [#693](https://github.com/apache/datafusion-python/pull/693) (richtia)
+- feat: expose `named_struct` in python [#700](https://github.com/apache/datafusion-python/pull/700) (Michael-J-Ward)
+- Website fixes [#702](https://github.com/apache/datafusion-python/pull/702) (Michael-J-Ward)
+
+## [37.1.0](https://github.com/apache/datafusion-python/tree/37.1.0) (2024-05-08)
+
+**Implemented enhancements:**
+
+- feat: add execute_stream and execute_stream_partitioned [#610](https://github.com/apache/datafusion-python/pull/610) (mesejo)
+
+**Documentation updates:**
+
+- docs: update docs CI to install python-311 requirements [#661](https://github.com/apache/datafusion-python/pull/661) (Michael-J-Ward)
+
+**Merged pull requests:**
+
+- Switch to Ruff for Python linting [#529](https://github.com/apache/datafusion-python/pull/529) (andygrove)
+- Remove sql-on-pandas/polars/cudf examples [#602](https://github.com/apache/datafusion-python/pull/602) (andygrove)
+- build(deps): bump object_store from 0.9.0 to 0.9.1 [#611](https://github.com/apache/datafusion-python/pull/611) (dependabot[bot])
+- More missing array funcs [#605](https://github.com/apache/datafusion-python/pull/605) (judahrand)
+- feat: add execute_stream and execute_stream_partitioned [#610](https://github.com/apache/datafusion-python/pull/610) (mesejo)
+- build(deps): bump uuid from 1.7.0 to 1.8.0 [#615](https://github.com/apache/datafusion-python/pull/615) (dependabot[bot])
+- Bind SQLOptions and relative ctx method #567 [#588](https://github.com/apache/datafusion-python/pull/588) (giacomorebecchi)
+- bugfix: no panic on empty table [#613](https://github.com/apache/datafusion-python/pull/613) (mesejo)
+- Expose `register_listing_table` [#618](https://github.com/apache/datafusion-python/pull/618) (henrifroese)
+- Expose unnest feature [#641](https://github.com/apache/datafusion-python/pull/641) (timsaucer)
+- Update domain names and paths in asf yaml [#643](https://github.com/apache/datafusion-python/pull/643) (andygrove)
+- use python 3.11 to publish docs [#645](https://github.com/apache/datafusion-python/pull/645) (andygrove)
+- docs: update docs CI to install python-311 requirements [#661](https://github.com/apache/datafusion-python/pull/661) (Michael-J-Ward)
+- Upgrade Datafusion to v37.1.0 [#669](https://github.com/apache/datafusion-python/pull/669) (Michael-J-Ward)
+
+## [36.0.0](https://github.com/apache/datafusion-python/tree/36.0.0) (2024-03-02)
+
+**Implemented enhancements:**
+
+- feat: Add `flatten` array function [#562](https://github.com/apache/datafusion-python/pull/562) (mobley-trent)
+
+**Documentation updates:**
+
+- docs: Add ASF attribution [#580](https://github.com/apache/datafusion-python/pull/580) (simicd)
+
+**Merged pull requests:**
+
+- Allow PyDataFrame to be used from other projects [#582](https://github.com/apache/datafusion-python/pull/582) (andygrove)
+- docs: Add ASF attribution [#580](https://github.com/apache/datafusion-python/pull/580) (simicd)
+- Add array functions [#560](https://github.com/apache/datafusion-python/pull/560) (ongchi)
+- feat: Add `flatten` array function [#562](https://github.com/apache/datafusion-python/pull/562) (mobley-trent)
+
+## [35.0.0](https://github.com/apache/datafusion-python/tree/35.0.0) (2024-01-20)
+
+**Merged pull requests:**
+
+- build(deps): bump syn from 2.0.41 to 2.0.43 [#559](https://github.com/apache/datafusion-python/pull/559) (dependabot[bot])
+- build(deps): bump tokio from 1.35.0 to 1.35.1 [#558](https://github.com/apache/datafusion-python/pull/558) (dependabot[bot])
+- build(deps): bump async-trait from 0.1.74 to 0.1.77 [#556](https://github.com/apache/datafusion-python/pull/556) (dependabot[bot])
+- build(deps): bump pyo3 from 0.20.0 to 0.20.2 [#557](https://github.com/apache/datafusion-python/pull/557) (dependabot[bot])
+
+## [34.0.0](https://github.com/apache/datafusion-python/tree/34.0.0) (2023-12-28)
+
+**Merged pull requests:**
+
+- Adjust visibility of crate private members & Functions [#537](https://github.com/apache/datafusion-python/pull/537) (jdye64)
+- Update json.rst [#538](https://github.com/apache/datafusion-python/pull/538) (ray-andrew)
+- Enable mimalloc local_dynamic_tls feature [#540](https://github.com/apache/datafusion-python/pull/540) (jdye64)
+- Enable substrait feature to be built by default in CI, for nightlies … [#544](https://github.com/apache/datafusion-python/pull/544) (jdye64)
+
+## [33.0.0](https://github.com/apache/datafusion-python/tree/33.0.0) (2023-11-16)
+
+**Merged pull requests:**
+
+- First pass at getting architectured builds working [#350](https://github.com/apache/datafusion-python/pull/350) (charlesbluca)
+- Remove libprotobuf dep [#527](https://github.com/apache/datafusion-python/pull/527) (jdye64)
+
+## [32.0.0](https://github.com/apache/datafusion-python/tree/32.0.0) (2023-10-21)
+
+**Implemented enhancements:**
+
+- feat: expose PyWindowFrame [#509](https://github.com/apache/datafusion-python/pull/509) (dlovell)
+- add Binary String Functions;encode,decode [#494](https://github.com/apache/datafusion-python/pull/494) (jiangzhx)
+- add bit_and,bit_or,bit_xor,bool_add,bool_or [#496](https://github.com/apache/datafusion-python/pull/496) (jiangzhx)
+- add first_value last_value [#498](https://github.com/apache/datafusion-python/pull/498) (jiangzhx)
+- add regr\_\* functions [#499](https://github.com/apache/datafusion-python/pull/499) (jiangzhx)
+- Add random missing bindings [#522](https://github.com/apache/datafusion-python/pull/522) (jdye64)
+- Allow for multiple input files per table instead of a single file [#519](https://github.com/apache/datafusion-python/pull/519) (jdye64)
+- Add support for window function bindings [#521](https://github.com/apache/datafusion-python/pull/521) (jdye64)
+
+**Merged pull requests:**
+
+- Prepare 31.0.0 release [#500](https://github.com/apache/datafusion-python/pull/500) (andygrove)
+- Improve release process documentation [#505](https://github.com/apache/datafusion-python/pull/505) (andygrove)
+- add Binary String Functions;encode,decode [#494](https://github.com/apache/datafusion-python/pull/494) (jiangzhx)
+- build(deps): bump mimalloc from 0.1.38 to 0.1.39 [#502](https://github.com/apache/datafusion-python/pull/502) (dependabot[bot])
+- build(deps): bump syn from 2.0.32 to 2.0.35 [#503](https://github.com/apache/datafusion-python/pull/503) (dependabot[bot])
+- build(deps): bump syn from 2.0.35 to 2.0.37 [#506](https://github.com/apache/datafusion-python/pull/506) (dependabot[bot])
+- Use latest DataFusion [#511](https://github.com/apache/datafusion-python/pull/511) (andygrove)
+- add bit_and,bit_or,bit_xor,bool_add,bool_or [#496](https://github.com/apache/datafusion-python/pull/496) (jiangzhx)
+- use DataFusion 32 [#515](https://github.com/apache/datafusion-python/pull/515) (andygrove)
+- add first_value last_value [#498](https://github.com/apache/datafusion-python/pull/498) (jiangzhx)
+- build(deps): bump regex-syntax from 0.7.5 to 0.8.1 [#517](https://github.com/apache/datafusion-python/pull/517) (dependabot[bot])
+- build(deps): bump pyo3-build-config from 0.19.2 to 0.20.0 [#516](https://github.com/apache/datafusion-python/pull/516) (dependabot[bot])
+- add regr\_\* functions [#499](https://github.com/apache/datafusion-python/pull/499) (jiangzhx)
+- Add random missing bindings [#522](https://github.com/apache/datafusion-python/pull/522) (jdye64)
+- build(deps): bump rustix from 0.38.18 to 0.38.19 [#523](https://github.com/apache/datafusion-python/pull/523) (dependabot[bot])
+- Allow for multiple input files per table instead of a single file [#519](https://github.com/apache/datafusion-python/pull/519) (jdye64)
+- Add support for window function bindings [#521](https://github.com/apache/datafusion-python/pull/521) (jdye64)
+- Small clippy fix [#524](https://github.com/apache/datafusion-python/pull/524) (andygrove)
+
+## [31.0.0](https://github.com/apache/datafusion-python/tree/31.0.0) (2023-09-12)
+
+[Full Changelog](https://github.com/apache/datafusion-python/compare/28.0.0...31.0.0)
+
+**Implemented enhancements:**
+
+- feat: add case function (#447) [#448](https://github.com/apache/datafusion-python/pull/448) (mesejo)
+- feat: add compression options [#456](https://github.com/apache/datafusion-python/pull/456) (mesejo)
+- feat: add register_json [#458](https://github.com/apache/datafusion-python/pull/458) (mesejo)
+- feat: add basic compression configuration to write_parquet [#459](https://github.com/apache/datafusion-python/pull/459) (mesejo)
+- feat: add example of reading parquet from s3 [#460](https://github.com/apache/datafusion-python/pull/460) (mesejo)
+- feat: add register_avro and read_table [#461](https://github.com/apache/datafusion-python/pull/461) (mesejo)
+- feat: add missing scalar math functions [#465](https://github.com/apache/datafusion-python/pull/465) (mesejo)
+
+**Documentation updates:**
+
+- docs: include pre-commit hooks section in contributor guide [#455](https://github.com/apache/datafusion-python/pull/455) (mesejo)
+
+**Merged pull requests:**
+
+- Build Linux aarch64 wheel [#443](https://github.com/apache/datafusion-python/pull/443) (gokselk)
+- feat: add case function (#447) [#448](https://github.com/apache/datafusion-python/pull/448) (mesejo)
+- enhancement(docs): Add user guide (#432) [#445](https://github.com/apache/datafusion-python/pull/445) (mesejo)
+- docs: include pre-commit hooks section in contributor guide [#455](https://github.com/apache/datafusion-python/pull/455) (mesejo)
+- feat: add compression options [#456](https://github.com/apache/datafusion-python/pull/456) (mesejo)
+- Upgrade to DF 28.0.0-rc1 [#457](https://github.com/apache/datafusion-python/pull/457) (andygrove)
+- feat: add register_json [#458](https://github.com/apache/datafusion-python/pull/458) (mesejo)
+- feat: add basic compression configuration to write_parquet [#459](https://github.com/apache/datafusion-python/pull/459) (mesejo)
+- feat: add example of reading parquet from s3 [#460](https://github.com/apache/datafusion-python/pull/460) (mesejo)
+- feat: add register_avro and read_table [#461](https://github.com/apache/datafusion-python/pull/461) (mesejo)
+- feat: add missing scalar math functions [#465](https://github.com/apache/datafusion-python/pull/465) (mesejo)
+- build(deps): bump arduino/setup-protoc from 1 to 2 [#452](https://github.com/apache/datafusion-python/pull/452) (dependabot[bot])
+- Revert "build(deps): bump arduino/setup-protoc from 1 to 2 (#452)" [#474](https://github.com/apache/datafusion-python/pull/474) (viirya)
+- Minor: fix wrongly copied function description [#497](https://github.com/apache/datafusion-python/pull/497) (viirya)
+- Upgrade to Datafusion 31.0.0 [#491](https://github.com/apache/datafusion-python/pull/491) (judahrand)
+- Add `isnan` and `iszero` [#495](https://github.com/apache/datafusion-python/pull/495) (judahrand)
+
+## 30.0.0
+
+- Skipped due to a breaking change in DataFusion
+
+## 29.0.0
+
+- Skipped
+
+## [28.0.0](https://github.com/apache/datafusion-python/tree/28.0.0) (2023-07-25)
+
+**Implemented enhancements:**
+
+- feat: expose offset in python API [#437](https://github.com/apache/datafusion-python/pull/437) (cpcloud)
+
+**Merged pull requests:**
+
+- File based input utils [#433](https://github.com/apache/datafusion-python/pull/433) (jdye64)
+- Upgrade to 28.0.0-rc1 [#434](https://github.com/apache/datafusion-python/pull/434) (andygrove)
+- Introduces utility for obtaining SqlTable information from a file like location [#398](https://github.com/apache/datafusion-python/pull/398) (jdye64)
+- feat: expose offset in python API [#437](https://github.com/apache/datafusion-python/pull/437) (cpcloud)
+- Use DataFusion 28 [#439](https://github.com/apache/datafusion-python/pull/439) (andygrove)
+
+## [27.0.0](https://github.com/apache/datafusion-python/tree/27.0.0) (2023-07-03)
+
+**Merged pull requests:**
+
+- LogicalPlan.to_variant() make public [#412](https://github.com/apache/datafusion-python/pull/412) (jdye64)
+- Prepare 27.0.0 release [#423](https://github.com/apache/datafusion-python/pull/423) (andygrove)
+
+## [26.0.0](https://github.com/apache/datafusion-python/tree/26.0.0) (2023-06-11)
+
+[Full Changelog](https://github.com/apache/datafusion-python/compare/25.0.0...26.0.0)
+
+**Merged pull requests:**
+
+- Add Expr::Case when_then_else support to rex_call_operands function [#388](https://github.com/apache/datafusion-python/pull/388) (jdye64)
+- Introduce BaseSessionContext abstract class [#390](https://github.com/apache/datafusion-python/pull/390) (jdye64)
+- CRUD Schema support for `BaseSessionContext` [#392](https://github.com/apache/datafusion-python/pull/392) (jdye64)
+- CRUD Table support for `BaseSessionContext` [#394](https://github.com/apache/datafusion-python/pull/394) (jdye64)
+
+## [25.0.0](https://github.com/apache/datafusion-python/tree/25.0.0) (2023-05-23)
+
+[Full Changelog](https://github.com/apache/datafusion-python/compare/24.0.0...25.0.0)
+
+**Merged pull requests:**
+
+- Prepare 24.0.0 Release [#376](https://github.com/apache/datafusion-python/pull/376) (andygrove)
+- build(deps): bump uuid from 1.3.1 to 1.3.2 [#359](https://github.com/apache/datafusion-python/pull/359) (dependabot[bot])
+- build(deps): bump mimalloc from 0.1.36 to 0.1.37 [#361](https://github.com/apache/datafusion-python/pull/361) (dependabot[bot])
+- build(deps): bump regex-syntax from 0.6.29 to 0.7.1 [#334](https://github.com/apache/datafusion-python/pull/334) (dependabot[bot])
+- upgrade maturin to 0.15.1 [#379](https://github.com/apache/datafusion-python/pull/379) (Jimexist)
+- Expand Expr to include RexType basic support [#378](https://github.com/apache/datafusion-python/pull/378) (jdye64)
+- Add Python script for generating changelog [#383](https://github.com/apache/datafusion-python/pull/383) (andygrove)
+
+## [24.0.0](https://github.com/apache/datafusion-python/tree/24.0.0) (2023-05-09)
+
+[Full Changelog](https://github.com/apache/datafusion-python/compare/23.0.0...24.0.0)
+
+**Documentation updates:**
+
+- Fix link to user guide [#354](https://github.com/apache/datafusion-python/pull/354) (andygrove)
+
+**Merged pull requests:**
+
+- Add interface to serialize Substrait plans to Python Bytes. [#344](https://github.com/apache/datafusion-python/pull/344) (kylebrooks-8451)
+- Add partition_count property to ExecutionPlan. [#346](https://github.com/apache/datafusion-python/pull/346) (kylebrooks-8451)
+- Remove unsendable from all Rust pyclass types. [#348](https://github.com/apache/datafusion-python/pull/348) (kylebrooks-8451)
+- Fix link to user guide [#354](https://github.com/apache/datafusion-python/pull/354) (andygrove)
+- Fix SessionContext execute. [#353](https://github.com/apache/datafusion-python/pull/353) (kylebrooks-8451)
+- Pub mod expr in lib.rs [#357](https://github.com/apache/datafusion-python/pull/357) (jdye64)
+- Add benchmark derived from TPC-H [#355](https://github.com/apache/datafusion-python/pull/355) (andygrove)
+- Add db-benchmark [#365](https://github.com/apache/datafusion-python/pull/365) (andygrove)
+- First pass of documentation in mdBook [#364](https://github.com/apache/datafusion-python/pull/364) (MrPowers)
+- Add 'pub' and '#[pyo3(get, set)]' to DataTypeMap [#371](https://github.com/apache/datafusion-python/pull/371) (jdye64)
+- Fix db-benchmark [#369](https://github.com/apache/datafusion-python/pull/369) (andygrove)
+- Docs explaining how to view query plans [#373](https://github.com/apache/datafusion-python/pull/373) (andygrove)
+- Improve db-benchmark [#372](https://github.com/apache/datafusion-python/pull/372) (andygrove)
+- Make expr member of PyExpr public [#375](https://github.com/apache/datafusion-python/pull/375) (jdye64)
+
+## [23.0.0](https://github.com/apache/datafusion-python/tree/23.0.0) (2023-04-23)
+
+[Full Changelog](https://github.com/apache/datafusion-python/compare/22.0.0...23.0.0)
+
+**Merged pull requests:**
+
+- Improve API docs, README, and examples for configuring context [#321](https://github.com/apache/datafusion-python/pull/321) (andygrove)
+- Osx build linker args [#330](https://github.com/apache/datafusion-python/pull/330) (jdye64)
+- Add requirements file for python 3.11 [#332](https://github.com/apache/datafusion-python/pull/332) (r4ntix)
+- mac arm64 build [#338](https://github.com/apache/datafusion-python/pull/338) (andygrove)
+- Add conda.yaml baseline workflow file [#281](https://github.com/apache/datafusion-python/pull/281) (jdye64)
+- Prepare for 23.0.0 release [#335](https://github.com/apache/datafusion-python/pull/335) (andygrove)
+- Reuse the Tokio Runtime [#341](https://github.com/apache/datafusion-python/pull/341) (kylebrooks-8451)
+
+## [22.0.0](https://github.com/apache/datafusion-python/tree/22.0.0) (2023-04-10)
+
+[Full Changelog](https://github.com/apache/datafusion-python/compare/21.0.0...22.0.0)
+
+**Merged pull requests:**
+
+- Fix invalid build yaml [#308](https://github.com/apache/datafusion-python/pull/308) (andygrove)
+- Try fix release build [#309](https://github.com/apache/datafusion-python/pull/309) (andygrove)
+- Fix release build [#310](https://github.com/apache/datafusion-python/pull/310) (andygrove)
+- Enable datafusion-substrait protoc feature, to remove compile-time dependency on protoc [#312](https://github.com/apache/datafusion-python/pull/312) (andygrove)
+- Fix Mac/Win release builds in CI [#313](https://github.com/apache/datafusion-python/pull/313) (andygrove)
+- install protoc in docs workflow [#314](https://github.com/apache/datafusion-python/pull/314) (andygrove)
+- Fix documentation generation in CI [#315](https://github.com/apache/datafusion-python/pull/315) (andygrove)
+- Source wheel fix [#319](https://github.com/apache/datafusion-python/pull/319) (andygrove)
+
+## [21.0.0](https://github.com/apache/datafusion-python/tree/21.0.0) (2023-03-30)
+
+[Full Changelog](https://github.com/apache/datafusion-python/compare/20.0.0...21.0.0)
+
+**Merged pull requests:**
+
+- minor: Fix minor warning on unused import [#289](https://github.com/apache/datafusion-python/pull/289) (viirya)
+- feature: Implement `describe()` method [#293](https://github.com/apache/datafusion-python/pull/293) (simicd)
+- fix: Printed results not visible in debugger & notebooks [#296](https://github.com/apache/datafusion-python/pull/296) (simicd)
+- add package.include and remove wildcard dependency [#295](https://github.com/apache/datafusion-python/pull/295) (andygrove)
+- Update main branch name in docs workflow [#303](https://github.com/apache/datafusion-python/pull/303) (andygrove)
+- Upgrade to DF 21 [#301](https://github.com/apache/datafusion-python/pull/301) (andygrove)
+
+## [20.0.0](https://github.com/apache/datafusion-python/tree/20.0.0) (2023-03-17)
+
+[Full Changelog](https://github.com/apache/datafusion-python/compare/0.8.0...20.0.0)
+
+**Implemented enhancements:**
+
+- Empty relation bindings [#208](https://github.com/apache/datafusion-python/pull/208) (jdye64)
+- wrap display_name and canonical_name functions [#214](https://github.com/apache/datafusion-python/pull/214) (jdye64)
+- Add PyAlias bindings [#216](https://github.com/apache/datafusion-python/pull/216) (jdye64)
+- Add bindings for scalar_variable [#218](https://github.com/apache/datafusion-python/pull/218) (jdye64)
+- Bindings for LIKE type expressions [#220](https://github.com/apache/datafusion-python/pull/220) (jdye64)
+- Bool expr bindings [#223](https://github.com/apache/datafusion-python/pull/223) (jdye64)
+- Between bindings [#229](https://github.com/apache/datafusion-python/pull/229) (jdye64)
+- Add bindings for GetIndexedField [#227](https://github.com/apache/datafusion-python/pull/227) (jdye64)
+- Add bindings for case, cast, and trycast [#232](https://github.com/apache/datafusion-python/pull/232) (jdye64)
+- add remaining expr bindings [#233](https://github.com/apache/datafusion-python/pull/233) (jdye64)
+- feature: Additional export methods [#236](https://github.com/apache/datafusion-python/pull/236) (simicd)
+- Add Python wrapper for LogicalPlan::Union [#240](https://github.com/apache/datafusion-python/pull/240) (iajoiner)
+- feature: Create dataframe from pandas, polars, dictionary, list or pyarrow Table [#242](https://github.com/apache/datafusion-python/pull/242) (simicd)
+- Add Python wrappers for `LogicalPlan::Join` and `LogicalPlan::CrossJoin` [#246](https://github.com/apache/datafusion-python/pull/246) (iajoiner)
+- feature: Set table name from ctx functions [#260](https://github.com/apache/datafusion-python/pull/260) (simicd)
+- Explain bindings [#264](https://github.com/apache/datafusion-python/pull/264) (jdye64)
+- Extension bindings [#266](https://github.com/apache/datafusion-python/pull/266) (jdye64)
+- Subquery alias bindings [#269](https://github.com/apache/datafusion-python/pull/269) (jdye64)
+- Create memory table [#271](https://github.com/apache/datafusion-python/pull/271) (jdye64)
+- Create view bindings [#273](https://github.com/apache/datafusion-python/pull/273) (jdye64)
+- Re-export Datafusion dependencies [#277](https://github.com/apache/datafusion-python/pull/277) (jdye64)
+- Distinct bindings [#275](https://github.com/apache/datafusion-python/pull/275) (jdye64)
+- Drop table bindings [#283](https://github.com/apache/datafusion-python/pull/283) (jdye64)
+- Bindings for LogicalPlan::Repartition [#285](https://github.com/apache/datafusion-python/pull/285) (jdye64)
+- Expand Rust return type support for Arrow DataTypes in ScalarValue [#287](https://github.com/apache/datafusion-python/pull/287) (jdye64)
+
+**Documentation updates:**
+
+- docs: Example of calling Python UDF & UDAF in SQL [#258](https://github.com/apache/datafusion-python/pull/258) (simicd)
+
+**Merged pull requests:**
+
+- Minor docs updates [#210](https://github.com/apache/datafusion-python/pull/210) (andygrove)
+- Empty relation bindings [#208](https://github.com/apache/datafusion-python/pull/208) (jdye64)
+- wrap display_name and canonical_name functions [#214](https://github.com/apache/datafusion-python/pull/214) (jdye64)
+- Add PyAlias bindings [#216](https://github.com/apache/datafusion-python/pull/216) (jdye64)
+- Add bindings for scalar_variable [#218](https://github.com/apache/datafusion-python/pull/218) (jdye64)
+- Bindings for LIKE type expressions [#220](https://github.com/apache/datafusion-python/pull/220) (jdye64)
+- Bool expr bindings [#223](https://github.com/apache/datafusion-python/pull/223) (jdye64)
+- Between bindings [#229](https://github.com/apache/datafusion-python/pull/229) (jdye64)
+- Add bindings for GetIndexedField [#227](https://github.com/apache/datafusion-python/pull/227) (jdye64)
+- Add bindings for case, cast, and trycast [#232](https://github.com/apache/datafusion-python/pull/232) (jdye64)
+- add remaining expr bindings [#233](https://github.com/apache/datafusion-python/pull/233) (jdye64)
+- Pre-commit hooks [#228](https://github.com/apache/datafusion-python/pull/228) (jdye64)
+- Implement new release process [#149](https://github.com/apache/datafusion-python/pull/149) (andygrove)
+- feature: Additional export methods [#236](https://github.com/apache/datafusion-python/pull/236) (simicd)
+- Add Python wrapper for LogicalPlan::Union [#240](https://github.com/apache/datafusion-python/pull/240) (iajoiner)
+- feature: Create dataframe from pandas, polars, dictionary, list or pyarrow Table [#242](https://github.com/apache/datafusion-python/pull/242) (simicd)
+- Fix release instructions [#238](https://github.com/apache/datafusion-python/pull/238) (andygrove)
+- Add Python wrappers for `LogicalPlan::Join` and `LogicalPlan::CrossJoin` [#246](https://github.com/apache/datafusion-python/pull/246) (iajoiner)
+- docs: Example of calling Python UDF & UDAF in SQL [#258](https://github.com/apache/datafusion-python/pull/258) (simicd)
+- feature: Set table name from ctx functions [#260](https://github.com/apache/datafusion-python/pull/260) (simicd)
+- Upgrade to DataFusion 19 [#262](https://github.com/apache/datafusion-python/pull/262) (andygrove)
+- Explain bindings [#264](https://github.com/apache/datafusion-python/pull/264) (jdye64)
+- Extension bindings [#266](https://github.com/apache/datafusion-python/pull/266) (jdye64)
+- Subquery alias bindings [#269](https://github.com/apache/datafusion-python/pull/269) (jdye64)
+- Create memory table [#271](https://github.com/apache/datafusion-python/pull/271) (jdye64)
+- Create view bindings [#273](https://github.com/apache/datafusion-python/pull/273) (jdye64)
+- Re-export Datafusion dependencies [#277](https://github.com/apache/datafusion-python/pull/277) (jdye64)
+- Distinct bindings [#275](https://github.com/apache/datafusion-python/pull/275) (jdye64)
+- build(deps): bump actions/checkout from 2 to 3 [#244](https://github.com/apache/datafusion-python/pull/244) (dependabot[bot])
+- build(deps): bump actions/upload-artifact from 2 to 3 [#245](https://github.com/apache/datafusion-python/pull/245) (dependabot[bot])
+- build(deps): bump actions/download-artifact from 2 to 3 [#243](https://github.com/apache/datafusion-python/pull/243) (dependabot[bot])
+- Use DataFusion 20 [#278](https://github.com/apache/datafusion-python/pull/278) (andygrove)
+- Drop table bindings [#283](https://github.com/apache/datafusion-python/pull/283) (jdye64)
+- Bindings for LogicalPlan::Repartition [#285](https://github.com/apache/datafusion-python/pull/285) (jdye64)
+- Expand Rust return type support for Arrow DataTypes in ScalarValue [#287](https://github.com/apache/datafusion-python/pull/287) (jdye64)
+
+## [0.8.0](https://github.com/apache/datafusion-python/tree/0.8.0) (2023-02-22)
+
+[Full Changelog](https://github.com/apache/datafusion-python/compare/0.8.0-rc1...0.8.0)
+
+**Implemented enhancements:**
+
+- Add support for cuDF physical execution engine [\#202](https://github.com/apache/datafusion-python/issues/202)
+- Make it easier to create a Pandas dataframe from DataFusion query results [\#139](https://github.com/apache/datafusion-python/issues/139)
+
+**Fixed bugs:**
+
+- Build error: could not compile `thiserror` due to 2 previous errors [\#69](https://github.com/apache/datafusion-python/issues/69)
+
+**Closed issues:**
+
+- Integrate with the new `object_store` crate [\#22](https://github.com/apache/datafusion-python/issues/22)
+
+**Merged pull requests:**
+
+- Update README in preparation for 0.8 release [\#206](https://github.com/apache/datafusion-python/pull/206) ([andygrove](https://github.com/andygrove))
+- Add support for cudf as a physical execution engine [\#205](https://github.com/apache/datafusion-python/pull/205) ([jdye64](https://github.com/jdye64))
+- Run `maturin develop` instead of `cargo build` in verification script [\#200](https://github.com/apache/datafusion-python/pull/200) ([andygrove](https://github.com/andygrove))
+- Add tests for recently added functionality [\#199](https://github.com/apache/datafusion-python/pull/199) ([andygrove](https://github.com/andygrove))
+- Implement `to_pandas()` [\#197](https://github.com/apache/datafusion-python/pull/197) ([simicd](https://github.com/simicd))
+- Add Python wrapper for LogicalPlan::Sort [\#196](https://github.com/apache/datafusion-python/pull/196) ([andygrove](https://github.com/andygrove))
+- Add Python wrapper for LogicalPlan::Aggregate [\#195](https://github.com/apache/datafusion-python/pull/195) ([andygrove](https://github.com/andygrove))
+- Add Python wrapper for LogicalPlan::Limit [\#193](https://github.com/apache/datafusion-python/pull/193) ([andygrove](https://github.com/andygrove))
+- Add Python wrapper for LogicalPlan::Filter [\#192](https://github.com/apache/datafusion-python/pull/192) ([andygrove](https://github.com/andygrove))
+- Add experimental support for executing SQL with Polars and Pandas [\#190](https://github.com/apache/datafusion-python/pull/190) ([andygrove](https://github.com/andygrove))
+- Update changelog for 0.8 release [\#188](https://github.com/apache/datafusion-python/pull/188) ([andygrove](https://github.com/andygrove))
+- Add ability to execute ExecutionPlan and get a stream of RecordBatch [\#186](https://github.com/apache/datafusion-python/pull/186) ([andygrove](https://github.com/andygrove))
+- Dffield bindings [\#185](https://github.com/apache/datafusion-python/pull/185) ([jdye64](https://github.com/jdye64))
+- Add bindings for DFSchema [\#183](https://github.com/apache/datafusion-python/pull/183) ([jdye64](https://github.com/jdye64))
+- test: Window functions [\#182](https://github.com/apache/datafusion-python/pull/182) ([simicd](https://github.com/simicd))
+- Add bindings for Projection [\#180](https://github.com/apache/datafusion-python/pull/180) ([jdye64](https://github.com/jdye64))
+- Table scan bindings [\#178](https://github.com/apache/datafusion-python/pull/178) ([jdye64](https://github.com/jdye64))
+- Make session configurable [\#176](https://github.com/apache/datafusion-python/pull/176) ([andygrove](https://github.com/andygrove))
+- Upgrade to DataFusion 18.0.0 [\#175](https://github.com/apache/datafusion-python/pull/175) ([andygrove](https://github.com/andygrove))
+- Use latest DataFusion rev in preparation for DF 18 release [\#174](https://github.com/apache/datafusion-python/pull/174) ([andygrove](https://github.com/andygrove))
+- Arrow type bindings [\#173](https://github.com/apache/datafusion-python/pull/173) ([jdye64](https://github.com/jdye64))
+- Pyo3 bump [\#171](https://github.com/apache/datafusion-python/pull/171) ([jdye64](https://github.com/jdye64))
+- feature: Add additional aggregation functions [\#170](https://github.com/apache/datafusion-python/pull/170) ([simicd](https://github.com/simicd))
+- Make from_substrait_plan return DataFrame instead of LogicalPlan [\#164](https://github.com/apache/datafusion-python/pull/164) ([andygrove](https://github.com/andygrove))
+- feature: Implement count method [\#163](https://github.com/apache/datafusion-python/pull/163) ([simicd](https://github.com/simicd))
+- CI Fixes [\#162](https://github.com/apache/datafusion-python/pull/162) ([jdye64](https://github.com/jdye64))
+- Upgrade to DataFusion 17 [\#160](https://github.com/apache/datafusion-python/pull/160) ([andygrove](https://github.com/andygrove))
+- feature: Improve string representation of datafusion classes [\#159](https://github.com/apache/datafusion-python/pull/159) ([simicd](https://github.com/simicd))
+- Make PyExecutionPlan.plan public [\#156](https://github.com/apache/datafusion-python/pull/156) ([andygrove](https://github.com/andygrove))
+- Expose methods on logical and execution plans [\#155](https://github.com/apache/datafusion-python/pull/155) ([andygrove](https://github.com/andygrove))
+- Fix clippy for new Rust version [\#154](https://github.com/apache/datafusion-python/pull/154) ([andygrove](https://github.com/andygrove))
+- Add DataFrame methods for accessing plans [\#153](https://github.com/apache/datafusion-python/pull/153) ([andygrove](https://github.com/andygrove))
+- Use DataFusion rev 5238e8c97f998b4d2cb9fab85fb182f325a1a7fb [\#150](https://github.com/apache/datafusion-python/pull/150) ([andygrove](https://github.com/andygrove))
+- build\(deps\): bump async-trait from 0.1.61 to 0.1.62 [\#148](https://github.com/apache/datafusion-python/pull/148) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Rename default branch from master to main [\#147](https://github.com/apache/datafusion-python/pull/147) ([andygrove](https://github.com/andygrove))
+- Substrait bindings [\#145](https://github.com/apache/datafusion-python/pull/145) ([jdye64](https://github.com/jdye64))
+- build\(deps\): bump uuid from 0.8.2 to 1.2.2 [\#143](https://github.com/apache/datafusion-python/pull/143) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Prepare for 0.8.0 release [\#141](https://github.com/apache/datafusion-python/pull/141) ([andygrove](https://github.com/andygrove))
+- Improve README and add more examples [\#137](https://github.com/apache/datafusion-python/pull/137) ([andygrove](https://github.com/andygrove))
+- test: Expand tests for built-in functions [\#129](https://github.com/apache/datafusion-python/pull/129) ([simicd](https://github.com/simicd))
+- build\(deps\): bump object_store from 0.5.2 to 0.5.3 [\#126](https://github.com/apache/datafusion-python/pull/126) ([dependabot[bot]](https://github.com/apps/dependabot))
+- build\(deps\): bump mimalloc from 0.1.32 to 0.1.34 [\#125](https://github.com/apache/datafusion-python/pull/125) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Introduce conda directory containing datafusion-dev.yaml conda enviro… [\#124](https://github.com/apache/datafusion-python/pull/124) ([jdye64](https://github.com/jdye64))
+- build\(deps\): bump bzip2 from 0.4.3 to 0.4.4 [\#121](https://github.com/apache/datafusion-python/pull/121) ([dependabot[bot]](https://github.com/apps/dependabot))
+- build\(deps\): bump tokio from 1.23.0 to 1.24.1 [\#119](https://github.com/apache/datafusion-python/pull/119) ([dependabot[bot]](https://github.com/apps/dependabot))
+- build\(deps\): bump async-trait from 0.1.60 to 0.1.61 [\#118](https://github.com/apache/datafusion-python/pull/118) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Upgrade to DataFusion 16.0.0 [\#115](https://github.com/apache/datafusion-python/pull/115) ([andygrove](https://github.com/andygrove))
+- Bump async-trait from 0.1.57 to 0.1.60 [\#114](https://github.com/apache/datafusion-python/pull/114) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Bump object_store from 0.5.1 to 0.5.2 [\#112](https://github.com/apache/datafusion-python/pull/112) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Bump tokio from 1.21.2 to 1.23.0 [\#109](https://github.com/apache/datafusion-python/pull/109) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Add entries for publishing production \(asf-site\) and staging docs [\#107](https://github.com/apache/datafusion-python/pull/107) ([martin-g](https://github.com/martin-g))
+- Add a workflow that builds the docs and deploys them at staged or production [\#104](https://github.com/apache/datafusion-python/pull/104) ([martin-g](https://github.com/martin-g))
+- Upgrade to DataFusion 15.0.0 [\#103](https://github.com/apache/datafusion-python/pull/103) ([andygrove](https://github.com/andygrove))
+- build\(deps\): bump futures from 0.3.24 to 0.3.25 [\#102](https://github.com/apache/datafusion-python/pull/102) ([dependabot[bot]](https://github.com/apps/dependabot))
+- build\(deps\): bump pyo3 from 0.17.2 to 0.17.3 [\#101](https://github.com/apache/datafusion-python/pull/101) ([dependabot[bot]](https://github.com/apps/dependabot))
+- build\(deps\): bump mimalloc from 0.1.30 to 0.1.32 [\#98](https://github.com/apache/datafusion-python/pull/98) ([dependabot[bot]](https://github.com/apps/dependabot))
+- build\(deps\): bump rand from 0.7.3 to 0.8.5 [\#97](https://github.com/apache/datafusion-python/pull/97) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Fix GitHub actions warnings [\#95](https://github.com/apache/datafusion-python/pull/95) ([martin-g](https://github.com/martin-g))
+- Fixes \#81 - Add CI workflow for source distribution [\#93](https://github.com/apache/datafusion-python/pull/93) ([martin-g](https://github.com/martin-g))
+- post-release updates [\#91](https://github.com/apache/datafusion-python/pull/91) ([andygrove](https://github.com/andygrove))
+- Build for manylinux 2014 [\#88](https://github.com/apache/datafusion-python/pull/88) ([martin-g](https://github.com/martin-g))
+- update release readme tag [\#86](https://github.com/apache/datafusion-python/pull/86) ([Jimexist](https://github.com/Jimexist))
+- Upgrade Maturin to 0.14.2 [\#85](https://github.com/apache/datafusion-python/pull/85) ([martin-g](https://github.com/martin-g))
+- Update release instructions [\#83](https://github.com/apache/datafusion-python/pull/83) ([andygrove](https://github.com/andygrove))
+- \[Functions\] - Add python function binding to `functions` [\#73](https://github.com/apache/datafusion-python/pull/73) ([francis-du](https://github.com/francis-du))
+
+## [0.8.0-rc1](https://github.com/apache/datafusion-python/tree/0.8.0-rc1) (2023-02-17)
+
+[Full Changelog](https://github.com/apache/datafusion-python/compare/0.7.0-rc2...0.8.0-rc1)
+
+**Implemented enhancements:**
+
+- Add bindings for datafusion_common::DFField [\#184](https://github.com/apache/datafusion-python/issues/184)
+- Add bindings for DFSchema/DFSchemaRef [\#181](https://github.com/apache/datafusion-python/issues/181)
+- Add bindings for datafusion_expr Projection [\#179](https://github.com/apache/datafusion-python/issues/179)
+- Add bindings for `TableScan` struct from `datafusion_expr::TableScan` [\#177](https://github.com/apache/datafusion-python/issues/177)
+- Add a "mapping" struct for types [\#172](https://github.com/apache/datafusion-python/issues/172)
+- Improve string representation of datafusion classes \(dataframe, context, expression, ...\) [\#158](https://github.com/apache/datafusion-python/issues/158)
+- Add DataFrame count method [\#151](https://github.com/apache/datafusion-python/issues/151)
+- \[REQUEST\] Github Actions Improvements [\#146](https://github.com/apache/datafusion-python/issues/146)
+- Change default branch name from master to main [\#144](https://github.com/apache/datafusion-python/issues/144)
+- Bump pyo3 to 0.18.0 [\#140](https://github.com/apache/datafusion-python/issues/140)
+- Add script for Python linting [\#134](https://github.com/apache/datafusion-python/issues/134)
+- Add Python bindings for substrait module [\#132](https://github.com/apache/datafusion-python/issues/132)
+- Expand unit tests for built-in functions [\#128](https://github.com/apache/datafusion-python/issues/128)
+- support creating arrow-datafusion-python conda environment [\#122](https://github.com/apache/datafusion-python/issues/122)
+- Build Python source distribution in GitHub workflow [\#81](https://github.com/apache/datafusion-python/issues/81)
+- EPIC: Add all functions to python binding `functions` [\#72](https://github.com/apache/datafusion-python/issues/72)
+
+**Fixed bugs:**
+
+- Build is broken [\#161](https://github.com/apache/datafusion-python/issues/161)
+- Out of memory when sorting [\#157](https://github.com/apache/datafusion-python/issues/157)
+- window_lead test appears to be non-deterministic [\#135](https://github.com/apache/datafusion-python/issues/135)
+- Reading csv does not work [\#130](https://github.com/apache/datafusion-python/issues/130)
+- Github actions produce a lot of warnings [\#94](https://github.com/apache/datafusion-python/issues/94)
+- ASF source release tarball has wrong directory name [\#90](https://github.com/apache/datafusion-python/issues/90)
+- Python Release Build failing after upgrading to maturin 14.2 [\#87](https://github.com/apache/datafusion-python/issues/87)
+- Maturin build hangs on Linux ARM64 [\#84](https://github.com/apache/datafusion-python/issues/84)
+- Cannot install on Mac M1 from source tarball from testpypi [\#82](https://github.com/apache/datafusion-python/issues/82)
+- ImportPathMismatchError when running pytest locally [\#77](https://github.com/apache/datafusion-python/issues/77)
+
+**Closed issues:**
+
+- Publish documentation for Python bindings [\#39](https://github.com/apache/datafusion-python/issues/39)
+- Add Python binding for `approx_median` [\#32](https://github.com/apache/datafusion-python/issues/32)
+- Release version 0.7.0 [\#7](https://github.com/apache/datafusion-python/issues/7)
+
+## [0.7.0-rc2](https://github.com/apache/datafusion-python/tree/0.7.0-rc2) (2022-11-26)
+
+[Full Changelog](https://github.com/apache/datafusion-python/compare/0.7.0...0.7.0-rc2)
+
+## [Unreleased](https://github.com/datafusion-contrib/datafusion-python/tree/HEAD)
+
+[Full Changelog](https://github.com/datafusion-contrib/datafusion-python/compare/0.5.1...HEAD)
+
+**Merged pull requests:**
+
+- use \_\_getitem\_\_ for df column selection [\#41](https://github.com/datafusion-contrib/datafusion-python/pull/41) ([Jimexist](https://github.com/Jimexist))
+- fix demo in readme [\#40](https://github.com/datafusion-contrib/datafusion-python/pull/40) ([Jimexist](https://github.com/Jimexist))
+- Implement select_columns [\#39](https://github.com/datafusion-contrib/datafusion-python/pull/39) ([andygrove](https://github.com/andygrove))
+- update readme and changelog [\#38](https://github.com/datafusion-contrib/datafusion-python/pull/38) ([Jimexist](https://github.com/Jimexist))
+- Add PyDataFrame.explain [\#36](https://github.com/datafusion-contrib/datafusion-python/pull/36) ([andygrove](https://github.com/andygrove))
+- Release 0.5.0 [\#34](https://github.com/datafusion-contrib/datafusion-python/pull/34) ([Jimexist](https://github.com/Jimexist))
+- disable nightly in workflow [\#33](https://github.com/datafusion-contrib/datafusion-python/pull/33) ([Jimexist](https://github.com/Jimexist))
+- update requirements to 37 and 310, update readme [\#32](https://github.com/datafusion-contrib/datafusion-python/pull/32) ([Jimexist](https://github.com/Jimexist))
+- Add custom global allocator [\#30](https://github.com/datafusion-contrib/datafusion-python/pull/30) ([matthewmturner](https://github.com/matthewmturner))
+- Remove pandas dependency [\#25](https://github.com/datafusion-contrib/datafusion-python/pull/25) ([matthewmturner](https://github.com/matthewmturner))
+- upgrade datafusion and pyo3 [\#20](https://github.com/datafusion-contrib/datafusion-python/pull/20) ([Jimexist](https://github.com/Jimexist))
+- update maturin 0.12+ [\#17](https://github.com/datafusion-contrib/datafusion-python/pull/17) ([Jimexist](https://github.com/Jimexist))
+- Update README.md [\#16](https://github.com/datafusion-contrib/datafusion-python/pull/16) ([Jimexist](https://github.com/Jimexist))
+- apply cargo clippy --fix [\#15](https://github.com/datafusion-contrib/datafusion-python/pull/15) ([Jimexist](https://github.com/Jimexist))
+- update test workflow to include rust clippy and check [\#14](https://github.com/datafusion-contrib/datafusion-python/pull/14) ([Jimexist](https://github.com/Jimexist))
+- use maturin 0.12.6 [\#13](https://github.com/datafusion-contrib/datafusion-python/pull/13) ([Jimexist](https://github.com/Jimexist))
+- apply cargo fmt [\#12](https://github.com/datafusion-contrib/datafusion-python/pull/12) ([Jimexist](https://github.com/Jimexist))
+- use stable not nightly [\#11](https://github.com/datafusion-contrib/datafusion-python/pull/11) ([Jimexist](https://github.com/Jimexist))
+- ci: test against more compilers, setup clippy and fix clippy lints [\#9](https://github.com/datafusion-contrib/datafusion-python/pull/9) ([cpcloud](https://github.com/cpcloud))
+- Fix use of importlib.metadata and unify requirements.txt [\#8](https://github.com/datafusion-contrib/datafusion-python/pull/8) ([cpcloud](https://github.com/cpcloud))
+- Ship the Cargo.lock file in the source distribution [\#7](https://github.com/datafusion-contrib/datafusion-python/pull/7) ([cpcloud](https://github.com/cpcloud))
+- add \_\_version\_\_ attribute to datafusion object [\#3](https://github.com/datafusion-contrib/datafusion-python/pull/3) ([tfeda](https://github.com/tfeda))
+- fix ci by fixing directories [\#2](https://github.com/datafusion-contrib/datafusion-python/pull/2) ([Jimexist](https://github.com/Jimexist))
+- setup workflow [\#1](https://github.com/datafusion-contrib/datafusion-python/pull/1) ([Jimexist](https://github.com/Jimexist))
+
+## [0.5.1](https://github.com/datafusion-contrib/datafusion-python/tree/0.5.1) (2022-03-15)
+
+[Full Changelog](https://github.com/datafusion-contrib/datafusion-python/compare/0.5.1-rc1...0.5.1)
+
+## [0.5.1-rc1](https://github.com/datafusion-contrib/datafusion-python/tree/0.5.1-rc1) (2022-03-15)
+
+[Full Changelog](https://github.com/datafusion-contrib/datafusion-python/compare/0.5.0...0.5.1-rc1)
+
+## [0.5.0](https://github.com/datafusion-contrib/datafusion-python/tree/0.5.0) (2022-03-10)
+
+[Full Changelog](https://github.com/datafusion-contrib/datafusion-python/compare/0.5.0-rc2...0.5.0)
+
+## [0.5.0-rc2](https://github.com/datafusion-contrib/datafusion-python/tree/0.5.0-rc2) (2022-03-10)
+
+[Full Changelog](https://github.com/datafusion-contrib/datafusion-python/compare/0.5.0-rc1...0.5.0-rc2)
+
+**Closed issues:**
+
+- Add support for Ballista [\#37](https://github.com/datafusion-contrib/datafusion-python/issues/37)
+- Implement DataFrame.explain [\#35](https://github.com/datafusion-contrib/datafusion-python/issues/35)
+
+## [0.5.0-rc1](https://github.com/datafusion-contrib/datafusion-python/tree/0.5.0-rc1) (2022-03-09)
+
+[Full Changelog](https://github.com/datafusion-contrib/datafusion-python/compare/4c98b8e9c3c3f8e2e6a8f2d1ffcfefda344c4680...0.5.0-rc1)
+
+**Closed issues:**
+
+- Investigate exposing additional optimizations [\#28](https://github.com/datafusion-contrib/datafusion-python/issues/28)
+- Use custom allocator in Python build [\#27](https://github.com/datafusion-contrib/datafusion-python/issues/27)
+- Why is pandas a requirement? [\#24](https://github.com/datafusion-contrib/datafusion-python/issues/24)
+- Unable to build [\#18](https://github.com/datafusion-contrib/datafusion-python/issues/18)
+- Setup CI against multiple Python version [\#6](https://github.com/datafusion-contrib/datafusion-python/issues/6)
diff --git a/dev/check_crates_patch.py b/dev/check_crates_patch.py
new file mode 100644
index 000000000..74e489e1f
--- /dev/null
+++ b/dev/check_crates_patch.py
@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""Check that no Cargo.toml files contain [patch.crates-io] entries.
+
+Release builds must not depend on patched crates. During development it is
+common to temporarily patch crates-io dependencies, but those patches must
+be removed before creating a release.
+
+An empty [patch.crates-io] section is allowed.
+"""
+
+import sys
+from pathlib import Path
+
+import tomllib
+
+
+def main() -> int:
+    errors: list[str] = []
+    for cargo_toml in sorted(Path().rglob("Cargo.toml")):
+        if "target" in cargo_toml.parts:
+            continue
+        with Path.open(cargo_toml, "rb") as f:
+            data = tomllib.load(f)
+        patch = data.get("patch", {}).get("crates-io", {})
+        if patch:
+            errors.append(str(cargo_toml))
+            for name, spec in patch.items():
+                errors.append(f"  {name} = {spec}")
+
+    if errors:
+        print("ERROR: Release builds must not contain [patch.crates-io] entries.")
+        print()
+        for line in errors:
+            print(line)
+        print()
+        print("Remove all [patch.crates-io] entries before creating a release.")
+        return 1
+
+    print("OK: No [patch.crates-io] entries found.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/dev/clean.sh b/dev/clean.sh
new file mode 100755
index 000000000..0d86680e8
--- /dev/null
+++ b/dev/clean.sh
@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+# This cleans up the project by removing build artifacts and other generated files.
+
+# Function to remove a directory and print the action
+remove_dir() {
+    if [ -d "$1" ]; then
+        echo "Removing directory: $1"
+        rm -rf "$1"
+    fi
+}
+
+# Function to remove a file and print the action
+remove_file() {
+    if [ -f "$1" ]; then
+        echo "Removing file: $1"
+        rm -f "$1"
+    fi
+}
+
+# Remove .pytest_cache directory
+remove_dir .pytest_cache/
+
+# Remove target directory
+remove_dir target/
+
+# Remove any __pycache__ directories
+find python/ -type d -name "__pycache__" -print | while read -r dir; do
+    remove_dir "$dir"
+done
+
+# Remove pytest-coverage.lcov file
+# remove_file .coverage
+# remove_file pytest-coverage.lcov
+
+# Remove rust-coverage.lcov file
+# remove_file rust-coverage.lcov
+
+# Remove pyo3 files
+find python/ -type f -name '_internal.*.so' -print | while read -r file; do
+    remove_file "$file"
+done
+
+echo "Cleanup complete."
\ No newline at end of file
diff --git a/dev/create_license.py b/dev/create_license.py
index 2a67cb8fd..acbf8587c 100644
--- a/dev/create_license.py
+++ b/dev/create_license.py
@@ -20,12 +20,11 @@
 
 import json
 import subprocess
+from pathlib import Path
 
-subprocess.check_output(["cargo", "install", "cargo-license"])
 data = subprocess.check_output(
     [
-        "cargo",
-        "license",
+        "cargo-license",
         "--avoid-build-deps",
         "--avoid-dev-deps",
         "--do-not-bundle",
@@ -248,5 +247,5 @@
     result += "------------------\n\n"
     result += f"### {name} {version}\n* source: [{repository}]({repository})\n* license: {license}\n\n"
 
-with open("LICENSE.txt", "w") as f:
+with Path.open("LICENSE.txt", "w") as f:
     f.write(result)
diff --git a/dev/python_lint.sh b/dev/python_lint.sh
index 949346294..2d867f29d 100755
--- a/dev/python_lint.sh
+++ b/dev/python_lint.sh
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
@@ -21,6 +21,6 @@
 # DataFusion CI does
 
 set -e
-source venv/bin/activate
-flake8 --exclude venv --ignore=E501,W503
+source .venv/bin/activate
+flake8 --exclude venv,benchmarks/db-benchmark --ignore=E501,W503
 black --line-length 79 .
diff --git a/dev/release/README.md b/dev/release/README.md
index cec0eef5e..ed28f4aa6 100644
--- a/dev/release/README.md
+++ b/dev/release/README.md
@@ -56,33 +56,43 @@ Before creating a new release:
 - a PR should be created and merged to update the major version number of the project
 - A new release branch should be created, such as `branch-0.8`
 
-### Update CHANGELOG.md
+## Preparing a Release Candidate
 
-Define release branch (e.g. `branch-0.8`), base version tag (e.g. `0.7.0`) and future version tag (e.g. `0.9.0`). Commits
-between the base version tag and the release branch will be used to populate the changelog content.
+### Change Log
+
+We maintain a `CHANGELOG.md` so our users know what has been changed between releases.
+
+The changelog is generated using a Python script:
 
 ```bash
-# create the changelog
-CHANGELOG_GITHUB_TOKEN=<TOKEN> ./dev/release/update_change_log-datafusion-python.sh main 0.8.0 0.7.0
-# review change log / edit issues and labels if needed, rerun until you are happy with the result
-git commit -a -m 'Create changelog for release'
+$ GITHUB_TOKEN=<TOKEN> ./dev/release/generate-changelog.py 24.0.0 HEAD 25.0.0 > dev/changelog/25.0.0.md
 ```
 
-_If you see the error `"You have exceeded a secondary rate limit"` when running this script, try reducing the CPU
-allocation to slow the process down and throttle the number of GitHub requests made per minute, by modifying the
-value of the `--cpus` argument in the `update_change_log.sh` script._
+This script creates a changelog from GitHub PRs based on the labels associated with them as well as looking for
+titles starting with `feat:`, `fix:`, or `docs:` . The script will produce output similar to:
 
-You can add `invalid` or `development-process` label to exclude items from
-release notes.
+```
+Fetching list of commits between 24.0.0 and HEAD
+Fetching pull requests
+Categorizing pull requests
+Generating changelog content
+```
 
-Send a PR to get these changes merged into the release branch (e.g. `branch-0.8`). If new commits that could change the
-change log content landed in the release branch before you could merge the PR, you need to rerun the changelog update
-script to regenerate the changelog and update the PR accordingly.
+### Update the version number
 
-### Preparing a Release Candidate
+The only place you should need to update the version is in the root `Cargo.toml`.
+After updating the toml file, run `cargo update` to update the cargo lock file.
+If you do not want to update all the dependencies, you can instead run `cargo build`
+which should only update the version number for `datafusion-python`.
 
 ### Tag the Repository
 
+Commit the changes to the changelog and version.
+
+Assuming you have set up a remote to the `apache` repository rather than your personal fork,
+you need to push a tag to start the CI process for release candidates. The following assumes
+the upstream repository is called `apache`.
+
 ```bash
 git tag 0.8.0-rc1
 git push apache 0.8.0-rc1
@@ -94,42 +104,7 @@ git push apache 0.8.0-rc1
 ./dev/release/create-tarball.sh 0.8.0 1
 ```
 
-This will also create the email template to send to the mailing list. Here is an example:
-
-```
-To: dev@arrow.apache.org
-Subject: [VOTE][RUST][DataFusion] Release DataFusion Python Bindings 0.7.0 RC2
-Hi,
-
-I would like to propose a release of Apache Arrow DataFusion Python Bindings,
-version 0.7.0.
-
-This release candidate is based on commit: bd1b78b6d444b7ab172c6aec23fa58c842a592d7 [1]
-The proposed release tarball and signatures are hosted at [2].
-The changelog is located at [3].
-The Python wheels are located at [4].
-
-Please download, verify checksums and signatures, run the unit tests, and vote
-on the release. The vote will be open for at least 72 hours.
-
-Only votes from PMC members are binding, but all members of the community are
-encouraged to test the release and vote with "(non-binding)".
-
-The standard verification procedure is documented at https://github.com/apache/arrow-datafusion-python/blob/main/dev/release/README.md#verifying-release-candidates.
-
-[ ] +1 Release this as Apache Arrow DataFusion Python 0.7.0
-[ ] +0
-[ ] -1 Do not release this as Apache Arrow DataFusion Python 0.7.0 because...
-
-Here is my vote:
-
-+1
-
-[1]: https://github.com/apache/arrow-datafusion-python/tree/bd1b78b6d444b7ab172c6aec23fa58c842a592d7
-[2]: https://dist.apache.org/repos/dist/dev/arrow/apache-arrow-datafusion-python-0.7.0-rc2
-[3]: https://github.com/apache/arrow-datafusion-python/blob/bd1b78b6d444b7ab172c6aec23fa58c842a592d7/CHANGELOG.md
-[4]: https://test.pypi.org/project/datafusion/0.7.0/
-```
+This will also create the email template to send to the mailing list.
 
 Create a draft email using this content, but do not send until after completing the next step.
 
@@ -142,17 +117,25 @@ This section assumes some familiarity with publishing Python packages to PyPi. F
 
 Pushing an `rc` tag to the release branch will cause a GitHub Workflow to run that will build the Python wheels.
 
-Go to https://github.com/apache/arrow-datafusion-python/actions and look for an action named "Python Release Build"
+Go to https://github.com/apache/datafusion-python/actions and look for an action named "Python Release Build"
 that has run against the pushed tag.
 
-Click on the action and scroll down to the bottom of the page titled "Artifacts". Download `dist.zip`.
+Click on the action and scroll down to the bottom of the page titled "Artifacts". Download `dist.zip`. It should
+contain files such as:
+
+```text
+datafusion-22.0.0-cp37-abi3-macosx_10_7_x86_64.whl
+datafusion-22.0.0-cp37-abi3-macosx_11_0_arm64.whl
+datafusion-22.0.0-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl
+datafusion-22.0.0-cp37-abi3-win_amd64.whl
+```
 
 Upload the wheels to testpypi.
 
 ```bash
 unzip dist.zip
 python3 -m pip install --upgrade setuptools twine build
-python3 -m twine upload --repository testpypi datafusion-0.7.0-cp37-abi3-*.whl
+python3 -m twine upload --repository testpypi datafusion-22.0.0-cp37-abi3-*.whl
 ```
 
 When prompted for username, enter `__token__`. When prompted for a password, enter a valid GitHub Personal Access Token
@@ -162,7 +145,7 @@ When prompted for username, enter `__token__`. When prompted for a password, ent
 Download the source tarball created in the previous step, untar it, and run:
 
 ```bash
-python3 -m build
+maturin sdist
 ```
 
 This will create a file named `dist/datafusion-0.7.0.tar.gz`. Upload this to testpypi:
@@ -171,16 +154,62 @@ This will create a file named `dist/datafusion-0.7.0.tar.gz`. Upload this to tes
 python3 -m twine upload --repository testpypi dist/datafusion-0.7.0.tar.gz
 ```
 
+### Run Verify Release Candidate Workflow
+
+Before sending the vote email, run the manually triggered GitHub Actions workflow
+"Verify Release Candidate" and confirm all matrix jobs pass across the OS/architecture matrix
+(for example, Linux, macOS, and Windows runners):
+
+1. Go to https://github.com/apache/datafusion-python/actions/workflows/verify-release-candidate.yml
+2. Click "Run workflow"
+3. Set `version` to the release version (for example, `52.0.0`)
+4. Set `rc_number` to the RC number (for example, `0`)
+5. Wait for all jobs to complete successfully
+
+Include a short note in the vote email template that this workflow was run across all OS/architecture
+matrix entries and that all jobs passed.
+
+```text
+Verification note: The manually triggered "Verify Release Candidate" workflow was run for version <VERSION> and rc_number <RC_NUMBER> across all configured OS/architecture matrix entries, and all matrix jobs completed successfully.
+```
+
 ### Send the Email
 
 Send the email to start the vote.
 
 ## Verifying a Release
 
-Install the release from testpypi:
+Releases may be verified using `verify-release-candidate.sh`:
 
 ```bash
-pip install --extra-index-url https://test.pypi.org/simple/ datafusion==0.7.0
+git clone https://github.com/apache/datafusion-python.git
+dev/release/verify-release-candidate.sh 48.0.0 1
+```
+
+Alternatively, one can run unit tests against a testpypi release candidate:
+
+```bash
+# clone a fresh repo
+git clone https://github.com/apache/datafusion-python.git
+cd datafusion-python
+
+# checkout the release commit
+git fetch --tags
+git checkout 40.0.0-rc1
+git submodule update --init --recursive
+
+# create the env
+python3 -m venv .venv
+source .venv/bin/activate
+
+# install release candidate
+pip install --extra-index-url https://test.pypi.org/simple/ datafusion==40.0.0
+
+# install test dependencies
+pip install pytest numpy pytest-asyncio
+
+# run the tests
+pytest --import-mode=importlib python/tests -vv
 ```
 
 Try running one of the examples from the top-level README, or write some custom Python code to query some available
@@ -198,6 +227,14 @@ Create the source release tarball:
 ./dev/release/release-tarball.sh 0.8.0 1
 ```
 
+### Publishing Rust Crate to crates.io
+
+Some projects depend on the Rust crate directly, so we publish this to crates.io
+
+```shell
+cargo publish
+```
+
 ### Publishing Python Artifacts to PyPi
 
 Go to the Test PyPI page of Datafusion, and download
@@ -208,33 +245,59 @@ uploading them using `twine`:
 twine upload --repository pypi dist-release/*
 ```
 
-### Publish Python Artifacts to Anaconda
+### Publish Python Artifacts to conda-forge
+
+Pypi packages auto upload to conda-forge via [datafusion feedstock](https://github.com/conda-forge/datafusion-feedstock)
 
-Publishing artifacts to Anaconda is similar to PyPi. First, Download the source tarball created in the previous step and untar it.
+### Push the Release Tag
 
 ```bash
-# Assuming you have an existing conda environment named `datafusion-dev` if not see root README for instructions
-conda activate datafusion-dev
-conda build .
+git checkout 0.8.0-rc1
+git tag 0.8.0
+git push apache 0.8.0
 ```
 
-This will setup a virtual conda environment and build the artifacts inside of that virtual env. This step can take a few minutes as the entire build, host, and runtime environments are setup. Once complete a local filesystem path will be emitted for the location of the resulting package. Observe that path and copy to your clipboard.
+### Add the release to Apache Reporter
+
+Add the release to https://reporter.apache.org/addrelease.html?datafusion with a version name prefixed with `DATAFUSION-PYTHON`,
+for example `DATAFUSION-PYTHON-31.0.0`.
+
+The release information is used to generate a template for a board report (see example from Apache Arrow
+[here](https://github.com/apache/arrow/pull/14357)).
+
+### Delete old RCs and Releases
+
+See the ASF documentation on [when to archive](https://www.apache.org/legal/release-policy.html#when-to-archive)
+for more information.
 
-Ex: `/home/conda/envs/datafusion/conda-bld/linux-64/datafusion-0.7.0.tar.bz2`
+#### Deleting old release candidates from `dev` svn
 
-Now you are ready to publish this resulting package to anaconda.org. This can be accomplished in a few simple steps.
+Release candidates should be deleted once the release is published.
+
+Get a list of DataFusion release candidates:
 
 ```bash
-# First login to Anaconda with the datafusion credentials
-anaconda login
-# Upload the package
-anaconda upload /home/conda/envs/datafusion/conda-bld/linux-64/datafusion-0.7.0.tar.bz2
+svn ls https://dist.apache.org/repos/dist/dev/datafusion | grep datafusion-python
 ```
 
-### Push the Release Tag
+Delete a release candidate:
 
 ```bash
-git checkout 0.8.0-rc1
-git tag 0.8.0
-git push apache 0.8.0
+svn delete -m "delete old DataFusion RC" https://dist.apache.org/repos/dist/dev/datafusion/apache-datafusion-python-7.1.0-rc1/
+```
+
+#### Deleting old releases from `release` svn
+
+Only the latest release should be available. Delete old releases after publishing the new release.
+
+Get a list of DataFusion releases:
+
+```bash
+svn ls https://dist.apache.org/repos/dist/release/datafusion | grep datafusion-python
+```
+
+Delete a release:
+
+```bash
+svn delete -m "delete old DataFusion release" https://dist.apache.org/repos/dist/release/datafusion/datafusion-python-7.0.0
 ```
diff --git a/dev/release/check-rat-report.py b/dev/release/check-rat-report.py
index 30a01116b..72a35212e 100644
--- a/dev/release/check-rat-report.py
+++ b/dev/release/check-rat-report.py
@@ -21,17 +21,16 @@
 import re
 import sys
 import xml.etree.ElementTree as ET
+from pathlib import Path
 
 if len(sys.argv) != 3:
-    sys.stderr.write(
-        "Usage: %s exclude_globs.lst rat_report.xml\n" % sys.argv[0]
-    )
+    sys.stderr.write("Usage: %s exclude_globs.lst rat_report.xml\n" % sys.argv[0])
     sys.exit(1)
 
 exclude_globs_filename = sys.argv[1]
 xml_filename = sys.argv[2]
 
-globs = [line.strip() for line in open(exclude_globs_filename, "r")]
+globs = [line.strip() for line in Path.open(exclude_globs_filename)]
 
 tree = ET.parse(xml_filename)
 root = tree.getroot()
diff --git a/dev/release/create-tarball.sh b/dev/release/create-tarball.sh
index c05da5b75..d6ca76561 100755
--- a/dev/release/create-tarball.sh
+++ b/dev/release/create-tarball.sh
@@ -21,9 +21,9 @@
 # Adapted from https://github.com/apache/arrow-rs/tree/master/dev/release/create-tarball.sh
 
 # This script creates a signed tarball in
-# dev/dist/apache-arrow-datafusion-python-<version>-<sha>.tar.gz and uploads it to
+# dev/dist/apache-datafusion-python-<version>-<sha>.tar.gz and uploads it to
 # the "dev" area of the dist.apache.arrow repository and prepares an
-# email for sending to the dev@arrow.apache.org list for a formal
+# email for sending to the dev@datafusion.apache.org list for a formal
 # vote.
 #
 # See release/README.md for full release instructions
@@ -65,25 +65,25 @@ tag="${version}-rc${rc}"
 echo "Attempting to create ${tarball} from tag ${tag}"
 release_hash=$(cd "${SOURCE_TOP_DIR}" && git rev-list --max-count=1 ${tag})
 
-release=apache-arrow-datafusion-python-${version}
+release=apache-datafusion-python-${version}
 distdir=${SOURCE_TOP_DIR}/dev/dist/${release}-rc${rc}
 tarname=${release}.tar.gz
 tarball=${distdir}/${tarname}
-url="https://dist.apache.org/repos/dist/dev/arrow/${release}-rc${rc}"
+url="https://dist.apache.org/repos/dist/dev/datafusion/${release}-rc${rc}"
 
 if [ -z "$release_hash" ]; then
     echo "Cannot continue: unknown git tag: ${tag}"
 fi
 
-echo "Draft email for dev@arrow.apache.org mailing list"
+echo "Draft email for dev@datafusion.apache.org mailing list"
 echo ""
 echo "---------------------------------------------------------"
 cat <<MAIL
-To: dev@arrow.apache.org
-Subject: [VOTE][RUST][DataFusion] Release DataFusion Python Bindings ${version} RC${rc}
+To: dev@datafusion.apache.org
+Subject: [VOTE] Release DataFusion Python Bindings ${version} RC${rc}
 Hi,
 
-I would like to propose a release of Apache Arrow DataFusion Python Bindings,
+I would like to propose a release of the Apache DataFusion Python Bindings,
 version ${version}.
 
 This release candidate is based on commit: ${release_hash} [1]
@@ -97,19 +97,19 @@ on the release. The vote will be open for at least 72 hours.
 Only votes from PMC members are binding, but all members of the community are
 encouraged to test the release and vote with "(non-binding)".
 
-The standard verification procedure is documented at https://github.com/apache/arrow-datafusion-python/blob/main/dev/release/README.md#verifying-release-candidates.
+The standard verification procedure is documented at https://github.com/apache/datafusion-python/blob/main/dev/release/README.md#verifying-release-candidates.
 
-[ ] +1 Release this as Apache Arrow DataFusion Python ${version}
+[ ] +1 Release this as Apache DataFusion Python ${version}
 [ ] +0
-[ ] -1 Do not release this as Apache Arrow DataFusion Python ${version} because...
+[ ] -1 Do not release this as Apache DataFusion Python ${version} because...
 
 Here is my vote:
 
 +1
 
-[1]: https://github.com/apache/arrow-datafusion-python/tree/${release_hash}
+[1]: https://github.com/apache/datafusion-python/tree/${release_hash}
 [2]: ${url}
-[3]: https://github.com/apache/arrow-datafusion-python/blob/${release_hash}/CHANGELOG.md
+[3]: https://github.com/apache/datafusion-python/blob/${release_hash}/CHANGELOG.md
 [4]: https://test.pypi.org/project/datafusion/${version}/
 MAIL
 echo "---------------------------------------------------------"
@@ -127,12 +127,12 @@ echo "Signing tarball and creating checksums"
 gpg --armor --output ${tarball}.asc --detach-sig ${tarball}
 # create signing with relative path of tarball
 # so that they can be verified with a command such as
-#  shasum --check apache-arrow-datafusion-python-4.1.0-rc2.tar.gz.sha512
+#  shasum --check apache-datafusion-python-4.1.0-rc2.tar.gz.sha512
 (cd ${distdir} && shasum -a 256 ${tarname}) > ${tarball}.sha256
 (cd ${distdir} && shasum -a 512 ${tarname}) > ${tarball}.sha512
 
 
-echo "Uploading to apache dist/dev to ${url}"
-svn co --depth=empty https://dist.apache.org/repos/dist/dev/arrow ${SOURCE_TOP_DIR}/dev/dist
+echo "Uploading to datafusion dist/dev to ${url}"
+svn co --depth=empty https://dist.apache.org/repos/dist/dev/datafusion ${SOURCE_TOP_DIR}/dev/dist
 svn add ${distdir}
-svn ci -m "Apache Arrow DataFusion Python ${version} ${rc}" ${distdir}
+svn ci -m "Apache DataFusion Python ${version} ${rc}" ${distdir}
diff --git a/dev/release/generate-changelog.py b/dev/release/generate-changelog.py
new file mode 100755
index 000000000..d86736773
--- /dev/null
+++ b/dev/release/generate-changelog.py
@@ -0,0 +1,179 @@
+#!/usr/bin/env python
+
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import os
+import re
+import subprocess
+import sys
+
+from github import Github
+
+
+def print_pulls(repo_name, title, pulls) -> None:
+    if len(pulls) > 0:
+        print(f"**{title}:**")
+        print()
+        for pull, commit in pulls:
+            url = f"https://github.com/{repo_name}/pull/{pull.number}"
+            print(f"- {pull.title} [#{pull.number}]({url}) ({commit.author.login})")
+        print()
+
+
+def generate_changelog(repo, repo_name, tag1, tag2, version) -> None:
+    # get a list of commits between two tags
+    print(f"Fetching list of commits between {tag1} and {tag2}", file=sys.stderr)
+    comparison = repo.compare(tag1, tag2)
+
+    # get the pull requests for these commits
+    print("Fetching pull requests", file=sys.stderr)
+    unique_pulls = []
+    all_pulls = []
+    for commit in comparison.commits:
+        pulls = commit.get_pulls()
+        for pull in pulls:
+            # there can be multiple commits per PR if squash merge is not being used and
+            # in this case we should get all the author names, but for now just pick one
+            if pull.number not in unique_pulls:
+                unique_pulls.append(pull.number)
+                all_pulls.append((pull, commit))
+
+    # we split the pulls into categories
+    breaking = []
+    bugs = []
+    docs = []
+    enhancements = []
+    performance = []
+    other = []
+
+    # categorize the pull requests based on GitHub labels
+    print("Categorizing pull requests", file=sys.stderr)
+    for pull, commit in all_pulls:
+        # see if PR title uses Conventional Commits
+        cc_type = ""
+        cc_breaking = ""
+        parts = re.findall(r"^([a-z]+)(\([a-z]+\))?(!)?:", pull.title)
+        if len(parts) == 1:
+            parts_tuple = parts[0]
+            cc_type = parts_tuple[0]  # fix, feat, docs, chore
+            # cc_scope = parts_tuple[1]  # component within project
+            cc_breaking = parts_tuple[2] == "!"
+
+        labels = [label.name for label in pull.labels]
+        if "api change" in labels or cc_breaking:
+            breaking.append((pull, commit))
+        elif "bug" in labels or cc_type == "fix":
+            bugs.append((pull, commit))
+        elif "performance" in labels or cc_type == "perf":
+            performance.append((pull, commit))
+        elif "enhancement" in labels or cc_type == "feat":
+            enhancements.append((pull, commit))
+        elif "documentation" in labels or cc_type == "docs" or cc_type == "doc":
+            docs.append((pull, commit))
+        else:
+            other.append((pull, commit))
+
+    # produce the changelog content
+    print("Generating changelog content", file=sys.stderr)
+
+    # ASF header
+    print("""<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+-->\n""")
+
+    print(f"# Apache DataFusion Python {version} Changelog\n")
+
+    # get the number of commits
+    commit_count = subprocess.check_output(
+        f"git log --pretty=oneline {tag1}..{tag2} | wc -l", shell=True, text=True
+    ).strip()
+
+    # get number of contributors
+    contributor_count = subprocess.check_output(
+        f"git shortlog -sn {tag1}..{tag2} | wc -l", shell=True, text=True
+    ).strip()
+
+    print(
+        f"This release consists of {commit_count} commits from {contributor_count} contributors. "
+        f"See credits at the end of this changelog for more information.\n"
+    )
+
+    print_pulls(repo_name, "Breaking changes", breaking)
+    print_pulls(repo_name, "Performance related", performance)
+    print_pulls(repo_name, "Implemented enhancements", enhancements)
+    print_pulls(repo_name, "Fixed bugs", bugs)
+    print_pulls(repo_name, "Documentation updates", docs)
+    print_pulls(repo_name, "Other", other)
+
+    # show code contributions
+    credits = subprocess.check_output(
+        f"git shortlog -sn {tag1}..{tag2}", shell=True, text=True
+    ).rstrip()
+
+    print("## Credits\n")
+    print(
+        "Thank you to everyone who contributed to this release. Here is a breakdown of commits (PRs merged) "
+        "per contributor.\n"
+    )
+    print("```")
+    print(credits)
+    print("```\n")
+
+    print(
+        "Thank you also to everyone who contributed in other ways such as filing issues, reviewing "
+        "PRs, and providing feedback on this release.\n"
+    )
+
+
+def cli(args=None) -> None:
+    """Process command line arguments."""
+    if not args:
+        args = sys.argv[1:]
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("tag1", help="The previous commit or tag (e.g. 0.1.0)")
+    parser.add_argument("tag2", help="The current commit or tag (e.g. HEAD)")
+    parser.add_argument(
+        "version", help="The version number to include in the changelog"
+    )
+    args = parser.parse_args()
+
+    token = os.getenv("GITHUB_TOKEN")
+    project = "apache/datafusion-python"
+
+    g = Github(token)
+    repo = g.get_repo(project)
+    generate_changelog(repo, project, args.tag1, args.tag2, args.version)
+
+
+if __name__ == "__main__":
+    cli()
diff --git a/dev/release/rat_exclude_files.txt b/dev/release/rat_exclude_files.txt
index db5379d89..dcd5d9aac 100644
--- a/dev/release/rat_exclude_files.txt
+++ b/dev/release/rat_exclude_files.txt
@@ -42,4 +42,9 @@ Cargo.lock
 .history
 *rat.txt
 */.git
-docs.yaml
\ No newline at end of file
+.github/*
+benchmarks/tpch/queries/q*.sql
+benchmarks/tpch/create_tables.sql
+.cargo/config.toml
+**/.cargo/config.toml
+uv.lock
\ No newline at end of file
diff --git a/dev/release/release-tarball.sh b/dev/release/release-tarball.sh
index f5e8eb1bf..2b82d1bac 100755
--- a/dev/release/release-tarball.sh
+++ b/dev/release/release-tarball.sh
@@ -43,7 +43,14 @@ fi
 version=$1
 rc=$2
 
-tmp_dir=tmp-apache-arrow-datafusion-python-dist
+read -r -p "Proceed to release tarball for ${version}-rc${rc}? [y/N]: " answer
+answer=${answer:-no}
+if [ "${answer}" != "y" ]; then
+  echo "Cancelled tarball release!"
+  exit 1
+fi
+
+tmp_dir=tmp-apache-datafusion-python-dist
 
 echo "Recreate temporary directory: ${tmp_dir}"
 rm -rf ${tmp_dir}
@@ -52,23 +59,23 @@ mkdir -p ${tmp_dir}
 echo "Clone dev dist repository"
 svn \
   co \
-  https://dist.apache.org/repos/dist/dev/arrow/apache-arrow-datafusion-python-${version}-rc${rc} \
+  https://dist.apache.org/repos/dist/dev/datafusion/apache-datafusion-python-${version}-rc${rc} \
   ${tmp_dir}/dev
 
 echo "Clone release dist repository"
-svn co https://dist.apache.org/repos/dist/release/arrow ${tmp_dir}/release
+svn co https://dist.apache.org/repos/dist/release/datafusion ${tmp_dir}/release
 
 echo "Copy ${version}-rc${rc} to release working copy"
-release_version=arrow-datafusion-python-${version}
+release_version=datafusion-python-${version}
 mkdir -p ${tmp_dir}/release/${release_version}
 cp -r ${tmp_dir}/dev/* ${tmp_dir}/release/${release_version}/
 svn add ${tmp_dir}/release/${release_version}
 
 echo "Commit release"
-svn ci -m "Apache Arrow DataFusion Python ${version}" ${tmp_dir}/release
+svn ci -m "Apache DataFusion Python ${version}" ${tmp_dir}/release
 
 echo "Clean up"
 rm -rf ${tmp_dir}
 
 echo "Success! The release is available here:"
-echo "  https://dist.apache.org/repos/dist/release/arrow/${release_version}"
+echo "  https://dist.apache.org/repos/dist/release/datafusion/${release_version}"
diff --git a/dev/release/update_change_log-datafusion-python.sh b/dev/release/update_change_log-datafusion-python.sh
deleted file mode 100755
index a11447f0b..000000000
--- a/dev/release/update_change_log-datafusion-python.sh
+++ /dev/null
@@ -1,33 +0,0 @@
-#!/bin/bash
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-# Usage:
-# CHANGELOG_GITHUB_TOKEN=<TOKEN> ./update_change_log-datafusion.sh main 8.0.0 7.1.0
-# CHANGELOG_GITHUB_TOKEN=<TOKEN> ./update_change_log-datafusion.sh maint-7.x 7.1.0 7.0.0
-
-RELEASE_BRANCH=$1
-RELEASE_TAG=$2
-BASE_TAG=$3
-
-SOURCE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-${SOURCE_DIR}/update_change_log.sh \
-    "${BASE_TAG}" \
-    --future-release "${RELEASE_TAG}" \
-    --release-branch "${RELEASE_BRANCH}"
diff --git a/dev/release/update_change_log.sh b/dev/release/update_change_log.sh
deleted file mode 100755
index a0b398131..000000000
--- a/dev/release/update_change_log.sh
+++ /dev/null
@@ -1,87 +0,0 @@
-#!/bin/bash
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-# Adapted from https://github.com/apache/arrow-rs/tree/master/dev/release/update_change_log.sh
-
-# invokes the changelog generator from
-# https://github.com/github-changelog-generator/github-changelog-generator
-#
-# With the config located in
-# arrow-datafusion/.github_changelog_generator
-#
-# Usage:
-# CHANGELOG_GITHUB_TOKEN=<TOKEN> ./update_change_log.sh <PROJECT> <SINCE_TAG> <EXTRA_ARGS...>
-
-set -e
-
-SOURCE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-SOURCE_TOP_DIR="$(cd "${SOURCE_DIR}/../../" && pwd)"
-
-if [[ "$#" -lt 1 ]]; then
-    echo "USAGE: $0 SINCE_TAG EXTRA_ARGS..."
-    exit 1
-fi
-
-SINCE_TAG=$1
-shift 1
-
-OUTPUT_PATH="CHANGELOG.md"
-
-pushd ${SOURCE_TOP_DIR}
-
-# reset content in changelog
-git checkout "${SINCE_TAG}" "${OUTPUT_PATH}"
-# remove license header so github-changelog-generator has a clean base to append
-sed -i.bak '1,18d' "${OUTPUT_PATH}"
-
-docker run -it --rm \
-    --cpus "0.1" \
-    -e CHANGELOG_GITHUB_TOKEN=$CHANGELOG_GITHUB_TOKEN \
-    -v "$(pwd)":/usr/local/src/your-app \
-    githubchangeloggenerator/github-changelog-generator \
-    --user apache \
-    --project arrow-datafusion-python \
-    --since-tag "${SINCE_TAG}" \
-    --base "${OUTPUT_PATH}" \
-    --output "${OUTPUT_PATH}" \
-    "$@"
-
-sed -i.bak "s/\\\n/\n\n/" "${OUTPUT_PATH}"
-
-echo '<!---
-  Licensed to the Apache Software Foundation (ASF) under one
-  or more contributor license agreements.  See the NOTICE file
-  distributed with this work for additional information
-  regarding copyright ownership.  The ASF licenses this file
-  to you under the Apache License, Version 2.0 (the
-  "License"); you may not use this file except in compliance
-  with the License.  You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing,
-  software distributed under the License is distributed on an
-  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  KIND, either express or implied.  See the License for the
-  specific language governing permissions and limitations
-  under the License.
--->
-' | cat - "${OUTPUT_PATH}" > "${OUTPUT_PATH}".tmp
-mv "${OUTPUT_PATH}".tmp "${OUTPUT_PATH}"
diff --git a/dev/release/verify-release-candidate.sh b/dev/release/verify-release-candidate.sh
index be86f69e0..9591e0335 100755
--- a/dev/release/verify-release-candidate.sh
+++ b/dev/release/verify-release-candidate.sh
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
@@ -32,8 +32,8 @@ set -x
 set -o pipefail
 
 SOURCE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)"
-ARROW_DIR="$(dirname $(dirname ${SOURCE_DIR}))"
-ARROW_DIST_URL='https://dist.apache.org/repos/dist/dev/arrow'
+DATAFUSION_PYTHON_DIR="$(dirname $(dirname ${SOURCE_DIR}))"
+DATAFUSION_PYTHON_DIST_URL='https://dist.apache.org/repos/dist/dev/datafusion'
 
 download_dist_file() {
   curl \
@@ -41,11 +41,11 @@ download_dist_file() {
     --show-error \
     --fail \
     --location \
-    --remote-name $ARROW_DIST_URL/$1
+    --remote-name $DATAFUSION_PYTHON_DIST_URL/$1
 }
 
 download_rc_file() {
-  download_dist_file apache-arrow-datafusion-python-${VERSION}-rc${RC_NUMBER}/$1
+  download_dist_file apache-datafusion-python-${VERSION}-rc${RC_NUMBER}/$1
 }
 
 import_gpg_keys() {
@@ -89,31 +89,40 @@ verify_dir_artifact_signatures() {
 setup_tempdir() {
   cleanup() {
     if [ "${TEST_SUCCESS}" = "yes" ]; then
-      rm -fr "${ARROW_TMPDIR}"
+      rm -fr "${DATAFUSION_PYTHON_TMPDIR}"
     else
-      echo "Failed to verify release candidate. See ${ARROW_TMPDIR} for details."
+      echo "Failed to verify release candidate. See ${DATAFUSION_PYTHON_TMPDIR} for details."
     fi
   }
 
-  if [ -z "${ARROW_TMPDIR}" ]; then
-    # clean up automatically if ARROW_TMPDIR is not defined
-    ARROW_TMPDIR=$(mktemp -d -t "$1.XXXXX")
+  if [ -z "${DATAFUSION_PYTHON_TMPDIR}" ]; then
+    # clean up automatically if DATAFUSION_PYTHON_TMPDIR is not defined
+    DATAFUSION_PYTHON_TMPDIR=$(mktemp -d -t "$1.XXXXX")
     trap cleanup EXIT
   else
     # don't clean up automatically
-    mkdir -p "${ARROW_TMPDIR}"
+    mkdir -p "${DATAFUSION_PYTHON_TMPDIR}"
   fi
 }
 
 test_source_distribution() {
-  # install rust toolchain in a similar fashion like test-miniconda
+  # install rust toolchain
   export RUSTUP_HOME=$PWD/test-rustup
   export CARGO_HOME=$PWD/test-rustup
 
   curl https://sh.rustup.rs -sSf | sh -s -- -y --no-modify-path
 
-  export PATH=$RUSTUP_HOME/bin:$PATH
-  source $RUSTUP_HOME/env
+  # On Unix, rustup creates an env file. On Windows GitHub runners (MSYS bash),
+  # that file may not exist, so fall back to adding Cargo bin directly.
+  if [ -f "$CARGO_HOME/env" ]; then
+    # shellcheck disable=SC1090
+    source "$CARGO_HOME/env"
+  elif [ -f "$RUSTUP_HOME/env" ]; then
+    # shellcheck disable=SC1090
+    source "$RUSTUP_HOME/env"
+  else
+    export PATH="$CARGO_HOME/bin:$PATH"
+  fi
 
   # build and test rust
 
@@ -125,11 +134,21 @@ test_source_distribution() {
   git clone https://github.com/apache/arrow-testing.git testing
   git clone https://github.com/apache/parquet-testing.git parquet-testing
 
-  python3 -m venv venv
-  source venv/bin/activate
-  python3 -m pip install -U pip
-  python3 -m pip install -r requirements-310.txt
-  maturin develop
+  python3 -m venv .venv
+  if [ -x ".venv/bin/python" ]; then
+    VENV_PYTHON=".venv/bin/python"
+  elif [ -x ".venv/Scripts/python.exe" ]; then
+    VENV_PYTHON=".venv/Scripts/python.exe"
+  elif [ -x ".venv/Scripts/python" ]; then
+    VENV_PYTHON=".venv/Scripts/python"
+  else
+    echo "Unable to find python executable in virtual environment"
+    exit 1
+  fi
+
+  "$VENV_PYTHON" -m pip install -U pip
+  "$VENV_PYTHON" -m pip install -U maturin
+  "$VENV_PYTHON" -m maturin develop
 
   #TODO: we should really run tests here as well
   #python3 -m pytest
@@ -142,11 +161,11 @@ test_source_distribution() {
 
 TEST_SUCCESS=no
 
-setup_tempdir "arrow-${VERSION}"
-echo "Working in sandbox ${ARROW_TMPDIR}"
-cd ${ARROW_TMPDIR}
+setup_tempdir "datafusion-python-${VERSION}"
+echo "Working in sandbox ${DATAFUSION_PYTHON_TMPDIR}"
+cd ${DATAFUSION_PYTHON_TMPDIR}
 
-dist_name="apache-arrow-datafusion-python-${VERSION}"
+dist_name="apache-datafusion-python-${VERSION}"
 import_gpg_keys
 fetch_archive ${dist_name}
 tar xf ${dist_name}.tar.gz
diff --git a/dev/rust_lint.sh b/dev/rust_lint.sh
index b1285cbc3..eeb9e2302 100755
--- a/dev/rust_lint.sh
+++ b/dev/rust_lint.sh
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
diff --git a/docs/.gitignore b/docs/.gitignore
new file mode 100644
index 000000000..6e8a53b6f
--- /dev/null
+++ b/docs/.gitignore
@@ -0,0 +1,4 @@
+pokemon.csv
+yellow_trip_data.parquet
+yellow_tripdata_2021-01.parquet
+
diff --git a/docs/Makefile b/docs/Makefile
index e65c8e250..49ebae372 100644
--- a/docs/Makefile
+++ b/docs/Makefile
@@ -35,4 +35,4 @@ help:
 # Catch-all target: route all unknown targets to Sphinx using the new
 # "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
 %: Makefile
-	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
\ No newline at end of file
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) --fail-on-warning
\ No newline at end of file
diff --git a/docs/README.md b/docs/README.md
index a6f4998c8..502f1c2a1 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -19,46 +19,52 @@
 
 # DataFusion Documentation
 
-This folder contains the source content of the [python api](./source/api).
-These are both published to https://arrow.apache.org/datafusion/ 
-as part of the release process.
+This folder contains the source content of the [Python API](./source/api).
+This is published to https://datafusion.apache.org/python by a GitHub action
+when changes are merged to the main branch.
 
 ## Dependencies
 
 It's recommended to install build dependencies and build the documentation
-inside a Python virtualenv.
+inside a Python `venv` using `uv`.
 
-- Python
-- `pip install -r requirements.txt`
+To prepare building the documentation run the following on the root level of the project:
+
+```bash
+# Set up a virtual environment with the documentation dependencies
+uv sync --dev --group docs --no-install-package datafusion
+```
 
 ## Build & Preview
 
 Run the provided script to build the HTML pages.
 
 ```bash
-./build.sh
+# Build the repository
+uv run --no-project maturin develop --uv
+# Build the documentation
+uv run --no-project docs/build.sh
 ```
 
-The HTML will be generated into a `build` directory.
+The HTML will be generated into a `build` directory in `docs`.
 
 Preview the site on Linux by running this command.
 
 ```bash
-firefox build/html/index.html
+firefox docs/build/html/index.html
 ```
 
 ## Release Process
 
-The documentation is served through the
-[arrow-site](https://github.com/apache/arrow-site/) repo. To release a new
-version of the docs, follow these steps:
+This documentation is hosted at https://datafusion.apache.org/python
 
-1. Run `./build.sh` inside `docs` folder to generate the docs website inside the `build/html` folder.
-2. Clone the arrow-site repo
-3. Checkout to the `asf-site` branch (NOT `master`)
-4. Copy build artifacts into `arrow-site` repo's `datafusion` folder with a command such as
+When the PR is merged to the `main` branch of the DataFusion
+repository, a [github workflow](https://github.com/apache/datafusion-python/blob/main/.github/workflows/build.yml) which:
 
-- `cp -rT ./build/html/ ../../arrow-site/datafusion/` (doesn't work on mac)
-- `rsync -avzr ./build/html/ ../../arrow-site/datafusion/`
+1. Builds the html content
+2. Pushes the html content to the [`asf-site`](https://github.com/apache/datafusion-python/tree/asf-site) branch in this repository.
 
-5. Commit changes in `arrow-site` and send a PR.
\ No newline at end of file
+The Apache Software Foundation provides https://arrow.apache.org/,
+which serves content based on the configuration in
+[.asf.yaml](https://github.com/apache/datafusion-python/blob/main/.asf.yaml),
+which specifies the target as https://datafusion.apache.org/python.
diff --git a/docs/build.sh b/docs/build.sh
old mode 100644
new mode 100755
index 3f24f8eec..f73330323
--- a/docs/build.sh
+++ b/docs/build.sh
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
@@ -19,10 +19,23 @@
 #
 
 set -e
+
+original_dir=$(pwd)
+script_dir=$(dirname "$(realpath "$0")")
+cd "$script_dir" || exit
+
+if [ ! -f pokemon.csv ]; then
+    curl -O https://gist.githubusercontent.com/ritchie46/cac6b337ea52281aa23c049250a4ff03/raw/89a957ff3919d90e6ef2d34235e6bf22304f3366/pokemon.csv
+fi
+
+if [ ! -f yellow_tripdata_2021-01.parquet ]; then
+    curl -O https://d37ci6vzurychx.cloudfront.net/trip-data/yellow_tripdata_2021-01.parquet
+fi
+
 rm -rf build 2> /dev/null
 rm -rf temp 2> /dev/null
 mkdir temp
 cp -rf source/* temp/
-# replace relative URLs with absolute URLs
-#sed -i 's/\.\.\/\.\.\/\.\.\//https:\/\/github.com\/apache\/arrow-datafusion\/blob\/master\//g' temp/contributor-guide/index.md
-make SOURCEDIR=`pwd`/temp html
\ No newline at end of file
+make SOURCEDIR=`pwd`/temp html
+
+cd "$original_dir" || exit
diff --git a/docs/mdbook/README.md b/docs/mdbook/README.md
new file mode 100644
index 000000000..6dae6bc62
--- /dev/null
+++ b/docs/mdbook/README.md
@@ -0,0 +1,33 @@
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+# DataFusion Book
+
+This folder builds a DataFusion user guide using [mdBook](https://github.com/rust-lang/mdBook).
+
+## Build and run book locally
+
+Build the latest files with `mdbook build`.
+
+Open the book locally by running `open book/index.html`.
+
+## Install mdBook
+
+Download the `mdbook` binary or run `cargo install mdbook`.
+
+Then manually open it, so you have permissions to run it on your Mac.
+
+Add it to your path with a command like this so you can easily run the commands: `mv ~/Downloads/mdbook /Users/matthew.powers/.local/bin`.
diff --git a/datafusion/common.py b/docs/mdbook/book.toml
similarity index 85%
rename from datafusion/common.py
rename to docs/mdbook/book.toml
index dd56640a4..089cb9a97 100644
--- a/datafusion/common.py
+++ b/docs/mdbook/book.toml
@@ -15,9 +15,9 @@
 # specific language governing permissions and limitations
 # under the License.
 
-
-from ._internal import common
-
-
-def __getattr__(name):
-    return getattr(common, name)
+[book]
+authors = ["Apache Arrow <dev@arrow.apache.org>"]
+language = "en"
+multilingual = false
+src = "src"
+title = "DataFusion Book"
diff --git a/docs/mdbook/src/SUMMARY.md b/docs/mdbook/src/SUMMARY.md
new file mode 100644
index 000000000..23467ed4c
--- /dev/null
+++ b/docs/mdbook/src/SUMMARY.md
@@ -0,0 +1,25 @@
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+# Summary
+
+- [Index](./index.md)
+- [Installation](./installation.md)
+- [Quickstart](./quickstart.md)
+- [Usage](./usage/index.md)
+    - [Create a table](./usage/create-table.md)
+    - [Query a table](./usage/query-table.md)
+    - [Viewing Query Plans](./usage/query-plans.md)
\ No newline at end of file
diff --git a/docs/mdbook/src/images/datafusion-jupyterlab.png b/docs/mdbook/src/images/datafusion-jupyterlab.png
new file mode 100644
index 000000000..c4d46884e
Binary files /dev/null and b/docs/mdbook/src/images/datafusion-jupyterlab.png differ
diff --git a/docs/mdbook/src/images/plan.svg b/docs/mdbook/src/images/plan.svg
new file mode 100644
index 000000000..927147985
--- /dev/null
+++ b/docs/mdbook/src/images/plan.svg
@@ -0,0 +1,111 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+ "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<!-- Generated by graphviz version 2.43.0 (0)
+ -->
+<!-- Title: %3 Pages: 1 -->
+<svg width="1004pt" height="323pt"
+ viewBox="0.00 0.00 1004.00 323.00" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<g id="graph0" class="graph" transform="scale(1 1) rotate(0) translate(4 319)">
+<title>%3</title>
+<polygon fill="white" stroke="transparent" points="-4,4 -4,-319 1000,-319 1000,4 -4,4"/>
+<g id="clust1" class="cluster">
+<title>cluster_1</title>
+<polygon fill="none" stroke="black" points="8,-9 8,-306 494,-306 494,-9 8,-9"/>
+<text text-anchor="middle" x="251" y="-290.8" font-family="Times,serif" font-size="14.00">LogicalPlan</text>
+</g>
+<g id="clust2" class="cluster">
+<title>cluster_6</title>
+<polygon fill="none" stroke="black" points="502,-8 502,-307 988,-307 988,-8 502,-8"/>
+<text text-anchor="middle" x="745" y="-291.8" font-family="Times,serif" font-size="14.00">Detailed LogicalPlan</text>
+</g>
+<!-- 2 -->
+<g id="node1" class="node">
+<title>2</title>
+<polygon fill="none" stroke="black" points="405.5,-275 96.5,-275 96.5,-239 405.5,-239 405.5,-275"/>
+<text text-anchor="middle" x="251" y="-253.3" font-family="Times,serif" font-size="14.00">Projection: my_table.a, SUM(my_table.b)</text>
+</g>
+<!-- 3 -->
+<g id="node2" class="node">
+<title>3</title>
+<polygon fill="none" stroke="black" points="486,-201 16,-201 16,-165 486,-165 486,-201"/>
+<text text-anchor="middle" x="251" y="-179.3" font-family="Times,serif" font-size="14.00">Aggregate: groupBy=[[my_table.a]], aggr=[[SUM(my_table.b)]]</text>
+</g>
+<!-- 2&#45;&gt;3 -->
+<g id="edge1" class="edge">
+<title>2&#45;&gt;3</title>
+<path fill="none" stroke="black" d="M251,-228.72C251,-219.57 251,-209.63 251,-201.44"/>
+<polygon fill="black" stroke="black" points="247.5,-228.94 251,-238.94 254.5,-228.94 247.5,-228.94"/>
+</g>
+<!-- 4 -->
+<g id="node3" class="node">
+<title>4</title>
+<polygon fill="none" stroke="black" points="361.5,-127 140.5,-127 140.5,-91 361.5,-91 361.5,-127"/>
+<text text-anchor="middle" x="251" y="-105.3" font-family="Times,serif" font-size="14.00">Filter: my_table.a &lt; Int64(3)</text>
+</g>
+<!-- 3&#45;&gt;4 -->
+<g id="edge2" class="edge">
+<title>3&#45;&gt;4</title>
+<path fill="none" stroke="black" d="M251,-154.72C251,-145.57 251,-135.63 251,-127.44"/>
+<polygon fill="black" stroke="black" points="247.5,-154.94 251,-164.94 254.5,-154.94 247.5,-154.94"/>
+</g>
+<!-- 5 -->
+<g id="node4" class="node">
+<title>5</title>
+<polygon fill="none" stroke="black" points="332.5,-53 169.5,-53 169.5,-17 332.5,-17 332.5,-53"/>
+<text text-anchor="middle" x="251" y="-31.3" font-family="Times,serif" font-size="14.00">TableScan: my_table</text>
+</g>
+<!-- 4&#45;&gt;5 -->
+<g id="edge3" class="edge">
+<title>4&#45;&gt;5</title>
+<path fill="none" stroke="black" d="M251,-80.72C251,-71.57 251,-61.63 251,-53.44"/>
+<polygon fill="black" stroke="black" points="247.5,-80.94 251,-90.94 254.5,-80.94 247.5,-80.94"/>
+</g>
+<!-- 7 -->
+<g id="node5" class="node">
+<title>7</title>
+<polygon fill="none" stroke="black" points="921,-276 569,-276 569,-238 921,-238 921,-276"/>
+<text text-anchor="middle" x="745" y="-260.8" font-family="Times,serif" font-size="14.00">Projection: my_table.a, SUM(my_table.b)</text>
+<text text-anchor="middle" x="745" y="-245.8" font-family="Times,serif" font-size="14.00">Schema: [a:Int64;N, SUM(my_table.b):Int64;N]</text>
+</g>
+<!-- 8 -->
+<g id="node6" class="node">
+<title>8</title>
+<polygon fill="none" stroke="black" points="980,-202 510,-202 510,-164 980,-164 980,-202"/>
+<text text-anchor="middle" x="745" y="-186.8" font-family="Times,serif" font-size="14.00">Aggregate: groupBy=[[my_table.a]], aggr=[[SUM(my_table.b)]]</text>
+<text text-anchor="middle" x="745" y="-171.8" font-family="Times,serif" font-size="14.00">Schema: [a:Int64;N, SUM(my_table.b):Int64;N]</text>
+</g>
+<!-- 7&#45;&gt;8 -->
+<g id="edge4" class="edge">
+<title>7&#45;&gt;8</title>
+<path fill="none" stroke="black" d="M745,-227.57C745,-219.11 745,-210.06 745,-202.41"/>
+<polygon fill="black" stroke="black" points="741.5,-227.83 745,-237.83 748.5,-227.83 741.5,-227.83"/>
+</g>
+<!-- 9 -->
+<g id="node7" class="node">
+<title>9</title>
+<polygon fill="none" stroke="black" points="863,-128 627,-128 627,-90 863,-90 863,-128"/>
+<text text-anchor="middle" x="745" y="-112.8" font-family="Times,serif" font-size="14.00">Filter: my_table.a &lt; Int64(3)</text>
+<text text-anchor="middle" x="745" y="-97.8" font-family="Times,serif" font-size="14.00">Schema: [a:Int64;N, b:Int64;N]</text>
+</g>
+<!-- 8&#45;&gt;9 -->
+<g id="edge5" class="edge">
+<title>8&#45;&gt;9</title>
+<path fill="none" stroke="black" d="M745,-153.57C745,-145.11 745,-136.06 745,-128.41"/>
+<polygon fill="black" stroke="black" points="741.5,-153.83 745,-163.83 748.5,-153.83 741.5,-153.83"/>
+</g>
+<!-- 10 -->
+<g id="node8" class="node">
+<title>10</title>
+<polygon fill="none" stroke="black" points="863,-54 627,-54 627,-16 863,-16 863,-54"/>
+<text text-anchor="middle" x="745" y="-38.8" font-family="Times,serif" font-size="14.00">TableScan: my_table</text>
+<text text-anchor="middle" x="745" y="-23.8" font-family="Times,serif" font-size="14.00">Schema: [a:Int64;N, b:Int64;N]</text>
+</g>
+<!-- 9&#45;&gt;10 -->
+<g id="edge6" class="edge">
+<title>9&#45;&gt;10</title>
+<path fill="none" stroke="black" d="M745,-79.57C745,-71.11 745,-62.06 745,-54.41"/>
+<polygon fill="black" stroke="black" points="741.5,-79.83 745,-89.83 748.5,-79.83 741.5,-79.83"/>
+</g>
+</g>
+</svg>
diff --git a/docs/mdbook/src/index.md b/docs/mdbook/src/index.md
new file mode 100644
index 000000000..2c1d217f8
--- /dev/null
+++ b/docs/mdbook/src/index.md
@@ -0,0 +1,43 @@
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+# DataFusion Book
+
+DataFusion is a blazing fast query engine that lets you run data analyses quickly and reliably.
+
+DataFusion is written in Rust, but also exposes Python and SQL bindings, so you can easily query data in your language of choice.  You don't need to know any Rust to be a happy and productive user of DataFusion.
+
+DataFusion lets you run queries faster than pandas.  Let's compare query runtimes for a 5GB CSV file with 100 million rows of data.
+
+Take a look at a few rows of the data:
+
+```
++-------+-------+--------------+-----+-----+-------+----+----+-----------+
+| id1   | id2   | id3          | id4 | id5 | id6   | v1 | v2 | v3        |
++-------+-------+--------------+-----+-----+-------+----+----+-----------+
+| id016 | id016 | id0000042202 | 15  | 24  | 5971  | 5  | 11 | 37.211254 |
+| id039 | id045 | id0000029558 | 40  | 49  | 39457 | 5  | 4  | 48.951141 |
+| id047 | id023 | id0000071286 | 68  | 20  | 74463 | 2  | 14 | 60.469241 |
++-------+-------+--------------+-----+-----+-------+----+----+-----------+
+```
+
+Suppose you'd like to run the following query: `SELECT id1, sum(v1) AS v1 from the_table GROUP BY id1`.
+
+If you use pandas, then this query will take 43.6 seconds to execute.
+
+It only takes DataFusion 9.8 seconds to execute the same query.
+
+DataFusion is easy to use, powerful, and fast.  Let's learn more!
diff --git a/docs/mdbook/src/installation.md b/docs/mdbook/src/installation.md
new file mode 100644
index 000000000..b29f3b66b
--- /dev/null
+++ b/docs/mdbook/src/installation.md
@@ -0,0 +1,63 @@
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+# Installation
+
+DataFusion is easy to install, just like any other Python library.
+
+## Using uv
+
+If you do not yet have a virtual environment, create one:
+
+```bash
+uv venv
+```
+
+You can add datafusion to your virtual environment with the usual:
+
+```bash
+uv pip install datafusion
+```
+
+Or, to add to a project:
+
+```bash
+uv add datafusion
+```
+
+## Using pip
+
+``` bash
+pip install datafusion
+```
+
+## uv & JupyterLab setup
+
+This section explains how to install DataFusion in a uv environment with other libraries that allow for a nice Jupyter workflow.  This setup is completely optional.  These steps are only needed if you'd like to run DataFusion in a Jupyter notebook and have an interface like this:
+
+![DataFusion in Jupyter](https://github.com/MrPowers/datafusion-book/raw/main/src/images/datafusion-jupyterlab.png)
+
+Create a virtual environment with DataFusion, Jupyter, and other useful dependencies and start the desktop application.
+
+```bash
+uv venv
+uv pip install datafusion jupyterlab jupyterlab_code_formatter
+uv run jupyter lab
+```
+
+## Examples
+
+See the [DataFusion Python Examples](https://github.com/apache/arrow-datafusion-python/tree/main/examples) for a variety of Python scripts that show DataFusion in action!
diff --git a/docs/mdbook/src/quickstart.md b/docs/mdbook/src/quickstart.md
new file mode 100644
index 000000000..bba0b36ae
--- /dev/null
+++ b/docs/mdbook/src/quickstart.md
@@ -0,0 +1,77 @@
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+# DataFusion Quickstart
+
+You can easily query a DataFusion table with the Python API or with pure SQL.
+
+Let's create a small DataFrame and then run some queries with both APIs.
+
+Start by creating a DataFrame with four rows of data and two columns: `a` and `b`.
+
+```python
+from datafusion import SessionContext
+
+ctx = SessionContext()
+
+df = ctx.from_pydict({"a": [1, 2, 3, 1], "b": [4, 5, 6, 7]}, name="my_table")
+```
+
+Let's append a column to this DataFrame that adds columns `a` and `b` with the SQL API.
+
+```
+ctx.sql("select a, b, a + b as sum_a_b from my_table")
+
++---+---+---------+
+| a | b | sum_a_b |
++---+---+---------+
+| 1 | 4 | 5       |
+| 2 | 5 | 7       |
+| 3 | 6 | 9       |
+| 1 | 7 | 8       |
++---+---+---------+
+```
+
+DataFusion makes it easy to run SQL queries on DataFrames.
+
+Now let's run the same query with the DataFusion Python API:
+
+```python
+from datafusion import col
+
+df.select(
+    col("a"),
+    col("b"),
+    col("a") + col("b"),
+)
+```
+
+We get the same result as before:
+
+```
++---+---+-------------------------+
+| a | b | my_table.a + my_table.b |
++---+---+-------------------------+
+| 1 | 4 | 5                       |
+| 2 | 5 | 7                       |
+| 3 | 6 | 9                       |
+| 1 | 7 | 8                       |
++---+---+-------------------------+
+```
+
+DataFusion also allows you to query data with a well-designed Python interface.
+
+Python users have two great ways to query DataFusion tables.
diff --git a/docs/mdbook/src/usage/create-table.md b/docs/mdbook/src/usage/create-table.md
new file mode 100644
index 000000000..98870fac0
--- /dev/null
+++ b/docs/mdbook/src/usage/create-table.md
@@ -0,0 +1,59 @@
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+# DataFusion Create Table
+
+It's easy to create DataFusion tables from a variety of data sources.
+
+## Create Table from Python Dictionary
+
+Here's how to create a DataFusion table from a Python dictionary:
+
+```python
+from datafusion import SessionContext
+
+ctx = SessionContext()
+
+df = ctx.from_pydict({"a": [1, 2, 3, 1], "b": [4, 5, 6, 7]}, name="my_table")
+```
+
+Supplying the `name` parameter is optional.  You only need to name the table if you'd like to query it with the SQL API.
+
+You can also create a DataFrame without a name that can be queried with the Python API:
+
+```python
+from datafusion import SessionContext
+
+ctx = SessionContext()
+
+df = ctx.from_pydict({"a": [1, 2, 3, 1], "b": [4, 5, 6, 7]})
+```
+
+## Create Table from CSV
+
+You can read a CSV into a DataFusion DataFrame.  Here's how to read the `G1_1e8_1e2_0_0.csv` file into a table named `csv_1e8`:
+
+```python
+ctx.register_csv("csv_1e8", "G1_1e8_1e2_0_0.csv")
+```
+
+## Create Table from Parquet
+
+You can read a Parquet file into a DataFusion DataFrame.  Here's how to read the `yellow_tripdata_2021-01.parquet` file into a table named `taxi`.
+
+```python
+ctx.register_table("taxi", "yellow_tripdata_2021-01.parquet")
+```
diff --git a/docs/mdbook/src/usage/index.md b/docs/mdbook/src/usage/index.md
new file mode 100644
index 000000000..1ef4406f7
--- /dev/null
+++ b/docs/mdbook/src/usage/index.md
@@ -0,0 +1,25 @@
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+# Usage
+
+This section shows how to create DataFusion DataFrames from a variety of data sources like CSV files and Parquet files.
+
+You'll learn more about the SQL statements that are supported by DataFusion.
+
+You'll also learn about the DataFusion's Python API for querying data.
+
+The documentation will wrap up with a variety of real-world data processing tasks that are well suited for DataFusion.  The lightning-fast speed and reliable execution makes DataFusion the best technology for a variety of data processing tasks.
diff --git a/docs/mdbook/src/usage/query-plans.md b/docs/mdbook/src/usage/query-plans.md
new file mode 100644
index 000000000..a39aa9e42
--- /dev/null
+++ b/docs/mdbook/src/usage/query-plans.md
@@ -0,0 +1,170 @@
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+
+# DataFusion Query Plans
+
+DataFusion's `DataFrame` is a wrapper around a query plan. In this chapter we will learn how to view
+logical and physical query plans for DataFrames.
+
+## Sample Data
+
+Let's go ahead and create a simple DataFrame. You can do this in the Python shell or in a notebook.
+
+```python
+from datafusion import SessionContext
+
+ctx = SessionContext()
+
+df = ctx.from_pydict({"a": [1, 2, 3, 1], "b": [4, 5, 6, 7]}, name="my_table")
+```
+
+## Logical Plan
+
+Next, let's look at the logical plan for this dataframe.
+
+```python
+>>> df.logical_plan()
+TableScan: my_table
+```
+
+The logical plan here consists of a single `TableScan` operator. Let's make a more interesting plan by creating a new
+`DataFrame` representing an aggregate query with a filter.
+
+```python
+>>> df = ctx.sql("SELECT a, sum(b) FROM my_table WHERE a < 3 GROUP BY a")
+```
+
+When we view the plan for this `DataFrame` we can see that there are now four operators in the plan, each
+representing a logical transformation of the data. We start with a `TableScan` to read the data, followed by
+a `Filter` to filter out rows that do not match the filter expression, then an `Aggregate` is performed. Finally,
+a `Projection` is applied to ensure that the order of the final columns matches the `SELECT` part of the SQL query.
+
+```python
+>>> df.logical_plan()
+Projection: my_table.a, SUM(my_table.b)
+  Aggregate: groupBy=[[my_table.a]], aggr=[[SUM(my_table.b)]]
+    Filter: my_table.a < Int64(3)
+      TableScan: my_table
+```
+
+## Optimized Logical Plan
+
+DataFusion has a powerful query optimizer which will rewrite query plans to make them more efficient before they are
+executed. We can view the output of the optimized by viewint the optimized logical plan.
+
+```python
+>>> df.optimized_logical_plan()
+Aggregate: groupBy=[[my_table.a]], aggr=[[SUM(my_table.b)]]
+  Filter: my_table.a < Int64(3)
+    TableScan: my_table projection=[a, b]
+```
+
+We can see that there are two key differences compared to the unoptimized logical plan:
+
+- The `Projection` has been removed because it was redundant in this case (the output of the `Aggregatge` plan
+  already had the columns in the correct order).
+- The `TableScan` now has a projection pushed down so that it only reads the columns required to be able to execute
+  the query. In this case the table only has two columns and we referenced them both in the query, but this optimization
+  can be very effective in real-world queries against large tables.
+
+## Physical Plan
+
+Logical plans provide a representation of "what" the query should do it. Physical plans explain "how" the query
+should be executed.
+
+We can view the physical plan (also known as an execution plan) using the `execution_plan` method.
+
+```python
+>>> df.execution_plan()
+AggregateExec: mode=FinalPartitioned, gby=[a@0 as a], aggr=[SUM(my_table.b)]
+  CoalesceBatchesExec: target_batch_size=8192
+    RepartitionExec: partitioning=Hash([Column { name: "a", index: 0 }], 48), input_partitions=48
+      AggregateExec: mode=Partial, gby=[a@0 as a], aggr=[SUM(my_table.b)]
+        CoalesceBatchesExec: target_batch_size=8192
+          FilterExec: a@0 < 3
+            RepartitionExec: partitioning=RoundRobinBatch(48), input_partitions=1
+              MemoryExec: partitions=1, partition_sizes=[1]
+```
+
+The `TableScan` has now been replaced by a more specific `MemoryExec` for scanning the in-memory data. If we were
+querying a CSV file on disk then we would expect to see a `CsvExec` instead.
+
+This plan has additional operators that were not in the logical plan:
+
+- `RepartionExec` has been added so that the data can be split into partitions and processed in parallel using
+  multiple cores.
+- `CoalesceBatchesExec` will combine small batches into larger batches to ensure that processing remains efficient.
+
+The `Aggregate` operator now appears twice. This is because aggregates are performed in a two step process. Data is
+aggregated within each partition in parallel and then those results (which could contain duplicate grouping keys) are
+combined and the aggregate operations is applied again.
+
+## Creating Query Plan Diagrams
+
+DataFusion supports generating query plan diagrams in [DOT format](<https://en.wikipedia.org/wiki/DOT_(graph_description_language)>).
+
+DOT is a language for describing graphs and there are open source tools such as GraphViz that can render diagrams
+from DOT files.
+
+We can use the following code to generate a DOT file for a logical query plan.
+
+```python
+>>> diagram = df.logical_plan().display_graphviz()
+>>> with open('plan.dot', 'w') as f:
+>>>   f.write(diagram)
+```
+
+If we view the view, we will see the following content.
+
+```
+// Begin DataFusion GraphViz Plan (see https://graphviz.org)
+digraph {
+  subgraph cluster_1
+  {
+    graph[label="LogicalPlan"]
+    2[shape=box label="Projection: my_table.a, SUM(my_table.b)"]
+    3[shape=box label="Aggregate: groupBy=[[my_table.a]], aggr=[[SUM(my_table.b)]]"]
+    2 -> 3 [arrowhead=none, arrowtail=normal, dir=back]
+    4[shape=box label="Filter: my_table.a < Int64(3)"]
+    3 -> 4 [arrowhead=none, arrowtail=normal, dir=back]
+    5[shape=box label="TableScan: my_table"]
+    4 -> 5 [arrowhead=none, arrowtail=normal, dir=back]
+  }
+  subgraph cluster_6
+  {
+    graph[label="Detailed LogicalPlan"]
+    7[shape=box label="Projection: my_table.a, SUM(my_table.b)\nSchema: [a:Int64;N, SUM(my_table.b):Int64;N]"]
+    8[shape=box label="Aggregate: groupBy=[[my_table.a]], aggr=[[SUM(my_table.b)]]\nSchema: [a:Int64;N, SUM(my_table.b):Int64;N]"]
+    7 -> 8 [arrowhead=none, arrowtail=normal, dir=back]
+    9[shape=box label="Filter: my_table.a < Int64(3)\nSchema: [a:Int64;N, b:Int64;N]"]
+    8 -> 9 [arrowhead=none, arrowtail=normal, dir=back]
+    10[shape=box label="TableScan: my_table\nSchema: [a:Int64;N, b:Int64;N]"]
+    9 -> 10 [arrowhead=none, arrowtail=normal, dir=back]
+  }
+}
+// End DataFusion GraphViz Plan
+```
+
+We can use GraphViz from the command-line to convert this DOT file into an image.
+
+```bash
+dot -Tsvg plan.dot > plan.svg
+```
+
+This generates the following diagram:
+
+![Query Plan Diagram](../images/plan.svg)
diff --git a/docs/mdbook/src/usage/query-table.md b/docs/mdbook/src/usage/query-table.md
new file mode 100644
index 000000000..5e4e38001
--- /dev/null
+++ b/docs/mdbook/src/usage/query-table.md
@@ -0,0 +1,125 @@
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+# DataFusion Query Table
+
+DataFusion tables can be queried with SQL or with the Python API.
+
+Let's create a small table and show the different types of queries that can be run.
+
+```python
+df = ctx.from_pydict(
+    {
+        "first_name": ["li", "wang", "ron", "amanda"],
+        "age": [25, 75, 68, 18],
+        "country": ["china", "china", "us", "us"],
+    },
+    name="some_people",
+)
+```
+
+Here's the data in the table:
+
+```
++------------+-----+---------+
+| first_name | age | country |
++------------+-----+---------+
+| li         | 25  | china   |
+| wang       | 75  | china   |
+| ron        | 68  | us      |
+| amanda     | 18  | us      |
++------------+-----+---------+
+```
+
+## DataFusion Filter DataFrame
+
+Here's how to find all individuals that are older than 65 years old in the data with SQL:
+
+```
+ctx.sql("select * from some_people where age > 65")
+
++------------+-----+---------+
+| first_name | age | country |
++------------+-----+---------+
+| wang       | 75  | china   |
+| ron        | 68  | us      |
++------------+-----+---------+
+```
+
+Here's how to run the same query with Python:
+
+```python
+df.filter(col("age") > lit(65))
+```
+
+```
++------------+-----+---------+
+| first_name | age | country |
++------------+-----+---------+
+| wang       | 75  | china   |
+| ron        | 68  | us      |
++------------+-----+---------+
+```
+
+## DataFusion Select Columns from DataFrame
+
+Here's how to select the `first_name` and `country` columns from the DataFrame with SQL:
+
+```
+ctx.sql("select first_name, country from some_people")
+
+
++------------+---------+
+| first_name | country |
++------------+---------+
+| li         | china   |
+| wang       | china   |
+| ron        | us      |
+| amanda     | us      |
++------------+---------+
+```
+
+Here's how to run the same query with Python:
+
+```python
+df.select(col("first_name"), col("country"))
+```
+
+```
++------------+---------+
+| first_name | country |
++------------+---------+
+| li         | china   |
+| wang       | china   |
+| ron        | us      |
+| amanda     | us      |
++------------+---------+
+```
+
+## DataFusion Aggregation Query
+
+Here's how to run a group by aggregation query:
+
+```
+ctx.sql("select country, count(*) as num_people from some_people group by country")
+
++---------+------------+
+| country | num_people |
++---------+------------+
+| china   | 2          |
+| us      | 2          |
++---------+------------+
+```
diff --git a/docs/source/_static/images/2x_bgwhite_original.png b/docs/source/_static/images/2x_bgwhite_original.png
new file mode 100644
index 000000000..abb5fca6e
Binary files /dev/null and b/docs/source/_static/images/2x_bgwhite_original.png differ
diff --git a/docs/source/_static/images/DataFusion-Logo-Background-White.png b/docs/source/_static/images/DataFusion-Logo-Background-White.png
deleted file mode 100644
index 023c2373f..000000000
Binary files a/docs/source/_static/images/DataFusion-Logo-Background-White.png and /dev/null differ
diff --git a/docs/source/_static/images/DataFusion-Logo-Background-White.svg b/docs/source/_static/images/DataFusion-Logo-Background-White.svg
deleted file mode 100644
index b3bb47c5e..000000000
--- a/docs/source/_static/images/DataFusion-Logo-Background-White.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 350 170"><rect width="100%" height="105%" fill="white"/><defs><style>.cls-1{fill:none;stroke:#000;stroke-linecap:round;stroke-miterlimit:10;stroke-width:0.75px;stroke-dasharray:0.75 3;}.cls-2{fill:#f3971f;}.cls-3{fill:#f29720;}</style></defs><title>DataFUSION-Logo-Dark</title><g id="Layer_2" data-name="Layer 2" transform="translate(10 10)"><g id="logo"><path class="cls-1" d="M257.26,112.82c16,20.72,25.14,36.57,22,39.34"/><path class="cls-1" d="M184.24,37.13c6.55,4.41,15.83,12.47,26.43,23"/><path class="cls-1" d="M279.27,33.78c2.93,2.93-6.55,19.11-22,39.28"/><path class="cls-1" d="M208.83,127.75c-16.9,16.49-31,27-34,24.41"/><path class="cls-1" d="M227,19.05c3.86,0,7.25,18.31,9.11,39.88"/><path class="cls-1" d="M235.79,127.32c-1.91,19-5.12,37.24-8.75,37.24"/><path d="M0,.43H11.23a22,22,0,0,1,9.69,2.13,17.62,17.62,0,0,1,7.24,6.49A18.43,18.43,0,0,1,31,19.27a18.39,18.39,0,0,1-2.88,10.31,17.8,17.8,0,0,1-7.32,6.49,22.44,22.44,0,0,1-9.72,2.1H0ZM2.77,3.09V35.51H11a20,20,0,0,0,6.23-1,18.25,18.25,0,0,0,5.45-2.91,13.58,13.58,0,0,0,4-5.13,17.18,17.18,0,0,0,1.49-7.27,16.82,16.82,0,0,0-1.52-7.29,13.19,13.19,0,0,0-4-5.06A18.94,18.94,0,0,0,11.13,3.09Z"/><path d="M68.88,26H51.65L47,38.17H44.24L59,0H61.7L76.5,38.17H73.63ZM68,23.58,60.21,3.71,52.57,23.58Z"/><path d="M112.87,3.09H100.35V38.17H97.59V3.09H85.5V.43h27.37Z"/><path d="M146.45,26H129.21l-4.68,12.19h-2.72L136.56,0h2.71l14.8,38.17H151.2Zm-.93-2.4L137.78,3.71l-7.64,19.87Z"/><path d="M35.64,62.68H6.7a1.2,1.2,0,0,0-1.2,1.2V89.33a1.2,1.2,0,0,0,1.2,1.2H27.78a1.2,1.2,0,0,1,1.2,1.2v2.48a1.2,1.2,0,0,1-1.2,1.2H6.7a1.2,1.2,0,0,0-1.2,1.2v30.75a1,1,0,0,1-1,1H1.3a1,1,0,0,1-1-1V58.9a1.2,1.2,0,0,1,1.2-1.2h34.1a1.21,1.21,0,0,1,1.21,1.2v2.57A1.21,1.21,0,0,1,35.64,62.68Z"/><path d="M104,57.7a.94.94,0,0,1,1,.95v45q-.1,11.83-8,19.35t-19.85,7.51q-12.14,0-19.95-7.46t-7.91-19.5V58.65a1,1,0,0,1,1-.95h3.18a1,1,0,0,1,.95.95v45a21.46,21.46,0,0,0,6.61,15.76q6.42,6.12,16.17,6.12a22.55,22.55,0,0,0,16.12-6.12q6.47-6.11,6.57-15.76v-45a.94.94,0,0,1,.94-.95Z"/><path d="M139.56,55.41a29,29,0,0,1,13.79,3.05,1.09,1.09,0,0,1,.42,1.48l-1.3,2.37a1.1,1.1,0,0,1-1.38.48,31.23,31.23,0,0,0-11.93-2.5q-7.66,0-11.94,3.77A12.45,12.45,0,0,0,123,73.87a12.09,12.09,0,0,0,.5,3.62,8.63,8.63,0,0,0,1.85,3.18c.9,1,1.69,1.88,2.36,2.58a13.84,13.84,0,0,0,3.41,2.31l3.6,1.9,4.18,2.19,4,2.08q7.9,4.08,11.78,8.2t4,11.6q.1,9-6.61,14a26.07,26.07,0,0,1-16,5,36.05,36.05,0,0,1-10.7-1.69,37.09,37.09,0,0,1-7.41-3.07,1.1,1.1,0,0,1-.36-1.56L119,122a1.08,1.08,0,0,1,1.41-.35,33.62,33.62,0,0,0,16.54,4A20.46,20.46,0,0,0,148.32,122q5-3.5,4.87-10.47a13,13,0,0,0-1.19-5.19,12,12,0,0,0-3.37-4.13,31.66,31.66,0,0,0-4.27-3L138.73,96l-5.63-3.21-5.63-3.2a25.57,25.57,0,0,1-4.82-3.67,16,16,0,0,1-3.78-5.33,16.21,16.21,0,0,1-1.3-6.56q0-8.86,6.32-13.73T139.56,55.41Z"/><path d="M175,128.24h-3a1.09,1.09,0,0,1-1.09-1.09V58.79A1.09,1.09,0,0,1,172,57.7h3a1.09,1.09,0,0,1,1.09,1.09v68.36A1.09,1.09,0,0,1,175,128.24Z"/><path class="cls-2" d="M227,55.41a39.08,39.08,0,0,1,20.14,5.67A37.52,37.52,0,0,1,256,68.35,33.31,33.31,0,0,1,262.21,79a39.44,39.44,0,0,1,2.38,13.93q-.09,15.42-9.65,25.67Q244.31,130.23,227,130.53a39.35,39.35,0,0,1-10.05-1.34,39.75,39.75,0,0,1-18.85-11.7,33.13,33.13,0,0,1-6.22-10.64,39.18,39.18,0,0,1-2.39-13.93q0-16.11,10.79-26.81T227,55.41Zm0,4.68a32.37,32.37,0,0,0-14.18,3A27.74,27.74,0,0,0,202.71,71a37.51,37.51,0,0,0-5.77,10.5,33.82,33.82,0,0,0-2,11.39q0,14.13,9.05,23.53t23,9.4A31.48,31.48,0,0,0,244.35,121a30.34,30.34,0,0,0,11.14-12.24,35.59,35.59,0,0,0,3.63-15.87q0-14.33-9.05-23.53T227,60.09Z"/><path d="M328.12,128.24h-3.51a1.11,1.11,0,0,1-.9-.47L283.84,69.5a1.08,1.08,0,0,0-2,.61v57a1.09,1.09,0,0,1-1.09,1.09h-2.7a1.09,1.09,0,0,1-1.09-1.09V58.79a1.09,1.09,0,0,1,1.09-1.09h3.14a1.1,1.1,0,0,1,.89.47l40.25,58.49a1.09,1.09,0,0,0,2-.62V58.79a1.09,1.09,0,0,1,1.09-1.09h2.69a1.09,1.09,0,0,1,1.09,1.09v68.36A1.09,1.09,0,0,1,328.12,128.24Z"/><path d="M173.49,30.7a3.21,3.21,0,0,1,2.63.9,3.61,3.61,0,0,1,.95,2.59,3.34,3.34,0,0,1-1,2.48,3.46,3.46,0,0,1-2.58,1,3.52,3.52,0,0,1-2.49-6A3.38,3.38,0,0,1,173.49,30.7Z"/><path d="M279.46,152.37a2.92,2.92,0,0,1-2.49.42,11.78,11.78,0,0,1-2.29-.74,31.34,31.34,0,0,1-4.15-2.26,91.5,91.5,0,0,1-7.65-5.46c-4.92-3.86-9.58-8-14.16-12.28-9.15-8.5-17.79-17.52-26.19-26.75s-16.44-18.79-24.14-28.62q-5.73-7.41-11.08-15.11a156.2,156.2,0,0,1-9.82-16,.46.46,0,0,1,.81-.44h0c1.56,2.69,3.23,5.3,4.94,7.89s3.52,5.12,5.34,7.64c3.62,5,7.43,10,11.29,14.84,7.7,9.76,15.82,19.19,24.08,28.5S240.84,122.3,249.76,131c4.47,4.32,9.06,8.52,13.83,12.49a91.19,91.19,0,0,0,7.41,5.61,34.64,34.64,0,0,0,4,2.32,11.28,11.28,0,0,0,2.12.78,2.38,2.38,0,0,0,2-.21h0a.29.29,0,0,1,.4,0A.28.28,0,0,1,279.46,152.37Z"/><path d="M279.18,33.88a2.64,2.64,0,0,0-2.29-.18,11.63,11.63,0,0,0-2.3.92,36.9,36.9,0,0,0-4.29,2.61c-2.76,1.91-5.38,4-7.94,6.21-5.13,4.36-10.06,9-14.86,13.69-9.56,9.5-18.83,19.3-27.69,29.46s-17.56,20.47-25.69,31.22c-4.1,5.34-8.07,10.79-11.74,16.43-1.83,2.82-3.62,5.67-5.17,8.64a37.25,37.25,0,0,0-2.06,4.56,12.64,12.64,0,0,0-.62,2.38A2.52,2.52,0,0,0,175,152h0a.24.24,0,0,1,0,.33.22.22,0,0,1-.31,0,2.08,2.08,0,0,1-.66-1.23,4.34,4.34,0,0,1-.05-1.34,11.94,11.94,0,0,1,.53-2.54,37.13,37.13,0,0,1,1.92-4.75,98.74,98.74,0,0,1,4.91-8.91c3.57-5.77,7.44-11.33,11.43-16.8s8.21-10.76,12.48-16,8.63-10.42,13.14-15.46,9.07-10,13.74-14.92,9.44-9.69,14.37-14.33,10-9.18,15.24-13.41a100.81,100.81,0,0,1,8.22-6,36.53,36.53,0,0,1,4.45-2.5,12.69,12.69,0,0,1,2.43-.84,2.92,2.92,0,0,1,2.56.36.14.14,0,1,1-.17.21Z"/><path d="M227,19.35a3.59,3.59,0,0,0-2,.84,9.09,9.09,0,0,0-1.47,1.73,20.85,20.85,0,0,0-2.11,4.16,62.3,62.3,0,0,0-2.7,9,163.56,163.56,0,0,0-3.13,18.7,318.24,318.24,0,0,0-2,37.93q0,9.51.52,19c.32,6.33.81,12.65,1.54,18.94a171.5,171.5,0,0,0,3,18.75,66.25,66.25,0,0,0,2.7,9.08,22.89,22.89,0,0,0,2.08,4.21c.21.34.47.63.69.94a10.71,10.71,0,0,0,.81.84,4.11,4.11,0,0,0,1,.6,2.22,2.22,0,0,0,.52.2.72.72,0,0,1,.56.23h0a0,0,0,0,1,0,0h0a.74.74,0,0,1-.63.06,1.94,1.94,0,0,1-.59-.19,4.82,4.82,0,0,1-1.07-.64,10.1,10.1,0,0,1-.87-.86c-.25-.32-.53-.62-.75-.95a23.42,23.42,0,0,1-2.26-4.25,65.38,65.38,0,0,1-3-9.1,171.4,171.4,0,0,1-3.62-18.78c-.88-6.31-1.51-12.65-2-19s-.64-12.73-.68-19.1.18-12.75.55-19.11.9-12.72,1.78-19a164.9,164.9,0,0,1,3.56-18.81,64.19,64.19,0,0,1,3.07-9.11,21.75,21.75,0,0,1,2.35-4.24,9.39,9.39,0,0,1,1.7-1.81,4.19,4.19,0,0,1,2.4-.88.28.28,0,0,1,.29.29.29.29,0,0,1-.27.3Z"/><path class="cls-3" d="M173.48,29.89a4,4,0,0,1,3.25,1.1,4.46,4.46,0,0,1,1.17,3.2,4.16,4.16,0,0,1-1.23,3.07,4.33,4.33,0,0,1-3.19,1.23,4.3,4.3,0,1,1,0-8.6Z"/></g></g></svg>
\ No newline at end of file
diff --git a/docs/source/_static/images/DataFusion-Logo-Dark.png b/docs/source/_static/images/DataFusion-Logo-Dark.png
deleted file mode 100644
index cc60f12a0..000000000
Binary files a/docs/source/_static/images/DataFusion-Logo-Dark.png and /dev/null differ
diff --git a/docs/source/_static/images/DataFusion-Logo-Dark.svg b/docs/source/_static/images/DataFusion-Logo-Dark.svg
deleted file mode 100644
index e16f24443..000000000
--- a/docs/source/_static/images/DataFusion-Logo-Dark.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 329.21 164.93"><defs><style>.cls-1{fill:none;stroke:#000;stroke-linecap:round;stroke-miterlimit:10;stroke-width:0.75px;stroke-dasharray:0.75 3;}.cls-2{fill:#f3971f;}.cls-3{fill:#f29720;}</style></defs><title>DataFUSION-Logo-Dark</title><g id="Layer_2" data-name="Layer 2"><g id="logo"><path class="cls-1" d="M257.26,112.82c16,20.72,25.14,36.57,22,39.34"/><path class="cls-1" d="M184.24,37.13c6.55,4.41,15.83,12.47,26.43,23"/><path class="cls-1" d="M279.27,33.78c2.93,2.93-6.55,19.11-22,39.28"/><path class="cls-1" d="M208.83,127.75c-16.9,16.49-31,27-34,24.41"/><path class="cls-1" d="M227,19.05c3.86,0,7.25,18.31,9.11,39.88"/><path class="cls-1" d="M235.79,127.32c-1.91,19-5.12,37.24-8.75,37.24"/><path d="M0,.43H11.23a22,22,0,0,1,9.69,2.13,17.62,17.62,0,0,1,7.24,6.49A18.43,18.43,0,0,1,31,19.27a18.39,18.39,0,0,1-2.88,10.31,17.8,17.8,0,0,1-7.32,6.49,22.44,22.44,0,0,1-9.72,2.1H0ZM2.77,3.09V35.51H11a20,20,0,0,0,6.23-1,18.25,18.25,0,0,0,5.45-2.91,13.58,13.58,0,0,0,4-5.13,17.18,17.18,0,0,0,1.49-7.27,16.82,16.82,0,0,0-1.52-7.29,13.19,13.19,0,0,0-4-5.06A18.94,18.94,0,0,0,11.13,3.09Z"/><path d="M68.88,26H51.65L47,38.17H44.24L59,0H61.7L76.5,38.17H73.63ZM68,23.58,60.21,3.71,52.57,23.58Z"/><path d="M112.87,3.09H100.35V38.17H97.59V3.09H85.5V.43h27.37Z"/><path d="M146.45,26H129.21l-4.68,12.19h-2.72L136.56,0h2.71l14.8,38.17H151.2Zm-.93-2.4L137.78,3.71l-7.64,19.87Z"/><path d="M35.64,62.68H6.7a1.2,1.2,0,0,0-1.2,1.2V89.33a1.2,1.2,0,0,0,1.2,1.2H27.78a1.2,1.2,0,0,1,1.2,1.2v2.48a1.2,1.2,0,0,1-1.2,1.2H6.7a1.2,1.2,0,0,0-1.2,1.2v30.75a1,1,0,0,1-1,1H1.3a1,1,0,0,1-1-1V58.9a1.2,1.2,0,0,1,1.2-1.2h34.1a1.21,1.21,0,0,1,1.21,1.2v2.57A1.21,1.21,0,0,1,35.64,62.68Z"/><path d="M104,57.7a.94.94,0,0,1,1,.95v45q-.1,11.83-8,19.35t-19.85,7.51q-12.14,0-19.95-7.46t-7.91-19.5V58.65a1,1,0,0,1,1-.95h3.18a1,1,0,0,1,.95.95v45a21.46,21.46,0,0,0,6.61,15.76q6.42,6.12,16.17,6.12a22.55,22.55,0,0,0,16.12-6.12q6.47-6.11,6.57-15.76v-45a.94.94,0,0,1,.94-.95Z"/><path d="M139.56,55.41a29,29,0,0,1,13.79,3.05,1.09,1.09,0,0,1,.42,1.48l-1.3,2.37a1.1,1.1,0,0,1-1.38.48,31.23,31.23,0,0,0-11.93-2.5q-7.66,0-11.94,3.77A12.45,12.45,0,0,0,123,73.87a12.09,12.09,0,0,0,.5,3.62,8.63,8.63,0,0,0,1.85,3.18c.9,1,1.69,1.88,2.36,2.58a13.84,13.84,0,0,0,3.41,2.31l3.6,1.9,4.18,2.19,4,2.08q7.9,4.08,11.78,8.2t4,11.6q.1,9-6.61,14a26.07,26.07,0,0,1-16,5,36.05,36.05,0,0,1-10.7-1.69,37.09,37.09,0,0,1-7.41-3.07,1.1,1.1,0,0,1-.36-1.56L119,122a1.08,1.08,0,0,1,1.41-.35,33.62,33.62,0,0,0,16.54,4A20.46,20.46,0,0,0,148.32,122q5-3.5,4.87-10.47a13,13,0,0,0-1.19-5.19,12,12,0,0,0-3.37-4.13,31.66,31.66,0,0,0-4.27-3L138.73,96l-5.63-3.21-5.63-3.2a25.57,25.57,0,0,1-4.82-3.67,16,16,0,0,1-3.78-5.33,16.21,16.21,0,0,1-1.3-6.56q0-8.86,6.32-13.73T139.56,55.41Z"/><path d="M175,128.24h-3a1.09,1.09,0,0,1-1.09-1.09V58.79A1.09,1.09,0,0,1,172,57.7h3a1.09,1.09,0,0,1,1.09,1.09v68.36A1.09,1.09,0,0,1,175,128.24Z"/><path class="cls-2" d="M227,55.41a39.08,39.08,0,0,1,20.14,5.67A37.52,37.52,0,0,1,256,68.35,33.31,33.31,0,0,1,262.21,79a39.44,39.44,0,0,1,2.38,13.93q-.09,15.42-9.65,25.67Q244.31,130.23,227,130.53a39.35,39.35,0,0,1-10.05-1.34,39.75,39.75,0,0,1-18.85-11.7,33.13,33.13,0,0,1-6.22-10.64,39.18,39.18,0,0,1-2.39-13.93q0-16.11,10.79-26.81T227,55.41Zm0,4.68a32.37,32.37,0,0,0-14.18,3A27.74,27.74,0,0,0,202.71,71a37.51,37.51,0,0,0-5.77,10.5,33.82,33.82,0,0,0-2,11.39q0,14.13,9.05,23.53t23,9.4A31.48,31.48,0,0,0,244.35,121a30.34,30.34,0,0,0,11.14-12.24,35.59,35.59,0,0,0,3.63-15.87q0-14.33-9.05-23.53T227,60.09Z"/><path d="M328.12,128.24h-3.51a1.11,1.11,0,0,1-.9-.47L283.84,69.5a1.08,1.08,0,0,0-2,.61v57a1.09,1.09,0,0,1-1.09,1.09h-2.7a1.09,1.09,0,0,1-1.09-1.09V58.79a1.09,1.09,0,0,1,1.09-1.09h3.14a1.1,1.1,0,0,1,.89.47l40.25,58.49a1.09,1.09,0,0,0,2-.62V58.79a1.09,1.09,0,0,1,1.09-1.09h2.69a1.09,1.09,0,0,1,1.09,1.09v68.36A1.09,1.09,0,0,1,328.12,128.24Z"/><path d="M173.49,30.7a3.21,3.21,0,0,1,2.63.9,3.61,3.61,0,0,1,.95,2.59,3.34,3.34,0,0,1-1,2.48,3.46,3.46,0,0,1-2.58,1,3.52,3.52,0,0,1-2.49-6A3.38,3.38,0,0,1,173.49,30.7Z"/><path d="M279.46,152.37a2.92,2.92,0,0,1-2.49.42,11.78,11.78,0,0,1-2.29-.74,31.34,31.34,0,0,1-4.15-2.26,91.5,91.5,0,0,1-7.65-5.46c-4.92-3.86-9.58-8-14.16-12.28-9.15-8.5-17.79-17.52-26.19-26.75s-16.44-18.79-24.14-28.62q-5.73-7.41-11.08-15.11a156.2,156.2,0,0,1-9.82-16,.46.46,0,0,1,.81-.44h0c1.56,2.69,3.23,5.3,4.94,7.89s3.52,5.12,5.34,7.64c3.62,5,7.43,10,11.29,14.84,7.7,9.76,15.82,19.19,24.08,28.5S240.84,122.3,249.76,131c4.47,4.32,9.06,8.52,13.83,12.49a91.19,91.19,0,0,0,7.41,5.61,34.64,34.64,0,0,0,4,2.32,11.28,11.28,0,0,0,2.12.78,2.38,2.38,0,0,0,2-.21h0a.29.29,0,0,1,.4,0A.28.28,0,0,1,279.46,152.37Z"/><path d="M279.18,33.88a2.64,2.64,0,0,0-2.29-.18,11.63,11.63,0,0,0-2.3.92,36.9,36.9,0,0,0-4.29,2.61c-2.76,1.91-5.38,4-7.94,6.21-5.13,4.36-10.06,9-14.86,13.69-9.56,9.5-18.83,19.3-27.69,29.46s-17.56,20.47-25.69,31.22c-4.1,5.34-8.07,10.79-11.74,16.43-1.83,2.82-3.62,5.67-5.17,8.64a37.25,37.25,0,0,0-2.06,4.56,12.64,12.64,0,0,0-.62,2.38A2.52,2.52,0,0,0,175,152h0a.24.24,0,0,1,0,.33.22.22,0,0,1-.31,0,2.08,2.08,0,0,1-.66-1.23,4.34,4.34,0,0,1-.05-1.34,11.94,11.94,0,0,1,.53-2.54,37.13,37.13,0,0,1,1.92-4.75,98.74,98.74,0,0,1,4.91-8.91c3.57-5.77,7.44-11.33,11.43-16.8s8.21-10.76,12.48-16,8.63-10.42,13.14-15.46,9.07-10,13.74-14.92,9.44-9.69,14.37-14.33,10-9.18,15.24-13.41a100.81,100.81,0,0,1,8.22-6,36.53,36.53,0,0,1,4.45-2.5,12.69,12.69,0,0,1,2.43-.84,2.92,2.92,0,0,1,2.56.36.14.14,0,1,1-.17.21Z"/><path d="M227,19.35a3.59,3.59,0,0,0-2,.84,9.09,9.09,0,0,0-1.47,1.73,20.85,20.85,0,0,0-2.11,4.16,62.3,62.3,0,0,0-2.7,9,163.56,163.56,0,0,0-3.13,18.7,318.24,318.24,0,0,0-2,37.93q0,9.51.52,19c.32,6.33.81,12.65,1.54,18.94a171.5,171.5,0,0,0,3,18.75,66.25,66.25,0,0,0,2.7,9.08,22.89,22.89,0,0,0,2.08,4.21c.21.34.47.63.69.94a10.71,10.71,0,0,0,.81.84,4.11,4.11,0,0,0,1,.6,2.22,2.22,0,0,0,.52.2.72.72,0,0,1,.56.23h0a0,0,0,0,1,0,0h0a.74.74,0,0,1-.63.06,1.94,1.94,0,0,1-.59-.19,4.82,4.82,0,0,1-1.07-.64,10.1,10.1,0,0,1-.87-.86c-.25-.32-.53-.62-.75-.95a23.42,23.42,0,0,1-2.26-4.25,65.38,65.38,0,0,1-3-9.1,171.4,171.4,0,0,1-3.62-18.78c-.88-6.31-1.51-12.65-2-19s-.64-12.73-.68-19.1.18-12.75.55-19.11.9-12.72,1.78-19a164.9,164.9,0,0,1,3.56-18.81,64.19,64.19,0,0,1,3.07-9.11,21.75,21.75,0,0,1,2.35-4.24,9.39,9.39,0,0,1,1.7-1.81,4.19,4.19,0,0,1,2.4-.88.28.28,0,0,1,.29.29.29.29,0,0,1-.27.3Z"/><path class="cls-3" d="M173.48,29.89a4,4,0,0,1,3.25,1.1,4.46,4.46,0,0,1,1.17,3.2,4.16,4.16,0,0,1-1.23,3.07,4.33,4.33,0,0,1-3.19,1.23,4.3,4.3,0,1,1,0-8.6Z"/></g></g></svg>
\ No newline at end of file
diff --git a/docs/source/_static/images/DataFusion-Logo-Light.png b/docs/source/_static/images/DataFusion-Logo-Light.png
deleted file mode 100644
index 8992213b0..000000000
Binary files a/docs/source/_static/images/DataFusion-Logo-Light.png and /dev/null differ
diff --git a/docs/source/_static/images/DataFusion-Logo-Light.svg b/docs/source/_static/images/DataFusion-Logo-Light.svg
deleted file mode 100644
index b3bef2193..000000000
--- a/docs/source/_static/images/DataFusion-Logo-Light.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 329.21 164.93"><defs><style>.cls-1{fill:none;stroke:#fff;stroke-linecap:round;stroke-miterlimit:10;stroke-width:0.75px;stroke-dasharray:0.75 3;}.cls-2{fill:#fff;}.cls-3{fill:#f3971f;}.cls-4{fill:#f29720;}</style></defs><title>DataFUSION-Logo-Light</title><g id="Layer_2" data-name="Layer 2"><g id="logo"><path class="cls-1" d="M257.26,112.82c16,20.72,25.14,36.57,22,39.34"/><path class="cls-1" d="M184.24,37.13c6.55,4.41,15.83,12.47,26.43,23"/><path class="cls-1" d="M279.27,33.78c2.93,2.93-6.55,19.11-22,39.28"/><path class="cls-1" d="M208.83,127.75c-16.9,16.49-31,27-34,24.41"/><path class="cls-1" d="M227,19.05c3.86,0,7.25,18.31,9.11,39.88"/><path class="cls-1" d="M235.79,127.32c-1.91,19-5.12,37.24-8.75,37.24"/><path class="cls-2" d="M0,.43H11.23a22,22,0,0,1,9.69,2.13,17.62,17.62,0,0,1,7.24,6.49A18.43,18.43,0,0,1,31,19.27a18.39,18.39,0,0,1-2.88,10.31,17.8,17.8,0,0,1-7.32,6.49,22.44,22.44,0,0,1-9.72,2.1H0ZM2.77,3.09V35.51H11a20,20,0,0,0,6.23-1,18.25,18.25,0,0,0,5.45-2.91,13.58,13.58,0,0,0,4-5.13,17.18,17.18,0,0,0,1.49-7.27,16.82,16.82,0,0,0-1.52-7.29,13.19,13.19,0,0,0-4-5.06A18.94,18.94,0,0,0,11.13,3.09Z"/><path class="cls-2" d="M68.88,26H51.65L47,38.17H44.24L59,0H61.7L76.5,38.17H73.63ZM68,23.58,60.21,3.71,52.57,23.58Z"/><path class="cls-2" d="M112.87,3.09H100.35V38.17H97.59V3.09H85.5V.43h27.37Z"/><path class="cls-2" d="M146.45,26H129.21l-4.68,12.19h-2.72L136.56,0h2.71l14.8,38.17H151.2Zm-.93-2.4L137.78,3.71l-7.64,19.87Z"/><path class="cls-2" d="M35.64,62.68H6.7a1.2,1.2,0,0,0-1.2,1.2V89.33a1.2,1.2,0,0,0,1.2,1.2H27.78a1.2,1.2,0,0,1,1.2,1.2v2.48a1.2,1.2,0,0,1-1.2,1.2H6.7a1.2,1.2,0,0,0-1.2,1.2v30.75a1,1,0,0,1-1,1H1.3a1,1,0,0,1-1-1V58.9a1.2,1.2,0,0,1,1.2-1.2h34.1a1.21,1.21,0,0,1,1.21,1.2v2.57A1.21,1.21,0,0,1,35.64,62.68Z"/><path class="cls-2" d="M104,57.7a.94.94,0,0,1,1,.95v45q-.1,11.83-8,19.35t-19.85,7.51q-12.14,0-19.95-7.46t-7.91-19.5V58.65a1,1,0,0,1,1-.95h3.18a1,1,0,0,1,.95.95v45a21.46,21.46,0,0,0,6.61,15.76q6.42,6.12,16.17,6.12a22.55,22.55,0,0,0,16.12-6.12q6.47-6.11,6.57-15.76v-45a.94.94,0,0,1,.94-.95Z"/><path class="cls-2" d="M139.56,55.41a29,29,0,0,1,13.79,3.05,1.09,1.09,0,0,1,.42,1.48l-1.3,2.37a1.1,1.1,0,0,1-1.38.48,31.23,31.23,0,0,0-11.93-2.5q-7.66,0-11.94,3.77A12.45,12.45,0,0,0,123,73.87a12.09,12.09,0,0,0,.5,3.62,8.63,8.63,0,0,0,1.85,3.18c.9,1,1.69,1.88,2.36,2.58a13.84,13.84,0,0,0,3.41,2.31l3.6,1.9,4.18,2.19,4,2.08q7.9,4.08,11.78,8.2t4,11.6q.1,9-6.61,14a26.07,26.07,0,0,1-16,5,36.05,36.05,0,0,1-10.7-1.69,37.09,37.09,0,0,1-7.41-3.07,1.1,1.1,0,0,1-.36-1.56L119,122a1.08,1.08,0,0,1,1.41-.35,33.62,33.62,0,0,0,16.54,4A20.46,20.46,0,0,0,148.32,122q5-3.5,4.87-10.47a13,13,0,0,0-1.19-5.19,12,12,0,0,0-3.37-4.13,31.66,31.66,0,0,0-4.27-3L138.73,96l-5.63-3.21-5.63-3.2a25.57,25.57,0,0,1-4.82-3.67,16,16,0,0,1-3.78-5.33,16.21,16.21,0,0,1-1.3-6.56q0-8.86,6.32-13.73T139.56,55.41Z"/><path class="cls-2" d="M175,128.24h-3a1.09,1.09,0,0,1-1.09-1.09V58.79A1.09,1.09,0,0,1,172,57.7h3a1.09,1.09,0,0,1,1.09,1.09v68.36A1.09,1.09,0,0,1,175,128.24Z"/><path class="cls-3" d="M227,55.41a39.08,39.08,0,0,1,20.14,5.67A37.52,37.52,0,0,1,256,68.35,33.31,33.31,0,0,1,262.21,79a39.44,39.44,0,0,1,2.38,13.93q-.09,15.42-9.65,25.67Q244.31,130.23,227,130.53a39.35,39.35,0,0,1-10.05-1.34,39.75,39.75,0,0,1-18.85-11.7,33.13,33.13,0,0,1-6.22-10.64,39.18,39.18,0,0,1-2.39-13.93q0-16.11,10.79-26.81T227,55.41Zm0,4.68a32.37,32.37,0,0,0-14.18,3A27.74,27.74,0,0,0,202.71,71a37.51,37.51,0,0,0-5.77,10.5,33.82,33.82,0,0,0-2,11.39q0,14.13,9.05,23.53t23,9.4A31.48,31.48,0,0,0,244.35,121a30.34,30.34,0,0,0,11.14-12.24,35.59,35.59,0,0,0,3.63-15.87q0-14.33-9.05-23.53T227,60.09Z"/><path class="cls-2" d="M328.12,128.24h-3.51a1.11,1.11,0,0,1-.9-.47L283.84,69.5a1.08,1.08,0,0,0-2,.61v57a1.09,1.09,0,0,1-1.09,1.09h-2.7a1.09,1.09,0,0,1-1.09-1.09V58.79a1.09,1.09,0,0,1,1.09-1.09h3.14a1.1,1.1,0,0,1,.89.47l40.25,58.49a1.09,1.09,0,0,0,2-.62V58.79a1.09,1.09,0,0,1,1.09-1.09h2.69a1.09,1.09,0,0,1,1.09,1.09v68.36A1.09,1.09,0,0,1,328.12,128.24Z"/><path d="M173.49,30.7a3.21,3.21,0,0,1,2.63.9,3.61,3.61,0,0,1,.95,2.59,3.34,3.34,0,0,1-1,2.48,3.46,3.46,0,0,1-2.58,1,3.52,3.52,0,0,1-2.49-6A3.38,3.38,0,0,1,173.49,30.7Z"/><path class="cls-2" d="M279.46,152.37a2.92,2.92,0,0,1-2.49.42,11.78,11.78,0,0,1-2.29-.74,31.34,31.34,0,0,1-4.15-2.26,91.5,91.5,0,0,1-7.65-5.46c-4.92-3.86-9.58-8-14.16-12.28-9.15-8.5-17.79-17.52-26.19-26.75s-16.44-18.79-24.14-28.62q-5.73-7.41-11.08-15.11a156.2,156.2,0,0,1-9.82-16,.46.46,0,0,1,.81-.44h0c1.56,2.69,3.23,5.3,4.94,7.89s3.52,5.12,5.34,7.64c3.62,5,7.43,10,11.29,14.84,7.7,9.76,15.82,19.19,24.08,28.5S240.84,122.3,249.76,131c4.47,4.32,9.06,8.52,13.83,12.49a91.19,91.19,0,0,0,7.41,5.61,34.64,34.64,0,0,0,4,2.32,11.28,11.28,0,0,0,2.12.78,2.38,2.38,0,0,0,2-.21h0a.29.29,0,0,1,.4,0A.28.28,0,0,1,279.46,152.37Z"/><path class="cls-2" d="M279.18,33.88a2.64,2.64,0,0,0-2.29-.18,11.63,11.63,0,0,0-2.3.92,36.9,36.9,0,0,0-4.29,2.61c-2.76,1.91-5.38,4-7.94,6.21-5.13,4.36-10.06,9-14.86,13.69-9.56,9.5-18.83,19.3-27.69,29.46s-17.56,20.47-25.69,31.22c-4.1,5.34-8.07,10.79-11.74,16.43-1.83,2.82-3.62,5.67-5.17,8.64a37.25,37.25,0,0,0-2.06,4.56,12.64,12.64,0,0,0-.62,2.38A2.52,2.52,0,0,0,175,152h0a.24.24,0,0,1,0,.33.22.22,0,0,1-.31,0,2.08,2.08,0,0,1-.66-1.23,4.34,4.34,0,0,1-.05-1.34,11.94,11.94,0,0,1,.53-2.54,37.13,37.13,0,0,1,1.92-4.75,98.74,98.74,0,0,1,4.91-8.91c3.57-5.77,7.44-11.33,11.43-16.8s8.21-10.76,12.48-16,8.63-10.42,13.14-15.46,9.07-10,13.74-14.92,9.44-9.69,14.37-14.33,10-9.18,15.24-13.41a100.81,100.81,0,0,1,8.22-6,36.53,36.53,0,0,1,4.45-2.5,12.69,12.69,0,0,1,2.43-.84,2.92,2.92,0,0,1,2.56.36.14.14,0,1,1-.17.21Z"/><path class="cls-2" d="M227,19.35a3.59,3.59,0,0,0-2,.84,9.09,9.09,0,0,0-1.47,1.73,20.85,20.85,0,0,0-2.11,4.16,62.3,62.3,0,0,0-2.7,9,163.56,163.56,0,0,0-3.13,18.7,318.24,318.24,0,0,0-2,37.93q0,9.51.52,19c.32,6.33.81,12.65,1.54,18.94a171.5,171.5,0,0,0,3,18.75,66.25,66.25,0,0,0,2.7,9.08,22.89,22.89,0,0,0,2.08,4.21c.21.34.47.63.69.94a10.71,10.71,0,0,0,.81.84,4.11,4.11,0,0,0,1,.6,2.22,2.22,0,0,0,.52.2.72.72,0,0,1,.56.23h0a0,0,0,0,1,0,0h0a.74.74,0,0,1-.63.06,1.94,1.94,0,0,1-.59-.19,4.82,4.82,0,0,1-1.07-.64,10.1,10.1,0,0,1-.87-.86c-.25-.32-.53-.62-.75-.95a23.42,23.42,0,0,1-2.26-4.25,65.38,65.38,0,0,1-3-9.1,171.4,171.4,0,0,1-3.62-18.78c-.88-6.31-1.51-12.65-2-19s-.64-12.73-.68-19.1.18-12.75.55-19.11.9-12.72,1.78-19a164.9,164.9,0,0,1,3.56-18.81,64.19,64.19,0,0,1,3.07-9.11,21.75,21.75,0,0,1,2.35-4.24,9.39,9.39,0,0,1,1.7-1.81,4.19,4.19,0,0,1,2.4-.88.28.28,0,0,1,.29.29.29.29,0,0,1-.27.3Z"/><path class="cls-4" d="M173.48,29.89a4,4,0,0,1,3.25,1.1,4.46,4.46,0,0,1,1.17,3.2,4.16,4.16,0,0,1-1.23,3.07,4.33,4.33,0,0,1-3.19,1.23,4.3,4.3,0,1,1,0-8.6Z"/></g></g></svg>
\ No newline at end of file
diff --git a/docs/source/_static/images/original.png b/docs/source/_static/images/original.png
new file mode 100644
index 000000000..687f94676
Binary files /dev/null and b/docs/source/_static/images/original.png differ
diff --git a/docs/source/_static/images/original.svg b/docs/source/_static/images/original.svg
new file mode 100644
index 000000000..6ba0ece99
--- /dev/null
+++ b/docs/source/_static/images/original.svg
@@ -0,0 +1,31 @@
+<svg width="801" height="168" viewBox="0 0 801 168" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_1_181)">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M76.1297 168C88.4597 168 99.6097 158.25 107.58 142.55C127.23 144.6 143.09 139.99 149.76 128.51C156.29 117.25 152.65 101.68 141.58 86.09C152.36 70.67 155.85 55.32 149.39 44.19C143.01 33.19 128.19 28.5 109.69 29.92C101.65 11.62 89.5997 0 76.1297 0C62.6597 0 50.4997 11.73 42.4497 30.18C24.3497 28.97 9.87966 33.68 3.59966 44.51C-2.81034 55.56 0.589656 70.78 11.1897 86.09C0.299656 101.57 -3.24034 117.01 3.23966 128.18C9.80966 139.5 25.3097 144.13 44.5597 142.31C52.5397 158.15 63.7297 168 76.1297 168ZM52.7197 141.19C59.5097 154.21 68.6197 162.18 78.6397 162.18C88.6597 162.18 97.6397 154.63 104.76 142.22C95.7497 141.01 86.0297 138.46 76.0797 134.58C68.0497 137.65 60.1797 139.86 52.7197 141.19ZM65.0697 129.77C59.6397 131.52 54.3497 132.84 49.3097 133.72C47.3697 128.87 45.6997 123.54 44.3597 117.82C47.6797 120.07 51.1497 122.25 54.7497 124.32C58.1797 126.29 61.6197 128.11 65.0597 129.77H65.0697ZM76.1197 125.68C82.0597 123.2 88.0897 120.24 94.0797 116.79C102.76 111.8 110.61 106.25 117.41 100.43C118.01 95.13 118.33 89.64 118.33 84C118.33 76.79 117.81 69.8 116.84 63.17C111.11 58.53 104.73 54.12 97.7797 50.13C90.5497 45.98 83.2397 42.57 76.0697 39.91C69.1797 42.52 62.1597 45.82 55.2197 49.81C50.8597 52.32 46.7097 54.99 42.8197 57.78C41.3997 65.98 40.6297 74.8 40.6297 84C40.6297 91.65 41.1597 99.05 42.1597 106.04C47.2997 109.94 52.9197 113.66 58.9297 117.12C64.6597 120.41 70.4297 123.27 76.1197 125.68ZM87.1297 129.83C90.8397 128.07 94.5497 126.12 98.2497 124C104.42 120.45 110.18 116.61 115.48 112.58C113.79 120.73 111.42 128.22 108.52 134.76C101.82 133.95 94.6097 132.3 87.1297 129.83ZM117.71 110.84C116.16 119.65 113.87 127.8 110.98 135.03C127.49 136.56 140.52 132.79 145.95 123.44C151.17 114.43 148.57 101.58 140 88.28C134.26 96.01 126.71 103.7 117.71 110.84ZM136.56 79.61C145.46 66.59 148.33 53.99 143.08 44.93C137.99 36.16 126.02 31.96 110.76 32.43C114.3 41.14 116.97 51.23 118.5 62.2C125.46 67.76 131.53 73.64 136.55 79.61H136.56ZM108.21 32.55C111.86 40.6 114.7 50.11 116.43 60.57C110.98 56.37 105.01 52.37 98.6097 48.69C91.9597 44.87 85.2397 41.62 78.6197 38.96C89.0597 35.24 99.1497 33.11 108.2 32.54L108.21 32.55ZM107.08 30.16C97.4397 31.18 86.8897 33.79 76.0797 37.98C67.2997 34.65 58.7097 32.35 50.6497 31.1C57.5997 15.56 67.5697 5.83 78.6397 5.83C89.7097 5.83 99.7197 15.18 107.08 30.16ZM73.5197 38.99C65.2297 36.1 57.1697 34.21 49.6897 33.32C46.9897 39.84 44.7997 47.28 43.2497 55.38C46.7897 52.94 50.4997 50.6 54.3797 48.37C60.7497 44.71 67.1697 41.58 73.5197 38.99ZM33.7197 62.5C35.2297 51.54 37.8697 41.46 41.3797 32.74C26.5297 32.46 14.9097 36.66 9.91966 45.26C4.70966 54.24 7.48966 66.68 16.1997 79.58C21.0897 73.73 26.9797 67.96 33.7197 62.5ZM12.7697 88.3C18.3697 95.9 25.7197 103.48 34.4997 110.54C36.0297 119.36 38.3097 127.53 41.1797 134.78C25.0597 136.11 12.3797 132.31 7.03966 123.12C1.85966 114.19 4.36966 101.48 12.7597 88.31L12.7697 88.3ZM17.5697 81.54C21.9097 75.99 27.2197 70.45 33.3797 65.17C32.6597 71.22 32.2697 77.53 32.2697 84C32.2697 88.91 32.4897 93.72 32.9097 98.4C26.7997 92.89 21.6197 87.18 17.5597 81.53L17.5697 81.54ZM135.19 81.55C131 87.32 125.65 93.15 119.32 98.76C119.76 93.97 120 89.03 120 84C120 77.41 119.6 70.99 118.85 64.84C125.22 70.21 130.72 75.87 135.19 81.55Z" fill="url(#paint0_linear_1_181)"/>
+<path d="M204.34 45.97H192.83L190.47 52.2H185.2L196.07 23.88H201.47L212.54 52.2H206.78L204.34 45.97ZM202.74 41.74L198.54 30.99L194.46 41.74H202.73H202.74Z" fill="#1F2937"/>
+<path d="M235.55 23.88H246.82C249.59 23.88 251.9 24.73 253.73 26.44C255.57 28.14 256.49 30.38 256.49 33.15C256.49 35.92 255.57 38.2 253.73 39.9C251.89 41.6 249.59 42.46 246.82 42.46H240.95V52.21H235.56V23.89L235.55 23.88ZM240.94 37.26H246.85C248 37.26 248.96 36.87 249.73 36.1C250.5 35.3 250.89 34.32 250.89 33.14C250.89 31.96 250.5 31 249.73 30.22C248.98 29.45 248.02 29.06 246.85 29.06H240.94V37.25V37.26Z" fill="#1F2937"/>
+<path d="M293.67 45.97H282.16L279.8 52.2H274.53L285.4 23.88H290.79L301.86 52.2H296.1L293.66 45.97H293.67ZM292.07 41.74L287.87 30.99L283.79 41.74H292.06H292.07Z" fill="#1F2937"/>
+<path d="M335.99 23C338.57 23 340.92 23.68 343.02 25.04C345.15 26.37 346.84 28.18 348.1 30.47L343.1 32.87C341.37 29.57 339 27.92 335.99 27.92C333.62 27.92 331.65 28.91 330.07 30.88C328.53 32.82 327.75 35.22 327.75 38.07C327.75 40.92 328.52 43.32 330.07 45.26C331.62 47.18 333.59 48.14 335.99 48.14C337.45 48.14 338.81 47.73 340.07 46.9C341.32 46.05 342.32 44.93 343.07 43.54L347.99 45.9C346.79 48.14 345.13 49.89 342.99 51.17C340.86 52.42 338.53 53.05 336 53.05C331.95 53.05 328.63 51.65 326.05 48.86C323.47 46.04 322.17 42.44 322.17 38.07C322.17 33.7 323.48 30.13 326.09 27.28C328.73 24.43 332.03 23.01 336 23.01L335.99 23Z" fill="#1F2937"/>
+<path d="M393.49 52.2H388.09V40.61H377.1V52.2H371.71V23.88H377.1V35.43H388.09V23.88H393.49V52.2Z" fill="#1F2937"/>
+<path d="M435.17 29.07H423.9V35.46H432.41V40.65H423.9V47H435.17V52.19H418.51V23.87H435.17V29.06V29.07Z" fill="#1F2937"/>
+<path d="M185 76.1H207.25C218.63 76.1 227.58 79.3 234.1 85.69C240.69 92.02 243.98 100.14 243.98 110.04C243.98 119.94 240.69 128.1 234.1 134.49C227.51 140.88 218.53 144.08 207.15 144.08H184.99V76.1H185ZM199.96 90.49V129.7H206.67C209.55 129.7 212.2 129.38 214.63 128.74C217.12 128.1 219.43 127.08 221.54 125.67C223.71 124.26 225.41 122.25 226.62 119.63C227.83 116.95 228.44 113.75 228.44 110.04C228.44 106.33 227.83 103.17 226.62 100.55C225.4 97.93 223.71 95.92 221.54 94.51C219.43 93.1 217.16 92.08 214.73 91.44C212.3 90.8 209.61 90.48 206.67 90.48H199.96V90.49Z" fill="#1F2937"/>
+<path d="M291.82 130.85H264.96L259.97 144.08H245.39L271.38 76.1H286.34L312.91 144.08H296.89L291.81 130.85H291.82ZM287.4 119.35L278.29 95.76L269.37 119.35H287.4Z" fill="#1F2937"/>
+<path d="M362.7 90.49H342.94V144.09H327.98V90.49H308.51V76.11H362.7V90.49Z" fill="#1F2937"/>
+<path d="M404.77 130.85H377.92L372.93 144.08H358.35L384.34 76.1H399.3L425.87 144.08H409.85L404.77 130.85ZM400.36 119.35L391.25 95.76L382.33 119.35H400.36Z" fill="#1F2937"/>
+<path d="M474.73 90.49H448.45V102.95H468.4V117.33H448.45V144.08H433.49V76.1H474.73V90.48V90.49Z" fill="#1F2937"/>
+<path d="M541.71 76.1V118.96C541.65 127.27 538.96 133.85 533.65 138.71C528.41 143.57 521.53 146 513.03 146C504.53 146 497.78 143.57 492.41 138.71C487.04 133.85 484.39 127.27 484.45 118.96V76.1H499.32V119.05C499.32 122.88 500.6 125.95 503.16 128.25C505.78 130.49 509.08 131.61 513.04 131.61C517 131.61 520.27 130.49 522.82 128.25C525.38 125.95 526.69 122.88 526.75 119.05V76.1H541.71Z" fill="#1F2937"/>
+<path d="M578.69 73.99C585.72 73.99 591.96 75.59 597.39 78.78L590.77 91.24C585.98 89.19 581.43 88.17 577.15 88.17C570.95 88.17 567.85 90.25 567.85 94.4C567.85 96.45 569.03 98.17 571.4 99.58C573.83 100.92 577.28 102.39 581.76 103.99C586.3 105.52 589.72 106.96 592.02 108.3C598.22 111.88 601.32 117.25 601.32 124.41C601.32 131.12 598.86 136.4 593.93 140.23C589.01 144.07 582.87 145.98 575.52 145.98C571.36 145.98 567.05 145.21 562.57 143.68C558.09 142.15 554.61 140.39 552.12 138.41L560.18 126.43C567.02 130.46 573.22 132.21 578.79 131.7C580.96 131.51 582.76 130.74 584.16 129.4C585.63 128.06 586.24 126.43 585.98 124.51C585.72 122.72 584.22 121.25 581.47 120.1C578.72 118.89 575.14 117.48 570.73 115.88C566.38 114.28 562.83 112.4 560.08 110.22C555.03 106.13 552.5 101.05 552.5 94.98C552.5 91.98 553.01 89.26 554.03 86.83C555.05 84.4 556.4 82.42 558.06 80.89C559.79 79.29 561.8 77.98 564.1 76.96C566.4 75.87 568.77 75.11 571.2 74.66C573.63 74.21 576.12 73.99 578.68 73.99H578.69Z" fill="#1F2937"/>
+<path d="M626.79 144.08H611.83V76.1H626.79V144.08Z" fill="#1F2937"/>
+<path d="M647.04 84.16C653.88 77.38 662.48 74 672.84 74C683.2 74 691.73 77.39 698.45 84.16C705.23 90.87 708.62 99.4 708.62 109.76C708.62 120.12 705.33 128.68 698.74 135.45C692.15 142.16 683.52 145.68 672.84 146C662.48 146 653.88 142.58 647.04 135.74C640.26 128.84 636.87 120.21 636.87 109.85C636.87 99.49 640.26 90.93 647.04 84.15V84.16ZM672.84 87.61C666.64 87.61 661.68 89.69 657.97 93.84C654.26 97.99 652.41 103.3 652.41 109.76C652.41 116.22 654.26 121.62 657.97 125.96C661.74 130.24 666.7 132.38 672.84 132.38C678.98 132.38 683.96 130.24 687.61 125.96C691.25 121.68 693.08 116.31 693.08 109.85C693.08 103.39 691.26 98.12 687.61 94.03C684.03 89.88 679.11 87.73 672.84 87.61Z" fill="#1F2937"/>
+<path d="M775 144.08H759.65L732.7 101.99V144.08H718.7V76.1H732.99L761 118.57V76.1H775V144.08Z" fill="#1F2937"/>
+<path d="M788.01 78.18H784.62V87.44H782.46V78.18H779.13V76.1H788.01V78.18ZM800.56 87.45H798.48V80.17L795.5 85.79H794.12L791.14 80.17L791.12 87.45H789.1V76.11H791.13L794.87 83.04L798.45 76.11H800.51L800.53 87.45H800.56Z" fill="#1F2937"/>
+</g>
+<defs>
+<linearGradient id="paint0_linear_1_181" x1="17.0897" y1="117.74" x2="162.73" y2="36.78" gradientUnits="userSpaceOnUse">
+<stop stop-color="#EF4137"/>
+<stop offset="1" stop-color="#FBB042"/>
+</linearGradient>
+<clipPath id="clip0_1_181">
+<rect width="800.56" height="168" fill="white"/>
+</clipPath>
+</defs>
+</svg>
diff --git a/docs/source/_static/images/original2x.png b/docs/source/_static/images/original2x.png
new file mode 100644
index 000000000..a7402109b
Binary files /dev/null and b/docs/source/_static/images/original2x.png differ
diff --git a/docs/source/_static/theme_overrides.css b/docs/source/_static/theme_overrides.css
index 1e972cc6f..aaa40fba2 100644
--- a/docs/source/_static/theme_overrides.css
+++ b/docs/source/_static/theme_overrides.css
@@ -56,7 +56,7 @@ a.navbar-brand img {
 
 
 /* This is the bootstrap CSS style for "table-striped". Since the theme does
-not yet provide an easy way to configure this globaly, it easier to simply
+not yet provide an easy way to configure this globally, it easier to simply
 include this snippet here than updating each table in all rst files to
 add ":class: table-striped" */
 
diff --git a/docs/source/_templates/docs-sidebar.html b/docs/source/_templates/docs-sidebar.html
index bc2bf0092..44deeed25 100644
--- a/docs/source/_templates/docs-sidebar.html
+++ b/docs/source/_templates/docs-sidebar.html
@@ -1,6 +1,6 @@
 
 <a class="navbar-brand" href="{{ pathto(master_doc) }}">
-  <img src="{{ pathto('_static/images/' + logo, 1) }}" class="logo" alt="logo">
+  <img src="{{ pathto('_static/images/2x_bgwhite_original.png', 1) }}" class="logo" alt="logo">
 </a>
 
 <form class="bd-search d-flex align-items-center" action="{{ pathto('search') }}" method="get">
diff --git a/docs/source/_templates/layout.html b/docs/source/_templates/layout.html
index a9d0f30bc..9f7880049 100644
--- a/docs/source/_templates/layout.html
+++ b/docs/source/_templates/layout.html
@@ -3,3 +3,24 @@
 {# Silence the navbar #}
 {% block docs_navbar %}
 {% endblock %}
+
+<!--
+    Custom footer
+-->
+{% block footer %}
+<!-- Based on pydata_sphinx_theme/footer.html -->
+<footer class="footer mt-5 mt-md-0">
+  <div class="container">
+    {% for footer_item in theme_footer_items %}
+    <div class="footer-item">
+      {% include footer_item %}
+    </div>
+    {% endfor %}
+    <div class="footer-item">
+      <p>Apache Arrow DataFusion, Arrow DataFusion, Apache, the Apache feather logo, and the Apache Arrow DataFusion project logo</p>
+      <p>are either registered trademarks or trademarks of The Apache Software Foundation in the United States and other countries.</p>
+    </div>
+  </div>
+</footer>
+
+{% endblock %}
diff --git a/docs/source/api/expression.rst b/docs/source/api/expression.rst
deleted file mode 100644
index 30137d135..000000000
--- a/docs/source/api/expression.rst
+++ /dev/null
@@ -1,27 +0,0 @@
-.. Licensed to the Apache Software Foundation (ASF) under one
-.. or more contributor license agreements.  See the NOTICE file
-.. distributed with this work for additional information
-.. regarding copyright ownership.  The ASF licenses this file
-.. to you under the Apache License, Version 2.0 (the
-.. "License"); you may not use this file except in compliance
-.. with the License.  You may obtain a copy of the License at
-
-..   http://www.apache.org/licenses/LICENSE-2.0
-
-.. Unless required by applicable law or agreed to in writing,
-.. software distributed under the License is distributed on an
-.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-.. KIND, either express or implied.  See the License for the
-.. specific language governing permissions and limitations
-.. under the License.
-
-.. _api.expression:
-.. currentmodule:: datafusion
-
-Expr
-==========
-
-.. autosummary::
-   :toctree: ../generated/
-
-   Expr
diff --git a/docs/source/api/functions.rst b/docs/source/api/functions.rst
deleted file mode 100644
index 958606df2..000000000
--- a/docs/source/api/functions.rst
+++ /dev/null
@@ -1,27 +0,0 @@
-.. Licensed to the Apache Software Foundation (ASF) under one
-.. or more contributor license agreements.  See the NOTICE file
-.. distributed with this work for additional information
-.. regarding copyright ownership.  The ASF licenses this file
-.. to you under the Apache License, Version 2.0 (the
-.. "License"); you may not use this file except in compliance
-.. with the License.  You may obtain a copy of the License at
-
-..   http://www.apache.org/licenses/LICENSE-2.0
-
-.. Unless required by applicable law or agreed to in writing,
-.. software distributed under the License is distributed on an
-.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-.. KIND, either express or implied.  See the License for the
-.. specific language governing permissions and limitations
-.. under the License.
-
-.. _api.functions:
-.. currentmodule:: datafusion
-
-Functions
-=========
-
-.. autosummary::
-   :toctree: ../generated/
-
-   functions.functions
diff --git a/docs/source/api/object_store.rst b/docs/source/api/object_store.rst
deleted file mode 100644
index eeb6c4326..000000000
--- a/docs/source/api/object_store.rst
+++ /dev/null
@@ -1,27 +0,0 @@
-.. Licensed to the Apache Software Foundation (ASF) under one
-.. or more contributor license agreements.  See the NOTICE file
-.. distributed with this work for additional information
-.. regarding copyright ownership.  The ASF licenses this file
-.. to you under the Apache License, Version 2.0 (the
-.. "License"); you may not use this file except in compliance
-.. with the License.  You may obtain a copy of the License at
-
-..   http://www.apache.org/licenses/LICENSE-2.0
-
-.. Unless required by applicable law or agreed to in writing,
-.. software distributed under the License is distributed on an
-.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-.. KIND, either express or implied.  See the License for the
-.. specific language governing permissions and limitations
-.. under the License.
-
-.. _api.object_store:
-.. currentmodule:: datafusion.object_store
-
-ObjectStore
-=========
-
-.. autosummary::
-   :toctree: ../generated/
-
-   object_store
\ No newline at end of file
diff --git a/docs/source/conf.py b/docs/source/conf.py
index 929c24930..01813b032 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -15,6 +15,8 @@
 # specific language governing permissions and limitations
 # under the License.
 
+"""Documentation generation."""
+
 # Configuration file for the Sphinx documentation builder.
 #
 # This file only contains a selection of the most common options. For a full
@@ -33,9 +35,9 @@
 
 # -- Project information -----------------------------------------------------
 
-project = "Arrow DataFusion"
-copyright = "2022, Apache Software Foundation"
-author = "Arrow DataFusion Authors"
+project = "Apache Arrow DataFusion"
+copyright = "2019-2024, Apache Software Foundation"
+author = "Apache Software Foundation"
 
 
 # -- General configuration ---------------------------------------------------
@@ -44,14 +46,11 @@
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
 extensions = [
-    "sphinx.ext.autodoc",
-    "sphinx.ext.autosummary",
-    "sphinx.ext.doctest",
-    "sphinx.ext.ifconfig",
     "sphinx.ext.mathjax",
-    "sphinx.ext.viewcode",
     "sphinx.ext.napoleon",
     "myst_parser",
+    "IPython.sphinxext.ipython_directive",
+    "autoapi.extension",
 ]
 
 source_suffix = {
@@ -67,15 +66,47 @@
 # This pattern also affects html_static_path and html_extra_path.
 exclude_patterns = []
 
-# Show members for classes in .. autosummary
-autodoc_default_options = {
-    "members": None,
-    "undoc-members": None,
-    "show-inheritance": None,
-    "inherited-members": None,
-}
+autoapi_dirs = ["../../python"]
+autoapi_ignore = ["*tests*"]
+autoapi_member_order = "groupwise"
+suppress_warnings = ["autoapi.python_import_resolution"]
+autoapi_python_class_content = "both"
+autoapi_keep_files = False  # set to True for debugging generated files
+
+
+def autoapi_skip_member_fn(app, what, name, obj, skip, options) -> bool:  # noqa: ARG001
+    skip_contents = [
+        # Re-exports
+        ("class", "datafusion.DataFrame"),
+        ("class", "datafusion.SessionContext"),
+        ("module", "datafusion.common"),
+        # Duplicate modules (skip module-level docs to avoid duplication)
+        ("module", "datafusion.col"),
+        ("module", "datafusion.udf"),
+        # Deprecated
+        ("class", "datafusion.substrait.serde"),
+        ("class", "datafusion.substrait.plan"),
+        ("class", "datafusion.substrait.producer"),
+        ("class", "datafusion.substrait.consumer"),
+        ("method", "datafusion.context.SessionContext.tables"),
+        ("method", "datafusion.dataframe.DataFrame.unnest_column"),
+    ]
+    # Explicitly skip certain members listed above. These are either
+    # re-exports, duplicate module-level documentation, deprecated
+    # API surfaces, or private variables that would otherwise appear
+    # in the generated docs and cause confusing duplication.
+    # Keeping this explicit list avoids surprising entries in the
+    # AutoAPI output and gives us a single place to opt-out items
+    # when we intentionally hide them from the docs.
+    if (what, name) in skip_contents:
+        skip = True
+
+    return skip
+
+
+def setup(sphinx) -> None:
+    sphinx.connect("autoapi-skip-member", autoapi_skip_member_fn)
 
-autosummary_generate = True
 
 # -- Options for HTML output -------------------------------------------------
 
@@ -84,9 +115,7 @@
 #
 html_theme = "pydata_sphinx_theme"
 
-html_theme_options = {
-    "use_edit_page_button": True,
-}
+html_theme_options = {"use_edit_page_button": False, "show_toc_level": 2}
 
 html_context = {
     "github_user": "apache",
@@ -100,7 +129,7 @@
 # so a file named "default.css" will overwrite the builtin "default.css".
 html_static_path = ["_static"]
 
-html_logo = "_static/images/DataFusion-Logo-Background-White.png"
+html_logo = "_static/images/2x_bgwhite_original.png"
 
 html_css_files = ["theme_overrides.css"]
 
diff --git a/docs/source/contributor-guide/ffi.rst b/docs/source/contributor-guide/ffi.rst
new file mode 100644
index 000000000..e0158e0a2
--- /dev/null
+++ b/docs/source/contributor-guide/ffi.rst
@@ -0,0 +1,278 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+.. _ffi:
+
+Python Extensions
+=================
+
+The DataFusion in Python project is designed to allow users to extend its functionality in a few core
+areas. Ideally many users would like to package their extensions as a Python package and easily
+integrate that package with this project. This page serves to describe some of the challenges we face
+when doing these integrations and the approach our project uses.
+
+The Primary Issue
+-----------------
+
+Suppose you wish to use DataFusion and you have a custom data source that can produce tables that
+can then be queried against, similar to how you can register a :ref:`CSV <io_csv>` or
+:ref:`Parquet <io_parquet>` file. In DataFusion terminology, you likely want to implement a 
+:ref:`Custom Table Provider <io_custom_table_provider>`. In an effort to make your data source
+as performant as possible and to utilize the features of DataFusion, you may decide to write
+your source in Rust and then expose it through `PyO3 <https://pyo3.rs>`_ as a Python library.
+
+At first glance, it may appear the best way to do this is to add the ``datafusion-python``
+crate as a dependency, provide a ``PyTable``, and then to register it with the
+``SessionContext``. Unfortunately, this will not work.
+
+When you produce your code as a Python library and it needs to interact with the DataFusion
+library, at the lowest level they communicate through an Application Binary Interface (ABI).
+The acronym sounds similar to API (Application Programming Interface), but it is distinctly
+different.
+
+The ABI sets the standard for how these libraries can share data and functions between each
+other. One of the key differences between Rust and other programming languages is that Rust
+does not have a stable ABI. What this means in practice is that if you compile a Rust library
+with one version of the ``rustc`` compiler and I compile another library to interface with it
+but I use a different version of the compiler, there is no guarantee the interface will be
+the same.
+
+In practice, this means that a Python library built with ``datafusion-python`` as a Rust
+dependency will generally **not** be compatible with the DataFusion Python package, even
+if they reference the same version of ``datafusion-python``. If you attempt to do this, it may
+work on your local computer if you have built both packages with the same optimizations.
+This can sometimes lead to a false expectation that the code will work, but it frequently
+breaks the moment you try to use your package against the released packages.
+
+You can find more information about the Rust ABI in their
+`online documentation <https://doc.rust-lang.org/reference/abi.html>`_.
+
+The FFI Approach
+----------------
+
+Rust supports interacting with other programming languages through it's Foreign Function
+Interface (FFI). The advantage of using the FFI is that it enables you to write data structures
+and functions that have a stable ABI. The allows you to use Rust code with C, Python, and
+other languages. In fact, the `PyO3 <https://pyo3.rs>`_ library uses the FFI to share data
+and functions between Python and Rust.
+
+The approach we are taking in the DataFusion in Python project is to incrementally expose
+more portions of the DataFusion project via FFI interfaces. This allows users to write Rust
+code that does **not** require the ``datafusion-python`` crate as a dependency, expose their
+code in Python via PyO3, and have it interact with the DataFusion Python package.
+
+Early adopters of this approach include `delta-rs <https://delta-io.github.io/delta-rs/>`_
+who has adapted their Table Provider for use in ```datafusion-python``` with only a few lines
+of code. Also, the DataFusion Python project uses the existing definitions from
+`Apache Arrow CStream Interface <https://arrow.apache.org/docs/format/CStreamInterface.html>`_
+to support importing **and** exporting tables. Any Python package that supports reading
+the Arrow C Stream interface can work with DataFusion Python out of the box! You can read
+more about working with Arrow sources in the :ref:`Data Sources <user_guide_data_sources>`
+page.
+
+To learn more about the Foreign Function Interface in Rust, the
+`Rustonomicon <https://doc.rust-lang.org/nomicon/ffi.html>`_ is a good resource.
+
+Inspiration from Arrow
+----------------------
+
+DataFusion is built upon `Apache Arrow <https://arrow.apache.org/>`_. The canonical Python
+Arrow implementation, `pyarrow <https://arrow.apache.org/docs/python/index.html>`_ provides
+an excellent way to share Arrow data between Python projects without performing any copy
+operations on the data. They do this by using a well defined set of interfaces. You can
+find the details about their stream interface
+`here <https://arrow.apache.org/docs/format/CStreamInterface.html>`_. The
+`Rust Arrow Implementation <https://github.com/apache/arrow-rs>`_ also supports these
+``C`` style definitions via the Foreign Function Interface.
+
+In addition to using these interfaces to transfer Arrow data between libraries, ``pyarrow``
+goes one step further to make sharing the interfaces easier in Python. They do this
+by exposing PyCapsules that contain the expected functionality.
+
+You can learn more about PyCapsules from the official
+`Python online documentation <https://docs.python.org/3/c-api/capsule.html>`_. PyCapsules
+have excellent support in PyO3 already. The
+`PyO3 online documentation <https://pyo3.rs/main/doc/pyo3/types/struct.pycapsule>`_ is a good source
+for more details on using PyCapsules in Rust.
+
+Two lessons we leverage from the Arrow project in DataFusion Python are:
+
+- We reuse the existing Arrow FFI functionality wherever possible.
+- We expose PyCapsules that contain a FFI stable struct.
+
+Implementation Details
+----------------------
+
+The bulk of the code necessary to perform our FFI operations is in the upstream 
+`DataFusion <https://datafusion.apache.org/>`_ core repository. You can review the code and
+documentation in the `datafusion-ffi`_ crate.
+
+Our FFI implementation is narrowly focused at sharing data and functions with Rust backed
+libraries. This allows us to use the `abi_stable crate <https://crates.io/crates/abi_stable>`_.
+This is an excellent crate that allows for easy conversion between Rust native types
+and FFI-safe alternatives. For example, if you needed to pass a ``Vec<String>`` via FFI,
+you can simply convert it to a ``RVec<RString>`` in an intuitive manner. It also supports
+features like ``RResult`` and ``ROption`` that do not have an obvious translation to a
+C equivalent.
+
+The `datafusion-ffi`_ crate has been designed to make it easy to convert from DataFusion
+traits into their FFI counterparts. For example, if you have defined a custom
+`TableProvider <https://docs.rs/datafusion/45.0.0/datafusion/catalog/trait.TableProvider.html>`_
+and you want to create a sharable FFI counterpart, you could write:
+
+.. code-block:: rust
+
+    let my_provider = MyTableProvider::default();
+    let ffi_provider = FFI_TableProvider::new(Arc::new(my_provider), false, None);
+
+.. _ffi_pyclass_mutability:
+
+PyO3 class mutability guidelines
+--------------------------------
+
+PyO3 bindings should present immutable wrappers whenever a struct stores shared or
+interior-mutable state. In practice this means that any ``#[pyclass]`` containing an
+``Arc<RwLock<_>>`` or similar synchronized primitive must opt into ``#[pyclass(frozen)]``
+unless there is a compelling reason not to.
+
+The :mod:`datafusion` configuration helpers illustrate the preferred pattern. The
+``PyConfig`` class in :file:`src/config.rs` stores an ``Arc<RwLock<ConfigOptions>>`` and is
+explicitly frozen so callers interact with configuration state through provided methods
+instead of mutating the container directly:
+
+.. code-block:: rust
+
+    #[pyclass(from_py_object, name = "Config", module = "datafusion", subclass, frozen)]
+    #[derive(Clone)]
+    pub(crate) struct PyConfig {
+        config: Arc<RwLock<ConfigOptions>>,
+    }
+
+The same approach applies to execution contexts. ``PySessionContext`` in
+:file:`src/context.rs` stays frozen even though it shares mutable state internally via
+``SessionContext``. This ensures PyO3 tracks borrows correctly while Python-facing APIs
+clone the inner ``SessionContext`` or return new wrappers instead of mutating the
+existing instance in place:
+
+.. code-block:: rust
+
+    #[pyclass(from_py_object, frozen, name = "SessionContext", module = "datafusion", subclass)]
+    #[derive(Clone)]
+    pub struct PySessionContext {
+        pub ctx: SessionContext,
+    }
+
+Occasionally a type must remain mutable—for example when PyO3 attribute setters need to
+update fields directly. In these rare cases add an inline justification so reviewers and
+future contributors understand why ``frozen`` is unsafe to enable. ``DataTypeMap`` in
+:file:`src/common/data_type.rs` includes such a comment because PyO3 still needs to track
+field updates:
+
+.. code-block:: rust
+
+    // TODO: This looks like this needs pyo3 tracking so leaving unfrozen for now
+    #[derive(Debug, Clone)]
+    #[pyclass(from_py_object, name = "DataTypeMap", module = "datafusion.common", subclass)]
+    pub struct DataTypeMap {
+        #[pyo3(get, set)]
+        pub arrow_type: PyDataType,
+        #[pyo3(get, set)]
+        pub python_type: PythonType,
+        #[pyo3(get, set)]
+        pub sql_type: SqlType,
+    }
+
+When reviewers encounter a mutable ``#[pyclass]`` without a comment, they should request
+an explanation or ask that ``frozen`` be added. Keeping these wrappers frozen by default
+helps avoid subtle bugs stemming from PyO3's interior mutability tracking.
+
+If you were interfacing with a library that provided the above ``FFI_TableProvider`` and
+you needed to turn it back into an ``TableProvider``, you can turn it into a
+``ForeignTableProvider`` with implements the ``TableProvider`` trait.
+
+.. code-block:: rust
+
+    let foreign_provider: ForeignTableProvider = ffi_provider.into();
+
+If you review the code in `datafusion-ffi`_ you will find that each of the traits we share
+across the boundary has two portions, one with a ``FFI_`` prefix and one with a ``Foreign``
+prefix. This is used to distinguish which side of the FFI boundary that struct is
+designed to be used on. The structures with the ``FFI_`` prefix are to be used on the
+**provider** of the structure. In the example we're showing, this means the code that has
+written the underlying ``TableProvider`` implementation to access your custom data source.
+The structures with the ``Foreign`` prefix are to be used by the receiver. In this case,
+it is the ``datafusion-python`` library.
+
+In order to share these FFI structures, we need to wrap them in some kind of Python object
+that can be used to interface from one package to another. As described in the above
+section on our inspiration from Arrow, we use ``PyCapsule``. We can create a ``PyCapsule``
+for our provider thusly:
+
+.. code-block:: rust
+
+    let name = CString::new("datafusion_table_provider")?;
+    let my_capsule = PyCapsule::new_bound(py, provider, Some(name))?;
+
+On the receiving side, turn this pycapsule object into the ``FFI_TableProvider``, which
+can then be turned into a ``ForeignTableProvider`` the associated code is:
+
+.. code-block:: rust
+
+    let capsule = capsule.cast::<PyCapsule>()?;
+    let data: NonNull<FFI_TableProvider> = capsule
+        .pointer_checked(Some(name))?
+        .cast();
+    let codec = unsafe { data.as_ref() };
+
+By convention the ``datafusion-python`` library expects a Python object that has a
+``TableProvider`` PyCapsule to have this capsule accessible by calling a function named
+``__datafusion_table_provider__``. You can see a complete working example of how to
+share a ``TableProvider`` from one python library to DataFusion Python in the
+`repository examples folder <https://github.com/apache/datafusion-python/tree/main/examples/datafusion-ffi-example>`_.
+
+This section has been written using ``TableProvider`` as an example. It is the first
+extension that has been written using this approach and the most thoroughly implemented.
+As we continue to expose more of the DataFusion features, we intend to follow this same
+design pattern.
+
+Alternative Approach
+--------------------
+
+Suppose you needed to expose some other features of DataFusion and you could not wait
+for the upstream repository to implement the FFI approach we describe. In this case
+you decide to create your dependency on the ``datafusion-python`` crate instead.
+
+As we discussed, this is not guaranteed to work across different compiler versions and
+optimization levels. If you wish to go down this route, there are two approaches we
+have identified you can use.
+
+#. Re-export all of ``datafusion-python`` yourself with your extensions built in.
+#. Carefully synchronize your software releases with the ``datafusion-python`` CI build
+   system so that your libraries use the exact same compiler, features, and
+   optimization level.
+
+We currently do not recommend either of these approaches as they are difficult to
+maintain over a long period. Additionally, they require a tight version coupling
+between libraries.
+
+Status of Work
+--------------
+
+At the time of this writing, the FFI features are under active development. To see
+the latest status, we recommend reviewing the code in the `datafusion-ffi`_ crate.
+
+.. _datafusion-ffi: https://crates.io/crates/datafusion-ffi
diff --git a/docs/source/contributor-guide/introduction.rst b/docs/source/contributor-guide/introduction.rst
new file mode 100644
index 000000000..33c2b274c
--- /dev/null
+++ b/docs/source/contributor-guide/introduction.rst
@@ -0,0 +1,154 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+Introduction
+============
+We welcome and encourage contributions of all kinds, such as:
+
+1. Tickets with issue reports of feature requests
+2. Documentation improvements
+3. Code, both PR and (especially) PR Review.
+
+In addition to submitting new PRs, we have a healthy tradition of community members reviewing each other’s PRs.
+Doing so is a great way to help the community as well as get more familiar with Rust and the relevant codebases.
+
+Before opening a pull request that touches PyO3 bindings, please review the
+:ref:`PyO3 class mutability guidelines <ffi_pyclass_mutability>` so you can flag missing
+``#[pyclass(frozen)]`` annotations during development and review.
+
+How to develop
+--------------
+
+This assumes that you have rust and cargo installed. We use the workflow recommended by
+`pyo3 <https://github.com/PyO3/pyo3>`_ and `maturin <https://github.com/PyO3/maturin>`_. We recommend using
+`uv <https://docs.astral.sh/uv/>`_ for python package management.
+
+By default `uv` will attempt to build the datafusion python package. For our development we prefer to build manually. This means
+that when creating your virtual environment using `uv sync` you need to pass in the additional `--no-install-package datafusion`
+and for `uv run` commands the additional parameter `--no-project`
+
+Bootstrap:
+
+.. code-block:: shell
+
+    # fetch this repo
+    git clone git@github.com:apache/datafusion-python.git
+    # create the virtual environment
+    uv sync --dev --no-install-package datafusion
+    # activate the environment
+    source .venv/bin/activate
+
+The tests rely on test data in git submodules.
+
+.. code-block:: shell
+
+    git submodule init
+    git submodule update
+
+
+Whenever rust code changes (your changes or via `git pull`):
+
+.. code-block:: shell
+
+   # make sure you activate the venv using "source .venv/bin/activate" first
+   maturin develop -uv
+   python -m pytest
+
+Running & Installing pre-commit hooks
+-------------------------------------
+
+arrow-datafusion-python takes advantage of `pre-commit <https://pre-commit.com/>`_ to assist developers with code linting to help reduce the number of commits that ultimately fail in CI due to linter errors. Using the pre-commit hooks is optional for the developer but certainly helpful for keeping PRs clean and concise.
+
+Our pre-commit hooks can be installed by running :code:`pre-commit install`, which will install the configurations in your ARROW_DATAFUSION_PYTHON_ROOT/.github directory and run each time you perform a commit, failing to complete the commit if an offending lint is found allowing you to make changes locally before pushing.
+
+The pre-commit hooks can also be run adhoc without installing them by simply running :code:`pre-commit run --all-files`
+
+Guidelines for Separating Python and Rust Code
+----------------------------------------------
+
+Version 40 of ``datafusion-python`` introduced ``python`` wrappers around the ``pyo3`` generated code to vastly improve the user experience. (See the `blog post <https://datafusion.apache.org/blog/2024/08/20/python-datafusion-40.0.0/>`_ and `pull request <https://github.com/apache/datafusion-python/pull/750>`_ for more details.)
+
+Mostly, the ``python`` code is limited to pure wrappers with type hints and good docstrings, but there are a few reasons for when the code does more:
+
+1. Trivial aliases like :py:func:`~datafusion.functions.array_append` and :py:func:`~datafusion.functions.list_append`.
+2. Simple type conversion, like from a ``path`` to a ``string`` of the path or from ``number`` to ``lit(number)``.
+3. The additional code makes an API **much** more pythonic, like we do for :py:func:`~datafusion.functions.named_struct` (see `source code <https://github.com/apache/datafusion-python/blob/a0913c728f5f323c1eb4913e614c9d996083e274/python/datafusion/functions.py#L1040-L1046>`_).
+
+
+Update Dependencies
+-------------------
+
+To change test dependencies, change the ``pyproject.toml`` and run
+
+To update dependencies, run
+
+.. code-block:: shell
+
+    uv sync --dev --no-install-package datafusion
+
+Improving Build Speed
+---------------------
+
+The `pyo3 <https://github.com/PyO3/pyo3>`_ dependency of this project contains a ``build.rs`` file which
+can cause it to rebuild frequently. You can prevent this from happening by defining a ``PYO3_CONFIG_FILE``
+environment variable that points to a file with your build configuration. Whenever your build configuration
+changes, such as during some major version updates, you will need to regenerate this file. This variable
+should point to a fully resolved path on your build machine.
+
+To generate this file, use the following command:
+
+.. code-block:: shell
+
+    PYO3_PRINT_CONFIG=1 cargo build
+
+This will generate some output that looks like the following. You will want to copy these contents intro
+a file. If you place this file in your project directory with filename ``.pyo3_build_config`` it will
+be ignored by ``git``.
+
+.. code-block::
+
+    implementation=CPython
+    version=3.9
+    shared=true
+    abi3=true
+    lib_name=python3.12
+    lib_dir=/opt/homebrew/opt/python@3.12/Frameworks/Python.framework/Versions/3.12/lib
+    executable=/Users/myusername/src/datafusion-python/.venv/bin/python
+    pointer_width=64
+    build_flags=
+    suppress_build_script_link_lines=false
+
+Add the environment variable to your system.
+
+.. code-block:: shell
+
+    export PYO3_CONFIG_FILE="/Users//myusername/src/datafusion-python/.pyo3_build_config"
+
+If you are on a Mac and you use VS Code for your IDE, you will want to add these variables
+to your settings. You can find the appropriate rust flags by looking in the
+``.cargo/config.toml`` file.
+
+.. code-block::
+
+    "rust-analyzer.cargo.extraEnv": {
+        "RUSTFLAGS": "-C link-arg=-undefined -C link-arg=dynamic_lookup",
+        "PYO3_CONFIG_FILE": "/Users/myusername/src/datafusion-python/.pyo3_build_config"
+    },
+    "rust-analyzer.runnables.extraEnv": {
+        "RUSTFLAGS": "-C link-arg=-undefined -C link-arg=dynamic_lookup",
+        "PYO3_CONFIG_FILE": "/Users/myusername/src/personal/datafusion-python/.pyo3_build_config"
+    }
diff --git a/docs/source/images/jupyter_lab_df_view.png b/docs/source/images/jupyter_lab_df_view.png
new file mode 100644
index 000000000..9dafb4f61
Binary files /dev/null and b/docs/source/images/jupyter_lab_df_view.png differ
diff --git a/docs/source/index.rst b/docs/source/index.rst
index 78f44ea17..134d41cb6 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -19,7 +19,7 @@
 DataFusion in Python
 ====================
 
-This is a Python library that binds to `Apache Arrow <https://arrow.apache.org/>`_ in-memory query engine `DataFusion <https://github.com/apache/arrow/tree/master/rust/datafusion>`_.
+This is a Python library that binds to `Apache Arrow <https://arrow.apache.org/>`_ in-memory query engine `DataFusion <https://github.com/apache/datafusion>`_.
 
 Like pyspark, it allows you to build a plan through SQL or a DataFrame API against in-memory data, parquet or CSV files, run it in a multi-threaded environment, and obtain the result back in Python.
 
@@ -31,261 +31,66 @@ Its query engine, DataFusion, is written in `Rust <https://www.rust-lang.org>`_,
 
 Technically, zero-copy is achieved via the `c data interface <https://arrow.apache.org/docs/format/CDataInterface.html>`_.
 
-How to use it
-=============
-
-Simple usage:
-
-.. code-block:: python
-
-    import datafusion
-    from datafusion import col
-    import pyarrow
-
-    # create a context
-    ctx = datafusion.SessionContext()
-
-    # create a RecordBatch and a new DataFrame from it
-    batch = pyarrow.RecordBatch.from_arrays(
-        [pyarrow.array([1, 2, 3]), pyarrow.array([4, 5, 6])],
-        names=["a", "b"],
-    )
-    df = ctx.create_dataframe([[batch]])
-
-    # create a new statement
-    df = df.select(
-        col("a") + col("b"),
-        col("a") - col("b"),
-    )
-
-    # execute and collect the first (and only) batch
-    result = df.collect()[0]
-
-    assert result.column(0) == pyarrow.array([5, 7, 9])
-    assert result.column(1) == pyarrow.array([-3, -3, -3])
-
-
-We can also execute a query against data stored in CSV 
-
-.. code-block:: bash
-
-    echo "a,b\n1,4\n2,5\n3,6" > example.csv
-
-
-.. code-block:: python
-
-    import datafusion
-    from datafusion import col
-    import pyarrow
-
-    # create a context
-    ctx = datafusion.SessionContext()
-
-    # register a CSV
-    ctx.register_csv('example', 'example.csv')
-  
-    # create a new statement
-    df = ctx.table('example').select(
-        col("a") + col("b"),
-        col("a") - col("b"),
-    )
-
-    # execute and collect the first (and only) batch
-    result = df.collect()[0]
-
-    assert result.column(0) == pyarrow.array([5, 7, 9])
-    assert result.column(1) == pyarrow.array([-3, -3, -3])
-
-
-And how to execute a query against a CSV using SQL: 
-
-
-.. code-block:: python
-
-    import datafusion
-    from datafusion import col
-    import pyarrow
-
-    # create a context
-    ctx = datafusion.SessionContext()
-
-    # register a CSV
-    ctx.register_csv('example', 'example.csv')
-
-    # create a new statement via SQL
-    df = ctx.sql("SELECT a+b, a-b FROM example")
-
-    # execute and collect the first (and only) batch
-    result = df.collect()[0]
-
-    assert result.column(0) == pyarrow.array([5, 7, 9])
-    assert result.column(1) == pyarrow.array([-3, -3, -3])
-
-
-
-UDFs
-----
-
-.. code-block:: python
-
-    import pyarrow
-    from datafusion import udf
-
-    def is_null(array: pyarrow.Array) -> pyarrow.Array:
-        return array.is_null()
-
-    is_null_arr = udf(is_null, [pyarrow.int64()], pyarrow.bool_(), 'stable')
-
-    # create a context
-    ctx = datafusion.SessionContext()
-
-    # create a RecordBatch and a new DataFrame from it
-    batch = pyarrow.RecordBatch.from_arrays(
-        [pyarrow.array([1, 2, 3]), pyarrow.array([4, 5, 6])],
-        names=["a", "b"],
-    )
-    df = ctx.create_dataframe([[batch]])
-
-    df = df.select(is_null_arr(col("a")))
-
-    result = df.collect()[0]
-
-    assert result.column(0) == pyarrow.array([False] * 3)
-
-
-UDAF
-----
-
-.. code-block:: python
-
-    import pyarrow
-    import pyarrow.compute
-    import datafusion
-    from datafusion import udaf, Accumulator
-    from datafusion import col
-
-
-    class MyAccumulator(Accumulator):
-        """
-        Interface of a user-defined accumulation.
-        """
-        def __init__(self):
-            self._sum = pyarrow.scalar(0.0)
-
-        def update(self, values: pyarrow.Array) -> None:
-            # not nice since pyarrow scalars can't be summed yet. This breaks on `None`
-            self._sum = pyarrow.scalar(self._sum.as_py() + pyarrow.compute.sum(values).as_py())
-
-        def merge(self, states: pyarrow.Array) -> None:
-            # not nice since pyarrow scalars can't be summed yet. This breaks on `None`
-            self._sum = pyarrow.scalar(self._sum.as_py() + pyarrow.compute.sum(states).as_py())
-
-        def state(self) -> pyarrow.Array:
-            return pyarrow.array([self._sum.as_py()])
-
-        def evaluate(self) -> pyarrow.Scalar:
-            return self._sum
-
-    # create a context
-    ctx = datafusion.SessionContext()
-
-    # create a RecordBatch and a new DataFrame from it
-    batch = pyarrow.RecordBatch.from_arrays(
-        [pyarrow.array([1, 2, 3]), pyarrow.array([4, 5, 6])],
-        names=["a", "b"],
-    )
-    df = ctx.create_dataframe([[batch]])
-
-    my_udaf = udaf(MyAccumulator, pyarrow.float64(), pyarrow.float64(), [pyarrow.float64()], 'stable')
-
-    df = df.aggregate(
-        [],
-        [my_udaf(col("a"))]
-    )
-
-    result = df.collect()[0]
-
-    assert result.column(0) == pyarrow.array([6.0])
-
-How to install (from pip)
-=========================
-
-.. code-block:: shell
-
-   pip install datafusion
-
-You can verify the installation by running:
-
-.. code-block:: python
-
-    >>> import datafusion
-    >>> datafusion.__version__
-    '0.6.0'
-
-
-How to develop
-==============
-
-This assumes that you have rust and cargo installed. We use the workflow recommended by `pyo3 <https://github.com/PyO3/pyo3>`_ and `maturin <https://github.com/PyO3/maturin>`_.
-
-Bootstrap:
+Install
+-------
 
 .. code-block:: shell
 
-    # fetch this repo
-    git clone git@github.com:apache/arrow-datafusion-python.git
-    # prepare development environment (used to build wheel / install in development)
-    python3 -m venv venv
-    # activate the venv
-    source venv/bin/activate
-    # update pip itself if necessary
-    python -m pip install -U pip
-    # install dependencies (for Python 3.8+)
-    python -m pip install -r requirements-310.txt
+    pip install datafusion
 
-The tests rely on test data in git submodules.
+Example
+-------
 
-.. code-block:: shell
+.. ipython:: python
 
-    git submodule init
-    git submodule update
+    from datafusion import SessionContext
 
+    ctx = SessionContext()
 
-Whenever rust code changes (your changes or via `git pull`):
+    df = ctx.read_csv("pokemon.csv")
 
-.. code-block:: shell
+    df.show()
 
-   # make sure you activate the venv using "source venv/bin/activate" first
-   maturin develop
-   python -m pytest
-
-
-How to update dependencies
-==========================
-
-To change test dependencies, change the `requirements.in` and run
-
-.. code-block:: shell
-
-    # install pip-tools (this can be done only once), also consider running in venv
-    python -m pip install pip-tools
-    python -m piptools compile --generate-hashes -o requirements-310.txt
-
-
-To update dependencies, run with `-U`
-
-.. code-block:: shell
-
-   python -m piptools compile -U --generate-hashes -o requirements-310.txt
 
+.. _toc.links:
+.. toctree::
+   :hidden:
+   :maxdepth: 1
+   :caption: LINKS
 
-More details about pip-tools `here <https://github.com/jazzband/pip-tools>`_
+   Github and Issue Tracker <https://github.com/apache/datafusion-python>
+   Rust's API Docs <https://docs.rs/datafusion/latest/datafusion/>
+   Code of conduct <https://github.com/apache/datafusion/blob/main/CODE_OF_CONDUCT.md>
+   Examples <https://github.com/apache/datafusion-python/tree/main/examples>
 
+.. _toc.guide:
+.. toctree::
+   :hidden:
+   :maxdepth: 1
+   :caption: USER GUIDE
+
+   user-guide/introduction
+   user-guide/basics
+   user-guide/data-sources
+   user-guide/dataframe/index
+   user-guide/common-operations/index
+   user-guide/io/index
+   user-guide/configuration
+   user-guide/sql
+   user-guide/upgrade-guides
+
+
+.. _toc.contributor_guide:
+.. toctree::
+   :hidden:
+   :maxdepth: 1
+   :caption: CONTRIBUTOR GUIDE
 
-API reference
-=============
+   contributor-guide/introduction
+   contributor-guide/ffi
 
+.. _toc.api:
 .. toctree::
-   :maxdepth: 2
-
-   api
+   :hidden:
+   :maxdepth: 1
+   :caption: API
diff --git a/docs/source/user-guide/basics.rst b/docs/source/user-guide/basics.rst
new file mode 100644
index 000000000..7c6820461
--- /dev/null
+++ b/docs/source/user-guide/basics.rst
@@ -0,0 +1,98 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+.. _user_guide_concepts:
+
+Concepts
+========
+
+In this section, we will cover a basic example to introduce a few key concepts. We will use the
+2021 Yellow Taxi Trip Records (`download <https://d37ci6vzurychx.cloudfront.net/trip-data/yellow_tripdata_2021-01.parquet>`_),
+from the `TLC Trip Record Data <https://www.nyc.gov/site/tlc/about/tlc-trip-record-data.page>`_.
+
+.. ipython:: python
+
+    from datafusion import SessionContext, col, lit, functions as f
+
+    ctx = SessionContext()
+
+    df = ctx.read_parquet("yellow_tripdata_2021-01.parquet")
+
+    df = df.select(
+        "trip_distance",
+        col("total_amount").alias("total"),
+        (f.round(lit(100.0) * col("tip_amount") / col("total_amount"), lit(1))).alias("tip_percent"),
+    )
+
+    df.show()
+
+Session Context
+---------------
+
+The first statement group creates a :py:class:`~datafusion.context.SessionContext`.
+
+.. code-block:: python
+
+    # create a context
+    ctx = datafusion.SessionContext()
+
+A Session Context is the main interface for executing queries with DataFusion. It maintains the state
+of the connection between a user and an instance of the DataFusion engine. Additionally it provides
+the following functionality:
+
+- Create a DataFrame from a data source.
+- Register a data source as a table that can be referenced from a SQL query.
+- Execute a SQL query
+
+DataFrame
+---------
+
+The second statement group creates a :code:`DataFrame`,
+
+.. code-block:: python
+
+    # Create a DataFrame from a file
+    df = ctx.read_parquet("yellow_tripdata_2021-01.parquet")
+
+A DataFrame refers to a (logical) set of rows that share the same column names, similar to a `Pandas DataFrame <https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.html>`_.
+DataFrames are typically created by calling a method on :py:class:`~datafusion.context.SessionContext`, such as :code:`read_csv`, and can then be modified by
+calling the transformation methods, such as :py:func:`~datafusion.dataframe.DataFrame.filter`, :py:func:`~datafusion.dataframe.DataFrame.select`, :py:func:`~datafusion.dataframe.DataFrame.aggregate`,
+and :py:func:`~datafusion.dataframe.DataFrame.limit` to build up a query definition.
+
+For more details on working with DataFrames, including visualization options and conversion to other formats, see :doc:`dataframe/index`.
+
+Expressions
+-----------
+
+The third statement uses :code:`Expressions` to build up a query definition. You can find
+explanations for what the functions below do in the user documentation for
+:py:func:`~datafusion.col`, :py:func:`~datafusion.lit`, :py:func:`~datafusion.functions.round`,
+and :py:func:`~datafusion.expr.Expr.alias`.
+
+.. code-block:: python
+
+    df = df.select(
+        "trip_distance",
+        col("total_amount").alias("total"),
+        (f.round(lit(100.0) * col("tip_amount") / col("total_amount"), lit(1))).alias("tip_percent"),
+    )
+
+Finally the :py:func:`~datafusion.dataframe.DataFrame.show` method converts the logical plan
+represented by the DataFrame into a physical plan and execute it, collecting all results and
+displaying them to the user. It is important to note that DataFusion performs lazy evaluation
+of the DataFrame. Until you call a method such as :py:func:`~datafusion.dataframe.DataFrame.show`
+or :py:func:`~datafusion.dataframe.DataFrame.collect`, DataFusion will not perform the query.
diff --git a/docs/source/user-guide/common-operations/aggregations.rst b/docs/source/user-guide/common-operations/aggregations.rst
new file mode 100644
index 000000000..e458e5fcb
--- /dev/null
+++ b/docs/source/user-guide/common-operations/aggregations.rst
@@ -0,0 +1,216 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+.. _aggregation:
+
+Aggregation
+============
+
+An aggregate or aggregation is a function where the values of multiple rows are processed together
+to form a single summary value. For performing an aggregation, DataFusion provides the
+:py:func:`~datafusion.dataframe.DataFrame.aggregate`
+
+.. ipython:: python
+
+    from datafusion import SessionContext, col, lit, functions as f
+
+    ctx = SessionContext()
+    df = ctx.read_csv("pokemon.csv")
+
+    col_type_1 = col('"Type 1"')
+    col_type_2 = col('"Type 2"')
+    col_speed = col('"Speed"')
+    col_attack = col('"Attack"')
+
+    df.aggregate([col_type_1], [
+        f.approx_distinct(col_speed).alias("Count"),
+        f.approx_median(col_speed).alias("Median Speed"),
+        f.approx_percentile_cont(col_speed, 0.9).alias("90% Speed")])
+
+When the :code:`group_by` list is empty the aggregation is done over the whole :class:`.DataFrame`.
+For grouping the :code:`group_by` list must contain at least one column.
+
+.. ipython:: python
+
+    df.aggregate([col_type_1], [
+        f.max(col_speed).alias("Max Speed"),
+        f.avg(col_speed).alias("Avg Speed"),
+        f.min(col_speed).alias("Min Speed")])
+
+More than one column can be used for grouping
+
+.. ipython:: python
+
+    df.aggregate([col_type_1, col_type_2], [
+        f.max(col_speed).alias("Max Speed"),
+        f.avg(col_speed).alias("Avg Speed"),
+        f.min(col_speed).alias("Min Speed")])
+
+
+
+Setting Parameters
+------------------
+
+Each of the built in aggregate functions provides arguments for the parameters that affect their
+operation. These can also be overridden using the builder approach to setting any of the following
+parameters. When you use the builder, you must call ``build()`` to finish. For example, these two
+expressions are equivalent.
+
+.. ipython:: python
+
+    first_1 = f.first_value(col("a"), order_by=[col("a")])
+    first_2 = f.first_value(col("a")).order_by(col("a")).build()
+
+Ordering
+^^^^^^^^
+
+You can control the order in which rows are processed by window functions by providing
+a list of ``order_by`` functions for the ``order_by`` parameter. In the following example, we
+sort the Pokemon by their attack in increasing order and take the first value, which gives us the
+Pokemon with the smallest attack value in each ``Type 1``.
+
+.. ipython:: python
+
+    df.aggregate(
+        [col('"Type 1"')],
+        [f.first_value(
+            col('"Name"'),
+            order_by=[col('"Attack"').sort(ascending=True)]
+            ).alias("Smallest Attack")
+        ])
+
+Distinct
+^^^^^^^^
+
+When you set the parameter ``distinct`` to ``True``, then unique values will only be evaluated one
+time each. Suppose we want to create an array of all of the ``Type 2`` for each ``Type 1`` of our
+Pokemon set. Since there will be many entries of ``Type 2`` we only one each distinct value.
+
+.. ipython:: python
+
+    df.aggregate([col_type_1], [f.array_agg(col_type_2, distinct=True).alias("Type 2 List")])
+
+In the output of the above we can see that there are some ``Type 1`` for which the ``Type 2`` entry
+is ``null``. In reality, we probably want to filter those out. We can do this in two ways. First,
+we can filter DataFrame rows that have no ``Type 2``. If we do this, we might have some ``Type 1``
+entries entirely removed. The second is we can use the ``filter`` argument described below.
+
+.. ipython:: python
+
+    df.filter(col_type_2.is_not_null()).aggregate([col_type_1], [f.array_agg(col_type_2, distinct=True).alias("Type 2 List")])
+
+    df.aggregate([col_type_1], [f.array_agg(col_type_2, distinct=True, filter=col_type_2.is_not_null()).alias("Type 2 List")])
+
+Which approach you take should depend on your use case.
+
+Null Treatment
+^^^^^^^^^^^^^^
+
+This option allows you to either respect or ignore null values.
+
+One common usage for handling nulls is the case where you want to find the first value within a
+partition. By setting the null treatment to ignore nulls, we can find the first non-null value
+in our partition.
+
+
+.. ipython:: python
+
+    from datafusion.common import NullTreatment
+
+    df.aggregate([col_type_1], [
+        f.first_value(
+            col_type_2,
+            order_by=[col_attack],
+            null_treatment=NullTreatment.RESPECT_NULLS
+        ).alias("Lowest Attack Type 2")])
+
+    df.aggregate([col_type_1], [
+        f.first_value(
+            col_type_2,
+            order_by=[col_attack],
+            null_treatment=NullTreatment.IGNORE_NULLS
+        ).alias("Lowest Attack Type 2")])
+
+Filter
+^^^^^^
+
+Using the filter option is useful for filtering results to include in the aggregate function. It can
+be seen in the example above on how this can be useful to only filter rows evaluated by the
+aggregate function without filtering rows from the entire DataFrame.
+
+Filter takes a single expression.
+
+Suppose we want to find the speed values for only Pokemon that have low Attack values.
+
+.. ipython:: python
+
+    df.aggregate([col_type_1], [
+        f.avg(col_speed).alias("Avg Speed All"),
+        f.avg(col_speed, filter=col_attack < lit(50)).alias("Avg Speed Low Attack")])
+
+
+Aggregate Functions
+-------------------
+
+The available aggregate functions are:
+
+1. Comparison Functions
+    - :py:func:`datafusion.functions.min`
+    - :py:func:`datafusion.functions.max`
+2. Math Functions
+    - :py:func:`datafusion.functions.sum`
+    - :py:func:`datafusion.functions.avg`
+    - :py:func:`datafusion.functions.median`
+3. Array Functions
+    - :py:func:`datafusion.functions.array_agg`
+4. Logical Functions
+    - :py:func:`datafusion.functions.bit_and`
+    - :py:func:`datafusion.functions.bit_or`
+    - :py:func:`datafusion.functions.bit_xor`
+    - :py:func:`datafusion.functions.bool_and`
+    - :py:func:`datafusion.functions.bool_or`
+5. Statistical Functions
+    - :py:func:`datafusion.functions.count`
+    - :py:func:`datafusion.functions.corr`
+    - :py:func:`datafusion.functions.covar_samp`
+    - :py:func:`datafusion.functions.covar_pop`
+    - :py:func:`datafusion.functions.stddev`
+    - :py:func:`datafusion.functions.stddev_pop`
+    - :py:func:`datafusion.functions.var_samp`
+    - :py:func:`datafusion.functions.var_pop`
+6. Linear Regression Functions
+    - :py:func:`datafusion.functions.regr_count`
+    - :py:func:`datafusion.functions.regr_slope`
+    - :py:func:`datafusion.functions.regr_intercept`
+    - :py:func:`datafusion.functions.regr_r2`
+    - :py:func:`datafusion.functions.regr_avgx`
+    - :py:func:`datafusion.functions.regr_avgy`
+    - :py:func:`datafusion.functions.regr_sxx`
+    - :py:func:`datafusion.functions.regr_syy`
+    - :py:func:`datafusion.functions.regr_slope`
+7. Positional Functions
+    - :py:func:`datafusion.functions.first_value`
+    - :py:func:`datafusion.functions.last_value`
+    - :py:func:`datafusion.functions.nth_value`
+8. String Functions
+    - :py:func:`datafusion.functions.string_agg`
+9. Approximation Functions
+    - :py:func:`datafusion.functions.approx_distinct`
+    - :py:func:`datafusion.functions.approx_median`
+    - :py:func:`datafusion.functions.approx_percentile_cont`
+    - :py:func:`datafusion.functions.approx_percentile_cont_with_weight`
+
diff --git a/docs/source/user-guide/common-operations/basic-info.rst b/docs/source/user-guide/common-operations/basic-info.rst
new file mode 100644
index 000000000..d48b49d5c
--- /dev/null
+++ b/docs/source/user-guide/common-operations/basic-info.rst
@@ -0,0 +1,61 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+Basic Operations
+================
+
+In this section, you will learn how to display essential details of DataFrames using specific functions.
+
+.. ipython:: python
+    
+    from datafusion import SessionContext
+    import random
+    
+    ctx = SessionContext()
+    df = ctx.from_pydict({
+        "nrs": [1, 2, 3, 4, 5],
+        "names": ["python", "ruby", "java", "haskell", "go"],
+        "random": random.sample(range(1000), 5),
+        "groups": ["A", "A", "B", "C", "B"],
+    })
+    df
+
+Use :py:func:`~datafusion.dataframe.DataFrame.limit` to view the top rows of the frame:
+
+.. ipython:: python
+
+    df.limit(2)
+
+Display the columns of the DataFrame using :py:func:`~datafusion.dataframe.DataFrame.schema`:
+
+.. ipython:: python
+
+    df.schema()
+
+The method :py:func:`~datafusion.dataframe.DataFrame.to_pandas` uses pyarrow to convert to pandas DataFrame, by collecting the batches,
+passing them to an Arrow table, and then converting them to a pandas DataFrame.
+
+.. ipython:: python
+
+    df.to_pandas()
+
+:py:func:`~datafusion.dataframe.DataFrame.describe` shows a quick statistic summary of your data:
+
+.. ipython:: python
+
+    df.describe()
+
diff --git a/docs/source/user-guide/common-operations/expressions.rst b/docs/source/user-guide/common-operations/expressions.rst
new file mode 100644
index 000000000..7848b4ee7
--- /dev/null
+++ b/docs/source/user-guide/common-operations/expressions.rst
@@ -0,0 +1,196 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+.. _expressions:
+
+Expressions
+===========
+
+In DataFusion an expression is an abstraction that represents a computation.
+Expressions are used as the primary inputs and outputs for most functions within
+DataFusion. As such, expressions can be combined to create expression trees, a
+concept shared across most compilers and databases.
+
+Column
+------
+
+The first expression most new users will interact with is the Column, which is created by calling :py:func:`~datafusion.col`.
+This expression represents a column within a DataFrame. The function :py:func:`~datafusion.col` takes as in input a string
+and returns an expression as it's output.
+
+Literal
+-------
+
+Literal expressions represent a single value. These are helpful in a wide range of operations where
+a specific, known value is of interest. You can create a literal expression using the function :py:func:`~datafusion.lit`.
+The type of the object passed to the :py:func:`~datafusion.lit` function will be used to convert it to a known data type.
+
+In the following example we create expressions for the column named `color` and the literal scalar string `red`.
+The resultant variable `red_units` is itself also an expression.
+
+.. ipython:: python
+
+    red_units = col("color") == lit("red")
+
+Boolean
+-------
+
+When combining expressions that evaluate to a boolean value, you can combine these expressions using boolean operators.
+It is important to note that in order to combine these expressions, you *must* use bitwise operators. See the following
+examples for the and, or, and not operations.
+
+
+.. ipython:: python
+
+    red_or_green_units = (col("color") == lit("red")) | (col("color") == lit("green"))
+    heavy_red_units = (col("color") == lit("red")) & (col("weight") > lit(42))
+    not_red_units = ~(col("color") == lit("red"))
+
+Arrays
+------
+
+For columns that contain arrays of values, you can access individual elements of the array by index
+using bracket indexing. This is similar to calling the function
+:py:func:`datafusion.functions.array_element`, except that array indexing using brackets is 0 based,
+similar to Python arrays and ``array_element`` is 1 based indexing to be compatible with other SQL
+approaches.
+
+.. ipython:: python
+
+    from datafusion import SessionContext, col
+
+    ctx = SessionContext()
+    df = ctx.from_pydict({"a": [[1, 2, 3], [4, 5, 6]]})
+    df.select(col("a")[0].alias("a0"))
+
+.. warning::
+
+    Indexing an element of an array via ``[]`` starts at index 0 whereas
+    :py:func:`~datafusion.functions.array_element` starts at index 1.
+
+Starting in DataFusion 49.0.0 you can also create slices of array elements using
+slice syntax from Python.
+
+.. ipython:: python
+
+    df.select(col("a")[1:3].alias("second_two_elements"))
+
+To check if an array is empty, you can use the function :py:func:`datafusion.functions.array_empty` or `datafusion.functions.empty`.
+This function returns a boolean indicating whether the array is empty.
+
+.. ipython:: python
+
+    from datafusion import SessionContext, col
+    from datafusion.functions import array_empty
+
+    ctx = SessionContext()
+    df = ctx.from_pydict({"a": [[], [1, 2, 3]]})
+    df.select(array_empty(col("a")).alias("is_empty"))
+
+In this example, the `is_empty` column will contain `True` for the first row and `False` for the second row.
+
+To get the total number of elements in an array, you can use the function :py:func:`datafusion.functions.cardinality`.
+This function returns an integer indicating the total number of elements in the array.
+
+.. ipython:: python
+
+    from datafusion import SessionContext, col
+    from datafusion.functions import cardinality
+
+    ctx = SessionContext()
+    df = ctx.from_pydict({"a": [[1, 2, 3], [4, 5, 6]]})
+    df.select(cardinality(col("a")).alias("num_elements"))
+
+In this example, the `num_elements` column will contain `3` for both rows.
+
+To concatenate two arrays, you can use the function :py:func:`datafusion.functions.array_cat` or :py:func:`datafusion.functions.array_concat`.
+These functions return a new array that is the concatenation of the input arrays.
+
+.. ipython:: python
+
+    from datafusion import SessionContext, col
+    from datafusion.functions import array_cat, array_concat
+
+    ctx = SessionContext()
+    df = ctx.from_pydict({"a": [[1, 2, 3]], "b": [[4, 5, 6]]})
+    df.select(array_cat(col("a"), col("b")).alias("concatenated_array"))
+
+In this example, the `concatenated_array` column will contain `[1, 2, 3, 4, 5, 6]`.
+
+To repeat the elements of an array a specified number of times, you can use the function :py:func:`datafusion.functions.array_repeat`.
+This function returns a new array with the elements repeated.
+
+.. ipython:: python
+
+    from datafusion import SessionContext, col, literal
+    from datafusion.functions import array_repeat
+
+    ctx = SessionContext()
+    df = ctx.from_pydict({"a": [[1, 2, 3]]})
+    df.select(array_repeat(col("a"), literal(2)).alias("repeated_array"))
+
+In this example, the `repeated_array` column will contain `[[1, 2, 3], [1, 2, 3]]`.
+
+
+Structs
+-------
+
+Columns that contain struct elements can be accessed using the bracket notation as if they were
+Python dictionary style objects. This expects a string key as the parameter passed.
+
+.. ipython:: python
+
+    ctx = SessionContext()
+    data = {"a": [{"size": 15, "color": "green"}, {"size": 10, "color": "blue"}]}
+    df = ctx.from_pydict(data)
+    df.select(col("a")["size"].alias("a_size"))
+
+
+Functions
+---------
+
+As mentioned before, most functions in DataFusion return an expression at their output. This allows us to create
+a wide variety of expressions built up from other expressions. For example, :py:func:`~datafusion.expr.Expr.alias` is a function that takes
+as it input a single expression and returns an expression in which the name of the expression has changed.
+
+The following example shows a series of expressions that are built up from functions operating on expressions.
+
+.. ipython:: python
+
+    from datafusion import SessionContext
+    from datafusion import column, lit
+    from datafusion import functions as f
+    import random
+
+    ctx = SessionContext()
+    df = ctx.from_pydict(
+        {
+            "name": ["Albert", "Becca", "Carlos", "Dante"],
+            "age": [42, 67, 27, 71],
+            "years_in_position": [13, 21, 10, 54],
+        },
+        name="employees"
+    )
+
+    age_col = col("age")
+    renamed_age = age_col.alias("age_in_years")
+    start_age = age_col - col("years_in_position")
+    started_young = start_age < lit(18)
+    can_retire = age_col > lit(65)
+    long_timer = started_young & can_retire
+
+    df.filter(long_timer).select(col("name"), renamed_age, col("years_in_position"))
diff --git a/docs/source/user-guide/common-operations/functions.rst b/docs/source/user-guide/common-operations/functions.rst
new file mode 100644
index 000000000..ccb47a4e7
--- /dev/null
+++ b/docs/source/user-guide/common-operations/functions.rst
@@ -0,0 +1,152 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+Functions
+=========
+
+DataFusion provides a large number of built-in functions for performing complex queries without requiring user-defined functions.
+In here we will cover some of the more popular use cases. If you want to view all the functions go to the :py:mod:`Functions <datafusion.functions>` API Reference.
+
+We'll use the pokemon dataset in the following examples.
+
+.. ipython:: python
+
+    from datafusion import SessionContext
+
+    ctx = SessionContext()
+    ctx.register_csv("pokemon", "pokemon.csv")
+    df = ctx.table("pokemon")
+
+Mathematical
+------------
+
+DataFusion offers mathematical functions such as :py:func:`~datafusion.functions.pow` or :py:func:`~datafusion.functions.log`
+
+.. ipython:: python
+
+    from datafusion import col, literal, string_literal, str_lit
+    from datafusion import functions as f
+
+    df.select(
+        f.pow(col('"Attack"'), literal(2)) - f.pow(col('"Defense"'), literal(2))
+    ).limit(10)
+
+
+Conditional
+-----------
+
+There 3 conditional functions in DataFusion :py:func:`~datafusion.functions.coalesce`, :py:func:`~datafusion.functions.nullif` and :py:func:`~datafusion.functions.case`.
+
+.. ipython:: python
+
+    df.select(
+        f.coalesce(col('"Type 1"'), col('"Type 2"')).alias("dominant_type")
+    ).limit(10)
+
+Temporal
+--------
+
+For selecting the current time use :py:func:`~datafusion.functions.now`
+
+.. ipython:: python
+
+    df.select(f.now())
+
+Convert to timestamps using :py:func:`~datafusion.functions.to_timestamp`
+
+.. ipython:: python
+
+    df.select(f.to_timestamp(col('"Total"')).alias("timestamp"))
+
+Extracting parts of a date using :py:func:`~datafusion.functions.date_part` (alias :py:func:`~datafusion.functions.extract`)
+
+.. ipython:: python
+
+     df.select(
+        f.date_part(literal("month"), f.to_timestamp(col('"Total"'))).alias("month"),
+        f.extract(literal("day"), f.to_timestamp(col('"Total"'))).alias("day")
+     )
+  
+String
+------
+
+In the field of data science, working with textual data is a common task. To make string manipulation easier,
+DataFusion offers a range of helpful options.
+
+.. ipython:: python
+
+    df.select(
+        f.char_length(col('"Name"')).alias("len"),
+        f.lower(col('"Name"')).alias("lower"),
+        f.left(col('"Name"'), literal(4)).alias("code")
+    )
+
+This also includes the functions for regular expressions like :py:func:`~datafusion.functions.regexp_replace` and :py:func:`~datafusion.functions.regexp_match`
+
+.. ipython:: python
+
+    df.select(
+        f.regexp_match(col('"Name"'), literal("Char")).alias("dragons"),
+        f.regexp_replace(col('"Name"'), literal("saur"), literal("fleur")).alias("flowers")
+    )
+
+Casting
+-------
+
+Casting expressions to different data types using :py:func:`~datafusion.functions.arrow_cast`
+
+.. ipython:: python
+
+    df.select(
+        f.arrow_cast(col('"Total"'), string_literal("Float64")).alias("total_as_float"),
+        f.arrow_cast(col('"Total"'), str_lit("Int32")).alias("total_as_int")
+    )
+
+Other
+-----
+
+The function :py:func:`~datafusion.functions.in_list` allows to check a column for the presence of multiple values:
+
+.. ipython:: python
+
+    types = [literal("Grass"), literal("Fire"), literal("Water")]
+    (
+        df.select(f.in_list(col('"Type 1"'), types, negated=False).alias("basic_types"))
+          .limit(20)
+          .to_pandas()
+    )
+
+
+Handling Missing Values 
+=======================
+
+DataFusion provides methods to handle missing values in DataFrames:
+
+fill_null
+---------
+
+The ``fill_null()`` method replaces NULL values in specified columns with a provided value:
+
+.. code-block:: python
+
+    # Fill all NULL values with 0 where possible
+    df = df.fill_null(0)
+
+    # Fill NULL values only in specific string columns
+    df = df.fill_null("missing", subset=["name", "category"]) 
+
+The fill value will be cast to match each column's type. If casting fails for a column, that column remains unchanged.
diff --git a/docs/source/api.rst b/docs/source/user-guide/common-operations/index.rst
similarity index 76%
rename from docs/source/api.rst
rename to docs/source/user-guide/common-operations/index.rst
index a3e7e24df..7abd1f138 100644
--- a/docs/source/api.rst
+++ b/docs/source/user-guide/common-operations/index.rst
@@ -15,18 +15,20 @@
 .. specific language governing permissions and limitations
 .. under the License.
 
-.. _api:
+Common Operations
+=================
 
-*************
-API Reference
-*************
+The contents of this section are designed to guide a new user through how to use DataFusion.
 
 .. toctree::
    :maxdepth: 2
 
-   api/config
-   api/dataframe
-   api/execution_context
-   api/expr
-   api/functions
-   api/object_store
+   views
+   basic-info
+   select-and-filter
+   expressions
+   joins
+   functions
+   aggregations
+   windows
+   udf-and-udfa
diff --git a/docs/source/user-guide/common-operations/joins.rst b/docs/source/user-guide/common-operations/joins.rst
new file mode 100644
index 000000000..1d9d70385
--- /dev/null
+++ b/docs/source/user-guide/common-operations/joins.rst
@@ -0,0 +1,136 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+Joins
+=====
+
+DataFusion supports the following join variants via the method :py:func:`~datafusion.dataframe.DataFrame.join`
+
+- Inner Join
+- Left Join
+- Right Join
+- Full Join
+- Left Semi Join
+- Left Anti Join
+
+For the examples in this section we'll use the following two DataFrames
+
+.. ipython:: python
+
+    from datafusion import SessionContext
+
+    ctx = SessionContext()
+
+    left = ctx.from_pydict(
+        {
+            "customer_id": [1, 2, 3],
+            "customer": ["Alice", "Bob", "Charlie"],
+        }
+    )
+
+    right = ctx.from_pylist([
+        {"id": 1, "name": "CityCabs"},
+        {"id": 2, "name": "MetroRide"},
+        {"id": 5, "name": "UrbanGo"},
+    ])
+
+Inner Join
+----------
+
+When using an inner join, only rows containing the common values between the two join columns present in both DataFrames
+will be included in the resulting DataFrame.
+
+.. ipython:: python
+
+    left.join(right, left_on="customer_id", right_on="id", how="inner")
+
+The parameter ``join_keys`` specifies the columns from the left DataFrame and right DataFrame that contains the values
+that should match.
+
+Left Join
+---------
+
+A left join combines rows from two DataFrames using the key columns. It returns all rows from the left DataFrame and
+matching rows from the right DataFrame. If there's no match in the right DataFrame, it returns null
+values for the corresponding columns.
+
+.. ipython:: python
+
+    left.join(right, left_on="customer_id", right_on="id", how="left")
+
+Full Join
+---------
+
+A full join merges rows from two tables based on a related column, returning all rows from both tables, even if there
+is no match. Unmatched rows will have null values.
+
+.. ipython:: python
+
+    left.join(right, left_on="customer_id", right_on="id", how="full")
+
+Left Semi Join
+--------------
+
+A left semi join retrieves matching rows from the left table while
+omitting duplicates with multiple matches in the right table.
+
+.. ipython:: python
+
+    left.join(right, left_on="customer_id", right_on="id", how="semi")
+
+Left Anti Join
+--------------
+
+A left anti join shows all rows from the left table without any matching rows in the right table,
+based on a the specified matching columns. It excludes rows from the left table that have at least one matching row in
+the right table.
+
+.. ipython:: python
+
+    left.join(right, left_on="customer_id", right_on="id", how="anti")
+
+Duplicate Keys
+--------------
+
+It is common to join two DataFrames on a common column name. Starting in
+version 51.0.0, ``datafusion-python``` will now coalesce on column with identical names by
+default. This reduces problems with ambiguous column selection after joins.
+You can disable this feature by setting the parameter ``coalesce_duplicate_keys``
+to ``False``.
+
+.. ipython:: python
+
+    left = ctx.from_pydict(
+        {
+            "id": [1, 2, 3],
+            "customer": ["Alice", "Bob", "Charlie"],
+        }
+    )
+
+    right = ctx.from_pylist([
+        {"id": 1, "name": "CityCabs"},
+        {"id": 2, "name": "MetroRide"},
+        {"id": 5, "name": "UrbanGo"},
+    ])
+
+    left.join(right, "id", how="inner")
+
+In contrast to the above example, if we wish to get both columns:
+
+.. ipython:: python
+
+    left.join(right, "id", how="inner", coalesce_duplicate_keys=False)
diff --git a/docs/source/user-guide/common-operations/select-and-filter.rst b/docs/source/user-guide/common-operations/select-and-filter.rst
new file mode 100644
index 000000000..083bcbbd2
--- /dev/null
+++ b/docs/source/user-guide/common-operations/select-and-filter.rst
@@ -0,0 +1,64 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+Column Selections
+=================
+
+Use :py:func:`~datafusion.dataframe.DataFrame.select`  for basic column selection.
+
+DataFusion can work with several file types, to start simple we can use a subset of the 
+`TLC Trip Record Data <https://www.nyc.gov/site/tlc/about/tlc-trip-record-data.page>`_,
+which you can download `here <https://d37ci6vzurychx.cloudfront.net/trip-data/yellow_tripdata_2021-01.parquet>`_.
+
+.. ipython:: python
+
+    from datafusion import SessionContext
+    
+    ctx = SessionContext()
+    df = ctx.read_parquet("yellow_tripdata_2021-01.parquet")
+    df.select("trip_distance", "passenger_count")
+
+For mathematical or logical operations use :py:func:`~datafusion.col` to select columns, and give meaningful names to the resulting
+operations using :py:func:`~datafusion.expr.Expr.alias`
+
+
+.. ipython:: python
+    
+    from datafusion import col, lit
+    df.select((col("tip_amount") + col("tolls_amount")).alias("tips_plus_tolls"))
+
+.. warning::
+
+    Please be aware that all identifiers are effectively made lower-case in SQL, so if your file has capital letters
+    (ex: Name) you must put your column name in double quotes or the selection won’t work. As an alternative for simple
+    column selection use :py:func:`~datafusion.dataframe.DataFrame.select` without double quotes
+
+For selecting columns with capital letters use ``'"VendorID"'``
+
+.. ipython:: python
+
+    df.select(col('"VendorID"'))
+
+
+To combine it with literal values use the :py:func:`~datafusion.lit`
+
+.. ipython:: python
+
+    large_trip_distance = col("trip_distance") > lit(5.0)
+    low_passenger_count = col("passenger_count") < lit(4)
+    df.select((large_trip_distance & low_passenger_count).alias("lonely_trips"))
+
diff --git a/docs/source/user-guide/common-operations/udf-and-udfa.rst b/docs/source/user-guide/common-operations/udf-and-udfa.rst
new file mode 100644
index 000000000..f669721a3
--- /dev/null
+++ b/docs/source/user-guide/common-operations/udf-and-udfa.rst
@@ -0,0 +1,306 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+User-Defined Functions
+======================
+
+DataFusion provides powerful expressions and functions, reducing the need for custom Python
+functions. However you can still incorporate your own functions, i.e. User-Defined Functions (UDFs).
+
+Scalar Functions
+----------------
+
+When writing a user-defined function that can operate on a row by row basis, these are called Scalar
+Functions. You can define your own scalar function by calling
+:py:func:`~datafusion.user_defined.ScalarUDF.udf` .
+
+The basic definition of a scalar UDF is a python function that takes one or more
+`pyarrow <https://arrow.apache.org/docs/python/index.html>`_ arrays and returns a single array as
+output. DataFusion scalar UDFs operate on an entire batch of records at a time, though the
+evaluation of those records should be on a row by row basis. In the following example, we compute
+if the input array contains null values.
+
+.. ipython:: python
+
+    import pyarrow
+    import datafusion
+    from datafusion import udf, col
+
+    def is_null(array: pyarrow.Array) -> pyarrow.Array:
+        return array.is_null()
+
+    is_null_arr = udf(is_null, [pyarrow.int64()], pyarrow.bool_(), 'stable')
+
+    ctx = datafusion.SessionContext()
+
+    batch = pyarrow.RecordBatch.from_arrays(
+        [pyarrow.array([1, None, 3]), pyarrow.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+    df = ctx.create_dataframe([[batch]], name="batch_array")
+
+    df.select(col("a"), is_null_arr(col("a")).alias("is_null")).show()
+
+In the previous example, we used the fact that pyarrow provides a variety of built in array
+functions such as ``is_null()``. There are additional pyarrow
+`compute functions <https://arrow.apache.org/docs/python/compute.html>`_ available. When possible,
+it is highly recommended to use these functions because they can perform computations without doing
+any copy operations from the original arrays. This leads to greatly improved performance.
+
+If you need to perform an operation in python that is not available with the pyarrow compute
+functions, you will need to convert the record batch into python values, perform your operation,
+and construct an array. This operation of converting the built in data type of the array into a
+python object can be one of the slowest operations in DataFusion, so it should be done sparingly.
+
+The following example performs the same operation as before with ``is_null`` but demonstrates
+converting to Python objects to do the evaluation.
+
+.. ipython:: python
+
+    import pyarrow
+    import datafusion
+    from datafusion import udf, col
+
+    def is_null(array: pyarrow.Array) -> pyarrow.Array:
+        return pyarrow.array([value.as_py() is None for value in array])
+
+    is_null_arr = udf(is_null, [pyarrow.int64()], pyarrow.bool_(), 'stable')
+
+    ctx = datafusion.SessionContext()
+
+    batch = pyarrow.RecordBatch.from_arrays(
+        [pyarrow.array([1, None, 3]), pyarrow.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+    df = ctx.create_dataframe([[batch]], name="batch_array")
+
+    df.select(col("a"), is_null_arr(col("a")).alias("is_null")).show()
+
+In this example we passed the PyArrow ``DataType`` when we defined the function
+by calling ``udf()``. If you need additional control, such as specifying
+metadata or nullability of the input or output, you can instead specify a
+PyArrow ``Field``.
+
+If you need to write a custom function but do not want to incur the performance
+cost of converting to Python objects and back, a more advanced approach is to
+write Rust based UDFs and to expose them to Python. There is an example in the
+`DataFusion blog <https://datafusion.apache.org/blog/2024/11/19/datafusion-python-udf-comparisons/>`_
+describing how to do this.
+
+Aggregate Functions
+-------------------
+
+The :py:func:`~datafusion.user_defined.AggregateUDF.udaf` function allows you to define User-Defined
+Aggregate Functions (UDAFs). To use this you must implement an
+:py:class:`~datafusion.user_defined.Accumulator` that determines how the aggregation is performed.
+
+When defining a UDAF there are four methods you need to implement. The ``update`` function takes the
+array(s) of input and updates the internal state of the accumulator. You should define this function
+to have as many input arguments as you will pass when calling the UDAF. Since aggregation may be
+split into multiple batches, we must have a method to combine multiple batches. For this, we have
+two functions, ``state`` and ``merge``. ``state`` will return an array of scalar values that contain
+the current state of a single batch accumulation. Then we must ``merge`` the results of these
+different states. Finally ``evaluate`` is the call that will return the final result after the
+``merge`` is complete.
+
+In the following example we want to define a custom aggregate function that will return the
+difference between the sum of two columns. The state can be represented by a single value and we can
+also see how the inputs to ``update`` and ``merge`` differ.
+
+.. code-block:: python
+
+    import pyarrow as pa
+    import pyarrow.compute
+    import datafusion
+    from datafusion import col, udaf, Accumulator
+    from typing import List
+
+    class MyAccumulator(Accumulator):
+        """
+        Interface of a user-defined accumulation.
+        """
+        def __init__(self):
+            self._sum = 0.0
+
+        def update(self, values_a: pa.Array, values_b: pa.Array) -> None:
+            self._sum = self._sum + pyarrow.compute.sum(values_a).as_py() - pyarrow.compute.sum(values_b).as_py()
+
+        def merge(self, states: list[pa.Array]) -> None:
+            self._sum = self._sum + pyarrow.compute.sum(states[0]).as_py()
+
+        def state(self) -> list[pa.Scalar]:
+            return [pyarrow.scalar(self._sum)]
+
+        def evaluate(self) -> pa.Scalar:
+            return pyarrow.scalar(self._sum)
+
+    ctx = datafusion.SessionContext()
+    df = ctx.from_pydict(
+        {
+            "a": [4, 5, 6],
+            "b": [1, 2, 3],
+        }
+    )
+
+    my_udaf = udaf(MyAccumulator, [pa.float64(), pa.float64()], pa.float64(), [pa.float64()], 'stable')
+
+    df.aggregate([], [my_udaf(col("a"), col("b")).alias("col_diff")])
+
+FAQ
+^^^
+
+**How do I return a list from a UDAF?**
+
+Both the ``evaluate`` and the ``state`` functions expect to return scalar values.
+If you wish to return a list array as a scalar value, the best practice is to
+wrap the values in a ``pyarrow.Scalar`` object. For example, you can return a
+timestamp list with ``pa.scalar([...], type=pa.list_(pa.timestamp("ms")))`` and
+register the appropriate return or state types as
+``return_type=pa.list_(pa.timestamp("ms"))`` and
+``state_type=[pa.list_(pa.timestamp("ms"))]``, respectively.
+
+As of DataFusion 52.0.0 , you can pass return any Python object, including a
+PyArrow array, as the return value(s) for these functions and DataFusion will
+attempt to create a scalar type from the value. DataFusion has been tested to
+convert PyArrow, nanoarrow, and arro3 objects as well as primitive data types
+like integers, strings, and so on.
+
+Window Functions
+----------------
+
+To implement a User-Defined Window Function (UDWF) you must call the
+:py:func:`~datafusion.user_defined.WindowUDF.udwf` function using a class that implements the abstract
+class :py:class:`~datafusion.user_defined.WindowEvaluator`.
+
+There are three methods of evaluation of UDWFs.
+
+- ``evaluate`` is the simplest case, where you are given an array and are expected to calculate the
+  value for a single row of that array. This is the simplest case, but also the least performant.
+- ``evaluate_all`` computes the values for all rows for an input array at a single time.
+- ``evaluate_all_with_rank`` computes the values for all rows, but you only have the rank
+  information for the rows.
+
+Which methods you implement are based upon which of these options are set.
+
+.. list-table::
+   :header-rows: 1
+
+   * - ``uses_window_frame``
+     - ``supports_bounded_execution``
+     - ``include_rank``
+     - function_to_implement
+   * - False (default)
+     - False (default)
+     - False (default)
+     - ``evaluate_all``
+   * - False
+     - True
+     - False
+     - ``evaluate``
+   * - False
+     - True
+     - False
+     - ``evaluate_all_with_rank``
+   * - True
+     - True/False
+     - True/False
+     - ``evaluate``
+
+UDWF options
+^^^^^^^^^^^^
+
+When you define your UDWF you can override the functions that return these values. They will
+determine which evaluate functions are called.
+
+- ``uses_window_frame`` is set for functions that compute based on the specified window frame. If
+  your function depends upon the specified frame, set this to ``True``.
+- ``supports_bounded_execution`` specifies if your function can be incrementally computed.
+- ``include_rank`` is set to ``True`` for window functions that can be computed only using the rank
+  information.
+
+
+.. code-block:: python
+
+    import pyarrow as pa
+    from datafusion import udwf, col, SessionContext
+    from datafusion.user_defined import WindowEvaluator
+
+    class ExponentialSmooth(WindowEvaluator):
+        def __init__(self, alpha: float) -> None:
+            self.alpha = alpha
+
+        def evaluate_all(self, values: list[pa.Array], num_rows: int) -> pa.Array:
+            results = []
+            curr_value = 0.0
+            values = values[0]
+            for idx in range(num_rows):
+                if idx == 0:
+                    curr_value = values[idx].as_py()
+                else:
+                    curr_value = values[idx].as_py() * self.alpha + curr_value * (
+                        1.0 - self.alpha
+                    )
+                results.append(curr_value)
+
+            return pa.array(results)
+
+    exp_smooth = udwf(
+        ExponentialSmooth(0.9),
+        pa.float64(),
+        pa.float64(),
+        volatility="immutable",
+    )
+
+    ctx = SessionContext()
+
+    df = ctx.from_pydict({
+        "a": [1.0, 2.1, 2.9, 4.0, 5.1, 6.0, 6.9, 8.0]
+    })
+
+    df.select("a", exp_smooth(col("a")).alias("smooth_a")).show()
+
+Table Functions
+---------------
+
+User Defined Table Functions are slightly different than the other functions
+described here. These functions take any number of `Expr` arguments, but only
+literal expressions are supported. Table functions must return a Table
+Provider as described in the ref:`_io_custom_table_provider` page.
+
+Once you have a table function, you can register it with the session context
+by using :py:func:`datafusion.context.SessionContext.register_udtf`.
+
+There are examples of both rust backed and python based table functions in the
+examples folder of the repository. If you have a rust backed table function
+that you wish to expose via PyO3, you need to expose it as a ``PyCapsule``.
+
+.. code-block:: rust
+
+    #[pymethods]
+    impl MyTableFunction {
+        fn __datafusion_table_function__<'py>(
+            &self,
+            py: Python<'py>,
+        ) -> PyResult<Bound<'py, PyCapsule>> {
+            let name = cr"datafusion_table_function".into();
+
+            let func = self.clone();
+            let provider = FFI_TableFunction::new(Arc::new(func), None);
+
+            PyCapsule::new(py, provider, Some(name))
+        }
+    }
diff --git a/docs/source/user-guide/common-operations/views.rst b/docs/source/user-guide/common-operations/views.rst
new file mode 100644
index 000000000..df11e3abe
--- /dev/null
+++ b/docs/source/user-guide/common-operations/views.rst
@@ -0,0 +1,58 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+======================
+Registering Views
+======================
+
+You can use the context's ``register_view`` method to register a DataFrame as a view
+
+.. code-block:: python
+
+    from datafusion import SessionContext, col, literal
+
+    # Create a DataFusion context
+    ctx = SessionContext()
+
+    # Create sample data
+    data = {"a": [1, 2, 3, 4, 5], "b": [10, 20, 30, 40, 50]}
+
+    # Create a DataFrame from the dictionary
+    df = ctx.from_pydict(data, "my_table")
+
+    # Filter the DataFrame (for example, keep rows where a > 2)
+    df_filtered = df.filter(col("a") > literal(2))
+
+    # Register the dataframe as a view with the context
+    ctx.register_view("view1", df_filtered)
+
+    # Now run a SQL query against the registered view
+    df_view = ctx.sql("SELECT * FROM view1")
+
+    # Collect the results
+    results = df_view.collect()
+
+    # Convert results to a list of dictionaries for display
+    result_dicts = [batch.to_pydict() for batch in results]
+
+    print(result_dicts)
+
+This will output:
+
+.. code-block:: python
+
+    [{'a': [3, 4, 5], 'b': [30, 40, 50]}]
diff --git a/docs/source/user-guide/common-operations/windows.rst b/docs/source/user-guide/common-operations/windows.rst
new file mode 100644
index 000000000..c8fdea8f4
--- /dev/null
+++ b/docs/source/user-guide/common-operations/windows.rst
@@ -0,0 +1,216 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+.. _window_functions:
+
+Window Functions
+================
+
+In this section you will learn about window functions. A window function utilizes values from one or
+multiple rows to produce a result for each individual row, unlike an aggregate function that
+provides a single value for multiple rows.
+
+The window functions are available in the :py:mod:`~datafusion.functions` module.
+
+We'll use the pokemon dataset (from Ritchie Vink) in the following examples.
+
+.. ipython:: python
+
+    from datafusion import SessionContext
+    from datafusion import col, lit
+    from datafusion import functions as f
+
+    ctx = SessionContext()
+    df = ctx.read_csv("pokemon.csv")
+
+Here is an example that shows how you can compare each pokemon's speed to the speed of the
+previous row in the DataFrame.
+
+.. ipython:: python
+
+    df.select(
+        col('"Name"'),
+        col('"Speed"'),
+        f.lag(col('"Speed"')).alias("Previous Speed")
+    )
+
+Setting Parameters
+------------------
+
+
+Ordering
+^^^^^^^^
+
+You can control the order in which rows are processed by window functions by providing
+a list of ``order_by`` functions for the ``order_by`` parameter.
+
+.. ipython:: python
+
+    df.select(
+        col('"Name"'),
+        col('"Attack"'),
+        col('"Type 1"'),
+        f.rank(
+            partition_by=[col('"Type 1"')],
+            order_by=[col('"Attack"').sort(ascending=True)],
+        ).alias("rank"),
+    ).sort(col('"Type 1"'), col('"Attack"'))
+
+Partitions
+^^^^^^^^^^
+
+A window function can take a list of ``partition_by`` columns similar to an
+:ref:`Aggregation Function<aggregation>`. This will cause the window values to be evaluated
+independently for each of the partitions. In the example above, we found the rank of each
+Pokemon per ``Type 1`` partitions. We can see the first couple of each partition if we do
+the following:
+
+.. ipython:: python
+
+    df.select(
+        col('"Name"'),
+        col('"Attack"'),
+        col('"Type 1"'),
+        f.rank(
+            partition_by=[col('"Type 1"')],
+            order_by=[col('"Attack"').sort(ascending=True)],
+        ).alias("rank"),
+    ).filter(col("rank") < lit(3)).sort(col('"Type 1"'), col("rank"))
+
+Window Frame
+^^^^^^^^^^^^
+
+When using aggregate functions, the Window Frame of defines the rows over which it operates.
+If you do not specify a Window Frame, the frame will be set depending on the following
+criteria.
+
+* If an ``order_by`` clause is set, the default window frame is defined as the rows between
+  unbounded preceding and the current row.
+* If an ``order_by`` is not set, the default frame is defined as the rows between unbounded
+  and unbounded following (the entire partition).
+
+Window Frames are defined by three parameters: unit type, starting bound, and ending bound.
+
+The unit types available are:
+
+* Rows: The starting and ending boundaries are defined by the number of rows relative to the
+  current row.
+* Range: When using Range, the ``order_by`` clause must have exactly one term. The boundaries
+  are defined bow how close the rows are to the value of the expression in the ``order_by``
+  parameter.
+* Groups: A "group" is the set of all rows that have equivalent values for all terms in the
+  ``order_by`` clause.
+
+In this example we perform a "rolling average" of the speed of the current Pokemon and the
+two preceding rows.
+
+.. ipython:: python
+
+    from datafusion.expr import Window, WindowFrame
+
+    df.select(
+        col('"Name"'),
+        col('"Speed"'),
+        f.avg(col('"Speed"'))
+        .over(Window(window_frame=WindowFrame("rows", 2, 0), order_by=[col('"Speed"')]))
+        .alias("Previous Speed"),
+    )
+
+Null Treatment
+^^^^^^^^^^^^^^
+
+When using aggregate functions as window functions, it is often useful to specify how null values
+should be treated. In order to do this you need to use the builder function. In future releases
+we expect this to be simplified in the interface.
+
+One common usage for handling nulls is the case where you want to find the last value up to the
+current row. In the following example we demonstrate how setting the null treatment to ignore
+nulls will fill in with the value of the most recent non-null row. To do this, we also will set
+the window frame so that we only process up to the current row.
+
+In this example, we filter down to one specific type of Pokemon that does have some entries in
+it's ``Type 2`` column that are null.
+
+.. ipython:: python
+
+    from datafusion.common import NullTreatment
+
+    df.filter(col('"Type 1"') == lit("Bug")).select(
+        '"Name"',
+        '"Type 2"',
+        f.last_value(col('"Type 2"'))
+        .over(
+            Window(
+                window_frame=WindowFrame("rows", None, 0),
+                order_by=[col('"Speed"')],
+                null_treatment=NullTreatment.IGNORE_NULLS,
+            )
+        )
+        .alias("last_wo_null"),
+        f.last_value(col('"Type 2"'))
+        .over(
+            Window(
+                window_frame=WindowFrame("rows", None, 0),
+                order_by=[col('"Speed"')],
+                null_treatment=NullTreatment.RESPECT_NULLS,
+            )
+        )
+        .alias("last_with_null"),
+    )
+
+Aggregate Functions
+-------------------
+
+You can use any :ref:`Aggregation Function<aggregation>` as a window function. Currently
+aggregate functions must use the deprecated
+:py:func:`datafusion.functions.window` API but this should be resolved in
+DataFusion 42.0 (`Issue Link <https://github.com/apache/datafusion-python/issues/833>`_). Here
+is an example that shows how to compare each pokemons’s attack power with the average attack
+power in its ``"Type 1"`` using the :py:func:`datafusion.functions.avg` function.
+
+.. ipython:: python
+    :okwarning:
+
+    df.select(
+        col('"Name"'),
+        col('"Attack"'),
+        col('"Type 1"'),
+        f.window("avg", [col('"Attack"')])
+            .partition_by(col('"Type 1"'))
+            .build()
+            .alias("Average Attack"),
+    )
+
+Available Functions
+-------------------
+
+The possible window functions are:
+
+1. Rank Functions
+    - :py:func:`datafusion.functions.rank`
+    - :py:func:`datafusion.functions.dense_rank`
+    - :py:func:`datafusion.functions.ntile`
+    - :py:func:`datafusion.functions.row_number`
+
+2. Analytical Functions
+    - :py:func:`datafusion.functions.cume_dist`
+    - :py:func:`datafusion.functions.percent_rank`
+    - :py:func:`datafusion.functions.lag`
+    - :py:func:`datafusion.functions.lead`
+
+3. Aggregate Functions
+    - All :ref:`Aggregation Functions<aggregation>` can be used as window functions.
diff --git a/docs/source/user-guide/configuration.rst b/docs/source/user-guide/configuration.rst
new file mode 100644
index 000000000..f8e613cd4
--- /dev/null
+++ b/docs/source/user-guide/configuration.rst
@@ -0,0 +1,188 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+.. _configuration:
+
+Configuration
+=============
+
+Let's look at how we can configure DataFusion. When creating a :py:class:`~datafusion.context.SessionContext`, you can pass in
+a :py:class:`~datafusion.context.SessionConfig` and :py:class:`~datafusion.context.RuntimeEnvBuilder` object. These two cover a wide range of options.
+
+.. code-block:: python
+
+    from datafusion import RuntimeEnvBuilder, SessionConfig, SessionContext
+
+    # create a session context with default settings
+    ctx = SessionContext()
+    print(ctx)
+
+    # create a session context with explicit runtime and config settings
+    runtime = RuntimeEnvBuilder().with_disk_manager_os().with_fair_spill_pool(10000000)
+    config = (
+        SessionConfig()
+        .with_create_default_catalog_and_schema(True)
+        .with_default_catalog_and_schema("foo", "bar")
+        .with_target_partitions(8)
+        .with_information_schema(True)
+        .with_repartition_joins(False)
+        .with_repartition_aggregations(False)
+        .with_repartition_windows(False)
+        .with_parquet_pruning(False)
+        .set("datafusion.execution.parquet.pushdown_filters", "true")
+    )
+    ctx = SessionContext(config, runtime)
+    print(ctx)
+
+Maximizing CPU Usage
+--------------------
+
+DataFusion uses partitions to parallelize work. For small queries the
+default configuration (number of CPU cores) is often sufficient, but to
+fully utilize available hardware you can tune how many partitions are
+created and when DataFusion will repartition data automatically.
+
+Configure a ``SessionContext`` with a higher partition count:
+
+.. code-block:: python
+
+    from datafusion import SessionConfig, SessionContext
+
+    # allow up to 16 concurrent partitions
+    config = SessionConfig().with_target_partitions(16)
+    ctx = SessionContext(config)
+
+Automatic repartitioning for joins, aggregations, window functions and
+other operations can be enabled to increase parallelism:
+
+.. code-block:: python
+
+    config = (
+        SessionConfig()
+        .with_target_partitions(16)
+        .with_repartition_joins(True)
+        .with_repartition_aggregations(True)
+        .with_repartition_windows(True)
+    )
+
+Manual repartitioning is available on DataFrames when you need precise
+control:
+
+.. code-block:: python
+
+    from datafusion import col
+
+    df = ctx.read_parquet("data.parquet")
+
+    # Evenly divide into 16 partitions
+    df = df.repartition(16)
+
+    # Or partition by the hash of a column
+    df = df.repartition_by_hash(col("a"), num=16)
+
+    result = df.collect()
+
+
+Benchmark Example
+^^^^^^^^^^^^^^^^^
+
+The repository includes a benchmark script that demonstrates how to maximize CPU usage
+with DataFusion. The :code:`benchmarks/max_cpu_usage.py` script shows a practical example
+of configuring DataFusion for optimal parallelism.
+
+You can run the benchmark script to see the impact of different configuration settings:
+
+.. code-block:: bash
+
+    # Run with default settings (uses all CPU cores)
+    python benchmarks/max_cpu_usage.py
+
+    # Run with specific number of rows and partitions
+    python benchmarks/max_cpu_usage.py --rows 5000000 --partitions 16
+
+    # See all available options
+    python benchmarks/max_cpu_usage.py --help
+
+Here's an example showing the performance difference between single and multiple partitions:
+
+.. code-block:: bash
+
+    # Single partition - slower processing
+    $ python benchmarks/max_cpu_usage.py --rows=10000000 --partitions 1
+    Processed 10000000 rows using 1 partitions in 0.107s
+
+    # Multiple partitions - faster processing
+    $ python benchmarks/max_cpu_usage.py --rows=10000000 --partitions 10
+    Processed 10000000 rows using 10 partitions in 0.038s
+
+This example demonstrates nearly 3x performance improvement (0.107s vs 0.038s) when using 
+10 partitions instead of 1, showcasing how proper partitioning can significantly improve 
+CPU utilization and query performance.
+
+The script demonstrates several key optimization techniques:
+
+1. **Higher target partition count**: Uses :code:`with_target_partitions()` to set the number of concurrent partitions
+2. **Automatic repartitioning**: Enables repartitioning for joins, aggregations, and window functions
+3. **Manual repartitioning**: Uses :code:`repartition()` to ensure all partitions are utilized
+4. **CPU-intensive operations**: Performs aggregations that can benefit from parallelization
+
+The benchmark creates synthetic data and measures the time taken to perform a sum aggregation
+across the specified number of partitions. This helps you understand how partition configuration
+affects performance on your specific hardware.
+
+Important Considerations
+""""""""""""""""""""""""
+
+The provided benchmark script demonstrates partitioning concepts using synthetic in-memory data
+and simple aggregation operations. While useful for understanding basic configuration principles,
+actual performance in production environments may vary significantly based on numerous factors:
+
+**Data Sources and I/O Characteristics:**
+
+- **Table providers**: Performance differs greatly between Parquet files, CSV files, databases, and cloud storage
+- **Storage type**: Local SSD, network-attached storage, and cloud storage have vastly different characteristics  
+- **Network latency**: Remote data sources introduce additional latency considerations
+- **File sizes and distribution**: Large files may benefit differently from partitioning than many small files
+
+**Query and Workload Characteristics:**
+
+- **Operation complexity**: Simple aggregations versus complex joins, window functions, or nested queries
+- **Data distribution**: Skewed data may not partition evenly, affecting parallel efficiency
+- **Memory usage**: Large datasets may require different memory management strategies
+- **Concurrent workloads**: Multiple queries running simultaneously affect resource allocation
+
+**Hardware and Environment Factors:**
+
+- **CPU architecture**: Different processors have varying parallel processing capabilities
+- **Available memory**: Limited RAM may require different optimization strategies
+- **System load**: Other applications competing for resources affect DataFusion performance
+
+**Recommendations for Production Use:**
+
+To optimize DataFusion for your specific use case, it is strongly recommended to:
+
+1. **Create custom benchmarks** using your actual data sources, formats, and query patterns
+2. **Test with representative data volumes** that match your production workloads  
+3. **Measure end-to-end performance** including data loading, processing, and result handling
+4. **Evaluate different configuration combinations** for your specific hardware and workload
+5. **Monitor resource utilization** (CPU, memory, I/O) to identify bottlenecks in your environment
+
+This approach will provide more accurate insights into how DataFusion configuration options
+will impact your particular applications and infrastructure.
+
+For more information about available :py:class:`~datafusion.context.SessionConfig` options, see the `rust DataFusion Configuration guide <https://arrow.apache.org/datafusion/user-guide/configs.html>`_,
+and about :code:`RuntimeEnvBuilder` options in the rust `online API documentation <https://docs.rs/datafusion/latest/datafusion/execution/runtime_env/struct.RuntimeEnvBuilder.html>`_.
diff --git a/docs/source/user-guide/data-sources.rst b/docs/source/user-guide/data-sources.rst
new file mode 100644
index 000000000..26f1303c4
--- /dev/null
+++ b/docs/source/user-guide/data-sources.rst
@@ -0,0 +1,274 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+.. _user_guide_data_sources:
+
+Data Sources
+============
+
+DataFusion provides a wide variety of ways to get data into a DataFrame to perform operations.
+
+Local file
+----------
+
+DataFusion has the ability to read from a variety of popular file formats, such as :ref:`Parquet <io_parquet>`,
+:ref:`CSV <io_csv>`, :ref:`JSON <io_json>`, and :ref:`AVRO <io_avro>`.
+
+.. ipython:: python
+
+    from datafusion import SessionContext
+    ctx = SessionContext()
+    df = ctx.read_csv("pokemon.csv")
+    df.show()
+
+Create in-memory
+----------------
+
+Sometimes it can be convenient to create a small DataFrame from a Python list or dictionary object.
+To do this in DataFusion, you can use one of the three functions
+:py:func:`~datafusion.context.SessionContext.from_pydict`,
+:py:func:`~datafusion.context.SessionContext.from_pylist`, or
+:py:func:`~datafusion.context.SessionContext.create_dataframe`.
+
+As their names suggest, ``from_pydict`` and ``from_pylist`` will create DataFrames from Python
+dictionary and list objects, respectively. ``create_dataframe`` assumes you will pass in a list
+of list of `PyArrow Record Batches <https://arrow.apache.org/docs/python/generated/pyarrow.RecordBatch.html>`_.
+
+The following three examples all will create identical DataFrames:
+
+.. ipython:: python
+
+    import pyarrow as pa
+
+    ctx.from_pylist([
+        { "a": 1, "b": 10.0, "c": "alpha" },
+        { "a": 2, "b": 20.0, "c": "beta" },
+        { "a": 3, "b": 30.0, "c": "gamma" },
+    ]).show()
+
+    ctx.from_pydict({
+        "a": [1, 2, 3],
+        "b": [10.0, 20.0, 30.0],
+        "c": ["alpha", "beta", "gamma"],
+    }).show()
+
+    batch = pa.RecordBatch.from_arrays(
+        [
+            pa.array([1, 2, 3]),
+            pa.array([10.0, 20.0, 30.0]),
+            pa.array(["alpha", "beta", "gamma"]),
+        ],
+        names=["a", "b", "c"],
+    )
+
+    ctx.create_dataframe([[batch]]).show()
+
+
+Object Store
+------------
+
+DataFusion has support for multiple storage options in addition to local files.
+The example below requires an appropriate S3 account with access credentials.
+
+Supported Object Stores are
+
+- :py:class:`~datafusion.object_store.AmazonS3`
+- :py:class:`~datafusion.object_store.GoogleCloud`
+- :py:class:`~datafusion.object_store.Http`
+- :py:class:`~datafusion.object_store.LocalFileSystem`
+- :py:class:`~datafusion.object_store.MicrosoftAzure`
+
+.. code-block:: python
+
+    from datafusion.object_store import AmazonS3
+
+    region = "us-east-1"
+    bucket_name = "yellow-trips"
+
+    s3 = AmazonS3(
+        bucket_name=bucket_name,
+        region=region,
+        access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),
+        secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),
+    )
+
+    path = f"s3://{bucket_name}/"
+    ctx.register_object_store("s3://", s3, None)
+
+    ctx.register_parquet("trips", path)
+
+    ctx.table("trips").show()
+
+Other DataFrame Libraries
+-------------------------
+
+DataFusion can import DataFrames directly from other libraries, such as
+`Polars <https://pola.rs/>`_ and `Pandas <https://pandas.pydata.org/>`_.
+Since DataFusion version 42.0.0, any DataFrame library that supports the Arrow FFI PyCapsule
+interface can be imported to DataFusion using the
+:py:func:`~datafusion.context.SessionContext.from_arrow` function. Older versions of Polars may
+not support the arrow interface. In those cases, you can still import via the
+:py:func:`~datafusion.context.SessionContext.from_polars` function.
+
+.. code-block:: python
+
+    import pandas as pd
+
+    data = { "a": [1, 2, 3], "b": [10.0, 20.0, 30.0], "c": ["alpha", "beta", "gamma"] }
+    pandas_df = pd.DataFrame(data)
+
+    datafusion_df = ctx.from_arrow(pandas_df)
+    datafusion_df.show()
+
+.. code-block:: python
+
+    import polars as pl
+    polars_df = pl.DataFrame(data)
+
+    datafusion_df = ctx.from_arrow(polars_df)
+    datafusion_df.show()
+
+Delta Lake
+----------
+
+DataFusion 43.0.0 and later support the ability to register table providers from sources such
+as Delta Lake. This will require a recent version of
+`deltalake <https://delta-io.github.io/delta-rs/>`_ to provide the required interfaces.
+
+.. code-block:: python
+
+    from deltalake import DeltaTable
+
+    delta_table = DeltaTable("path_to_table")
+    ctx.register_table("my_delta_table", delta_table)
+    df = ctx.table("my_delta_table")
+    df.show()
+
+On older versions of ``deltalake`` (prior to 0.22) you can use the
+`Arrow DataSet <https://arrow.apache.org/docs/python/generated/pyarrow.dataset.Dataset.html>`_
+interface to import to DataFusion, but this does not support features such as filter push down
+which can lead to a significant performance difference.
+
+.. code-block:: python
+
+    from deltalake import DeltaTable
+
+    delta_table = DeltaTable("path_to_table")
+    ctx.register_dataset("my_delta_table", delta_table.to_pyarrow_dataset())
+    df = ctx.table("my_delta_table")
+    df.show()
+
+Apache Iceberg
+--------------
+
+DataFusion 45.0.0 and later support the ability to register Apache Iceberg tables as table providers through the Custom Table Provider interface.
+
+This requires either the `pyiceberg <https://pypi.org/project/pyiceberg/>`__ library (>=0.10.0) or the `pyiceberg-core <https://pypi.org/project/pyiceberg-core/>`__ library (>=0.5.0).
+
+* The ``pyiceberg-core`` library exposes Iceberg Rust's implementation of the Custom Table Provider interface as python bindings.
+* The ``pyiceberg`` library utilizes the ``pyiceberg-core`` python bindings under the hood and provides a native way for Python users to interact with the DataFusion.
+
+.. code-block:: python
+
+    from datafusion import SessionContext
+    from pyiceberg.catalog import load_catalog
+    import pyarrow as pa
+
+    # Load catalog and create/load a table
+    catalog = load_catalog("catalog", type="in-memory")
+    catalog.create_namespace_if_not_exists("default")
+
+    # Create some sample data
+    data = pa.table({"x": [1, 2, 3], "y": [4, 5, 6]})
+    iceberg_table = catalog.create_table("default.test", schema=data.schema)
+    iceberg_table.append(data)
+
+    # Register the table with DataFusion
+    ctx = SessionContext()
+    ctx.register_table_provider("test", iceberg_table)
+
+    # Query the table using DataFusion
+    ctx.table("test").show()
+
+
+Note that the Datafusion integration rely on features from the `Iceberg Rust <https://github.com/apache/iceberg-rust/>`_ implementation instead of the `PyIceberg <https://github.com/apache/iceberg-python/>`_ implementation. 
+Features that are available in PyIceberg but not yet in Iceberg Rust will not be available when using DataFusion.
+
+Custom Table Provider
+---------------------
+
+You can implement a custom Data Provider in Rust and expose it to DataFusion through the
+the interface as describe in the :ref:`Custom Table Provider <io_custom_table_provider>`
+section. This is an advanced topic, but a
+`user example <https://github.com/apache/datafusion-python/tree/main/examples/datafusion-ffi-example>`_
+is provided in the DataFusion repository.
+
+Catalog
+=======
+
+A common technique for organizing tables is using a three level hierarchical approach. DataFusion
+supports this form of organizing using the :py:class:`~datafusion.catalog.Catalog`,
+:py:class:`~datafusion.catalog.Schema`, and :py:class:`~datafusion.catalog.Table`. By default,
+a :py:class:`~datafusion.context.SessionContext` comes with a single Catalog and a single Schema
+with the names ``datafusion`` and ``default``, respectively.
+
+The default implementation uses an in-memory approach to the catalog and schema. We have support
+for adding additional in-memory catalogs and schemas. This can be done like in the following
+example:
+
+.. code-block:: python
+
+    from datafusion.catalog import Catalog, Schema
+
+    my_catalog = Catalog.memory_catalog()
+    my_schema = Schema.memory_schema()
+
+    my_catalog.register_schema("my_schema_name", my_schema)
+
+    ctx.register_catalog("my_catalog_name", my_catalog)
+
+You could then register tables in ``my_schema`` and access them either through the DataFrame
+API or via sql commands such as ``"SELECT * from my_catalog_name.my_schema_name.my_table"``.
+
+User Defined Catalog and Schema
+-------------------------------
+
+If the in-memory catalogs are insufficient for your uses, there are two approaches you can take
+to implementing a custom catalog and/or schema. In the below discussion, we describe how to
+implement these for a Catalog, but the approach to implementing for a Schema is nearly
+identical.
+
+DataFusion supports Catalogs written in either Rust or Python. If you write a Catalog in Rust,
+you will need to export it as a Python library via PyO3. There is a complete example of a
+catalog implemented this way in the
+`examples folder <https://github.com/apache/datafusion-python/tree/main/examples/>`_
+of our repository. Writing catalog providers in Rust provides typically can lead to significant
+performance improvements over the Python based approach.
+
+To implement a Catalog in Python, you will need to inherit from the abstract base class
+:py:class:`~datafusion.catalog.CatalogProvider`. There are examples in the
+`unit tests <https://github.com/apache/datafusion-python/tree/main/python/tests>`_ of
+implementing a basic Catalog in Python where we simply keep a dictionary of the
+registered Schemas.
+
+One important note for developers is that when we have a Catalog defined in Python, we have
+two different ways of accessing this Catalog. First, we register the catalog with a Rust
+wrapper. This allows for any rust based code to call the Python functions as necessary.
+Second, if the user access the Catalog via the Python API, we identify this and return back
+the original Python object that implements the Catalog. This is an important distinction
+for developers because we do *not* return a Python wrapper around the Rust wrapper of the
+original Python object.
diff --git a/docs/source/user-guide/dataframe/index.rst b/docs/source/user-guide/dataframe/index.rst
new file mode 100644
index 000000000..510bcbc68
--- /dev/null
+++ b/docs/source/user-guide/dataframe/index.rst
@@ -0,0 +1,371 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+DataFrames
+==========
+
+Overview
+--------
+
+The ``DataFrame`` class is the core abstraction in DataFusion that represents tabular data and operations
+on that data. DataFrames provide a flexible API for transforming data through various operations such as
+filtering, projection, aggregation, joining, and more.
+
+A DataFrame represents a logical plan that is lazily evaluated. The actual execution occurs only when 
+terminal operations like ``collect()``, ``show()``, or ``to_pandas()`` are called.
+
+Creating DataFrames
+-------------------
+
+DataFrames can be created in several ways:
+
+* From SQL queries via a ``SessionContext``:
+
+  .. code-block:: python
+
+      from datafusion import SessionContext
+      
+      ctx = SessionContext()
+      df = ctx.sql("SELECT * FROM your_table")
+
+* From registered tables:
+
+  .. code-block:: python
+
+      df = ctx.table("your_table")
+
+* From various data sources:
+
+  .. code-block:: python
+
+      # From CSV files (see :ref:`io_csv` for detailed options)
+      df = ctx.read_csv("path/to/data.csv")
+      
+      # From Parquet files (see :ref:`io_parquet` for detailed options)
+      df = ctx.read_parquet("path/to/data.parquet")
+      
+      # From JSON files (see :ref:`io_json` for detailed options)
+      df = ctx.read_json("path/to/data.json")
+      
+      # From Avro files (see :ref:`io_avro` for detailed options)
+      df = ctx.read_avro("path/to/data.avro")
+      
+      # From Pandas DataFrame
+      import pandas as pd
+      pandas_df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+      df = ctx.from_pandas(pandas_df)
+      
+      # From Arrow data
+      import pyarrow as pa
+      batch = pa.RecordBatch.from_arrays(
+          [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+          names=["a", "b"]
+      )
+      df = ctx.from_arrow(batch)
+
+For detailed information about reading from different data sources, see the :doc:`I/O Guide <../io/index>`.
+For custom data sources, see :ref:`io_custom_table_provider`.
+
+Common DataFrame Operations
+---------------------------
+
+DataFusion's DataFrame API offers a wide range of operations:
+
+.. code-block:: python
+
+    from datafusion import column, literal
+    
+    # Select specific columns
+    df = df.select("col1", "col2")
+    
+    # Select with expressions
+    df = df.select(column("a") + column("b"), column("a") - column("b"))
+    
+    # Filter rows (expressions or SQL strings)
+    df = df.filter(column("age") > literal(25))
+    df = df.filter("age > 25")
+    
+    # Add computed columns
+    df = df.with_column("full_name", column("first_name") + literal(" ") + column("last_name"))
+    
+    # Multiple column additions
+    df = df.with_columns(
+        (column("a") + column("b")).alias("sum"),
+        (column("a") * column("b")).alias("product")
+    )
+    
+    # Sort data
+    df = df.sort(column("age").sort(ascending=False))
+    
+    # Join DataFrames
+    df = df1.join(df2, on="user_id", how="inner")
+    
+    # Aggregate data
+    from datafusion import functions as f
+    df = df.aggregate(
+        [],  # Group by columns (empty for global aggregation)
+        [f.sum(column("amount")).alias("total_amount")]
+    )
+    
+    # Limit rows
+    df = df.limit(100)
+    
+    # Drop columns
+    df = df.drop("temporary_column")
+
+Column Names as Function Arguments
+----------------------------------
+
+Some ``DataFrame`` methods accept column names when an argument refers to an
+existing column. These include:
+
+* :py:meth:`~datafusion.DataFrame.select`
+* :py:meth:`~datafusion.DataFrame.sort`
+* :py:meth:`~datafusion.DataFrame.drop`
+* :py:meth:`~datafusion.DataFrame.join` (``on`` argument)
+* :py:meth:`~datafusion.DataFrame.aggregate` (grouping columns)
+
+See the full function documentation for details on any specific function.
+
+Note that :py:meth:`~datafusion.DataFrame.join_on` expects ``col()``/``column()`` expressions rather than plain strings.
+
+For such methods, you can pass column names directly:
+
+.. code-block:: python
+
+    from datafusion import col, functions as f
+
+    df.sort('id')
+    df.aggregate('id', [f.count(col('value'))])
+
+The same operation can also be written with explicit column expressions, using either ``col()`` or ``column()``:
+
+.. code-block:: python
+
+    from datafusion import col, column, functions as f
+
+    df.sort(col('id'))
+    df.aggregate(column('id'), [f.count(col('value'))])
+
+Note that ``column()`` is an alias of ``col()``, so you can use either name; the example above shows both in action.
+
+Whenever an argument represents an expression—such as in
+:py:meth:`~datafusion.DataFrame.filter` or
+:py:meth:`~datafusion.DataFrame.with_column`—use ``col()`` to reference
+columns. The comparison and arithmetic operators on ``Expr`` will automatically
+convert any non-``Expr`` value into a literal expression, so writing
+
+.. code-block:: python
+
+    from datafusion import col
+    df.filter(col("age") > 21)
+
+is equivalent to using ``lit(21)`` explicitly. Use ``lit()`` (also available
+as ``literal()``) when you need to construct a literal expression directly.
+
+Terminal Operations
+-------------------
+
+To materialize the results of your DataFrame operations:
+
+.. code-block:: python
+
+    # Collect all data as PyArrow RecordBatches
+    result_batches = df.collect()
+    
+    # Convert to various formats
+    pandas_df = df.to_pandas()        # Pandas DataFrame
+    polars_df = df.to_polars()        # Polars DataFrame
+    arrow_table = df.to_arrow_table() # PyArrow Table
+    py_dict = df.to_pydict()          # Python dictionary
+    py_list = df.to_pylist()          # Python list of dictionaries
+    
+    # Display results
+    df.show()                         # Print tabular format to console
+
+    # Count rows
+    count = df.count()
+
+    # Collect a single column of data as a PyArrow Array
+    arr = df.collect_column("age")
+
+Zero-copy streaming to Arrow-based Python libraries
+---------------------------------------------------
+
+DataFusion DataFrames implement the ``__arrow_c_stream__`` protocol, enabling
+zero-copy, lazy streaming into Arrow-based Python libraries. With the streaming
+protocol, batches are produced on demand.
+
+.. note::
+
+    The protocol is implementation-agnostic and works with any Python library
+    that understands the Arrow C streaming interface (for example, PyArrow
+    or other Arrow-compatible implementations). The sections below provide a
+    short PyArrow-specific example and general guidance for other
+    implementations.
+
+PyArrow
+-------
+
+.. code-block:: python
+
+    import pyarrow as pa
+
+    # Create a PyArrow RecordBatchReader without materializing all batches
+    reader = pa.RecordBatchReader.from_stream(df)
+    for batch in reader:
+        ...  # process each batch as it is produced
+
+DataFrames are also iterable, yielding :class:`datafusion.RecordBatch`
+objects lazily so you can loop over results directly without importing
+PyArrow:
+
+.. code-block:: python
+
+    for batch in df:
+        ...  # each batch is a ``datafusion.RecordBatch``
+
+Each batch exposes ``to_pyarrow()``, allowing conversion to a PyArrow
+table. ``pa.table(df)`` collects the entire DataFrame eagerly into a
+PyArrow table:
+
+.. code-block:: python
+
+    import pyarrow as pa
+    table = pa.table(df)
+
+Asynchronous iteration is supported as well, allowing integration with
+``asyncio`` event loops:
+
+.. code-block:: python
+
+    async for batch in df:
+        ...  # process each batch as it is produced
+
+To work with the stream directly, use ``execute_stream()``, which returns a
+:class:`~datafusion.RecordBatchStream`.
+
+.. code-block:: python
+
+    stream = df.execute_stream()
+    for batch in stream:
+        ...
+
+Execute as Stream
+^^^^^^^^^^^^^^^^^
+
+For finer control over streaming execution, use
+:py:meth:`~datafusion.DataFrame.execute_stream` to obtain a
+:py:class:`datafusion.RecordBatchStream`:
+
+.. code-block:: python
+
+    stream = df.execute_stream()
+    for batch in stream:
+        ...  # process each batch as it is produced
+
+.. tip::
+
+    To get a PyArrow reader instead, call
+
+    ``pa.RecordBatchReader.from_stream(df)``.
+    
+When partition boundaries are important,
+:py:meth:`~datafusion.DataFrame.execute_stream_partitioned`
+returns an iterable of :py:class:`datafusion.RecordBatchStream` objects, one per
+partition:
+
+.. code-block:: python
+
+    for stream in df.execute_stream_partitioned():
+        for batch in stream:
+            ...  # each stream yields RecordBatches
+
+To process partitions concurrently, first collect the streams into a list
+and then poll each one in a separate ``asyncio`` task:
+
+.. code-block:: python
+
+    import asyncio
+
+    async def consume(stream):
+        async for batch in stream:
+            ...
+
+    streams = list(df.execute_stream_partitioned())
+    await asyncio.gather(*(consume(s) for s in streams))
+
+See :doc:`../io/arrow` for additional details on the Arrow interface.
+
+HTML Rendering
+--------------
+
+When working in Jupyter notebooks or other environments that support HTML rendering, DataFrames will
+automatically display as formatted HTML tables. For detailed information about customizing HTML 
+rendering, formatting options, and advanced styling, see :doc:`rendering`.
+
+Core Classes
+------------
+
+**DataFrame**
+    The main DataFrame class for building and executing queries.
+
+    See: :py:class:`datafusion.DataFrame`
+
+**SessionContext**
+    The primary entry point for creating DataFrames from various data sources.
+
+    Key methods for DataFrame creation:
+
+    * :py:meth:`~datafusion.SessionContext.read_csv` - Read CSV files
+    * :py:meth:`~datafusion.SessionContext.read_parquet` - Read Parquet files
+    * :py:meth:`~datafusion.SessionContext.read_json` - Read JSON files
+    * :py:meth:`~datafusion.SessionContext.read_avro` - Read Avro files
+    * :py:meth:`~datafusion.SessionContext.table` - Access registered tables
+    * :py:meth:`~datafusion.SessionContext.sql` - Execute SQL queries
+    * :py:meth:`~datafusion.SessionContext.from_pandas` - Create from Pandas DataFrame
+    * :py:meth:`~datafusion.SessionContext.from_arrow` - Create from Arrow data
+
+    See: :py:class:`datafusion.SessionContext`
+
+Expression Classes
+------------------
+
+**Expr**
+    Represents expressions that can be used in DataFrame operations.
+
+    See: :py:class:`datafusion.Expr`
+
+**Functions for creating expressions:**
+
+* :py:func:`datafusion.column` - Reference a column by name
+* :py:func:`datafusion.literal` - Create a literal value expression
+
+Built-in Functions
+------------------
+
+DataFusion provides many built-in functions for data manipulation:
+
+* :py:mod:`datafusion.functions` - Mathematical, string, date/time, and aggregation functions
+
+For a complete list of available functions, see the :py:mod:`datafusion.functions` module documentation.
+
+
+.. toctree::
+   :maxdepth: 1
+
+   rendering
diff --git a/docs/source/user-guide/dataframe/rendering.rst b/docs/source/user-guide/dataframe/rendering.rst
new file mode 100644
index 000000000..9dea948bb
--- /dev/null
+++ b/docs/source/user-guide/dataframe/rendering.rst
@@ -0,0 +1,223 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+HTML Rendering in Jupyter
+=========================
+
+When working in Jupyter notebooks or other environments that support rich HTML display, 
+DataFusion DataFrames automatically render as nicely formatted HTML tables. This functionality
+is provided by the ``_repr_html_`` method, which is automatically called by Jupyter to provide
+a richer visualization than plain text output.
+
+Basic HTML Rendering
+--------------------
+
+In a Jupyter environment, simply displaying a DataFrame object will trigger HTML rendering:
+
+.. code-block:: python
+
+    # Will display as HTML table in Jupyter
+    df
+
+    # Explicit display also uses HTML rendering
+    display(df)
+
+Customizing HTML Rendering
+---------------------------
+
+DataFusion provides extensive customization options for HTML table rendering through the
+``datafusion.html_formatter`` module.
+
+Configuring the HTML Formatter
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+You can customize how DataFrames are rendered by configuring the formatter:
+
+.. code-block:: python
+
+    from datafusion.html_formatter import configure_formatter
+    
+    # Change the default styling
+    configure_formatter(
+        max_cell_length=25,        # Maximum characters in a cell before truncation
+        max_width=1000,            # Maximum width in pixels
+        max_height=300,            # Maximum height in pixels
+        max_memory_bytes=2097152,  # Maximum memory for rendering (2MB)
+        min_rows=10,               # Minimum number of rows to display
+        max_rows=10,               # Maximum rows to display in __repr__
+        enable_cell_expansion=True,# Allow expanding truncated cells
+        custom_css=None,           # Additional custom CSS
+        show_truncation_message=True, # Show message when data is truncated
+        style_provider=None,       # Custom styling provider
+        use_shared_styles=True     # Share styles across tables
+    )
+
+The formatter settings affect all DataFrames displayed after configuration.
+
+Custom Style Providers
+-----------------------
+
+For advanced styling needs, you can create a custom style provider:
+
+.. code-block:: python
+
+    from datafusion.html_formatter import StyleProvider, configure_formatter
+    
+    class MyStyleProvider(StyleProvider):
+        def get_table_styles(self):
+            return {
+                "table": "border-collapse: collapse; width: 100%;",
+                "th": "background-color: #007bff; color: white; padding: 8px; text-align: left;",
+                "td": "border: 1px solid #ddd; padding: 8px;",
+                "tr:nth-child(even)": "background-color: #f2f2f2;",
+            }
+            
+        def get_value_styles(self, dtype, value):
+            """Return custom styles for specific values"""
+            if dtype == "float" and value < 0:
+                return "color: red;"
+            return None
+    
+    # Apply the custom style provider
+    configure_formatter(style_provider=MyStyleProvider())
+
+Performance Optimization with Shared Styles
+--------------------------------------------
+
+The ``use_shared_styles`` parameter (enabled by default) optimizes performance when displaying 
+multiple DataFrames in notebook environments:
+
+.. code-block:: python
+
+    from datafusion.html_formatter import StyleProvider, configure_formatter
+    # Default: Use shared styles (recommended for notebooks)
+    configure_formatter(use_shared_styles=True)
+
+    # Disable shared styles (each DataFrame includes its own styles)
+    configure_formatter(use_shared_styles=False)
+
+When ``use_shared_styles=True``:
+- CSS styles and JavaScript are included only once per notebook session
+- This reduces HTML output size and prevents style duplication
+- Improves rendering performance with many DataFrames
+- Applies consistent styling across all DataFrames
+
+Creating a Custom Formatter
+----------------------------
+
+For complete control over rendering, you can implement a custom formatter:
+
+.. code-block:: python
+
+    from datafusion.html_formatter import Formatter, get_formatter
+    
+    class MyFormatter(Formatter):
+        def format_html(self, batches, schema, has_more=False, table_uuid=None):
+            # Create your custom HTML here
+            html = "<div class='my-custom-table'>"
+            # ... formatting logic ...
+            html += "</div>"
+            return html
+    
+    # Set as the global formatter
+    configure_formatter(formatter_class=MyFormatter)
+    
+    # Or use the formatter just for specific operations
+    formatter = get_formatter()
+    custom_html = formatter.format_html(batches, schema)
+
+Managing Formatters
+-------------------
+
+Reset to default formatting:
+
+.. code-block:: python
+
+    from datafusion.html_formatter import reset_formatter
+    
+    # Reset to default settings
+    reset_formatter()
+
+Get the current formatter settings:
+
+.. code-block:: python
+
+    from datafusion.html_formatter import get_formatter
+    
+    formatter = get_formatter()
+    print(formatter.max_rows)
+    print(formatter.theme)
+
+Contextual Formatting
+----------------------
+
+You can also use a context manager to temporarily change formatting settings:
+
+.. code-block:: python
+
+    from datafusion.html_formatter import formatting_context
+    
+    # Default formatting
+    df.show()
+    
+    # Temporarily use different formatting
+    with formatting_context(max_rows=100, theme="dark"):
+        df.show()  # Will use the temporary settings
+    
+    # Back to default formatting
+    df.show()
+
+Memory and Display Controls
+---------------------------
+
+You can control how much data is displayed and how much memory is used for rendering:
+
+.. code-block:: python
+
+    configure_formatter(
+        max_memory_bytes=4 * 1024 * 1024,  # 4MB maximum memory for display
+        min_rows=20,                       # Always show at least 20 rows
+        max_rows=50                        # Show up to 50 rows in output
+    )
+
+These parameters help balance comprehensive data display against performance considerations.
+
+Best Practices
+--------------
+
+1. **Global Configuration**: Use ``configure_formatter()`` at the beginning of your notebook to set up consistent formatting for all DataFrames.
+
+2. **Memory Management**: Set appropriate ``max_memory_bytes`` limits to prevent performance issues with large datasets.
+
+3. **Shared Styles**: Keep ``use_shared_styles=True`` (default) for better performance in notebooks with multiple DataFrames.
+
+4. **Reset When Needed**: Call ``reset_formatter()`` when you want to start fresh with default settings.
+
+5. **Cell Expansion**: Use ``enable_cell_expansion=True`` when cells might contain longer content that users may want to see in full.
+
+Additional Resources
+--------------------
+
+* :doc:`../dataframe/index` - Complete guide to using DataFrames
+* :doc:`../io/index` - I/O Guide for reading data from various sources
+* :doc:`../data-sources` - Comprehensive data sources guide
+* :ref:`io_csv` - CSV file reading
+* :ref:`io_parquet` - Parquet file reading  
+* :ref:`io_json` - JSON file reading
+* :ref:`io_avro` - Avro file reading
+* :ref:`io_custom_table_provider` - Custom table providers
+* `API Reference <https://arrow.apache.org/datafusion-python/api/index.html>`_ - Full API reference
diff --git a/docs/source/user-guide/introduction.rst b/docs/source/user-guide/introduction.rst
new file mode 100644
index 000000000..7b30ef2b2
--- /dev/null
+++ b/docs/source/user-guide/introduction.rst
@@ -0,0 +1,77 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+.. _guide:
+
+Introduction
+============
+
+Welcome to the User Guide for the Python bindings of Arrow DataFusion. This guide aims to provide an introduction to
+DataFusion through various examples and highlight the most effective ways of using it.
+
+Installation
+------------
+
+DataFusion is a Python library and, as such, can be installed via pip from `PyPI <https://pypi.org/project/datafusion>`__.
+
+.. code-block:: shell
+
+    pip install datafusion
+
+You can verify the installation by running:
+
+.. ipython:: python
+
+    import datafusion
+    datafusion.__version__
+
+In this documentation we will also show some examples for how DataFusion integrates
+with Jupyter notebooks. To install and start a Jupyter labs session use
+
+.. code-block:: shell
+
+    pip install jupyterlab
+    jupyter lab
+
+To demonstrate working with DataFusion, we need a data source. Later in the tutorial we will show
+options for data sources. For our first example, we demonstrate using a Pokemon dataset that you
+can download
+`here <https://gist.githubusercontent.com/ritchie46/cac6b337ea52281aa23c049250a4ff03/raw/89a957ff3919d90e6ef2d34235e6bf22304f3366/pokemon.csv>`_.
+
+With that file in place you can use the following python example to view the DataFrame in
+DataFusion.
+
+.. ipython:: python
+
+    from datafusion import SessionContext
+
+    ctx = SessionContext()
+
+    df = ctx.read_csv("pokemon.csv")
+
+    df.show()
+
+If you are working in a Jupyter notebook, you can also use the following to give you a table
+display that may be easier to read.
+
+.. code-block:: shell
+
+    display(df)
+
+.. image:: ../images/jupyter_lab_df_view.png
+    :width: 800
+    :alt: Rendered table showing Pokemon DataFrame
diff --git a/docs/source/user-guide/io/arrow.rst b/docs/source/user-guide/io/arrow.rst
new file mode 100644
index 000000000..9196fcea7
--- /dev/null
+++ b/docs/source/user-guide/io/arrow.rst
@@ -0,0 +1,75 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+Arrow
+=====
+
+DataFusion implements the
+`Apache Arrow PyCapsule interface <https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html>`_
+for importing and exporting DataFrames with zero copy. With this feature, any Python
+project that implements this interface can share data back and forth with DataFusion
+with zero copy.
+
+We can demonstrate using `pyarrow <https://arrow.apache.org/docs/python/index.html>`_.
+
+Importing to DataFusion
+-----------------------
+
+Here we will create an Arrow table and import it to DataFusion.
+
+To import an Arrow table, use :py:func:`datafusion.context.SessionContext.from_arrow`.
+This will accept any Python object that implements
+`__arrow_c_stream__ <https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html#arrowstream-export>`_
+or `__arrow_c_array__ <https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html#arrowarray-export>`_
+and returns a ``StructArray``. Common pyarrow sources you can use are:
+
+- `Array <https://arrow.apache.org/docs/python/generated/pyarrow.Array.html>`_ (but it must return a Struct Array)
+- `Record Batch <https://arrow.apache.org/docs/python/generated/pyarrow.RecordBatch.html>`_
+- `Record Batch Reader <https://arrow.apache.org/docs/python/generated/pyarrow.RecordBatchReader.html>`_
+- `Table <https://arrow.apache.org/docs/python/generated/pyarrow.Table.html>`_
+
+.. ipython:: python
+
+    from datafusion import SessionContext
+    import pyarrow as pa
+
+    data = {"a": [1, 2, 3], "b": [4, 5, 6]}
+    table = pa.Table.from_pydict(data)
+
+    ctx = SessionContext()
+    df = ctx.from_arrow(table)
+    df
+
+Exporting from DataFusion
+-------------------------
+
+DataFusion DataFrames implement ``__arrow_c_stream__`` PyCapsule interface, so any
+Python library that accepts these can import a DataFusion DataFrame directly.
+
+Invoking ``__arrow_c_stream__`` triggers execution of the underlying query, but
+batches are yielded incrementally rather than materialized all at once in memory.
+Consumers can process the stream as it arrives. The stream executes lazily,
+letting downstream readers pull batches on demand.
+
+
+.. ipython:: python
+
+    from datafusion import col, lit
+
+    df = df.select((col("a") * lit(1.5)).alias("c"), lit("df").alias("d"))
+    pa.table(df)
+
diff --git a/docs/source/api/execution_context.rst b/docs/source/user-guide/io/avro.rst
similarity index 70%
rename from docs/source/api/execution_context.rst
rename to docs/source/user-guide/io/avro.rst
index 5b7e0f82f..66398ac7f 100644
--- a/docs/source/api/execution_context.rst
+++ b/docs/source/user-guide/io/avro.rst
@@ -15,13 +15,18 @@
 .. specific language governing permissions and limitations
 .. under the License.
 
-.. _api.execution_context:
-.. currentmodule:: datafusion
+.. _io_avro:
 
-SessionContext
-================
+Avro
+====
 
-.. autosummary::
-   :toctree: ../generated/
+`Avro <https://avro.apache.org/>`_ is a serialization format for record data. Reading an avro file is very straightforward
+with :py:func:`~datafusion.context.SessionContext.read_avro`
 
-   SessionContext
+.. code-block:: python
+
+
+    from datafusion import SessionContext
+
+    ctx = SessionContext()
+    df = ctx.read_avro("file.avro")
\ No newline at end of file
diff --git a/docs/source/user-guide/io/csv.rst b/docs/source/user-guide/io/csv.rst
new file mode 100644
index 000000000..9c23c291b
--- /dev/null
+++ b/docs/source/user-guide/io/csv.rst
@@ -0,0 +1,60 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+.. _io_csv:
+
+CSV
+===
+
+Reading a csv is very straightforward with :py:func:`~datafusion.context.SessionContext.read_csv`
+
+.. code-block:: python
+
+
+    from datafusion import SessionContext
+
+    ctx = SessionContext()
+    df = ctx.read_csv("file.csv")
+
+An alternative is to use :py:func:`~datafusion.context.SessionContext.register_csv`
+
+.. code-block:: python
+
+    ctx.register_csv("file", "file.csv")
+    df = ctx.table("file")
+
+If you require additional control over how to read the CSV file, you can use
+:py:class:`~datafusion.options.CsvReadOptions` to set a variety of options.
+
+.. code-block:: python
+
+    from datafusion import CsvReadOptions
+    options = (
+        CsvReadOptions()
+        .with_has_header(True) # File contains a header row
+        .with_delimiter(";") # Use ; as the delimiter instead of ,
+        .with_comment("#")  # Skip lines starting with #
+        .with_escape("\\")  # Escape character
+        .with_null_regex(r"^(null|NULL|N/A)$")  # Treat these as NULL
+        .with_truncated_rows(True) # Allow rows to have incomplete columns
+        .with_file_compression_type("gzip")  # Read gzipped CSV
+        .with_file_extension(".gz") # File extension other than .csv
+    )
+    df = ctx.read_csv("data.csv.gz", options=options)
+
+Details for all CSV reading options can be found on the
+`DataFusion documentation site <https://datafusion.apache.org/library-user-guide/custom-table-providers.html>`_.
diff --git a/docs/source/api/config.rst b/docs/source/user-guide/io/index.rst
similarity index 87%
rename from docs/source/api/config.rst
rename to docs/source/user-guide/io/index.rst
index df244aec5..b885cfeda 100644
--- a/docs/source/api/config.rst
+++ b/docs/source/user-guide/io/index.rst
@@ -15,13 +15,15 @@
 .. specific language governing permissions and limitations
 .. under the License.
 
-.. _api.config:
-.. currentmodule:: datafusion
+IO
+==
 
-Config
-=========
+.. toctree::
+   :maxdepth: 2
 
-.. autosummary::
-   :toctree: ../generated/
-
-   Config
+   arrow
+   avro
+   csv
+   json
+   parquet
+   table_provider
diff --git a/docs/source/api/dataframe.rst b/docs/source/user-guide/io/json.rst
similarity index 67%
rename from docs/source/api/dataframe.rst
rename to docs/source/user-guide/io/json.rst
index 0a3c4c8b1..39030db7f 100644
--- a/docs/source/api/dataframe.rst
+++ b/docs/source/user-guide/io/json.rst
@@ -15,13 +15,17 @@
 .. specific language governing permissions and limitations
 .. under the License.
 
-.. _api.dataframe:
-.. currentmodule:: datafusion
+.. _io_json:
 
-DataFrame
-=========
+JSON
+====
+`JSON <https://www.json.org/json-en.html>`_ (JavaScript Object Notation) is a lightweight data-interchange format.
+When it comes to reading a JSON file, using :py:func:`~datafusion.context.SessionContext.read_json` is a simple and easy
 
-.. autosummary::
-   :toctree: ../generated/
+.. code-block:: python
 
-   DataFrame
+
+    from datafusion import SessionContext
+
+    ctx = SessionContext()
+    df = ctx.read_json("file.json")
diff --git a/docs/source/user-guide/io/parquet.rst b/docs/source/user-guide/io/parquet.rst
new file mode 100644
index 000000000..c5b9ca3d4
--- /dev/null
+++ b/docs/source/user-guide/io/parquet.rst
@@ -0,0 +1,37 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+.. _io_parquet:
+
+Parquet
+=======
+
+It is quite simple to read a parquet file using the :py:func:`~datafusion.context.SessionContext.read_parquet` function.
+
+.. code-block:: python
+
+    from datafusion import SessionContext
+
+    ctx = SessionContext()
+    df = ctx.read_parquet("file.parquet")
+
+An alternative is to use :py:func:`~datafusion.context.SessionContext.register_parquet`
+
+.. code-block:: python
+
+    ctx.register_parquet("file", "file.parquet")
+    df = ctx.table("file")
diff --git a/docs/source/user-guide/io/table_provider.rst b/docs/source/user-guide/io/table_provider.rst
new file mode 100644
index 000000000..29e5d9880
--- /dev/null
+++ b/docs/source/user-guide/io/table_provider.rst
@@ -0,0 +1,62 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+.. _io_custom_table_provider:
+
+Custom Table Provider
+=====================
+
+If you have a custom data source that you want to integrate with DataFusion, you can do so by
+implementing the `TableProvider <https://datafusion.apache.org/library-user-guide/custom-table-providers.html>`_
+interface in Rust and then exposing it in Python. To do so,
+you must use DataFusion 43.0.0 or later and expose a `FFI_TableProvider <https://crates.io/crates/datafusion-ffi>`_
+via `PyCapsule <https://pyo3.rs/main/doc/pyo3/types/struct.pycapsule>`_.
+
+A complete example can be found in the `examples folder <https://github.com/apache/datafusion-python/tree/main/examples>`_.
+
+.. code-block:: rust
+
+    #[pymethods]
+    impl MyTableProvider {
+
+        fn __datafusion_table_provider__<'py>(
+            &self,
+            py: Python<'py>,
+        ) -> PyResult<Bound<'py, PyCapsule>> {
+            let name = cr"datafusion_table_provider".into();
+
+            let provider = Arc::new(self.clone());
+            let provider = FFI_TableProvider::new(provider, false, None);
+
+            PyCapsule::new_bound(py, provider, Some(name.clone()))
+        }
+    }
+
+Once you have this library available, you can construct a
+:py:class:`~datafusion.Table` in Python and register it with the
+``SessionContext``.
+
+.. code-block:: python
+
+    from datafusion import SessionContext, Table
+
+    ctx = SessionContext()
+    provider = MyTableProvider()
+
+    ctx.register_table("capsule_table", provider)
+
+    ctx.table("capsule_table").show()
diff --git a/docs/source/user-guide/sql.rst b/docs/source/user-guide/sql.rst
new file mode 100644
index 000000000..b4bfb9611
--- /dev/null
+++ b/docs/source/user-guide/sql.rst
@@ -0,0 +1,122 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+SQL
+===
+
+DataFusion also offers a SQL API, read the full reference `here <https://arrow.apache.org/datafusion/user-guide/sql/index.html>`_
+
+.. ipython:: python
+
+    import datafusion
+    from datafusion import DataFrame, SessionContext
+
+    # create a context
+    ctx = datafusion.SessionContext()
+
+    # register a CSV
+    ctx.register_csv("pokemon", "pokemon.csv")
+
+    # create a new statement via SQL
+    df = ctx.sql('SELECT "Attack"+"Defense", "Attack"-"Defense" FROM pokemon')
+
+    # collect and convert to pandas DataFrame
+    df.to_pandas()
+
+Parameterized queries
+---------------------
+
+In DataFusion-Python 51.0.0 we introduced the ability to pass parameters
+in a SQL query. These are similar in concept to
+`prepared statements <https://datafusion.apache.org/user-guide/sql/prepared_statements.html>`_,
+but allow passing named parameters into a SQL query. Consider this simple
+example.
+
+.. ipython:: python
+
+    def show_attacks(ctx: SessionContext, threshold: int) -> None:
+        ctx.sql(
+            'SELECT "Name", "Attack" FROM pokemon WHERE "Attack" > $val', val=threshold
+        ).show(num=5)
+    show_attacks(ctx, 75)
+
+When passing parameters like the example above we convert the Python objects
+into their string representation. We also have special case handling
+for :py:class:`~datafusion.dataframe.DataFrame` objects, since they cannot simply
+be turned into string representations for an SQL query. In these cases we
+will register a temporary view in the :py:class:`~datafusion.context.SessionContext`
+using a generated table name.
+
+The formatting for passing string replacement objects is to precede the
+variable name with a single ``$``. This works for all dialects in
+the SQL parser except ``hive`` and ``mysql``. Since these dialects do not
+support named placeholders, we are unable to do this type of replacement.
+We recommend either switching to another dialect or using Python
+f-string style replacement.
+
+.. warning::
+
+    To support DataFrame parameterized queries, your session must support
+    registration of temporary views. The default
+    :py:class:`~datafusion.catalog.CatalogProvider` and
+    :py:class:`~datafusion.catalog.SchemaProvider` do have this capability.
+    If you have implemented custom providers, it is important that temporary
+    views do not persist across :py:class:`~datafusion.context.SessionContext`
+    or you may get unintended consequences.
+
+The following example shows passing in both a :py:class:`~datafusion.dataframe.DataFrame`
+object as well as a Python object to be used in parameterized replacement.
+
+.. ipython:: python
+
+    def show_column(
+        ctx: SessionContext, column: str, df: DataFrame, threshold: int
+    ) -> None:
+        ctx.sql(
+            'SELECT "Name", $col FROM $df WHERE $col > $val',
+            col=column,
+            df=df,
+            val=threshold,
+        ).show(num=5)
+    df = ctx.table("pokemon")
+    show_column(ctx, '"Defense"', df, 75)
+
+The approach implemented for conversion of variables into a SQL query
+relies on string conversion. This has the potential for data loss,
+specifically for cases like floating point numbers. If you need to pass
+variables into a parameterized query and it is important to maintain the
+original value without conversion to a string, then you can use the
+optional parameter ``param_values`` to specify these. This parameter
+expects a dictionary mapping from the parameter name to a Python
+object. Those objects will be cast into a
+`PyArrow Scalar Value <https://arrow.apache.org/docs/python/generated/pyarrow.Scalar.html>`_.
+
+Using ``param_values`` will rely on the SQL dialect you have configured
+for your session. This can be set using the :ref:`configuration options <configuration>`
+of your :py:class:`~datafusion.context.SessionContext`. Similar to how
+`prepared statements <https://datafusion.apache.org/user-guide/sql/prepared_statements.html>`_
+work, these parameters are limited to places where you would pass in a
+scalar value, such as a comparison.
+
+.. ipython:: python
+
+    def param_attacks(ctx: SessionContext, threshold: int) -> None:
+        ctx.sql(
+            'SELECT "Name", "Attack" FROM pokemon WHERE "Attack" > $val',
+            param_values={"val": threshold},
+        ).show(num=5)
+    param_attacks(ctx, 75)
diff --git a/docs/source/user-guide/upgrade-guides.rst b/docs/source/user-guide/upgrade-guides.rst
new file mode 100644
index 000000000..e3d7c2d87
--- /dev/null
+++ b/docs/source/user-guide/upgrade-guides.rst
@@ -0,0 +1,117 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+Upgrade Guides
+==============
+
+DataFusion 53.0.0
+-----------------
+
+This version includes an upgraded version of ``pyo3``, which changed the way to extract an FFI
+object. Example:
+
+Before:
+
+.. code-block:: rust
+
+    let codec = unsafe { capsule.reference::<FFI_LogicalExtensionCodec>() };
+
+Now:
+
+.. code-block:: rust
+
+    let data: NonNull<FFI_LogicalExtensionCodec> = capsule
+        .pointer_checked(Some(c_str!("datafusion_logical_extension_codec")))?
+        .cast();
+    let codec = unsafe { data.as_ref() };
+
+DataFusion 52.0.0
+-----------------
+
+This version includes a major update to the :ref:`ffi` due to upgrades
+to the `Foreign Function Interface <https://doc.rust-lang.org/nomicon/ffi.html>`_.
+Users who contribute their own ``CatalogProvider``, ``SchemaProvider``,
+``TableProvider`` or ``TableFunction`` via FFI must now provide access to a
+``LogicalExtensionCodec`` and a ``TaskContextProvider``. The function signatures
+for the methods to get these ``PyCapsule`` objects now requires an additional
+parameter, which is a Python object that can be used to extract the
+``FFI_LogicalExtensionCodec`` that is necessary.
+
+A complete example can be found in the `FFI example <https://github.com/apache/datafusion-python/tree/main/examples/datafusion-ffi-example>`_.
+Your methods need to be updated to take an additional parameter like in this
+example.
+
+.. code-block:: rust
+
+    #[pymethods]
+    impl MyCatalogProvider {
+        pub fn __datafusion_catalog_provider__<'py>(
+            &self,
+            py: Python<'py>,
+            session: Bound<PyAny>,
+        ) -> PyResult<Bound<'py, PyCapsule>> {
+            let name = cr"datafusion_catalog_provider".into();
+
+            let provider = Arc::clone(&self.inner) as Arc<dyn CatalogProvider + Send>;
+
+            let codec = ffi_logical_codec_from_pycapsule(session)?;
+            let provider = FFI_CatalogProvider::new_with_ffi_codec(provider, None, codec);
+
+            PyCapsule::new(py, provider, Some(name))
+        }
+    }
+
+To extract the logical extension codec FFI object from the provided object you
+can implement a helper method such as:
+
+.. code-block:: rust
+
+    pub(crate) fn ffi_logical_codec_from_pycapsule(
+        obj: Bound<PyAny>,
+    ) -> PyResult<FFI_LogicalExtensionCodec> {
+        let attr_name = "__datafusion_logical_extension_codec__";
+        let capsule = if obj.hasattr(attr_name)? {
+            obj.getattr(attr_name)?.call0()?
+        } else {
+            obj
+        };
+
+        let capsule = capsule.downcast::<PyCapsule>()?;
+        validate_pycapsule(capsule, "datafusion_logical_extension_codec")?;
+
+        let codec = unsafe { capsule.reference::<FFI_LogicalExtensionCodec>() };
+
+        Ok(codec.clone())
+    }
+
+
+The DataFusion FFI interface updates no longer depend directly on the
+``datafusion`` core crate. You can improve your build times and potentially
+reduce your library binary size by removing this dependency and instead
+using the specific datafusion project crates.
+
+For example, instead of including expressions like:
+
+.. code-block:: rust
+
+    use datafusion::catalog::MemTable;
+
+Instead you can now write:
+
+.. code-block:: rust
+
+    use datafusion_catalog::MemTable;
diff --git a/examples/README.md b/examples/README.md
index 2c4775ea4..0ef194afe 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -27,6 +27,10 @@ Here is a direct link to the file used in the examples:
 
 - https://d37ci6vzurychx.cloudfront.net/trip-data/yellow_tripdata_2021-01.parquet
 
+### Creating a SessionContext
+
+- [Creating a SessionContext](./create-context.py)
+
 ### Executing Queries with DataFusion
 
 - [Query a Parquet file using SQL](./sql-parquet.py)
@@ -48,3 +52,67 @@ Here is a direct link to the file used in the examples:
 - [Executing SQL on Polars](./sql-on-polars.py)
 - [Executing SQL on Pandas](./sql-on-pandas.py)
 - [Executing SQL on cuDF](./sql-on-cudf.py)
+
+## TPC-H Examples
+
+Within the subdirectory `tpch` there are 22 examples that reproduce queries in
+the TPC-H specification. These include realistic data that can be generated at
+arbitrary scale and allow the user to see use cases for a variety of data frame
+operations.
+
+In the list below we describe which new operations can be found in the examples.
+The queries are designed to be of increasing complexity, so it is recommended to
+review them in order. For brevity, the following list does not include operations
+found in previous examples.
+
+- [Convert CSV to Parquet](./tpch/convert_data_to_parquet.py)
+    - Read from a CSV files where the delimiter is something other than a comma
+    - Specify schema during CVS reading
+    - Write to a parquet file
+- [Pricing Summary Report](./tpch/q01_pricing_summary_report.py)
+    - Aggregation computing the maximum value, average, sum, and number of entries
+    - Filter data by date and interval
+    - Sorting
+- [Minimum Cost Supplier](./tpch/q02_minimum_cost_supplier.py)
+    - Window operation to find minimum
+    - Sorting in descending order
+- [Shipping Priority](./tpch/q03_shipping_priority.py)
+- [Order Priority Checking](./tpch/q04_order_priority_checking.py)
+    - Aggregating multiple times in one data frame
+- [Local Supplier Volume](./tpch/q05_local_supplier_volume.py)
+- [Forecasting Revenue Change](./tpch/q06_forecasting_revenue_change.py)
+    - Using collect and extracting values as a python object
+- [Volume Shipping](./tpch/q07_volume_shipping.py)
+    - Finding multiple distinct and mutually exclusive values within one dataframe
+    - Using `case` and `when` statements
+- [Market Share](./tpch/q08_market_share.py)
+    - The operations in this query are similar to those in the prior examples, but
+      it is a more complex example of using filters, joins, and aggregates
+    - Using left outer joins
+- [Product Type Profit Measure](./tpch/q09_product_type_profit_measure.py)
+    - Extract year from a date
+- [Returned Item Reporting](./tpch/q10_returned_item_reporting.py)
+- [Important Stock Identification](./tpch/q11_important_stock_identification.py)
+- [Shipping Modes and Order](./tpch/q12_ship_mode_order_priority.py)
+    - Finding non-null values using a boolean operation in a filter
+    - Case statement with default value
+- [Customer Distribution](./tpch/q13_customer_distribution.py)
+- [Promotion Effect](./tpch/q14_promotion_effect.py)
+- [Top Supplier](./tpch/q15_top_supplier.py)
+- [Parts/Supplier Relationship](./tpch/q16_part_supplier_relationship.py)
+    - Using anti joins
+    - Using regular expressions (regex)
+    - Creating arrays of literal values
+    - Determine if an element exists within an array
+- [Small-Quantity-Order Revenue](./tpch/q17_small_quantity_order.py)
+- [Large Volume Customer](./tpch/q18_large_volume_customer.py)
+- [Discounted Revenue](./tpch/q19_discounted_revenue.py)
+    - Creating a user defined function (UDF)
+    - Convert pyarrow Array to python values
+    - Filtering based on a UDF
+- [Potential Part Promotion](./tpch/q20_potential_part_promotion.py)
+    - Extracting part of a string using substr
+- [Suppliers Who Kept Orders Waiting](./tpch/q21_suppliers_kept_orders_waiting.py)
+    - Using array aggregation
+    - Determining the size of array elements
+- [Global Sales Opportunity](./tpch/q22_global_sales_opportunity.py)
diff --git a/examples/create-context.py b/examples/create-context.py
new file mode 100644
index 000000000..0026d6162
--- /dev/null
+++ b/examples/create-context.py
@@ -0,0 +1,42 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from datafusion import RuntimeEnvBuilder, SessionConfig, SessionContext
+
+# create a session context with default settings
+ctx = SessionContext()
+print(ctx)
+
+# create a session context with explicit runtime and config settings
+runtime = RuntimeEnvBuilder().with_disk_manager_os().with_fair_spill_pool(10000000)
+config = (
+    SessionConfig()
+    .with_create_default_catalog_and_schema(enabled=True)
+    .with_default_catalog_and_schema("foo", "bar")
+    .with_target_partitions(8)
+    .with_information_schema(enabled=True)
+    .with_repartition_joins(enabled=False)
+    .with_repartition_aggregations(enabled=False)
+    .with_repartition_windows(enabled=False)
+    .with_parquet_pruning(enabled=False)
+    .set("datafusion.execution.parquet.pushdown_filters", "true")
+)
+ctx = SessionContext(config, runtime)
+print(ctx)
+
+ctx = ctx.enable_url_table()
+print(ctx)
diff --git a/examples/csv-read-options.py b/examples/csv-read-options.py
new file mode 100644
index 000000000..a5952d950
--- /dev/null
+++ b/examples/csv-read-options.py
@@ -0,0 +1,96 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""Example demonstrating CsvReadOptions usage."""
+
+from datafusion import CsvReadOptions, SessionContext
+
+# Create a SessionContext
+ctx = SessionContext()
+
+# Example 1: Using CsvReadOptions with default values
+print("Example 1: Default CsvReadOptions")
+options = CsvReadOptions()
+df = ctx.read_csv("data.csv", options=options)
+
+# Example 2: Using CsvReadOptions with custom parameters
+print("\nExample 2: Custom CsvReadOptions")
+options = CsvReadOptions(
+    has_header=True,
+    delimiter=",",
+    quote='"',
+    schema_infer_max_records=1000,
+    file_extension=".csv",
+)
+df = ctx.read_csv("data.csv", options=options)
+
+# Example 3: Using the builder pattern (recommended for readability)
+print("\nExample 3: Builder pattern")
+options = (
+    CsvReadOptions()
+    .with_has_header(True)  # noqa: FBT003
+    .with_delimiter("|")
+    .with_quote("'")
+    .with_schema_infer_max_records(500)
+    .with_truncated_rows(False)  # noqa: FBT003
+    .with_newlines_in_values(True)  # noqa: FBT003
+)
+df = ctx.read_csv("data.csv", options=options)
+
+# Example 4: Advanced options
+print("\nExample 4: Advanced options")
+options = (
+    CsvReadOptions()
+    .with_has_header(True)  # noqa: FBT003
+    .with_delimiter(",")
+    .with_comment("#")  # Skip lines starting with #
+    .with_escape("\\")  # Escape character
+    .with_null_regex(r"^(null|NULL|N/A)$")  # Treat these as NULL
+    .with_truncated_rows(True)  # noqa: FBT003
+    .with_file_compression_type("gzip")  # Read gzipped CSV
+    .with_file_extension(".gz")
+)
+df = ctx.read_csv("data.csv.gz", options=options)
+
+# Example 5: Register CSV table with options
+print("\nExample 5: Register CSV table")
+options = CsvReadOptions().with_has_header(True).with_delimiter(",")  # noqa: FBT003
+ctx.register_csv("my_table", "data.csv", options=options)
+df = ctx.sql("SELECT * FROM my_table")
+
+# Example 6: Backward compatibility (without options)
+print("\nExample 6: Backward compatibility")
+# Still works the old way!
+df = ctx.read_csv("data.csv", has_header=True, delimiter=",")
+
+print("\nAll examples completed!")
+print("\nFor all available options, see the CsvReadOptions documentation:")
+print("  - has_header: bool")
+print("  - delimiter: str")
+print("  - quote: str")
+print("  - terminator: str | None")
+print("  - escape: str | None")
+print("  - comment: str | None")
+print("  - newlines_in_values: bool")
+print("  - schema: pa.Schema | None")
+print("  - schema_infer_max_records: int")
+print("  - file_extension: str")
+print("  - table_partition_cols: list[tuple[str, pa.DataType]]")
+print("  - file_compression_type: str")
+print("  - file_sort_order: list[list[SortExpr]]")
+print("  - null_regex: str | None")
+print("  - truncated_rows: bool")
diff --git a/examples/datafusion-ffi-example/.cargo/config.toml b/examples/datafusion-ffi-example/.cargo/config.toml
new file mode 100644
index 000000000..af951327f
--- /dev/null
+++ b/examples/datafusion-ffi-example/.cargo/config.toml
@@ -0,0 +1,5 @@
+[target.x86_64-apple-darwin]
+rustflags = ["-C", "link-arg=-undefined", "-C", "link-arg=dynamic_lookup"]
+
+[target.aarch64-apple-darwin]
+rustflags = ["-C", "link-arg=-undefined", "-C", "link-arg=dynamic_lookup"]
diff --git a/examples/datafusion-ffi-example/Cargo.lock b/examples/datafusion-ffi-example/Cargo.lock
new file mode 100644
index 000000000..ede9b446b
--- /dev/null
+++ b/examples/datafusion-ffi-example/Cargo.lock
@@ -0,0 +1,3127 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "abi_stable"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69d6512d3eb05ffe5004c59c206de7f99c34951504056ce23fc953842f12c445"
+dependencies = [
+ "abi_stable_derive",
+ "abi_stable_shared",
+ "const_panic",
+ "core_extensions",
+ "crossbeam-channel",
+ "generational-arena",
+ "libloading",
+ "lock_api",
+ "parking_lot",
+ "paste",
+ "repr_offset",
+ "rustc_version",
+ "serde",
+ "serde_derive",
+ "serde_json",
+]
+
+[[package]]
+name = "abi_stable_derive"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7178468b407a4ee10e881bc7a328a65e739f0863615cca4429d43916b05e898"
+dependencies = [
+ "abi_stable_shared",
+ "as_derive_utils",
+ "core_extensions",
+ "proc-macro2",
+ "quote",
+ "rustc_version",
+ "syn 1.0.109",
+ "typed-arena",
+]
+
+[[package]]
+name = "abi_stable_shared"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2b5df7688c123e63f4d4d649cba63f2967ba7f7861b1664fca3f77d3dad2b63"
+dependencies = [
+ "core_extensions",
+]
+
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
+[[package]]
+name = "ahash"
+version = "0.8.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
+dependencies = [
+ "cfg-if",
+ "const-random",
+ "getrandom 0.3.4",
+ "once_cell",
+ "version_check",
+ "zerocopy",
+]
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "alloc-no-stdlib"
+version = "2.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
+
+[[package]]
+name = "alloc-stdlib"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece"
+dependencies = [
+ "alloc-no-stdlib",
+]
+
+[[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f0e0fee31ef5ed1ba1316088939cea399010ed7731dba877ed44aeb407a75ea"
+
+[[package]]
+name = "arc-swap"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9f3647c145568cec02c42054e07bdf9a5a698e15b466fb2341bfc393cd24aa5"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "arrow"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "602268ce9f569f282cedb9a9f6bac569b680af47b9b077d515900c03c5d190da"
+dependencies = [
+ "arrow-arith",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-cast",
+ "arrow-csv",
+ "arrow-data",
+ "arrow-ipc",
+ "arrow-json",
+ "arrow-ord",
+ "arrow-row",
+ "arrow-schema",
+ "arrow-select",
+ "arrow-string",
+]
+
+[[package]]
+name = "arrow-arith"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd53c6bf277dea91f136ae8e3a5d7041b44b5e489e244e637d00ae302051f56f"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "chrono",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-array"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e53796e07a6525edaf7dc28b540d477a934aff14af97967ad1d5550878969b9e"
+dependencies = [
+ "ahash",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "chrono",
+ "chrono-tz",
+ "half",
+ "hashbrown 0.16.1",
+ "num-complex",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-buffer"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2c1a85bb2e94ee10b76531d8bc3ce9b7b4c0d508cabfb17d477f63f2617bd20"
+dependencies = [
+ "bytes",
+ "half",
+ "num-bigint",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-cast"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89fb245db6b0e234ed8e15b644edb8664673fefe630575e94e62cd9d489a8a26"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-ord",
+ "arrow-schema",
+ "arrow-select",
+ "atoi",
+ "base64",
+ "chrono",
+ "comfy-table",
+ "half",
+ "lexical-core",
+ "num-traits",
+ "ryu",
+]
+
+[[package]]
+name = "arrow-csv"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d374882fb465a194462527c0c15a93aa19a554cf690a6b77a26b2a02539937a7"
+dependencies = [
+ "arrow-array",
+ "arrow-cast",
+ "arrow-schema",
+ "chrono",
+ "csv",
+ "csv-core",
+ "regex",
+]
+
+[[package]]
+name = "arrow-data"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "189d210bc4244c715fa3ed9e6e22864673cccb73d5da28c2723fb2e527329b33"
+dependencies = [
+ "arrow-buffer",
+ "arrow-schema",
+ "half",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-ipc"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7968c2e5210c41f4909b2ef76f6e05e172b99021c2def5edf3cc48fdd39d1d6c"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "arrow-select",
+ "flatbuffers",
+ "lz4_flex",
+]
+
+[[package]]
+name = "arrow-json"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92111dba5bf900f443488e01f00d8c4ddc2f47f5c50039d18120287b580baa22"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-cast",
+ "arrow-data",
+ "arrow-schema",
+ "chrono",
+ "half",
+ "indexmap",
+ "itoa",
+ "lexical-core",
+ "memchr",
+ "num-traits",
+ "ryu",
+ "serde_core",
+ "serde_json",
+ "simdutf8",
+]
+
+[[package]]
+name = "arrow-ord"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "211136cb253577ee1a6665f741a13136d4e563f64f5093ffd6fb837af90b9495"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "arrow-select",
+]
+
+[[package]]
+name = "arrow-row"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e0f20145f9f5ea3fe383e2ba7a7487bf19be36aa9dbf5dd6a1f92f657179663"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "half",
+]
+
+[[package]]
+name = "arrow-schema"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b47e0ca91cc438d2c7879fe95e0bca5329fff28649e30a88c6f760b1faeddcb"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "arrow-select"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "750a7d1dda177735f5e82a314485b6915c7cccdbb278262ac44090f4aba4a325"
+dependencies = [
+ "ahash",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-string"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1eab1208bc4fe55d768cdc9b9f3d9df5a794cdb3ee2586bf89f9b30dc31ad8c"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "arrow-select",
+ "memchr",
+ "num-traits",
+ "regex",
+ "regex-syntax",
+]
+
+[[package]]
+name = "as_derive_utils"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff3c96645900a44cf11941c111bd08a6573b0e2f9f69bc9264b179d8fae753c4"
+dependencies = [
+ "core_extensions",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "async-ffi"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4de21c0feef7e5a556e51af767c953f0501f7f300ba785cc99c47bdc8081a50"
+dependencies = [
+ "abi_stable",
+]
+
+[[package]]
+name = "async-trait"
+version = "0.1.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "atoi"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f28d99ec8bfea296261ca1af174f24225171fea9664ba9003cbebee704810528"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "bitflags"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
+
+[[package]]
+name = "brotli"
+version = "8.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bd8b9603c7aa97359dbd97ecf258968c95f3adddd6db2f7e7a5bef101c84560"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+ "brotli-decompressor",
+]
+
+[[package]]
+name = "brotli-decompressor"
+version = "5.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "874bb8112abecc98cbd6d81ea4fa7e94fb9449648c93cc89aa40c81c24d7de03"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c81d250916401487680ed13b8b675660281dcfc3ab0121fe44c94bcab9eae2fb"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "bytes"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
+
+[[package]]
+name = "cc"
+version = "1.2.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aebf35691d1bfb0ac386a69bac2fde4dd276fb618cf8bf4f5318fe285e821bb2"
+dependencies = [
+ "find-msvc-tools",
+ "jobserver",
+ "libc",
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "chrono"
+version = "0.4.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0"
+dependencies = [
+ "iana-time-zone",
+ "num-traits",
+ "windows-link",
+]
+
+[[package]]
+name = "chrono-tz"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6139a8597ed92cf816dfb33f5dd6cf0bb93a6adc938f11039f371bc5bcd26c3"
+dependencies = [
+ "chrono",
+ "phf",
+]
+
+[[package]]
+name = "comfy-table"
+version = "7.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "958c5d6ecf1f214b4c2bbbbf6ab9523a864bd136dcf71a7e8904799acfe1ad47"
+dependencies = [
+ "unicode-segmentation",
+ "unicode-width",
+]
+
+[[package]]
+name = "const-random"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87e00182fe74b066627d63b85fd550ac2998d4b0bd86bfed477a0ae4c7c71359"
+dependencies = [
+ "const-random-macro",
+]
+
+[[package]]
+name = "const-random-macro"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e"
+dependencies = [
+ "getrandom 0.2.17",
+ "once_cell",
+ "tiny-keccak",
+]
+
+[[package]]
+name = "const_panic"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e262cdaac42494e3ae34c43969f9cdeb7da178bdb4b66fa6a1ea2edb4c8ae652"
+dependencies = [
+ "typewit",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "core_extensions"
+version = "1.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42bb5e5d0269fd4f739ea6cedaf29c16d81c27a7ce7582008e90eb50dcd57003"
+dependencies = [
+ "core_extensions_proc_macros",
+]
+
+[[package]]
+name = "core_extensions_proc_macros"
+version = "1.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "533d38ecd2709b7608fb8e18e4504deb99e9a72879e6aa66373a76d8dc4259ea"
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "crunchy"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
+
+[[package]]
+name = "csv"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52cd9d68cf7efc6ddfaaee42e7288d3a99d613d4b50f76ce9827ae0c6e14f938"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde_core",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "704a3c26996a80471189265814dbc2c257598b96b8a7feae2d31ace646bb9782"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "dashmap"
+version = "6.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5041cc499144891f3790297212f32a74fb938e5136a14943f338ef9e0ae276cf"
+dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+ "hashbrown 0.14.5",
+ "lock_api",
+ "once_cell",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "datafusion-catalog"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "async-trait",
+ "dashmap",
+ "datafusion-common",
+ "datafusion-common-runtime",
+ "datafusion-datasource",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-physical-expr",
+ "datafusion-physical-plan",
+ "datafusion-session",
+ "futures",
+ "itertools",
+ "log",
+ "object_store",
+ "parking_lot",
+ "tokio",
+]
+
+[[package]]
+name = "datafusion-catalog-listing"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "async-trait",
+ "datafusion-catalog",
+ "datafusion-common",
+ "datafusion-datasource",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-physical-expr",
+ "datafusion-physical-expr-adapter",
+ "datafusion-physical-expr-common",
+ "datafusion-physical-plan",
+ "futures",
+ "itertools",
+ "log",
+ "object_store",
+]
+
+[[package]]
+name = "datafusion-common"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "ahash",
+ "arrow",
+ "arrow-ipc",
+ "chrono",
+ "half",
+ "hashbrown 0.16.1",
+ "indexmap",
+ "itertools",
+ "libc",
+ "log",
+ "object_store",
+ "parquet",
+ "paste",
+ "tokio",
+ "web-time",
+]
+
+[[package]]
+name = "datafusion-common-runtime"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "futures",
+ "log",
+ "tokio",
+]
+
+[[package]]
+name = "datafusion-datasource"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "async-trait",
+ "bytes",
+ "chrono",
+ "datafusion-common",
+ "datafusion-common-runtime",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-physical-expr",
+ "datafusion-physical-expr-adapter",
+ "datafusion-physical-expr-common",
+ "datafusion-physical-plan",
+ "datafusion-session",
+ "futures",
+ "glob",
+ "itertools",
+ "log",
+ "object_store",
+ "rand",
+ "tokio",
+ "url",
+]
+
+[[package]]
+name = "datafusion-datasource-arrow"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "arrow-ipc",
+ "async-trait",
+ "bytes",
+ "datafusion-common",
+ "datafusion-common-runtime",
+ "datafusion-datasource",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-physical-expr-common",
+ "datafusion-physical-plan",
+ "datafusion-session",
+ "futures",
+ "itertools",
+ "object_store",
+ "tokio",
+]
+
+[[package]]
+name = "datafusion-datasource-csv"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "async-trait",
+ "bytes",
+ "datafusion-common",
+ "datafusion-common-runtime",
+ "datafusion-datasource",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-physical-expr-common",
+ "datafusion-physical-plan",
+ "datafusion-session",
+ "futures",
+ "object_store",
+ "regex",
+ "tokio",
+]
+
+[[package]]
+name = "datafusion-datasource-json"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "async-trait",
+ "bytes",
+ "datafusion-common",
+ "datafusion-common-runtime",
+ "datafusion-datasource",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-physical-expr-common",
+ "datafusion-physical-plan",
+ "datafusion-session",
+ "futures",
+ "object_store",
+ "serde_json",
+ "tokio",
+ "tokio-stream",
+]
+
+[[package]]
+name = "datafusion-datasource-parquet"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "async-trait",
+ "bytes",
+ "datafusion-common",
+ "datafusion-common-runtime",
+ "datafusion-datasource",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-functions-aggregate-common",
+ "datafusion-physical-expr",
+ "datafusion-physical-expr-adapter",
+ "datafusion-physical-expr-common",
+ "datafusion-physical-plan",
+ "datafusion-pruning",
+ "datafusion-session",
+ "futures",
+ "itertools",
+ "log",
+ "object_store",
+ "parking_lot",
+ "parquet",
+ "tokio",
+]
+
+[[package]]
+name = "datafusion-doc"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+
+[[package]]
+name = "datafusion-execution"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "arrow-buffer",
+ "async-trait",
+ "chrono",
+ "dashmap",
+ "datafusion-common",
+ "datafusion-expr",
+ "datafusion-physical-expr-common",
+ "futures",
+ "log",
+ "object_store",
+ "parking_lot",
+ "rand",
+ "tempfile",
+ "url",
+]
+
+[[package]]
+name = "datafusion-expr"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "async-trait",
+ "chrono",
+ "datafusion-common",
+ "datafusion-doc",
+ "datafusion-expr-common",
+ "datafusion-functions-aggregate-common",
+ "datafusion-functions-window-common",
+ "datafusion-physical-expr-common",
+ "indexmap",
+ "itertools",
+ "paste",
+ "serde_json",
+ "sqlparser",
+]
+
+[[package]]
+name = "datafusion-expr-common"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "datafusion-common",
+ "indexmap",
+ "itertools",
+ "paste",
+]
+
+[[package]]
+name = "datafusion-ffi"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "abi_stable",
+ "arrow",
+ "arrow-schema",
+ "async-ffi",
+ "async-trait",
+ "datafusion-catalog",
+ "datafusion-common",
+ "datafusion-datasource",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-functions-aggregate-common",
+ "datafusion-physical-expr",
+ "datafusion-physical-expr-common",
+ "datafusion-physical-plan",
+ "datafusion-proto",
+ "datafusion-proto-common",
+ "datafusion-session",
+ "futures",
+ "log",
+ "prost",
+ "semver",
+ "tokio",
+]
+
+[[package]]
+name = "datafusion-ffi-example"
+version = "0.2.0"
+dependencies = [
+ "arrow",
+ "arrow-array",
+ "arrow-schema",
+ "async-trait",
+ "datafusion-catalog",
+ "datafusion-common",
+ "datafusion-expr",
+ "datafusion-ffi",
+ "datafusion-functions-aggregate",
+ "datafusion-functions-window",
+ "pyo3",
+ "pyo3-build-config",
+ "pyo3-log",
+]
+
+[[package]]
+name = "datafusion-functions"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "arrow-buffer",
+ "base64",
+ "chrono",
+ "chrono-tz",
+ "datafusion-common",
+ "datafusion-doc",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-expr-common",
+ "datafusion-macros",
+ "hex",
+ "itertools",
+ "log",
+ "memchr",
+ "num-traits",
+ "rand",
+ "regex",
+ "unicode-segmentation",
+ "uuid",
+]
+
+[[package]]
+name = "datafusion-functions-aggregate"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "ahash",
+ "arrow",
+ "datafusion-common",
+ "datafusion-doc",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-functions-aggregate-common",
+ "datafusion-macros",
+ "datafusion-physical-expr",
+ "datafusion-physical-expr-common",
+ "half",
+ "log",
+ "num-traits",
+ "paste",
+]
+
+[[package]]
+name = "datafusion-functions-aggregate-common"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "ahash",
+ "arrow",
+ "datafusion-common",
+ "datafusion-expr-common",
+ "datafusion-physical-expr-common",
+]
+
+[[package]]
+name = "datafusion-functions-table"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "async-trait",
+ "datafusion-catalog",
+ "datafusion-common",
+ "datafusion-expr",
+ "datafusion-physical-plan",
+ "parking_lot",
+ "paste",
+]
+
+[[package]]
+name = "datafusion-functions-window"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "datafusion-common",
+ "datafusion-doc",
+ "datafusion-expr",
+ "datafusion-functions-window-common",
+ "datafusion-macros",
+ "datafusion-physical-expr",
+ "datafusion-physical-expr-common",
+ "log",
+ "paste",
+]
+
+[[package]]
+name = "datafusion-functions-window-common"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "datafusion-common",
+ "datafusion-physical-expr-common",
+]
+
+[[package]]
+name = "datafusion-macros"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "datafusion-doc",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "datafusion-physical-expr"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "ahash",
+ "arrow",
+ "datafusion-common",
+ "datafusion-expr",
+ "datafusion-expr-common",
+ "datafusion-functions-aggregate-common",
+ "datafusion-physical-expr-common",
+ "half",
+ "hashbrown 0.16.1",
+ "indexmap",
+ "itertools",
+ "parking_lot",
+ "paste",
+ "petgraph",
+ "tokio",
+]
+
+[[package]]
+name = "datafusion-physical-expr-adapter"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "datafusion-common",
+ "datafusion-expr",
+ "datafusion-functions",
+ "datafusion-physical-expr",
+ "datafusion-physical-expr-common",
+ "itertools",
+]
+
+[[package]]
+name = "datafusion-physical-expr-common"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "ahash",
+ "arrow",
+ "chrono",
+ "datafusion-common",
+ "datafusion-expr-common",
+ "hashbrown 0.16.1",
+ "indexmap",
+ "itertools",
+ "parking_lot",
+]
+
+[[package]]
+name = "datafusion-physical-plan"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "ahash",
+ "arrow",
+ "arrow-ord",
+ "arrow-schema",
+ "async-trait",
+ "datafusion-common",
+ "datafusion-common-runtime",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-functions",
+ "datafusion-functions-aggregate-common",
+ "datafusion-functions-window-common",
+ "datafusion-physical-expr",
+ "datafusion-physical-expr-common",
+ "futures",
+ "half",
+ "hashbrown 0.16.1",
+ "indexmap",
+ "itertools",
+ "log",
+ "num-traits",
+ "parking_lot",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "datafusion-proto"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "chrono",
+ "datafusion-catalog",
+ "datafusion-catalog-listing",
+ "datafusion-common",
+ "datafusion-datasource",
+ "datafusion-datasource-arrow",
+ "datafusion-datasource-csv",
+ "datafusion-datasource-json",
+ "datafusion-datasource-parquet",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-functions-table",
+ "datafusion-physical-expr",
+ "datafusion-physical-expr-common",
+ "datafusion-physical-plan",
+ "datafusion-proto-common",
+ "object_store",
+ "prost",
+ "rand",
+]
+
+[[package]]
+name = "datafusion-proto-common"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "datafusion-common",
+ "prost",
+]
+
+[[package]]
+name = "datafusion-pruning"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "arrow",
+ "datafusion-common",
+ "datafusion-datasource",
+ "datafusion-expr-common",
+ "datafusion-physical-expr",
+ "datafusion-physical-expr-common",
+ "datafusion-physical-plan",
+ "itertools",
+ "log",
+]
+
+[[package]]
+name = "datafusion-session"
+version = "53.0.0"
+source = "git+https://github.com/apache/datafusion.git?rev=35749607f585b3bf25b66b7d2289c56c18d03e4f#35749607f585b3bf25b66b7d2289c56c18d03e4f"
+dependencies = [
+ "async-trait",
+ "datafusion-common",
+ "datafusion-execution",
+ "datafusion-expr",
+ "datafusion-physical-plan",
+ "parking_lot",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "fixedbitset"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
+
+[[package]]
+name = "flatbuffers"
+version = "25.12.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "35f6839d7b3b98adde531effaf34f0c2badc6f4735d26fe74709d8e513a96ef3"
+dependencies = [
+ "bitflags",
+ "rustc_version",
+]
+
+[[package]]
+name = "flate2"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
+dependencies = [
+ "miniz_oxide",
+ "zlib-rs",
+]
+
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "futures"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
+
+[[package]]
+name = "futures-macro"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
+
+[[package]]
+name = "futures-task"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
+
+[[package]]
+name = "futures-util"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "slab",
+]
+
+[[package]]
+name = "generational-arena"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877e94aff08e743b651baaea359664321055749b398adff8740a7399af7796e7"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasip2",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "139ef39800118c7683f2fd3c98c1b23c09ae076556b435f8e9064ae108aaeeec"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasip2",
+ "wasip3",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
+[[package]]
+name = "half"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+ "num-traits",
+ "zerocopy",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "foldhash 0.1.5",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+dependencies = [
+ "allocator-api2",
+ "equivalent",
+ "foldhash 0.2.0",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "http"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "humantime"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "135b12329e5e3ce057a9f972339ea52bc954fe1e9358ef27f95e89716fbc5424"
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "icu_collections"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
+
+[[package]]
+name = "icu_properties"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec"
+dependencies = [
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af"
+
+[[package]]
+name = "icu_provider"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.16.1",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "integer-encoding"
+version = "3.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8bb03732005da905c88227371639bf1ad885cc712789c011c31c5fb3ab3ccf02"
+
+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
+
+[[package]]
+name = "jobserver"
+version = "0.1.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
+dependencies = [
+ "getrandom 0.3.4",
+ "libc",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.85"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c942ebf8e95485ca0d52d97da7c5a2c387d0e7f0ba4c35e93bfcaee045955b3"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
+[[package]]
+name = "lexical-core"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594"
+dependencies = [
+ "lexical-parse-float",
+ "lexical-parse-integer",
+ "lexical-util",
+ "lexical-write-float",
+ "lexical-write-integer",
+]
+
+[[package]]
+name = "lexical-parse-float"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56"
+dependencies = [
+ "lexical-parse-integer",
+ "lexical-util",
+]
+
+[[package]]
+name = "lexical-parse-integer"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34"
+dependencies = [
+ "lexical-util",
+]
+
+[[package]]
+name = "lexical-util"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17"
+
+[[package]]
+name = "lexical-write-float"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361"
+dependencies = [
+ "lexical-util",
+ "lexical-write-integer",
+]
+
+[[package]]
+name = "lexical-write-integer"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df"
+dependencies = [
+ "lexical-util",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.182"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112"
+
+[[package]]
+name = "libloading"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f"
+dependencies = [
+ "cfg-if",
+ "winapi",
+]
+
+[[package]]
+name = "libm"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
+
+[[package]]
+name = "litemap"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+
+[[package]]
+name = "lz4_flex"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab6473172471198271ff72e9379150e9dfd70d8e533e0752a27e515b48dd375e"
+dependencies = [
+ "twox-hash",
+]
+
+[[package]]
+name = "memchr"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+ "libm",
+]
+
+[[package]]
+name = "object_store"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2858065e55c148d294a9f3aae3b0fa9458edadb41a108397094566f4e3c0dfb"
+dependencies = [
+ "async-trait",
+ "bytes",
+ "chrono",
+ "futures",
+ "http",
+ "humantime",
+ "itertools",
+ "parking_lot",
+ "percent-encoding",
+ "thiserror",
+ "tokio",
+ "tracing",
+ "url",
+ "walkdir",
+ "wasm-bindgen-futures",
+ "web-time",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "ordered-float"
+version = "2.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68f19d67e5a2795c94e73e0bb1cc1a7edeb2e28efd39e2e1c9b7a40c1108b11c"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "parking_lot"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-link",
+]
+
+[[package]]
+name = "parquet"
+version = "58.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f491d0ef1b510194426ee67ddc18a9b747ef3c42050c19322a2cd2e1666c29b"
+dependencies = [
+ "ahash",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-ipc",
+ "arrow-schema",
+ "arrow-select",
+ "base64",
+ "brotli",
+ "bytes",
+ "chrono",
+ "flate2",
+ "futures",
+ "half",
+ "hashbrown 0.16.1",
+ "lz4_flex",
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+ "object_store",
+ "paste",
+ "seq-macro",
+ "simdutf8",
+ "snap",
+ "thrift",
+ "tokio",
+ "twox-hash",
+ "zstd",
+]
+
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "petgraph"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455"
+dependencies = [
+ "fixedbitset",
+ "hashbrown 0.15.5",
+ "indexmap",
+ "serde",
+]
+
+[[package]]
+name = "phf"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "913273894cec178f401a31ec4b656318d95473527be05c0752cc41cdc32be8b7"
+dependencies = [
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06005508882fb681fd97892ecff4b7fd0fee13ef1aa569f8695dae7ab9099981"
+dependencies = [
+ "siphasher",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
+
+[[package]]
+name = "pkg-config"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "potential_utf"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
+dependencies = [
+ "zerovec",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "prost"
+version = "0.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2ea70524a2f82d518bce41317d0fae74151505651af45faf1ffbd6fd33f0568"
+dependencies = [
+ "bytes",
+ "prost-derive",
+]
+
+[[package]]
+name = "prost-derive"
+version = "0.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27c6023962132f4b30eb4c172c91ce92d933da334c59c23cddee82358ddafb0b"
+dependencies = [
+ "anyhow",
+ "itertools",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.28.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf85e27e86080aafd5a22eae58a162e133a589551542b3e5cee4beb27e54f8e1"
+dependencies = [
+ "libc",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.28.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8bf94ee265674bf76c09fa430b0e99c26e319c945d96ca0d5a8215f31bf81cf7"
+dependencies = [
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.28.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "491aa5fc66d8059dd44a75f4580a2962c1862a1c2945359db36f6c2818b748dc"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-log"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26c2ec80932c5c3b2d4fbc578c9b56b2d4502098587edb8bef5b6bfcad43682e"
+dependencies = [
+ "arc-swap",
+ "log",
+ "pyo3",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.28.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f5d671734e9d7a43449f8480f8b38115df67bef8d21f76837fa75ee7aaa5e52e"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.28.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22faaa1ce6c430a1f71658760497291065e6450d7b5dc2bcf254d49f66ee700a"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "rand"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+dependencies = [
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "regex"
+version = "1.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a96887878f22d7bad8a3b6dc5b7440e0ada9a245242924394987b21cf2210a4c"
+
+[[package]]
+name = "repr_offset"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb1070755bd29dffc19d0971cab794e607839ba2ef4b69a9e6fbc8733c1b72ea"
+dependencies = [
+ "tstr",
+]
+
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rustix"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "ryu"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "semver"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
+
+[[package]]
+name = "seq-macro"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc711410fbe7399f390ca1c3b60ad0f53f80e95c5eb935e52268a0e2cd49acc"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "simd-adler32"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"
+
+[[package]]
+name = "simdutf8"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
+
+[[package]]
+name = "siphasher"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2aa850e253778c88a04c3d7323b043aeda9d3e30d5971937c1855769763678e"
+
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "snap"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b6b67fb9a61334225b5b790716f609cd58395f895b3fe8b328786812a40bc3b"
+
+[[package]]
+name = "sqlparser"
+version = "0.61.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbf5ea8d4d7c808e1af1cbabebca9a2abe603bcefc22294c5b95018d53200cb7"
+dependencies = [
+ "log",
+ "sqlparser_derive",
+]
+
+[[package]]
+name = "sqlparser_derive"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6dd45d8fc1c79299bfbb7190e42ccbbdf6a5f52e4a6ad98d92357ea965bd289"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
+
+[[package]]
+name = "tempfile"
+version = "3.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0136791f7c95b1f6dd99f9cc786b91bb81c3800b639b3478e561ddb7be95e5f1"
+dependencies = [
+ "fastrand",
+ "getrandom 0.4.1",
+ "once_cell",
+ "rustix",
+ "windows-sys",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "thrift"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e54bc85fc7faa8bc175c4bab5b92ba8d9a3ce893d0e9f42cc455c8ab16a9e09"
+dependencies = [
+ "byteorder",
+ "integer-encoding",
+ "ordered-float",
+]
+
+[[package]]
+name = "tiny-keccak"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
+dependencies = [
+ "crunchy",
+]
+
+[[package]]
+name = "tinystr"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "tokio"
+version = "1.49.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86"
+dependencies = [
+ "bytes",
+ "pin-project-lite",
+ "tokio-macros",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "tokio-stream"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32da49809aab5c3bc678af03902d4ccddea2a87d028d86392a4b1560c6906c70"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+ "tokio",
+ "tokio-util",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "tracing"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
+dependencies = [
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "tstr"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f8e0294f14baae476d0dd0a2d780b2e24d66e349a9de876f5126777a37bdba7"
+dependencies = [
+ "tstr_proc_macros",
+]
+
+[[package]]
+name = "tstr_proc_macros"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e78122066b0cb818b8afd08f7ed22f7fdbc3e90815035726f0840d0d26c0747a"
+
+[[package]]
+name = "twox-hash"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ea3136b675547379c4bd395ca6b938e5ad3c3d20fad76e7fe85f9e0d011419c"
+
+[[package]]
+name = "typed-arena"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6af6ae20167a9ece4bcb41af5b80f8a1f1df981f6391189ce00fd257af04126a"
+
+[[package]]
+name = "typewit"
+version = "1.14.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8c1ae7cc0fdb8b842d65d127cb981574b0d2b249b74d1c7a2986863dc134f71"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
+
+[[package]]
+name = "unicode-width"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
+[[package]]
+name = "url"
+version = "2.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+]
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
+[[package]]
+name = "uuid"
+version = "1.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b672338555252d43fd2240c714dc444b8c6fb0a5c5335e65a07bba7742735ddb"
+dependencies = [
+ "getrandom 0.4.1",
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasip2"
+version = "1.0.2+wasi-0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasip3"
+version = "0.4.0+wasi-0.3.0-rc-2026-01-06"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64024a30ec1e37399cf85a7ffefebdb72205ca1c972291c51512360d90bd8566"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70a6e77fd0ae8029c9ea0063f87c46fde723e7d887703d74ad2616d792e51e6f"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "js-sys",
+ "once_cell",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "008b239d9c740232e71bd39e8ef6429d27097518b6b30bdf9086833bd5b6d608"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5256bae2d58f54820e6490f9839c49780dff84c65aeab9e772f15d5f0e913a55"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f01b580c9ac74c8d8f0c0e4afb04eeef2acf145458e52c03845ee9cd23e3d12"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
+dependencies = [
+ "leb128fmt",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
+dependencies = [
+ "anyhow",
+ "indexmap",
+ "wasm-encoder",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
+dependencies = [
+ "bitflags",
+ "hashbrown 0.15.5",
+ "indexmap",
+ "semver",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.85"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "312e32e551d92129218ea9a2452120f4aabc03529ef03e4d0d82fb2780608598"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "web-time"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-core"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+dependencies = [
+ "wit-bindgen-rust-macro",
+]
+
+[[package]]
+name = "wit-bindgen-core"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
+dependencies = [
+ "anyhow",
+ "heck",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-bindgen-rust"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck",
+ "indexmap",
+ "prettyplease",
+ "syn 2.0.117",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
+
+[[package]]
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
+dependencies = [
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
+]
+
+[[package]]
+name = "wit-component"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
+ "bitflags",
+ "indexmap",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder",
+ "wasm-metadata",
+ "wasmparser",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-parser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser",
+]
+
+[[package]]
+name = "writeable"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
+
+[[package]]
+name = "yoke"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "synstructure",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.39"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db6d35d663eadb6c932438e763b262fe1a70987f9ae936e60158176d710cae4a"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.39"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4122cd3169e94605190e77839c9a40d40ed048d305bfdc146e7df40ab0f3e517"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "synstructure",
+]
+
+[[package]]
+name = "zerotrie"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "zlib-rs"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c745c48e1007337ed136dc99df34128b9faa6ed542d80a1c673cf55a6d7236c8"
+
+[[package]]
+name = "zmij"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
+
+[[package]]
+name = "zstd"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a"
+dependencies = [
+ "zstd-safe",
+]
+
+[[package]]
+name = "zstd-safe"
+version = "7.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d"
+dependencies = [
+ "zstd-sys",
+]
+
+[[package]]
+name = "zstd-sys"
+version = "2.0.16+zstd.1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748"
+dependencies = [
+ "cc",
+ "pkg-config",
+]
diff --git a/examples/datafusion-ffi-example/Cargo.toml b/examples/datafusion-ffi-example/Cargo.toml
new file mode 100644
index 000000000..be6096faf
--- /dev/null
+++ b/examples/datafusion-ffi-example/Cargo.toml
@@ -0,0 +1,56 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+[package]
+name = "datafusion-ffi-example"
+version = "0.2.0"
+edition = "2024"
+
+[dependencies]
+datafusion-catalog = { version = "53", default-features = false }
+datafusion-common = { version = "53", default-features = false }
+datafusion-functions-aggregate = { version = "53" }
+datafusion-functions-window = { version = "53" }
+datafusion-expr = { version = "53" }
+datafusion-ffi = { version = "53" }
+
+pyo3 = { version = "0.28", features = [
+  "extension-module",
+  "abi3",
+  "abi3-py39",
+] }
+arrow = { version = "58" }
+arrow-array = { version = "58" }
+arrow-schema = { version = "58" }
+async-trait = "0.1.89"
+pyo3-log = "0.13.2"
+
+[build-dependencies]
+pyo3-build-config = "0.28"
+
+[lib]
+name = "datafusion_ffi_example"
+crate-type = ["cdylib", "rlib"]
+
+# TODO: remove when datafusion-53 is released
+[patch.crates-io]
+datafusion-catalog = { git = "https://github.com/apache/datafusion.git", rev = "35749607f585b3bf25b66b7d2289c56c18d03e4f" }
+datafusion-common = { git = "https://github.com/apache/datafusion.git", rev = "35749607f585b3bf25b66b7d2289c56c18d03e4f" }
+datafusion-functions-aggregate = { git = "https://github.com/apache/datafusion.git", rev = "35749607f585b3bf25b66b7d2289c56c18d03e4f" }
+datafusion-functions-window = { git = "https://github.com/apache/datafusion.git", rev = "35749607f585b3bf25b66b7d2289c56c18d03e4f" }
+datafusion-expr = { git = "https://github.com/apache/datafusion.git", rev = "35749607f585b3bf25b66b7d2289c56c18d03e4f" }
+datafusion-ffi = { git = "https://github.com/apache/datafusion.git", rev = "35749607f585b3bf25b66b7d2289c56c18d03e4f" }
diff --git a/examples/datafusion-ffi-example/build.rs b/examples/datafusion-ffi-example/build.rs
new file mode 100644
index 000000000..4878d8b0e
--- /dev/null
+++ b/examples/datafusion-ffi-example/build.rs
@@ -0,0 +1,20 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+fn main() {
+    pyo3_build_config::add_extension_module_link_args();
+}
diff --git a/examples/datafusion-ffi-example/pyproject.toml b/examples/datafusion-ffi-example/pyproject.toml
new file mode 100644
index 000000000..7f85e9487
--- /dev/null
+++ b/examples/datafusion-ffi-example/pyproject.toml
@@ -0,0 +1,33 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+[build-system]
+requires = ["maturin>=1.6,<2.0"]
+build-backend = "maturin"
+
+[project]
+name = "datafusion_ffi_example"
+requires-python = ">=3.9"
+classifiers = [
+  "Programming Language :: Rust",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Programming Language :: Python :: Implementation :: PyPy",
+]
+dynamic = ["version"]
+
+[tool.maturin]
+features = ["pyo3/extension-module"]
diff --git a/examples/datafusion-ffi-example/python/tests/_test_aggregate_udf.py b/examples/datafusion-ffi-example/python/tests/_test_aggregate_udf.py
new file mode 100644
index 000000000..7ea6b295c
--- /dev/null
+++ b/examples/datafusion-ffi-example/python/tests/_test_aggregate_udf.py
@@ -0,0 +1,77 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from __future__ import annotations
+
+import pyarrow as pa
+from datafusion import SessionContext, col, udaf
+from datafusion_ffi_example import MySumUDF
+
+
+def setup_context_with_table():
+    ctx = SessionContext()
+
+    # Pick numbers here so we get the same value in both groups
+    # since we cannot be certain of the output order of batches
+    batch = pa.RecordBatch.from_arrays(
+        [
+            pa.array([1, 2, 3, None], type=pa.int64()),
+            pa.array([1, 1, 2, 2], type=pa.int64()),
+        ],
+        names=["a", "b"],
+    )
+    ctx.register_record_batches("test_table", [[batch]])
+    return ctx
+
+
+def test_ffi_aggregate_register():
+    ctx = setup_context_with_table()
+    my_udaf = udaf(MySumUDF())
+    ctx.register_udaf(my_udaf)
+
+    result = ctx.sql("select my_custom_sum(a) from test_table group by b").collect()
+
+    assert len(result) == 2
+    assert result[0].num_columns == 1
+
+    result = [r.column(0) for r in result]
+    expected = [
+        pa.array([3], type=pa.int64()),
+        pa.array([3], type=pa.int64()),
+    ]
+
+    assert result == expected
+
+
+def test_ffi_aggregate_call_directly():
+    ctx = setup_context_with_table()
+    my_udaf = udaf(MySumUDF())
+
+    result = (
+        ctx.table("test_table").aggregate([col("b")], [my_udaf(col("a"))]).collect()
+    )
+
+    assert len(result) == 2
+    assert result[0].num_columns == 2
+
+    result = [r.column(1) for r in result]
+    expected = [
+        pa.array([3], type=pa.int64()),
+        pa.array([3], type=pa.int64()),
+    ]
+
+    assert result == expected
diff --git a/examples/datafusion-ffi-example/python/tests/_test_catalog_provider.py b/examples/datafusion-ffi-example/python/tests/_test_catalog_provider.py
new file mode 100644
index 000000000..a862b23ba
--- /dev/null
+++ b/examples/datafusion-ffi-example/python/tests/_test_catalog_provider.py
@@ -0,0 +1,136 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from __future__ import annotations
+
+import pyarrow as pa
+import pyarrow.dataset as ds
+import pytest
+from datafusion import SessionContext, Table
+from datafusion.catalog import Schema
+from datafusion_ffi_example import MyCatalogProvider, MyCatalogProviderList
+
+
+def create_test_dataset() -> Table:
+    """Create a simple test dataset."""
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([100, 200, 300]), pa.array([1.1, 2.2, 3.3])],
+        names=["id", "value"],
+    )
+    dataset = ds.dataset([batch])
+    return Table(dataset)
+
+
+@pytest.mark.parametrize("inner_capsule", [True, False])
+def test_ffi_catalog_provider_list(inner_capsule: bool) -> None:
+    """Test basic FFI CatalogProviderList functionality."""
+    ctx = SessionContext()
+
+    # Register FFI catalog
+    catalog_provider_list = MyCatalogProviderList()
+    if inner_capsule:
+        catalog_provider_list = (
+            catalog_provider_list.__datafusion_catalog_provider_list__(ctx)
+        )
+
+    ctx.register_catalog_provider_list(catalog_provider_list)
+
+    # Verify the catalog exists
+    catalog = ctx.catalog("auto_ffi_catalog")
+    schema_names = catalog.names()
+    assert "my_schema" in schema_names
+
+    ctx.register_catalog_provider("second", MyCatalogProvider())
+
+    assert ctx.catalog_names() == {"auto_ffi_catalog", "second"}
+
+
+@pytest.mark.parametrize("inner_capsule", [True, False])
+def test_ffi_catalog_provider_basic(inner_capsule: bool) -> None:
+    """Test basic FFI CatalogProvider functionality."""
+    ctx = SessionContext()
+
+    # Register FFI catalog
+    catalog_provider = MyCatalogProvider()
+    if inner_capsule:
+        catalog_provider = catalog_provider.__datafusion_catalog_provider__(ctx)
+
+    ctx.register_catalog_provider("ffi_catalog", catalog_provider)
+
+    # Verify the catalog exists
+    catalog = ctx.catalog("ffi_catalog")
+    schema_names = catalog.names()
+    assert "my_schema" in schema_names
+
+    # Query the pre-populated table
+    result = ctx.sql("SELECT * FROM ffi_catalog.my_schema.my_table").collect()
+    assert len(result) == 2
+    assert result[0].num_columns == 2
+
+
+def test_ffi_catalog_provider_register_schema():
+    """Test registering additional schemas to FFI CatalogProvider."""
+    ctx = SessionContext()
+
+    catalog_provider = MyCatalogProvider()
+    ctx.register_catalog_provider("ffi_catalog", catalog_provider)
+
+    catalog = ctx.catalog("ffi_catalog")
+
+    # Register a new memory schema
+    new_schema = Schema.memory_schema()
+    catalog.register_schema("additional_schema", new_schema)
+
+    # Verify the schema was registered
+    assert "additional_schema" in catalog.names()
+
+    # Add a table to the new schema
+    new_schema.register_table("new_table", create_test_dataset())
+
+    # Query the new table
+    result = ctx.sql("SELECT * FROM ffi_catalog.additional_schema.new_table").collect()
+    assert len(result) == 1
+    assert result[0].column(0) == pa.array([100, 200, 300])
+
+
+def test_ffi_catalog_provider_deregister_schema():
+    """Test deregistering schemas from FFI CatalogProvider."""
+    ctx = SessionContext()
+
+    catalog_provider = MyCatalogProvider()
+    ctx.register_catalog_provider("ffi_catalog", catalog_provider)
+
+    catalog = ctx.catalog("ffi_catalog")
+
+    # Register two schemas
+    schema1 = Schema.memory_schema()
+    schema2 = Schema.memory_schema()
+    catalog.register_schema("temp_schema1", schema1)
+    catalog.register_schema("temp_schema2", schema2)
+
+    # Verify both exist
+    names = catalog.names()
+    assert "temp_schema1" in names
+    assert "temp_schema2" in names
+
+    # Deregister one schema
+    catalog.deregister_schema("temp_schema1")
+
+    # Verify it's gone
+    names = catalog.names()
+    assert "temp_schema1" not in names
+    assert "temp_schema2" in names
diff --git a/examples/datafusion-ffi-example/python/tests/_test_scalar_udf.py b/examples/datafusion-ffi-example/python/tests/_test_scalar_udf.py
new file mode 100644
index 000000000..0c949c34a
--- /dev/null
+++ b/examples/datafusion-ffi-example/python/tests/_test_scalar_udf.py
@@ -0,0 +1,70 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from __future__ import annotations
+
+import pyarrow as pa
+from datafusion import SessionContext, col, udf
+from datafusion_ffi_example import IsNullUDF
+
+
+def setup_context_with_table():
+    ctx = SessionContext()
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3, None])],
+        names=["a"],
+    )
+    ctx.register_record_batches("test_table", [[batch]])
+    return ctx
+
+
+def test_ffi_scalar_register():
+    ctx = setup_context_with_table()
+    my_udf = udf(IsNullUDF())
+    ctx.register_udf(my_udf)
+
+    result = ctx.sql("select my_custom_is_null(a) from test_table").collect()
+
+    assert len(result) == 1
+    assert result[0].num_columns == 1
+    print(result)
+
+    result = [r.column(0) for r in result]
+    expected = [
+        pa.array([False, False, False, True], type=pa.bool_()),
+    ]
+
+    assert result == expected
+
+
+def test_ffi_scalar_call_directly():
+    ctx = setup_context_with_table()
+    my_udf = udf(IsNullUDF())
+
+    result = ctx.table("test_table").select(my_udf(col("a"))).collect()
+
+    assert len(result) == 1
+    assert result[0].num_columns == 1
+    print(result)
+
+    result = [r.column(0) for r in result]
+    expected = [
+        pa.array([False, False, False, True], type=pa.bool_()),
+    ]
+
+    assert result == expected
diff --git a/examples/datafusion-ffi-example/python/tests/_test_schema_provider.py b/examples/datafusion-ffi-example/python/tests/_test_schema_provider.py
new file mode 100644
index 000000000..93449c660
--- /dev/null
+++ b/examples/datafusion-ffi-example/python/tests/_test_schema_provider.py
@@ -0,0 +1,232 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from __future__ import annotations
+
+import pyarrow as pa
+import pyarrow.dataset as ds
+import pytest
+from datafusion import SessionContext, Table
+from datafusion.catalog import Schema
+from datafusion_ffi_example import FixedSchemaProvider, MyCatalogProvider
+
+
+def create_test_dataset() -> Table:
+    """Create a simple test dataset."""
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([100, 200, 300]), pa.array([1.1, 2.2, 3.3])],
+        names=["id", "value"],
+    )
+    dataset = ds.dataset([batch])
+    return Table(dataset)
+
+
+@pytest.mark.parametrize("inner_capsule", [True, False])
+def test_schema_provider_extract_values(inner_capsule: bool) -> None:
+    ctx = SessionContext()
+
+    my_schema_name = "my_schema"
+
+    schema_provider = FixedSchemaProvider()
+    if inner_capsule:
+        schema_provider = schema_provider.__datafusion_schema_provider__(ctx)
+
+    ctx.catalog().register_schema(my_schema_name, schema_provider)
+
+    expected_schema_name = "my_schema"
+    expected_table_name = "my_table"
+    expected_table_columns = ["units", "price"]
+
+    default_catalog = ctx.catalog()
+
+    catalog_schemas = default_catalog.names()
+    assert expected_schema_name in catalog_schemas
+    my_schema = default_catalog.schema(expected_schema_name)
+    assert expected_table_name in my_schema.names()
+    my_table = my_schema.table(expected_table_name)
+    assert expected_table_columns == my_table.schema.names
+
+    result = ctx.table(f"{expected_schema_name}.{expected_table_name}").collect()
+    assert len(result) == 2
+
+    col0_result = [r.column(0) for r in result]
+    col1_result = [r.column(1) for r in result]
+    expected_col0 = [
+        pa.array([10, 20, 30], type=pa.int32()),
+        pa.array([5, 7], type=pa.int32()),
+    ]
+    expected_col1 = [
+        pa.array([1, 2, 5], type=pa.float64()),
+        pa.array([1.5, 2.5], type=pa.float64()),
+    ]
+    assert col0_result == expected_col0
+    assert col1_result == expected_col1
+
+
+def test_ffi_schema_provider_basic():
+    """Test basic FFI SchemaProvider functionality."""
+    ctx = SessionContext()
+
+    # Register FFI schema
+    schema_provider = FixedSchemaProvider()
+    ctx.catalog().register_schema("ffi_schema", schema_provider)
+
+    # Verify the schema exists
+    schema = ctx.catalog().schema("ffi_schema")
+    table_names = schema.names()
+    assert "my_table" in table_names
+
+    # Query the pre-populated table
+    result = ctx.sql("SELECT * FROM ffi_schema.my_table").collect()
+    assert len(result) == 2
+    assert result[0].num_columns == 2
+
+
+def test_ffi_schema_provider_register_table():
+    """Test registering additional tables to FFI SchemaProvider."""
+    ctx = SessionContext()
+
+    schema_provider = FixedSchemaProvider()
+    ctx.catalog().register_schema("ffi_schema", schema_provider)
+
+    schema = ctx.catalog().schema("ffi_schema")
+
+    # Register a new table
+    schema.register_table("additional_table", create_test_dataset())
+
+    # Verify the table was registered
+    assert "additional_table" in schema.names()
+
+    # Query the new table
+    result = ctx.sql("SELECT * FROM ffi_schema.additional_table").collect()
+    assert len(result) == 1
+    assert result[0].column(0) == pa.array([100, 200, 300])
+    assert result[0].column(1) == pa.array([1.1, 2.2, 3.3])
+
+
+def test_ffi_schema_provider_deregister_table():
+    """Test deregistering tables from FFI SchemaProvider."""
+    ctx = SessionContext()
+
+    schema_provider = FixedSchemaProvider()
+    ctx.catalog().register_schema("ffi_schema", schema_provider)
+
+    schema = ctx.catalog().schema("ffi_schema")
+
+    # Register two tables
+    schema.register_table("temp_table1", create_test_dataset())
+    schema.register_table("temp_table2", create_test_dataset())
+
+    # Verify both exist
+    names = schema.names()
+    assert "temp_table1" in names
+    assert "temp_table2" in names
+
+    # Deregister one table
+    schema.deregister_table("temp_table1")
+
+    # Verify it's gone
+    names = schema.names()
+    assert "temp_table1" not in names
+    assert "temp_table2" in names
+
+
+def test_mixed_ffi_and_python_providers():
+    """Test mixing FFI and Python providers in the same catalog/schema."""
+    ctx = SessionContext()
+
+    # Register FFI catalog
+    ffi_catalog = MyCatalogProvider()
+    ctx.register_catalog_provider("ffi_catalog", ffi_catalog)
+
+    # Register Python memory schema to FFI catalog
+    python_schema = Schema.memory_schema()
+    ctx.catalog("ffi_catalog").register_schema("python_schema", python_schema)
+
+    # Add table to Python schema
+    python_schema.register_table("python_table", create_test_dataset())
+
+    # Query both FFI table and Python table
+    result_ffi = ctx.sql("SELECT * FROM ffi_catalog.my_schema.my_table").collect()
+    assert len(result_ffi) == 2
+
+    result_python = ctx.sql(
+        "SELECT * FROM ffi_catalog.python_schema.python_table"
+    ).collect()
+    assert len(result_python) == 1
+    assert result_python[0].column(0) == pa.array([100, 200, 300])
+
+
+def test_ffi_catalog_with_multiple_schemas():
+    """Test FFI catalog with multiple schemas of different types."""
+    ctx = SessionContext()
+
+    catalog_provider = MyCatalogProvider()
+    ctx.register_catalog_provider("multi_catalog", catalog_provider)
+
+    catalog = ctx.catalog("multi_catalog")
+
+    # Register different types of schemas
+    ffi_schema = FixedSchemaProvider()
+    memory_schema = Schema.memory_schema()
+
+    catalog.register_schema("ffi_schema", ffi_schema)
+    catalog.register_schema("memory_schema", memory_schema)
+
+    # Add tables to memory schema
+    memory_schema.register_table("mem_table", create_test_dataset())
+
+    # Verify all schemas exist
+    names = catalog.names()
+    assert "my_schema" in names  # Pre-populated
+    assert "ffi_schema" in names
+    assert "memory_schema" in names
+
+    # Query tables from each schema
+    result = ctx.sql("SELECT * FROM multi_catalog.my_schema.my_table").collect()
+    assert len(result) == 2
+
+    result = ctx.sql("SELECT * FROM multi_catalog.ffi_schema.my_table").collect()
+    assert len(result) == 2
+
+    result = ctx.sql("SELECT * FROM multi_catalog.memory_schema.mem_table").collect()
+    assert len(result) == 1
+    assert result[0].column(0) == pa.array([100, 200, 300])
+
+
+def test_ffi_schema_table_exist():
+    """Test table_exist method on FFI SchemaProvider."""
+    ctx = SessionContext()
+
+    schema_provider = FixedSchemaProvider()
+    ctx.catalog().register_schema("ffi_schema", schema_provider)
+
+    schema = ctx.catalog().schema("ffi_schema")
+
+    # Check pre-populated table
+    assert schema.table_exist("my_table")
+
+    # Check non-existent table
+    assert not schema.table_exist("nonexistent_table")
+
+    # Register a new table and check
+    schema.register_table("new_table", create_test_dataset())
+    assert schema.table_exist("new_table")
+
+    # Deregister and check
+    schema.deregister_table("new_table")
+    assert not schema.table_exist("new_table")
diff --git a/examples/datafusion-ffi-example/python/tests/_test_table_function.py b/examples/datafusion-ffi-example/python/tests/_test_table_function.py
new file mode 100644
index 000000000..bf5aae3bd
--- /dev/null
+++ b/examples/datafusion-ffi-example/python/tests/_test_table_function.py
@@ -0,0 +1,135 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import pyarrow as pa
+from datafusion import Expr, SessionContext, udtf
+from datafusion_ffi_example import MyTableFunction, MyTableProvider
+
+if TYPE_CHECKING:
+    from datafusion.context import TableProviderExportable
+
+
+def test_ffi_table_function_register() -> None:
+    ctx = SessionContext()
+    table_func = MyTableFunction()
+
+    table_udtf = udtf(table_func, "my_table_func")
+    ctx.register_udtf(table_udtf)
+    result = ctx.sql("select * from my_table_func()").collect()
+
+    assert len(result) == 2
+    assert result[0].num_columns == 4
+    print(result)
+
+    result = [r.column(0) for r in result]
+    expected = [
+        pa.array([0, 1, 2], type=pa.int32()),
+        pa.array([3, 4, 5, 6], type=pa.int32()),
+    ]
+
+    assert result == expected
+
+
+def test_ffi_table_function_call_directly():
+    ctx = SessionContext()
+    table_func = MyTableFunction()
+    table_udtf = udtf(table_func, "my_table_func")
+
+    my_table = table_udtf()
+    ctx.register_table("t", my_table)
+    result = ctx.table("t").collect()
+
+    assert len(result) == 2
+    assert result[0].num_columns == 4
+    print(result)
+
+    result = [r.column(0) for r in result]
+    expected = [
+        pa.array([0, 1, 2], type=pa.int32()),
+        pa.array([3, 4, 5, 6], type=pa.int32()),
+    ]
+
+    assert result == expected
+
+
+class PythonTableFunction:
+    """Python based table function.
+
+    This class is used as a Python implementation of a table function.
+    We use the existing TableProvider to create the underlying
+    provider, and this function takes no arguments
+    """
+
+    def __call__(
+        self, num_cols: Expr, num_rows: Expr, num_batches: Expr
+    ) -> TableProviderExportable:
+        args = [
+            num_cols.to_variant().value_i64(),
+            num_rows.to_variant().value_i64(),
+            num_batches.to_variant().value_i64(),
+        ]
+        return MyTableProvider(*args)
+
+
+def common_table_function_test(test_ctx: SessionContext) -> None:
+    result = test_ctx.sql("select * from my_table_func(3,2,4)").collect()
+
+    assert len(result) == 4
+    assert result[0].num_columns == 3
+    print(result)
+
+    result = [r.column(0) for r in result]
+    expected = [
+        pa.array([0, 1], type=pa.int32()),
+        pa.array([2, 3, 4], type=pa.int32()),
+        pa.array([4, 5, 6, 7], type=pa.int32()),
+        pa.array([6, 7, 8, 9, 10], type=pa.int32()),
+    ]
+
+    assert result == expected
+
+
+def test_python_table_function():
+    ctx = SessionContext()
+    table_func = PythonTableFunction()
+    table_udtf = udtf(table_func, "my_table_func")
+    ctx.register_udtf(table_udtf)
+
+    common_table_function_test(ctx)
+
+
+def test_python_table_function_decorator():
+    ctx = SessionContext()
+
+    @udtf("my_table_func")
+    def my_udtf(
+        num_cols: Expr, num_rows: Expr, num_batches: Expr
+    ) -> TableProviderExportable:
+        args = [
+            num_cols.to_variant().value_i64(),
+            num_rows.to_variant().value_i64(),
+            num_batches.to_variant().value_i64(),
+        ]
+        return MyTableProvider(*args)
+
+    ctx.register_udtf(my_udtf)
+
+    common_table_function_test(ctx)
diff --git a/examples/datafusion-ffi-example/python/tests/_test_table_provider.py b/examples/datafusion-ffi-example/python/tests/_test_table_provider.py
new file mode 100644
index 000000000..fc77d2d3b
--- /dev/null
+++ b/examples/datafusion-ffi-example/python/tests/_test_table_provider.py
@@ -0,0 +1,51 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from __future__ import annotations
+
+import pyarrow as pa
+import pytest
+from datafusion import SessionContext
+from datafusion_ffi_example import MyTableProvider
+
+
+@pytest.mark.parametrize("inner_capsule", [True, False])
+def test_table_provider_ffi(inner_capsule: bool) -> None:
+    ctx = SessionContext()
+    table = MyTableProvider(3, 2, 4)
+    if inner_capsule:
+        table = table.__datafusion_table_provider__(ctx)
+
+    ctx.register_table("t", table)
+    result = ctx.table("t").collect()
+
+    assert len(result) == 4
+    assert result[0].num_columns == 3
+
+    result = [r.column(0) for r in result]
+    expected = [
+        pa.array([0, 1], type=pa.int32()),
+        pa.array([2, 3, 4], type=pa.int32()),
+        pa.array([4, 5, 6, 7], type=pa.int32()),
+        pa.array([6, 7, 8, 9, 10], type=pa.int32()),
+    ]
+
+    assert result == expected
+
+    result = ctx.read_table(table).collect()
+    result = [r.column(0) for r in result]
+    assert result == expected
diff --git a/examples/datafusion-ffi-example/python/tests/_test_window_udf.py b/examples/datafusion-ffi-example/python/tests/_test_window_udf.py
new file mode 100644
index 000000000..7d96994b9
--- /dev/null
+++ b/examples/datafusion-ffi-example/python/tests/_test_window_udf.py
@@ -0,0 +1,89 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from __future__ import annotations
+
+import pyarrow as pa
+from datafusion import SessionContext, col, udwf
+from datafusion_ffi_example import MyRankUDF
+
+
+def setup_context_with_table():
+    ctx = SessionContext()
+
+    # Pick numbers here so we get the same value in both groups
+    # since we cannot be certain of the output order of batches
+    batch = pa.RecordBatch.from_arrays(
+        [
+            pa.array([40, 10, 30, 20], type=pa.int64()),
+        ],
+        names=["a"],
+    )
+    ctx.register_record_batches("test_table", [[batch]])
+    return ctx
+
+
+def test_ffi_window_register():
+    ctx = setup_context_with_table()
+    my_udwf = udwf(MyRankUDF())
+    ctx.register_udwf(my_udwf)
+
+    result = ctx.sql(
+        "select a, my_custom_rank() over (order by a) from test_table"
+    ).collect()
+    assert len(result) == 1
+    assert result[0].num_columns == 2
+
+    results = [
+        (result[0][0][idx].as_py(), result[0][1][idx].as_py()) for idx in range(4)
+    ]
+    results.sort()
+
+    expected = [
+        (10, 1),
+        (20, 2),
+        (30, 3),
+        (40, 4),
+    ]
+    assert results == expected
+
+
+def test_ffi_window_call_directly():
+    ctx = setup_context_with_table()
+    my_udwf = udwf(MyRankUDF())
+
+    result = (
+        ctx.table("test_table")
+        .select(col("a"), my_udwf().order_by(col("a")).build())
+        .collect()
+    )
+
+    assert len(result) == 1
+    assert result[0].num_columns == 2
+
+    results = [
+        (result[0][0][idx].as_py(), result[0][1][idx].as_py()) for idx in range(4)
+    ]
+    results.sort()
+
+    expected = [
+        (10, 1),
+        (20, 2),
+        (30, 3),
+        (40, 4),
+    ]
+    assert results == expected
diff --git a/datafusion/tests/test_catalog.py b/examples/datafusion-ffi-example/python/tests/conftest.py
similarity index 55%
rename from datafusion/tests/test_catalog.py
rename to examples/datafusion-ffi-example/python/tests/conftest.py
index 214f6b165..68f8057af 100644
--- a/datafusion/tests/test_catalog.py
+++ b/examples/datafusion-ffi-example/python/tests/conftest.py
@@ -15,26 +15,28 @@
 # specific language governing permissions and limitations
 # under the License.
 
-import pyarrow as pa
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
 import pytest
 
+if TYPE_CHECKING:
+    from collections.abc import Generator
+    from typing import Any
 
-def test_basic(ctx, database):
-    with pytest.raises(KeyError):
-        ctx.catalog("non-existent")
 
-    default = ctx.catalog()
-    assert default.names() == ["public"]
+class _FailOnWarning(logging.Handler):
+    def emit(self, record: logging.LogRecord) -> None:
+        if record.levelno >= logging.WARNING:
+            err = f"Unexpected log warning from '{record.name}': {self.format(record)}"
+            raise AssertionError(err)
 
-    for database in [default.database("public"), default.database()]:
-        assert database.names() == {"csv1", "csv", "csv2"}
 
-    table = database.table("csv")
-    assert table.kind == "physical"
-    assert table.schema == pa.schema(
-        [
-            pa.field("int", pa.int64(), nullable=True),
-            pa.field("str", pa.string(), nullable=True),
-            pa.field("float", pa.float64(), nullable=True),
-        ]
-    )
+@pytest.fixture(autouse=True)
+def fail_on_log_warnings() -> Generator[None, Any, None]:
+    handler = _FailOnWarning()
+    logging.root.addHandler(handler)
+    yield
+    logging.root.removeHandler(handler)
diff --git a/examples/datafusion-ffi-example/src/aggregate_udf.rs b/examples/datafusion-ffi-example/src/aggregate_udf.rs
new file mode 100644
index 000000000..d5343ff91
--- /dev/null
+++ b/examples/datafusion-ffi-example/src/aggregate_udf.rs
@@ -0,0 +1,87 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::any::Any;
+use std::sync::Arc;
+
+use arrow_schema::DataType;
+use datafusion_common::error::Result as DataFusionResult;
+use datafusion_expr::function::AccumulatorArgs;
+use datafusion_expr::{Accumulator, AggregateUDF, AggregateUDFImpl, Signature};
+use datafusion_ffi::udaf::FFI_AggregateUDF;
+use datafusion_functions_aggregate::sum::Sum;
+use pyo3::types::PyCapsule;
+use pyo3::{Bound, PyResult, Python, pyclass, pymethods};
+
+#[pyclass(
+    from_py_object,
+    name = "MySumUDF",
+    module = "datafusion_ffi_example",
+    subclass
+)]
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub(crate) struct MySumUDF {
+    inner: Arc<Sum>,
+}
+
+#[pymethods]
+impl MySumUDF {
+    #[new]
+    fn new() -> PyResult<Self> {
+        Ok(Self {
+            inner: Arc::new(Sum::new()),
+        })
+    }
+
+    fn __datafusion_aggregate_udf__<'py>(
+        &self,
+        py: Python<'py>,
+    ) -> PyResult<Bound<'py, PyCapsule>> {
+        let name = cr"datafusion_aggregate_udf".into();
+
+        let func = Arc::new(AggregateUDF::from(self.clone()));
+        let provider = FFI_AggregateUDF::from(func);
+
+        PyCapsule::new(py, provider, Some(name))
+    }
+}
+
+impl AggregateUDFImpl for MySumUDF {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn name(&self) -> &str {
+        "my_custom_sum"
+    }
+
+    fn signature(&self) -> &Signature {
+        self.inner.signature()
+    }
+
+    fn return_type(&self, arg_types: &[DataType]) -> DataFusionResult<DataType> {
+        self.inner.return_type(arg_types)
+    }
+
+    fn accumulator(&self, acc_args: AccumulatorArgs) -> DataFusionResult<Box<dyn Accumulator>> {
+        self.inner.accumulator(acc_args)
+    }
+
+    fn coerce_types(&self, arg_types: &[DataType]) -> DataFusionResult<Vec<DataType>> {
+        self.inner.coerce_types(arg_types)
+    }
+}
diff --git a/examples/datafusion-ffi-example/src/catalog_provider.rs b/examples/datafusion-ffi-example/src/catalog_provider.rs
new file mode 100644
index 000000000..d0e07c787
--- /dev/null
+++ b/examples/datafusion-ffi-example/src/catalog_provider.rs
@@ -0,0 +1,273 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::any::Any;
+use std::fmt::Debug;
+use std::sync::Arc;
+
+use arrow::datatypes::Schema;
+use async_trait::async_trait;
+use datafusion_catalog::{
+    CatalogProvider, CatalogProviderList, MemTable, MemoryCatalogProvider,
+    MemoryCatalogProviderList, MemorySchemaProvider, SchemaProvider, TableProvider,
+};
+use datafusion_common::error::{DataFusionError, Result};
+use datafusion_ffi::catalog_provider::FFI_CatalogProvider;
+use datafusion_ffi::catalog_provider_list::FFI_CatalogProviderList;
+use datafusion_ffi::schema_provider::FFI_SchemaProvider;
+use pyo3::types::PyCapsule;
+use pyo3::{Bound, PyAny, PyResult, Python, pyclass, pymethods};
+
+use crate::utils::ffi_logical_codec_from_pycapsule;
+
+pub fn my_table() -> Arc<dyn TableProvider + 'static> {
+    use arrow::datatypes::{DataType, Field};
+    use datafusion_common::record_batch;
+
+    let schema = Arc::new(Schema::new(vec![
+        Field::new("units", DataType::Int32, true),
+        Field::new("price", DataType::Float64, true),
+    ]));
+
+    let partitions = vec![
+        record_batch!(
+            ("units", Int32, vec![10, 20, 30]),
+            ("price", Float64, vec![1.0, 2.0, 5.0])
+        )
+        .unwrap(),
+        record_batch!(
+            ("units", Int32, vec![5, 7]),
+            ("price", Float64, vec![1.5, 2.5])
+        )
+        .unwrap(),
+    ];
+
+    Arc::new(MemTable::try_new(schema, vec![partitions]).unwrap())
+}
+
+#[pyclass(
+    skip_from_py_object,
+    name = "FixedSchemaProvider",
+    module = "datafusion_ffi_example",
+    subclass
+)]
+#[derive(Debug)]
+pub struct FixedSchemaProvider {
+    inner: Arc<MemorySchemaProvider>,
+}
+
+impl Default for FixedSchemaProvider {
+    fn default() -> Self {
+        let inner = Arc::new(MemorySchemaProvider::new());
+
+        let table = my_table();
+
+        let _ = inner.register_table("my_table".to_string(), table).unwrap();
+
+        Self { inner }
+    }
+}
+
+#[pymethods]
+impl FixedSchemaProvider {
+    #[new]
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn __datafusion_schema_provider__<'py>(
+        &self,
+        py: Python<'py>,
+        session: Bound<PyAny>,
+    ) -> PyResult<Bound<'py, PyCapsule>> {
+        let name = cr"datafusion_schema_provider".into();
+
+        let provider = Arc::clone(&self.inner) as Arc<dyn SchemaProvider + Send>;
+
+        let codec = ffi_logical_codec_from_pycapsule(session)?;
+        let provider = FFI_SchemaProvider::new_with_ffi_codec(provider, None, codec);
+
+        PyCapsule::new(py, provider, Some(name))
+    }
+}
+
+#[async_trait]
+impl SchemaProvider for FixedSchemaProvider {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn table_names(&self) -> Vec<String> {
+        self.inner.table_names()
+    }
+
+    async fn table(&self, name: &str) -> Result<Option<Arc<dyn TableProvider>>, DataFusionError> {
+        self.inner.table(name).await
+    }
+
+    fn register_table(
+        &self,
+        name: String,
+        table: Arc<dyn TableProvider>,
+    ) -> Result<Option<Arc<dyn TableProvider>>> {
+        self.inner.register_table(name, table)
+    }
+
+    fn deregister_table(&self, name: &str) -> Result<Option<Arc<dyn TableProvider>>> {
+        self.inner.deregister_table(name)
+    }
+
+    fn table_exist(&self, name: &str) -> bool {
+        self.inner.table_exist(name)
+    }
+}
+
+/// This catalog provider is intended only for unit tests. It prepopulates with one
+/// schema and only allows for schemas named after four types of fruit.
+#[pyclass(
+    skip_from_py_object,
+    name = "MyCatalogProvider",
+    module = "datafusion_ffi_example",
+    subclass
+)]
+#[derive(Debug, Clone)]
+pub(crate) struct MyCatalogProvider {
+    inner: Arc<MemoryCatalogProvider>,
+}
+
+impl CatalogProvider for MyCatalogProvider {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn schema_names(&self) -> Vec<String> {
+        self.inner.schema_names()
+    }
+
+    fn schema(&self, name: &str) -> Option<Arc<dyn SchemaProvider>> {
+        self.inner.schema(name)
+    }
+
+    fn register_schema(
+        &self,
+        name: &str,
+        schema: Arc<dyn SchemaProvider>,
+    ) -> Result<Option<Arc<dyn SchemaProvider>>> {
+        self.inner.register_schema(name, schema)
+    }
+
+    fn deregister_schema(
+        &self,
+        name: &str,
+        cascade: bool,
+    ) -> Result<Option<Arc<dyn SchemaProvider>>> {
+        self.inner.deregister_schema(name, cascade)
+    }
+}
+
+#[pymethods]
+impl MyCatalogProvider {
+    #[new]
+    pub fn new() -> PyResult<Self> {
+        let inner = Arc::new(MemoryCatalogProvider::new());
+
+        let schema_name: &str = "my_schema";
+        let _ = inner.register_schema(schema_name, Arc::new(FixedSchemaProvider::default()));
+
+        Ok(Self { inner })
+    }
+
+    pub fn __datafusion_catalog_provider__<'py>(
+        &self,
+        py: Python<'py>,
+        session: Bound<PyAny>,
+    ) -> PyResult<Bound<'py, PyCapsule>> {
+        let name = cr"datafusion_catalog_provider".into();
+
+        let provider = Arc::clone(&self.inner) as Arc<dyn CatalogProvider + Send>;
+
+        let codec = ffi_logical_codec_from_pycapsule(session)?;
+        let provider = FFI_CatalogProvider::new_with_ffi_codec(provider, None, codec);
+
+        PyCapsule::new(py, provider, Some(name))
+    }
+}
+
+/// This catalog provider list is intended only for unit tests.
+/// It pre-populates with a single catalog.
+#[pyclass(
+    skip_from_py_object,
+    name = "MyCatalogProviderList",
+    module = "datafusion_ffi_example",
+    subclass
+)]
+#[derive(Debug, Clone)]
+pub(crate) struct MyCatalogProviderList {
+    inner: Arc<MemoryCatalogProviderList>,
+}
+
+impl CatalogProviderList for MyCatalogProviderList {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn catalog_names(&self) -> Vec<String> {
+        self.inner.catalog_names()
+    }
+
+    fn catalog(&self, name: &str) -> Option<Arc<dyn CatalogProvider>> {
+        self.inner.catalog(name)
+    }
+
+    fn register_catalog(
+        &self,
+        name: String,
+        catalog: Arc<dyn CatalogProvider>,
+    ) -> Option<Arc<dyn CatalogProvider>> {
+        self.inner.register_catalog(name, catalog)
+    }
+}
+
+#[pymethods]
+impl MyCatalogProviderList {
+    #[new]
+    pub fn new() -> PyResult<Self> {
+        let inner = Arc::new(MemoryCatalogProviderList::new());
+
+        inner.register_catalog(
+            "auto_ffi_catalog".to_owned(),
+            Arc::new(MyCatalogProvider::new()?),
+        );
+
+        Ok(Self { inner })
+    }
+
+    pub fn __datafusion_catalog_provider_list__<'py>(
+        &self,
+        py: Python<'py>,
+        session: Bound<PyAny>,
+    ) -> PyResult<Bound<'py, PyCapsule>> {
+        let name = cr"datafusion_catalog_provider_list".into();
+
+        let provider = Arc::clone(&self.inner) as Arc<dyn CatalogProviderList + Send>;
+
+        let codec = ffi_logical_codec_from_pycapsule(session)?;
+        let provider = FFI_CatalogProviderList::new_with_ffi_codec(provider, None, codec);
+
+        PyCapsule::new(py, provider, Some(name))
+    }
+}
diff --git a/examples/datafusion-ffi-example/src/lib.rs b/examples/datafusion-ffi-example/src/lib.rs
new file mode 100644
index 000000000..23f2001a2
--- /dev/null
+++ b/examples/datafusion-ffi-example/src/lib.rs
@@ -0,0 +1,48 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use pyo3::prelude::*;
+
+use crate::aggregate_udf::MySumUDF;
+use crate::catalog_provider::{FixedSchemaProvider, MyCatalogProvider, MyCatalogProviderList};
+use crate::scalar_udf::IsNullUDF;
+use crate::table_function::MyTableFunction;
+use crate::table_provider::MyTableProvider;
+use crate::window_udf::MyRankUDF;
+
+pub(crate) mod aggregate_udf;
+pub(crate) mod catalog_provider;
+pub(crate) mod scalar_udf;
+pub(crate) mod table_function;
+pub(crate) mod table_provider;
+pub(crate) mod utils;
+pub(crate) mod window_udf;
+
+#[pymodule]
+fn datafusion_ffi_example(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    pyo3_log::init();
+
+    m.add_class::<MyTableProvider>()?;
+    m.add_class::<MyTableFunction>()?;
+    m.add_class::<MyCatalogProvider>()?;
+    m.add_class::<MyCatalogProviderList>()?;
+    m.add_class::<FixedSchemaProvider>()?;
+    m.add_class::<IsNullUDF>()?;
+    m.add_class::<MySumUDF>()?;
+    m.add_class::<MyRankUDF>()?;
+    Ok(())
+}
diff --git a/examples/datafusion-ffi-example/src/scalar_udf.rs b/examples/datafusion-ffi-example/src/scalar_udf.rs
new file mode 100644
index 000000000..374924781
--- /dev/null
+++ b/examples/datafusion-ffi-example/src/scalar_udf.rs
@@ -0,0 +1,97 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::any::Any;
+use std::sync::Arc;
+
+use arrow_array::{Array, BooleanArray};
+use arrow_schema::DataType;
+use datafusion_common::ScalarValue;
+use datafusion_common::error::Result as DataFusionResult;
+use datafusion_expr::{
+    ColumnarValue, ScalarFunctionArgs, ScalarUDF, ScalarUDFImpl, Signature, TypeSignature,
+    Volatility,
+};
+use datafusion_ffi::udf::FFI_ScalarUDF;
+use pyo3::types::PyCapsule;
+use pyo3::{Bound, PyResult, Python, pyclass, pymethods};
+
+#[pyclass(
+    from_py_object,
+    name = "IsNullUDF",
+    module = "datafusion_ffi_example",
+    subclass
+)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub(crate) struct IsNullUDF {
+    signature: Signature,
+}
+
+#[pymethods]
+impl IsNullUDF {
+    #[new]
+    fn new() -> Self {
+        Self {
+            signature: Signature::new(TypeSignature::Any(1), Volatility::Immutable),
+        }
+    }
+
+    fn __datafusion_scalar_udf__<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyCapsule>> {
+        let name = cr"datafusion_scalar_udf".into();
+
+        let func = Arc::new(ScalarUDF::from(self.clone()));
+        let provider = FFI_ScalarUDF::from(func);
+
+        PyCapsule::new(py, provider, Some(name))
+    }
+}
+
+impl ScalarUDFImpl for IsNullUDF {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn name(&self) -> &str {
+        "my_custom_is_null"
+    }
+
+    fn signature(&self) -> &Signature {
+        &self.signature
+    }
+
+    fn return_type(&self, _arg_types: &[DataType]) -> DataFusionResult<DataType> {
+        Ok(DataType::Boolean)
+    }
+
+    fn invoke_with_args(&self, args: ScalarFunctionArgs) -> DataFusionResult<ColumnarValue> {
+        let input = &args.args[0];
+
+        Ok(match input {
+            ColumnarValue::Array(arr) => match arr.is_nullable() {
+                true => {
+                    let nulls = arr.nulls().unwrap();
+                    let nulls = BooleanArray::from_iter(nulls.iter().map(|x| Some(!x)));
+                    ColumnarValue::Array(Arc::new(nulls))
+                }
+                false => ColumnarValue::Scalar(ScalarValue::Boolean(Some(false))),
+            },
+            ColumnarValue::Scalar(sv) => {
+                ColumnarValue::Scalar(ScalarValue::Boolean(Some(sv == &ScalarValue::Null)))
+            }
+        })
+    }
+}
diff --git a/examples/datafusion-ffi-example/src/table_function.rs b/examples/datafusion-ffi-example/src/table_function.rs
new file mode 100644
index 000000000..0914e161c
--- /dev/null
+++ b/examples/datafusion-ffi-example/src/table_function.rs
@@ -0,0 +1,66 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::sync::Arc;
+
+use datafusion_catalog::{TableFunctionImpl, TableProvider};
+use datafusion_common::error::Result as DataFusionResult;
+use datafusion_expr::Expr;
+use datafusion_ffi::udtf::FFI_TableFunction;
+use pyo3::types::PyCapsule;
+use pyo3::{Bound, PyAny, PyResult, Python, pyclass, pymethods};
+
+use crate::table_provider::MyTableProvider;
+use crate::utils::ffi_logical_codec_from_pycapsule;
+
+#[pyclass(
+    from_py_object,
+    name = "MyTableFunction",
+    module = "datafusion_ffi_example",
+    subclass
+)]
+#[derive(Debug, Clone)]
+pub(crate) struct MyTableFunction {}
+
+#[pymethods]
+impl MyTableFunction {
+    #[new]
+    fn new() -> Self {
+        Self {}
+    }
+
+    fn __datafusion_table_function__<'py>(
+        &self,
+        py: Python<'py>,
+        session: Bound<PyAny>,
+    ) -> PyResult<Bound<'py, PyCapsule>> {
+        let name = cr"datafusion_table_function".into();
+
+        let func = self.clone();
+        let codec = ffi_logical_codec_from_pycapsule(session)?;
+        let provider = FFI_TableFunction::new_with_ffi_codec(Arc::new(func), None, codec);
+
+        PyCapsule::new(py, provider, Some(name))
+    }
+}
+
+impl TableFunctionImpl for MyTableFunction {
+    fn call(&self, _args: &[Expr]) -> DataFusionResult<Arc<dyn TableProvider>> {
+        let provider = MyTableProvider::new(4, 3, 2).create_table()?;
+        Ok(Arc::new(provider))
+    }
+}
diff --git a/examples/datafusion-ffi-example/src/table_provider.rs b/examples/datafusion-ffi-example/src/table_provider.rs
new file mode 100644
index 000000000..2c79e6ef9
--- /dev/null
+++ b/examples/datafusion-ffi-example/src/table_provider.rs
@@ -0,0 +1,115 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::sync::Arc;
+
+use arrow_array::{ArrayRef, RecordBatch};
+use arrow_schema::{DataType, Field, Schema};
+use datafusion_catalog::MemTable;
+use datafusion_common::error::{DataFusionError, Result as DataFusionResult};
+use datafusion_ffi::table_provider::FFI_TableProvider;
+use pyo3::exceptions::PyRuntimeError;
+use pyo3::types::PyCapsule;
+use pyo3::{Bound, PyAny, PyResult, Python, pyclass, pymethods};
+
+use crate::utils::ffi_logical_codec_from_pycapsule;
+
+/// In order to provide a test that demonstrates different sized record batches,
+/// the first batch will have num_rows, the second batch num_rows+1, and so on.
+#[pyclass(
+    from_py_object,
+    name = "MyTableProvider",
+    module = "datafusion_ffi_example",
+    subclass
+)]
+#[derive(Clone)]
+pub(crate) struct MyTableProvider {
+    num_cols: usize,
+    num_rows: usize,
+    num_batches: usize,
+}
+
+fn create_record_batch(
+    schema: &Arc<Schema>,
+    num_cols: usize,
+    start_value: i32,
+    num_values: usize,
+) -> DataFusionResult<RecordBatch> {
+    let end_value = start_value + num_values as i32;
+    let row_values: Vec<i32> = (start_value..end_value).collect();
+
+    let columns: Vec<_> = (0..num_cols)
+        .map(|_| Arc::new(arrow::array::Int32Array::from(row_values.clone())) as ArrayRef)
+        .collect();
+
+    RecordBatch::try_new(Arc::clone(schema), columns).map_err(DataFusionError::from)
+}
+
+impl MyTableProvider {
+    pub fn create_table(&self) -> DataFusionResult<MemTable> {
+        let fields: Vec<_> = (0..self.num_cols)
+            .map(|idx| (b'A' + idx as u8) as char)
+            .map(|col_name| Field::new(col_name, DataType::Int32, true))
+            .collect();
+
+        let schema = Arc::new(Schema::new(fields));
+
+        let batches: DataFusionResult<Vec<_>> = (0..self.num_batches)
+            .map(|batch_idx| {
+                let start_value = batch_idx * self.num_rows;
+                create_record_batch(
+                    &schema,
+                    self.num_cols,
+                    start_value as i32,
+                    self.num_rows + batch_idx,
+                )
+            })
+            .collect();
+
+        MemTable::try_new(schema, vec![batches?])
+    }
+}
+
+#[pymethods]
+impl MyTableProvider {
+    #[new]
+    pub fn new(num_cols: usize, num_rows: usize, num_batches: usize) -> Self {
+        Self {
+            num_cols,
+            num_rows,
+            num_batches,
+        }
+    }
+
+    pub fn __datafusion_table_provider__<'py>(
+        &self,
+        py: Python<'py>,
+        session: Bound<PyAny>,
+    ) -> PyResult<Bound<'py, PyCapsule>> {
+        let name = cr"datafusion_table_provider".into();
+
+        let provider = self
+            .create_table()
+            .map_err(|e: DataFusionError| PyRuntimeError::new_err(e.to_string()))?;
+
+        let codec = ffi_logical_codec_from_pycapsule(session)?;
+        let provider =
+            FFI_TableProvider::new_with_ffi_codec(Arc::new(provider), false, None, codec);
+
+        PyCapsule::new(py, provider, Some(name))
+    }
+}
diff --git a/examples/datafusion-ffi-example/src/utils.rs b/examples/datafusion-ffi-example/src/utils.rs
new file mode 100644
index 000000000..5f2865aa2
--- /dev/null
+++ b/examples/datafusion-ffi-example/src/utils.rs
@@ -0,0 +1,64 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::ptr::NonNull;
+
+use datafusion_ffi::proto::logical_extension_codec::FFI_LogicalExtensionCodec;
+use pyo3::exceptions::PyValueError;
+use pyo3::ffi::c_str;
+use pyo3::prelude::{PyAnyMethods, PyCapsuleMethods};
+use pyo3::types::PyCapsule;
+use pyo3::{Bound, PyAny, PyResult};
+
+pub(crate) fn ffi_logical_codec_from_pycapsule(
+    obj: Bound<PyAny>,
+) -> PyResult<FFI_LogicalExtensionCodec> {
+    let attr_name = "__datafusion_logical_extension_codec__";
+    let capsule = if obj.hasattr(attr_name)? {
+        obj.getattr(attr_name)?.call0()?
+    } else {
+        obj
+    };
+
+    let capsule = capsule.cast::<PyCapsule>()?;
+    validate_pycapsule(capsule, "datafusion_logical_extension_codec")?;
+
+    let data: NonNull<FFI_LogicalExtensionCodec> = capsule
+        .pointer_checked(Some(c_str!("datafusion_logical_extension_codec")))?
+        .cast();
+    let codec = unsafe { data.as_ref() };
+
+    Ok(codec.clone())
+}
+
+pub(crate) fn validate_pycapsule(capsule: &Bound<PyCapsule>, name: &str) -> PyResult<()> {
+    let capsule_name = capsule.name()?;
+    if capsule_name.is_none() {
+        return Err(PyValueError::new_err(format!(
+            "Expected {name} PyCapsule to have name set."
+        )));
+    }
+
+    let capsule_name = unsafe { capsule_name.unwrap().as_cstr().to_str()? };
+    if capsule_name != name {
+        return Err(PyValueError::new_err(format!(
+            "Expected name '{name}' in PyCapsule, instead got '{capsule_name}'"
+        )));
+    }
+
+    Ok(())
+}
diff --git a/examples/datafusion-ffi-example/src/window_udf.rs b/examples/datafusion-ffi-example/src/window_udf.rs
new file mode 100644
index 000000000..cbf179a86
--- /dev/null
+++ b/examples/datafusion-ffi-example/src/window_udf.rs
@@ -0,0 +1,87 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::any::Any;
+use std::sync::Arc;
+
+use arrow_schema::{DataType, FieldRef};
+use datafusion_common::error::Result as DataFusionResult;
+use datafusion_expr::function::{PartitionEvaluatorArgs, WindowUDFFieldArgs};
+use datafusion_expr::{PartitionEvaluator, Signature, WindowUDF, WindowUDFImpl};
+use datafusion_ffi::udwf::FFI_WindowUDF;
+use datafusion_functions_window::rank::rank_udwf;
+use pyo3::types::PyCapsule;
+use pyo3::{Bound, PyResult, Python, pyclass, pymethods};
+
+#[pyclass(
+    from_py_object,
+    name = "MyRankUDF",
+    module = "datafusion_ffi_example",
+    subclass
+)]
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub(crate) struct MyRankUDF {
+    inner: Arc<WindowUDF>,
+}
+
+#[pymethods]
+impl MyRankUDF {
+    #[new]
+    fn new() -> PyResult<Self> {
+        Ok(Self { inner: rank_udwf() })
+    }
+
+    fn __datafusion_window_udf__<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyCapsule>> {
+        let name = cr"datafusion_window_udf".into();
+
+        let func = Arc::new(WindowUDF::from(self.clone()));
+        let provider = FFI_WindowUDF::from(func);
+
+        PyCapsule::new(py, provider, Some(name))
+    }
+}
+
+impl WindowUDFImpl for MyRankUDF {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn name(&self) -> &str {
+        "my_custom_rank"
+    }
+
+    fn signature(&self) -> &Signature {
+        self.inner.signature()
+    }
+
+    fn partition_evaluator(
+        &self,
+        partition_evaluator_args: PartitionEvaluatorArgs,
+    ) -> DataFusionResult<Box<dyn PartitionEvaluator>> {
+        self.inner
+            .inner()
+            .partition_evaluator(partition_evaluator_args)
+    }
+
+    fn field(&self, field_args: WindowUDFFieldArgs) -> DataFusionResult<FieldRef> {
+        self.inner.inner().field(field_args)
+    }
+
+    fn coerce_types(&self, arg_types: &[DataType]) -> DataFusionResult<Vec<DataType>> {
+        self.inner.coerce_types(arg_types)
+    }
+}
diff --git a/examples/export.py b/examples/export.py
index d179bf39d..c7a387bcb 100644
--- a/examples/export.py
+++ b/examples/export.py
@@ -17,7 +17,6 @@
 
 import datafusion
 
-
 # create a context
 ctx = datafusion.SessionContext()
 
@@ -48,6 +47,6 @@
 pylist = df.to_pylist()
 assert pylist == [{"a": 1, "b": 4}, {"a": 2, "b": 5}, {"a": 3, "b": 6}]
 
-# export to Pyton dictionary of columns
+# export to Python dictionary of columns
 pydict = df.to_pydict()
 assert pydict == {"a": [1, 2, 3], "b": [4, 5, 6]}
diff --git a/examples/import.py b/examples/import.py
index a249a1c4e..7b5ab5082 100644
--- a/examples/import.py
+++ b/examples/import.py
@@ -16,10 +16,9 @@
 # under the License.
 
 import datafusion
-import pyarrow as pa
 import pandas as pd
 import polars as pl
-
+import pyarrow as pa
 
 # Create a context
 ctx = datafusion.SessionContext()
@@ -28,7 +27,7 @@
 # The dictionary keys represent column names and the dictionary values
 # represent column values
 df = ctx.from_pydict({"a": [1, 2, 3], "b": [4, 5, 6]})
-assert type(df) == datafusion.DataFrame
+assert type(df) is datafusion.DataFrame
 # Dataframe:
 # +---+---+
 # | a | b |
@@ -40,19 +39,19 @@
 
 # Create a datafusion DataFrame from a Python list of rows
 df = ctx.from_pylist([{"a": 1, "b": 4}, {"a": 2, "b": 5}, {"a": 3, "b": 6}])
-assert type(df) == datafusion.DataFrame
+assert type(df) is datafusion.DataFrame
 
 # Convert pandas DataFrame to datafusion DataFrame
 pandas_df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
 df = ctx.from_pandas(pandas_df)
-assert type(df) == datafusion.DataFrame
+assert type(df) is datafusion.DataFrame
 
 # Convert polars DataFrame to datafusion DataFrame
 polars_df = pl.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
 df = ctx.from_polars(polars_df)
-assert type(df) == datafusion.DataFrame
+assert type(df) is datafusion.DataFrame
 
 # Convert Arrow Table to datafusion DataFrame
 arrow_table = pa.Table.from_pydict({"a": [1, 2, 3], "b": [4, 5, 6]})
-df = ctx.from_arrow_table(arrow_table)
-assert type(df) == datafusion.DataFrame
+df = ctx.from_arrow(arrow_table)
+assert type(df) is datafusion.DataFrame
diff --git a/examples/python-udaf.py b/examples/python-udaf.py
index ed705f5a9..6655edb0a 100644
--- a/examples/python-udaf.py
+++ b/examples/python-udaf.py
@@ -15,11 +15,10 @@
 # specific language governing permissions and limitations
 # under the License.
 
-import pyarrow
-import pyarrow.compute
 import datafusion
-from datafusion import udaf, Accumulator
-from datafusion import col
+import pyarrow as pa
+import pyarrow.compute
+from datafusion import Accumulator, col, udaf
 
 
 class MyAccumulator(Accumulator):
@@ -27,25 +26,21 @@ class MyAccumulator(Accumulator):
     Interface of a user-defined accumulation.
     """
 
-    def __init__(self):
-        self._sum = pyarrow.scalar(0.0)
+    def __init__(self) -> None:
+        self._sum = pa.scalar(0.0)
 
-    def update(self, values: pyarrow.Array) -> None:
+    def update(self, values: pa.Array) -> None:
         # not nice since pyarrow scalars can't be summed yet. This breaks on `None`
-        self._sum = pyarrow.scalar(
-            self._sum.as_py() + pyarrow.compute.sum(values).as_py()
-        )
+        self._sum = pa.scalar(self._sum.as_py() + pa.compute.sum(values).as_py())
 
-    def merge(self, states: pyarrow.Array) -> None:
+    def merge(self, states: pa.Array) -> None:
         # not nice since pyarrow scalars can't be summed yet. This breaks on `None`
-        self._sum = pyarrow.scalar(
-            self._sum.as_py() + pyarrow.compute.sum(states).as_py()
-        )
+        self._sum = pa.scalar(self._sum.as_py() + pa.compute.sum(states).as_py())
 
-    def state(self) -> pyarrow.Array:
-        return pyarrow.array([self._sum.as_py()])
+    def state(self) -> pa.Array:
+        return pa.array([self._sum.as_py()])
 
-    def evaluate(self) -> pyarrow.Scalar:
+    def evaluate(self) -> pa.Scalar:
         return self._sum
 
 
@@ -53,17 +48,17 @@ def evaluate(self) -> pyarrow.Scalar:
 ctx = datafusion.SessionContext()
 
 # create a RecordBatch and a new DataFrame from it
-batch = pyarrow.RecordBatch.from_arrays(
-    [pyarrow.array([1, 2, 3]), pyarrow.array([4, 5, 6])],
+batch = pa.RecordBatch.from_arrays(
+    [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
     names=["a", "b"],
 )
 df = ctx.create_dataframe([[batch]])
 
 my_udaf = udaf(
     MyAccumulator,
-    pyarrow.float64(),
-    pyarrow.float64(),
-    [pyarrow.float64()],
+    pa.float64(),
+    pa.float64(),
+    [pa.float64()],
     "stable",
 )
 
@@ -71,4 +66,4 @@ def evaluate(self) -> pyarrow.Scalar:
 
 result = df.collect()[0]
 
-assert result.column(0) == pyarrow.array([6.0])
+assert result.column(0) == pa.array([6.0])
diff --git a/examples/python-udf-comparisons.py b/examples/python-udf-comparisons.py
new file mode 100644
index 000000000..b870645a3
--- /dev/null
+++ b/examples/python-udf-comparisons.py
@@ -0,0 +1,185 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import time
+from pathlib import Path
+
+import pyarrow as pa
+import pyarrow.compute as pc
+from datafusion import SessionContext, col, lit, udf
+from datafusion import functions as F
+
+path = Path(__file__).parent.resolve()
+filepath = path / "./tpch/data/lineitem.parquet"
+
+# This example serves to demonstrate alternate approaches to answering the
+# question "return all of the rows that have a specific combination of these
+# values". We have the combinations we care about provided as a python
+# list of tuples. There is no built in function that supports this operation,
+# but it can be explicitly specified via a single expression or we can
+# use a user defined function.
+
+ctx = SessionContext()
+
+# These part keys and suppliers are chosen because there are
+# cases where two suppliers each have two of the part keys
+# but we are interested in these specific combinations.
+
+values_of_interest = [
+    (1530, 4031, "N"),
+    (6530, 1531, "N"),
+    (5618, 619, "N"),
+    (8118, 8119, "N"),
+]
+
+partkeys = [lit(r[0]) for r in values_of_interest]
+suppkeys = [lit(r[1]) for r in values_of_interest]
+returnflags = [lit(r[2]) for r in values_of_interest]
+
+df_lineitem = ctx.read_parquet(filepath).select(
+    "l_partkey", "l_suppkey", "l_returnflag"
+)
+
+start_time = time.time()
+
+df_simple_filter = df_lineitem.filter(
+    F.in_list(col("l_partkey"), partkeys),
+    F.in_list(col("l_suppkey"), suppkeys),
+    F.in_list(col("l_returnflag"), returnflags),
+)
+
+num_rows = df_simple_filter.count()
+print(
+    f"Simple filtering has number {num_rows} rows and took {time.time() - start_time} s"
+)
+print("This is the incorrect number of rows!")
+start_time = time.time()
+
+# Explicitly check for the combinations of interest.
+# This works but is not scalable.
+
+filter_expr = (
+    (
+        (col("l_partkey") == values_of_interest[0][0])
+        & (col("l_suppkey") == values_of_interest[0][1])
+        & (col("l_returnflag") == values_of_interest[0][2])
+    )
+    | (
+        (col("l_partkey") == values_of_interest[1][0])
+        & (col("l_suppkey") == values_of_interest[1][1])
+        & (col("l_returnflag") == values_of_interest[1][2])
+    )
+    | (
+        (col("l_partkey") == values_of_interest[2][0])
+        & (col("l_suppkey") == values_of_interest[2][1])
+        & (col("l_returnflag") == values_of_interest[2][2])
+    )
+    | (
+        (col("l_partkey") == values_of_interest[3][0])
+        & (col("l_suppkey") == values_of_interest[3][1])
+        & (col("l_returnflag") == values_of_interest[3][2])
+    )
+)
+
+df_explicit_filter = df_lineitem.filter(filter_expr)
+
+num_rows = df_explicit_filter.count()
+print(
+    f"Explicit filtering has number {num_rows} rows and took {time.time() - start_time} s"
+)
+start_time = time.time()
+
+# Instead try a python UDF
+
+
+def is_of_interest_impl(
+    partkey_arr: pa.Array,
+    suppkey_arr: pa.Array,
+    returnflag_arr: pa.Array,
+) -> pa.Array:
+    result = []
+    for idx, partkey_val in enumerate(partkey_arr):
+        partkey = partkey_val.as_py()
+        suppkey = suppkey_arr[idx].as_py()
+        returnflag = returnflag_arr[idx].as_py()
+        value = (partkey, suppkey, returnflag)
+        result.append(value in values_of_interest)
+
+    return pa.array(result)
+
+
+is_of_interest = udf(
+    is_of_interest_impl,
+    [pa.int64(), pa.int64(), pa.utf8()],
+    pa.bool_(),
+    "stable",
+)
+
+df_udf_filter = df_lineitem.filter(
+    is_of_interest(col("l_partkey"), col("l_suppkey"), col("l_returnflag"))
+)
+
+num_rows = df_udf_filter.count()
+print(f"UDF filtering has number {num_rows} rows and took {time.time() - start_time} s")
+start_time = time.time()
+
+# Now use a user defined function but lean on the built in pyarrow array
+# functions so we never convert rows to python objects.
+
+# To see other pyarrow compute functions see
+# https://arrow.apache.org/docs/python/api/compute.html
+#
+# It is important that the number of rows in the returned array
+# matches the original array, so we cannot use functions like
+# filtered_partkey_arr.filter(filtered_suppkey_arr).
+
+
+def udf_using_pyarrow_compute_impl(
+    partkey_arr: pa.Array,
+    suppkey_arr: pa.Array,
+    returnflag_arr: pa.Array,
+) -> pa.Array:
+    results = None
+    for partkey, suppkey, returnflag in values_of_interest:
+        filtered_partkey_arr = pc.equal(partkey_arr, partkey)
+        filtered_suppkey_arr = pc.equal(suppkey_arr, suppkey)
+        filtered_returnflag_arr = pc.equal(returnflag_arr, returnflag)
+
+        resultant_arr = pc.and_(filtered_partkey_arr, filtered_suppkey_arr)
+        resultant_arr = pc.and_(resultant_arr, filtered_returnflag_arr)
+
+        results = resultant_arr if results is None else pc.or_(results, resultant_arr)
+
+    return results
+
+
+udf_using_pyarrow_compute = udf(
+    udf_using_pyarrow_compute_impl,
+    [pa.int64(), pa.int64(), pa.utf8()],
+    pa.bool_(),
+    "stable",
+)
+
+df_udf_pyarrow_compute = df_lineitem.filter(
+    udf_using_pyarrow_compute(col("l_partkey"), col("l_suppkey"), col("l_returnflag"))
+)
+
+num_rows = df_udf_pyarrow_compute.count()
+print(
+    f"UDF filtering using pyarrow compute has number {num_rows} rows and took {time.time() - start_time} s"
+)
+start_time = time.time()
diff --git a/examples/python-udf.py b/examples/python-udf.py
index 30edd4198..1c08acd1a 100644
--- a/examples/python-udf.py
+++ b/examples/python-udf.py
@@ -15,22 +15,23 @@
 # specific language governing permissions and limitations
 # under the License.
 
-import pyarrow
-from datafusion import udf, SessionContext, functions as f
+import pyarrow as pa
+from datafusion import SessionContext, udf
+from datafusion import functions as f
 
 
-def is_null(array: pyarrow.Array) -> pyarrow.Array:
+def is_null(array: pa.Array) -> pa.Array:
     return array.is_null()
 
 
-is_null_arr = udf(is_null, [pyarrow.int64()], pyarrow.bool_(), "stable")
+is_null_arr = udf(is_null, [pa.int64()], pa.bool_(), "stable")
 
 # create a context
 ctx = SessionContext()
 
 # create a RecordBatch and a new DataFrame from it
-batch = pyarrow.RecordBatch.from_arrays(
-    [pyarrow.array([1, 2, 3]), pyarrow.array([4, 5, 6])],
+batch = pa.RecordBatch.from_arrays(
+    [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
     names=["a", "b"],
 )
 df = ctx.create_dataframe([[batch]])
@@ -39,4 +40,4 @@ def is_null(array: pyarrow.Array) -> pyarrow.Array:
 
 result = df.collect()[0]
 
-assert result.column(0) == pyarrow.array([False] * 3)
+assert result.column(0) == pa.array([False] * 3)
diff --git a/examples/python-udwf.py b/examples/python-udwf.py
new file mode 100644
index 000000000..645ded188
--- /dev/null
+++ b/examples/python-udwf.py
@@ -0,0 +1,274 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from __future__ import annotations
+
+import datafusion
+import pyarrow as pa
+from datafusion import col, lit, udwf
+from datafusion import functions as f
+from datafusion.expr import WindowFrame
+from datafusion.user_defined import WindowEvaluator
+
+# This example creates five different examples of user defined window functions in order
+# to demonstrate the variety of ways a user may need to implement.
+
+
+class ExponentialSmoothDefault(WindowEvaluator):
+    """Create a running smooth operation across an entire partition at once."""
+
+    def __init__(self, alpha: float) -> None:
+        self.alpha = alpha
+
+    def evaluate_all(self, values: list[pa.Array], num_rows: int) -> pa.Array:
+        results = []
+        curr_value = 0.0
+        values = values[0]
+        for idx in range(num_rows):
+            if idx == 0:
+                curr_value = values[idx].as_py()
+            else:
+                curr_value = values[idx].as_py() * self.alpha + curr_value * (
+                    1.0 - self.alpha
+                )
+            results.append(curr_value)
+
+        return pa.array(results)
+
+
+class SmoothBoundedFromPreviousRow(WindowEvaluator):
+    """Smooth over from the previous to current row only."""
+
+    def __init__(self, alpha: float) -> None:
+        self.alpha = alpha
+
+    def supports_bounded_execution(self) -> bool:
+        return True
+
+    def get_range(self, idx: int, num_rows: int) -> tuple[int, int]:  # noqa: ARG002
+        # Override the default range of current row since uses_window_frame is False
+        # So for the purpose of this test we just smooth from the previous row to
+        # current.
+        if idx == 0:
+            return (0, 0)
+        return (idx - 1, idx)
+
+    def evaluate(
+        self, values: list[pa.Array], eval_range: tuple[int, int]
+    ) -> pa.Scalar:
+        (start, stop) = eval_range
+        curr_value = 0.0
+        values = values[0]
+        for idx in range(start, stop + 1):
+            if idx == start:
+                curr_value = values[idx].as_py()
+            else:
+                curr_value = values[idx].as_py() * self.alpha + curr_value * (
+                    1.0 - self.alpha
+                )
+        return pa.scalar(curr_value).cast(pa.float64())
+
+
+class SmoothAcrossRank(WindowEvaluator):
+    """Smooth over the rank from the previous rank to current."""
+
+    def __init__(self, alpha: float) -> None:
+        self.alpha = alpha
+
+    def include_rank(self) -> bool:
+        return True
+
+    def evaluate_all_with_rank(
+        self, num_rows: int, ranks_in_partition: list[tuple[int, int]]
+    ) -> pa.Array:
+        results = []
+        for idx in range(num_rows):
+            if idx == 0:
+                prior_value = 1.0
+            matching_row = [
+                i
+                for i in range(len(ranks_in_partition))
+                if ranks_in_partition[i][0] <= idx and ranks_in_partition[i][1] > idx
+            ][0] + 1
+            curr_value = matching_row * self.alpha + prior_value * (1.0 - self.alpha)
+            results.append(curr_value)
+            prior_value = matching_row
+
+        return pa.array(results)
+
+
+class ExponentialSmoothFrame(WindowEvaluator):
+    "Find the value across an entire frame using exponential smoothing"
+
+    def __init__(self, alpha: float) -> None:
+        self.alpha = alpha
+
+    def uses_window_frame(self) -> bool:
+        return True
+
+    def evaluate(
+        self, values: list[pa.Array], eval_range: tuple[int, int]
+    ) -> pa.Scalar:
+        (start, stop) = eval_range
+        curr_value = 0.0
+        if len(values) > 1:
+            order_by = values[1]  # noqa: F841
+            values = values[0]
+        else:
+            values = values[0]
+        for idx in range(start, stop):
+            if idx == start:
+                curr_value = values[idx].as_py()
+            else:
+                curr_value = values[idx].as_py() * self.alpha + curr_value * (
+                    1.0 - self.alpha
+                )
+        return pa.scalar(curr_value).cast(pa.float64())
+
+
+class SmoothTwoColumn(WindowEvaluator):
+    """Smooth once column based on a condition of another column.
+
+    If the second column is above a threshold, then smooth over the first column from
+    the previous and next rows.
+    """
+
+    def __init__(self, alpha: float) -> None:
+        self.alpha = alpha
+
+    def evaluate_all(self, values: list[pa.Array], num_rows: int) -> pa.Array:
+        results = []
+        values_a = values[0]
+        values_b = values[1]
+        for idx in range(num_rows):
+            if not values_b[idx].is_valid:
+                if idx == 0:
+                    results.append(values_a[1].cast(pa.float64()))
+                elif idx == num_rows - 1:
+                    results.append(values_a[num_rows - 2].cast(pa.float64()))
+                else:
+                    results.append(
+                        pa.scalar(
+                            values_a[idx - 1].as_py() * self.alpha
+                            + values_a[idx + 1].as_py() * (1.0 - self.alpha)
+                        )
+                    )
+            else:
+                results.append(values_a[idx].cast(pa.float64()))
+
+        return pa.array(results)
+
+
+# create a context
+ctx = datafusion.SessionContext()
+
+# create a RecordBatch and a new DataFrame from it
+batch = pa.RecordBatch.from_arrays(
+    [
+        pa.array([1.0, 2.1, 2.9, 4.0, 5.1, 6.0, 6.9, 8.0]),
+        pa.array([1, 2, None, 4, 5, 6, None, 8]),
+        pa.array(["A", "A", "A", "A", "A", "B", "B", "B"]),
+    ],
+    names=["a", "b", "c"],
+)
+df = ctx.create_dataframe([[batch]])
+
+exp_smooth = udwf(
+    lambda: ExponentialSmoothDefault(0.9),
+    pa.float64(),
+    pa.float64(),
+    volatility="immutable",
+)
+
+smooth_two_row = udwf(
+    lambda: SmoothBoundedFromPreviousRow(0.9),
+    pa.float64(),
+    pa.float64(),
+    volatility="immutable",
+)
+
+smooth_rank = udwf(
+    lambda: SmoothAcrossRank(0.9),
+    pa.float64(),
+    pa.float64(),
+    volatility="immutable",
+)
+
+smooth_frame = udwf(
+    lambda: ExponentialSmoothFrame(0.9),
+    pa.float64(),
+    pa.float64(),
+    volatility="immutable",
+    name="smooth_frame",
+)
+
+smooth_two_col = udwf(
+    lambda: SmoothTwoColumn(0.9),
+    [pa.float64(), pa.int64()],
+    pa.float64(),
+    volatility="immutable",
+)
+
+# These are done with separate statements instead of one large `select` because that will
+# attempt to combine the window operations and our defined UDFs do not all support that.
+(
+    df.with_column("exp_smooth", exp_smooth(col("a")))
+    .with_column("smooth_prior_row", smooth_two_row(col("a")))
+    .with_column("smooth_rank", smooth_rank(col("a")).order_by(col("c")).build())
+    .with_column("smooth_two_col", smooth_two_col(col("a"), col("b")))
+    .with_column(
+        "smooth_frame",
+        smooth_frame(col("a")).window_frame(WindowFrame("rows", None, 0)).build(),
+    )
+    .select(
+        "a",
+        "b",
+        "c",
+        "exp_smooth",
+        "smooth_prior_row",
+        "smooth_rank",
+        "smooth_two_col",
+        "smooth_frame",
+    )
+).show()
+
+assert df.select(f.round(exp_smooth(col("a")), lit(3))).collect()[0].column(
+    0
+) == pa.array([1, 1.99, 2.809, 3.881, 4.978, 5.898, 6.8, 7.88])
+
+
+assert df.select(f.round(smooth_two_row(col("a")), lit(3))).collect()[0].column(
+    0
+) == pa.array([1.0, 1.99, 2.82, 3.89, 4.99, 5.91, 6.81, 7.89])
+
+
+assert df.select(smooth_rank(col("a")).order_by(col("c")).build()).collect()[0].column(
+    0
+) == pa.array([1, 1, 1, 1, 1, 1.9, 2.0, 2.0])
+
+
+assert df.select(smooth_two_col(col("a"), col("b"))).collect()[0].column(0) == pa.array(
+    [1, 2.1, 2.29, 4, 5.1, 6, 6.2, 8.0]
+)
+
+
+assert df.select(
+    f.round(
+        smooth_frame(col("a")).window_frame(WindowFrame("rows", None, 0)).build(),
+        lit(3),
+    )
+).collect()[0].column(0) == pa.array([1, 1.99, 2.809, 3.881, 4.978, 5.898, 6.8, 7.88])
diff --git a/examples/query-pyarrow-data.py b/examples/query-pyarrow-data.py
index 83e6884a7..9cfe8a62b 100644
--- a/examples/query-pyarrow-data.py
+++ b/examples/query-pyarrow-data.py
@@ -16,16 +16,15 @@
 # under the License.
 
 import datafusion
+import pyarrow as pa
 from datafusion import col
-import pyarrow
-
 
 # create a context
 ctx = datafusion.SessionContext()
 
 # create a RecordBatch and a new DataFrame from it
-batch = pyarrow.RecordBatch.from_arrays(
-    [pyarrow.array([1, 2, 3]), pyarrow.array([4, 5, 6])],
+batch = pa.RecordBatch.from_arrays(
+    [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
     names=["a", "b"],
 )
 df = ctx.create_dataframe([[batch]])
@@ -39,5 +38,5 @@
 # execute and collect the first (and only) batch
 result = df.collect()[0]
 
-assert result.column(0) == pyarrow.array([5, 7, 9])
-assert result.column(1) == pyarrow.array([-3, -3, -3])
+assert result.column(0) == pa.array([5, 7, 9])
+assert result.column(1) == pa.array([-3, -3, -3])
diff --git a/examples/sql-on-cudf.py b/examples/sql-on-cudf.py
deleted file mode 100644
index 999756fc8..000000000
--- a/examples/sql-on-cudf.py
+++ /dev/null
@@ -1,24 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-from datafusion.cudf import SessionContext
-
-
-ctx = SessionContext()
-ctx.register_parquet("taxi", "yellow_tripdata_2021-01.parquet")
-df = ctx.sql("select passenger_count from taxi")
-print(df)
diff --git a/examples/sql-on-pandas.py b/examples/sql-on-pandas.py
deleted file mode 100644
index 0efd77631..000000000
--- a/examples/sql-on-pandas.py
+++ /dev/null
@@ -1,24 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-from datafusion.pandas import SessionContext
-
-
-ctx = SessionContext()
-ctx.register_parquet("taxi", "yellow_tripdata_2021-01.parquet")
-df = ctx.sql("select passenger_count from taxi")
-print(df)
diff --git a/examples/sql-on-polars.py b/examples/sql-parquet-s3.py
similarity index 60%
rename from examples/sql-on-polars.py
rename to examples/sql-parquet-s3.py
index c208114c1..866e2ac68 100644
--- a/examples/sql-on-polars.py
+++ b/examples/sql-parquet-s3.py
@@ -15,12 +15,26 @@
 # specific language governing permissions and limitations
 # under the License.
 
-from datafusion.polars import SessionContext
+import os
 
+import datafusion
+from datafusion.object_store import AmazonS3
 
-ctx = SessionContext()
-ctx.register_parquet("taxi", "yellow_tripdata_2021-01.parquet")
-df = ctx.sql(
-    "select passenger_count, count(*) from taxi group by passenger_count"
+region = "us-east-1"
+bucket_name = "yellow-trips"
+
+s3 = AmazonS3(
+    bucket_name=bucket_name,
+    region=region,
+    access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),
+    secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),
 )
-print(df)
+
+ctx = datafusion.SessionContext()
+path = f"s3://{bucket_name}/"
+ctx.register_object_store("s3://", s3, None)
+
+ctx.register_parquet("trips", path)
+
+df = ctx.sql("select count(passenger_count) from trips")
+df.show()
diff --git a/examples/sql-to-pandas.py b/examples/sql-to-pandas.py
index 3e99b22de..34f7bde1b 100644
--- a/examples/sql-to-pandas.py
+++ b/examples/sql-to-pandas.py
@@ -17,7 +17,6 @@
 
 from datafusion import SessionContext
 
-
 # Create a DataFusion context
 ctx = SessionContext()
 
diff --git a/examples/sql-using-python-udaf.py b/examples/sql-using-python-udaf.py
index 3326c4a1c..f42bbdc23 100644
--- a/examples/sql-using-python-udaf.py
+++ b/examples/sql-using-python-udaf.py
@@ -15,8 +15,8 @@
 # specific language governing permissions and limitations
 # under the License.
 
-from datafusion import udaf, SessionContext, Accumulator
 import pyarrow as pa
+from datafusion import Accumulator, SessionContext, udaf
 
 
 # Define a user-defined aggregation function (UDAF)
@@ -25,23 +25,19 @@ class MyAccumulator(Accumulator):
     Interface of a user-defined accumulation.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._sum = pa.scalar(0.0)
 
-    def update(self, values: pa.Array) -> None:
+    def update(self, values: list[pa.Array]) -> None:
         # not nice since pyarrow scalars can't be summed yet. This breaks on `None`
-        self._sum = pa.scalar(
-            self._sum.as_py() + pa.compute.sum(values).as_py()
-        )
+        self._sum = pa.scalar(self._sum.as_py() + pa.compute.sum(values).as_py())
 
     def merge(self, states: pa.Array) -> None:
         # not nice since pyarrow scalars can't be summed yet. This breaks on `None`
-        self._sum = pa.scalar(
-            self._sum.as_py() + pa.compute.sum(states).as_py()
-        )
+        self._sum = pa.scalar(self._sum.as_py() + pa.compute.sum(states[0]).as_py())
 
-    def state(self) -> pa.Array:
-        return pa.array([self._sum.as_py()])
+    def state(self) -> list[pa.Array]:
+        return [self._sum]
 
     def evaluate(self) -> pa.Scalar:
         return self._sum
diff --git a/examples/sql-using-python-udf.py b/examples/sql-using-python-udf.py
index d6bbe3ab0..2f0a0b67d 100644
--- a/examples/sql-using-python-udf.py
+++ b/examples/sql-using-python-udf.py
@@ -15,8 +15,8 @@
 # specific language governing permissions and limitations
 # under the License.
 
-from datafusion import udf, SessionContext
 import pyarrow as pa
+from datafusion import SessionContext, udf
 
 
 # Define a user-defined function (UDF)
diff --git a/examples/substrait.py b/examples/substrait.py
index c167f7d90..fa6f77912 100644
--- a/examples/substrait.py
+++ b/examples/substrait.py
@@ -18,36 +18,32 @@
 from datafusion import SessionContext
 from datafusion import substrait as ss
 
-
 # Create a DataFusion context
 ctx = SessionContext()
 
 # Register table with context
-ctx.register_parquet(
-    "aggregate_test_data", "./testing/data/csv/aggregate_test_100.csv"
-)
+ctx.register_csv("aggregate_test_data", "./testing/data/csv/aggregate_test_100.csv")
 
-substrait_plan = ss.substrait.serde.serialize_to_plan(
-    "SELECT * FROM aggregate_test_data", ctx
-)
+substrait_plan = ss.Serde.serialize_to_plan("SELECT * FROM aggregate_test_data", ctx)
 # type(substrait_plan) -> <class 'datafusion.substrait.plan'>
 
+# Encode it to bytes
+substrait_bytes = substrait_plan.encode()
+# type(substrait_bytes) -> <class 'bytes'>, at this point the bytes can be distributed to file, network, etc safely
+# where they could subsequently be deserialized on the receiving end.
+
 # Alternative serialization approaches
-# type(substrait_bytes) -> <class 'list'>, at this point the bytes can be distributed to file, network, etc safely
+# type(substrait_bytes) -> <class 'bytes'>, at this point the bytes can be distributed to file, network, etc safely
 # where they could subsequently be deserialized on the receiving end.
-substrait_bytes = ss.substrait.serde.serialize_bytes(
-    "SELECT * FROM aggregate_test_data", ctx
-)
+substrait_bytes = ss.Serde.serialize_bytes("SELECT * FROM aggregate_test_data", ctx)
 
 # Imagine here bytes would be read from network, file, etc ... for example brevity this is omitted and variable is simply reused
 # type(substrait_plan) -> <class 'datafusion.substrait.plan'>
-substrait_plan = ss.substrait.serde.deserialize_bytes(substrait_bytes)
+substrait_plan = ss.Serde.deserialize_bytes(substrait_bytes)
 
 # type(df_logical_plan) -> <class 'substrait.LogicalPlan'>
-df_logical_plan = ss.substrait.consumer.from_substrait_plan(
-    ctx, substrait_plan
-)
+df_logical_plan = ss.Consumer.from_substrait_plan(ctx, substrait_plan)
 
 # Back to Substrait Plan just for demonstration purposes
 # type(substrait_plan) -> <class 'datafusion.substrait.plan'>
-substrait_plan = ss.substrait.producer.to_substrait_plan(df_logical_plan)
+substrait_plan = ss.Producer.to_substrait_plan(df_logical_plan, ctx)
diff --git a/examples/tpch/.gitignore b/examples/tpch/.gitignore
new file mode 100644
index 000000000..9e67bd47d
--- /dev/null
+++ b/examples/tpch/.gitignore
@@ -0,0 +1,2 @@
+data
+
diff --git a/examples/tpch/README.md b/examples/tpch/README.md
new file mode 100644
index 000000000..7c52c8230
--- /dev/null
+++ b/examples/tpch/README.md
@@ -0,0 +1,57 @@
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+
+# DataFusion Python Examples for TPC-H
+
+These examples reproduce the problems listed in the Transaction Process Council
+TPC-H benchmark. The purpose of these examples is to demonstrate how to use
+different aspects of Data Fusion and not necessarily geared towards creating the
+most performant queries possible. Within each example is a description of the
+problem. For users who are familiar with SQL style commands, you can compare the
+approaches in these examples with those listed in the specification.
+
+- https://www.tpc.org/tpch/
+
+The examples provided are based on version 2.18.0 of the TPC-H specification.
+
+## Data Setup
+
+To run these examples, you must first generate a dataset. The `dbgen` tool
+provided by TPC can create datasets of arbitrary scale. For testing it is
+typically sufficient to create a 1 gigabyte dataset. For convenience, this
+repository has a script which uses docker to create this dataset. From the
+`benchmarks/tpch` directory execute the following script.
+
+```bash
+./tpch-gen.sh 1
+```
+
+The examples provided use parquet files for the tables generated by `dbgen`.
+A python script is provided to convert the text files from `dbgen` into parquet
+files expected by the examples. From the `examples/tpch` directory you can
+execute the following command to create the necessary parquet files.
+
+```bash
+python convert_data_to_parquet.py
+```
+
+## Description of Examples
+
+For easier access, a description of the techniques demonstrated in each file
+is in the README.md file in the `examples` directory.
diff --git a/examples/tpch/_tests.py b/examples/tpch/_tests.py
new file mode 100644
index 000000000..780fcf5e5
--- /dev/null
+++ b/examples/tpch/_tests.py
@@ -0,0 +1,128 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from importlib import import_module
+
+import pyarrow as pa
+import pytest
+from datafusion import DataFrame, col, lit
+from datafusion import functions as F
+from util import get_answer_file
+
+
+def df_selection(col_name, col_type):
+    if col_type == pa.float64():
+        return F.round(col(col_name), lit(2)).alias(col_name)
+    if isinstance(col_type, pa.Decimal128Type):
+        return F.round(col(col_name).cast(pa.float64()), lit(2)).alias(col_name)
+    if col_type == pa.string() or col_type == pa.string_view():
+        return F.trim(col(col_name)).alias(col_name)
+    return col(col_name)
+
+
+def load_schema(col_name, col_type):
+    if col_type == pa.int64() or col_type == pa.int32():
+        return col_name, pa.string()
+    if isinstance(col_type, pa.Decimal128Type):
+        return col_name, pa.float64()
+    return col_name, col_type
+
+
+def expected_selection(col_name, col_type):
+    if col_type == pa.int64() or col_type == pa.int32():
+        return F.trim(col(col_name)).cast(col_type).alias(col_name)
+    if col_type == pa.string() or col_type == pa.string_view():
+        return F.trim(col(col_name)).alias(col_name)
+    return col(col_name)
+
+
+def selections_and_schema(original_schema):
+    columns = [(c, original_schema.field(c).type) for c in original_schema.names]
+
+    df_selections = [df_selection(c, t) for (c, t) in columns]
+    expected_schema = [load_schema(c, t) for (c, t) in columns]
+    expected_selections = [expected_selection(c, t) for (c, t) in columns]
+
+    return (df_selections, expected_schema, expected_selections)
+
+
+def check_q17(df):
+    raw_value = float(df.collect()[0]["avg_yearly"][0].as_py())
+    value = round(raw_value, 2)
+    assert abs(value - 348406.05) < 0.001
+
+
+@pytest.mark.parametrize(
+    ("query_code", "answer_file"),
+    [
+        ("q01_pricing_summary_report", "q1"),
+        ("q02_minimum_cost_supplier", "q2"),
+        ("q03_shipping_priority", "q3"),
+        ("q04_order_priority_checking", "q4"),
+        ("q05_local_supplier_volume", "q5"),
+        ("q06_forecasting_revenue_change", "q6"),
+        ("q07_volume_shipping", "q7"),
+        ("q08_market_share", "q8"),
+        ("q09_product_type_profit_measure", "q9"),
+        ("q10_returned_item_reporting", "q10"),
+        ("q11_important_stock_identification", "q11"),
+        ("q12_ship_mode_order_priority", "q12"),
+        ("q13_customer_distribution", "q13"),
+        ("q14_promotion_effect", "q14"),
+        ("q15_top_supplier", "q15"),
+        ("q16_part_supplier_relationship", "q16"),
+        ("q17_small_quantity_order", "q17"),
+        ("q18_large_volume_customer", "q18"),
+        ("q19_discounted_revenue", "q19"),
+        ("q20_potential_part_promotion", "q20"),
+        ("q21_suppliers_kept_orders_waiting", "q21"),
+        ("q22_global_sales_opportunity", "q22"),
+    ],
+)
+def test_tpch_query_vs_answer_file(query_code: str, answer_file: str) -> None:
+    module = import_module(query_code)
+    df: DataFrame = module.df
+
+    # Treat q17 as a special case. The answer file does not match the spec.
+    # Running at scale factor 1, we have manually verified this result does
+    # match the expected value.
+    if answer_file == "q17":
+        return check_q17(df)
+
+    (df_selections, expected_schema, expected_selections) = selections_and_schema(
+        df.schema()
+    )
+
+    df = df.select(*df_selections)
+
+    read_schema = pa.schema(expected_schema)
+
+    df_expected = module.ctx.read_csv(
+        get_answer_file(answer_file),
+        schema=read_schema,
+        delimiter="|",
+        file_extension=".out",
+    )
+
+    df_expected = df_expected.select(*expected_selections)
+
+    cols = list(read_schema.names)
+
+    assert df.join(df_expected, on=cols, how="anti").count() == 0
+    assert df.count() == df_expected.count()
+
+    return None
diff --git a/examples/tpch/convert_data_to_parquet.py b/examples/tpch/convert_data_to_parquet.py
new file mode 100644
index 000000000..af554c39e
--- /dev/null
+++ b/examples/tpch/convert_data_to_parquet.py
@@ -0,0 +1,142 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+This is a utility function that will consumer the data generated by dbgen from TPC-H and convert
+it into a parquet file with the column names as expected by the TPC-H specification. It assumes
+the data generated resides in a path ../../benchmarks/tpch/data relative to the current file,
+as will be generated by the script provided in this repository.
+"""
+
+from pathlib import Path
+
+import datafusion
+import pyarrow as pa
+
+ctx = datafusion.SessionContext()
+
+all_schemas = {}
+
+all_schemas["customer"] = [
+    ("C_CUSTKEY", pa.int64()),
+    ("C_NAME", pa.string()),
+    ("C_ADDRESS", pa.string()),
+    ("C_NATIONKEY", pa.int64()),
+    ("C_PHONE", pa.string()),
+    ("C_ACCTBAL", pa.decimal128(15, 2)),
+    ("C_MKTSEGMENT", pa.string()),
+    ("C_COMMENT", pa.string()),
+]
+
+all_schemas["lineitem"] = [
+    ("L_ORDERKEY", pa.int64()),
+    ("L_PARTKEY", pa.int64()),
+    ("L_SUPPKEY", pa.int64()),
+    ("L_LINENUMBER", pa.int32()),
+    ("L_QUANTITY", pa.decimal128(15, 2)),
+    ("L_EXTENDEDPRICE", pa.decimal128(15, 2)),
+    ("L_DISCOUNT", pa.decimal128(15, 2)),
+    ("L_TAX", pa.decimal128(15, 2)),
+    ("L_RETURNFLAG", pa.string()),
+    ("L_LINESTATUS", pa.string()),
+    ("L_SHIPDATE", pa.date32()),
+    ("L_COMMITDATE", pa.date32()),
+    ("L_RECEIPTDATE", pa.date32()),
+    ("L_SHIPINSTRUCT", pa.string()),
+    ("L_SHIPMODE", pa.string()),
+    ("L_COMMENT", pa.string()),
+]
+
+all_schemas["nation"] = [
+    ("N_NATIONKEY", pa.int64()),
+    ("N_NAME", pa.string()),
+    ("N_REGIONKEY", pa.int64()),
+    ("N_COMMENT", pa.string()),
+]
+
+all_schemas["orders"] = [
+    ("O_ORDERKEY", pa.int64()),
+    ("O_CUSTKEY", pa.int64()),
+    ("O_ORDERSTATUS", pa.string()),
+    ("O_TOTALPRICE", pa.decimal128(15, 2)),
+    ("O_ORDERDATE", pa.date32()),
+    ("O_ORDERPRIORITY", pa.string()),
+    ("O_CLERK", pa.string()),
+    ("O_SHIPPRIORITY", pa.int32()),
+    ("O_COMMENT", pa.string()),
+]
+
+all_schemas["part"] = [
+    ("P_PARTKEY", pa.int64()),
+    ("P_NAME", pa.string()),
+    ("P_MFGR", pa.string()),
+    ("P_BRAND", pa.string()),
+    ("P_TYPE", pa.string()),
+    ("P_SIZE", pa.int32()),
+    ("P_CONTAINER", pa.string()),
+    ("P_RETAILPRICE", pa.decimal128(15, 2)),
+    ("P_COMMENT", pa.string()),
+]
+
+all_schemas["partsupp"] = [
+    ("PS_PARTKEY", pa.int64()),
+    ("PS_SUPPKEY", pa.int64()),
+    ("PS_AVAILQTY", pa.int32()),
+    ("PS_SUPPLYCOST", pa.decimal128(15, 2)),
+    ("PS_COMMENT", pa.string()),
+]
+
+all_schemas["region"] = [
+    ("r_REGIONKEY", pa.int64()),
+    ("r_NAME", pa.string()),
+    ("r_COMMENT", pa.string()),
+]
+
+all_schemas["supplier"] = [
+    ("S_SUPPKEY", pa.int64()),
+    ("S_NAME", pa.string()),
+    ("S_ADDRESS", pa.string()),
+    ("S_NATIONKEY", pa.int32()),
+    ("S_PHONE", pa.string()),
+    ("S_ACCTBAL", pa.decimal128(15, 2)),
+    ("S_COMMENT", pa.string()),
+]
+
+curr_dir = Path(__file__).resolve().parent
+for filename, curr_schema_val in all_schemas.items():
+    # For convenience, go ahead and convert the schema column names to lowercase
+    curr_schema = [(s[0].lower(), s[1]) for s in curr_schema_val]
+
+    # Pre-collect the output columns so we can ignore the null field we add
+    # in to handle the trailing | in the file
+    output_cols = [r[0] for r in curr_schema]
+
+    curr_schema = [pa.field(r[0], r[1], nullable=False) for r in curr_schema]
+
+    # Trailing | requires extra field for in processing
+    curr_schema.append(("some_null", pa.null()))
+
+    schema = pa.schema(curr_schema)
+
+    source_file = (curr_dir / f"../../benchmarks/tpch/data/{filename}.csv").resolve()
+    dest_file = (curr_dir / f"./data/{filename}.parquet").resolve()
+
+    df = ctx.read_csv(source_file, schema=schema, has_header=False, delimiter="|")
+
+    df = df.select(*output_cols)
+
+    df.write_parquet(dest_file, compression="snappy")
diff --git a/examples/tpch/q01_pricing_summary_report.py b/examples/tpch/q01_pricing_summary_report.py
new file mode 100644
index 000000000..3f97f00dc
--- /dev/null
+++ b/examples/tpch/q01_pricing_summary_report.py
@@ -0,0 +1,90 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+TPC-H Problem Statement Query 1:
+
+The Pricing Summary Report Query provides a summary pricing report for all lineitems shipped as of
+a given date. The date is within 60 - 120 days of the greatest ship date contained in the database.
+The query lists totals for extended price, discounted extended price, discounted extended price
+plus tax, average quantity, average extended price, and average discount. These aggregates are
+grouped by RETURNFLAG and LINESTATUS, and listed in ascending order of RETURNFLAG and LINESTATUS.
+A count of the number of lineitems in each group is included.
+
+The above problem statement text is copyrighted by the Transaction Processing Performance Council
+as part of their TPC Benchmark H Specification revision 2.18.0.
+"""
+
+import pyarrow as pa
+from datafusion import SessionContext, col, lit
+from datafusion import functions as F
+from util import get_data_path
+
+ctx = SessionContext()
+
+df = ctx.read_parquet(get_data_path("lineitem.parquet"))
+
+# It may be that the date can be hard coded, based on examples shown.
+# This approach will work with any date range in the provided data set.
+
+greatest_ship_date = df.aggregate(
+    [], [F.max(col("l_shipdate")).alias("shipdate")]
+).collect()[0]["shipdate"][0]
+
+# From the given problem, this is how close to the last date in the database we
+# want to report results for. It should be between 60-120 days before the end.
+DAYS_BEFORE_FINAL = 90
+
+interval = pa.scalar((0, DAYS_BEFORE_FINAL, 0), type=pa.month_day_nano_interval())
+
+print("Final date in database:", greatest_ship_date)
+
+# Filter data to the dates of interest
+df = df.filter(col("l_shipdate") <= lit(greatest_ship_date) - lit(interval))
+
+# Aggregate the results
+
+df = df.aggregate(
+    [col("l_returnflag"), col("l_linestatus")],
+    [
+        F.sum(col("l_quantity")).alias("sum_qty"),
+        F.sum(col("l_extendedprice")).alias("sum_base_price"),
+        F.sum(col("l_extendedprice") * (lit(1) - col("l_discount"))).alias(
+            "sum_disc_price"
+        ),
+        F.sum(
+            col("l_extendedprice")
+            * (lit(1) - col("l_discount"))
+            * (lit(1) + col("l_tax"))
+        ).alias("sum_charge"),
+        F.avg(col("l_quantity")).alias("avg_qty"),
+        F.avg(col("l_extendedprice")).alias("avg_price"),
+        F.avg(col("l_discount")).alias("avg_disc"),
+        F.count(col("l_returnflag")).alias(
+            "count_order"
+        ),  # Counting any column should return same result
+    ],
+)
+
+# Sort per the expected result
+
+df = df.sort(col("l_returnflag").sort(), col("l_linestatus").sort())
+
+# Note: There appears to be a discrepancy between what is returned here and what is in the generated
+# answers file for the case of return flag N and line status O, but I did not investigate further.
+
+df.show()
diff --git a/examples/tpch/q02_minimum_cost_supplier.py b/examples/tpch/q02_minimum_cost_supplier.py
new file mode 100644
index 000000000..7390d0892
--- /dev/null
+++ b/examples/tpch/q02_minimum_cost_supplier.py
@@ -0,0 +1,146 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+TPC-H Problem Statement Query 2:
+
+The Minimum Cost Supplier Query finds, in a given region, for each part of a certain type and size,
+the supplier who can supply it at minimum cost. If several suppliers in that region offer the
+desired part type and size at the same (minimum) cost, the query lists the parts from suppliers with
+the 100 highest account balances. For each supplier, the query lists the supplier's account balance,
+name and nation; the part's number and manufacturer; the supplier's address, phone number and
+comment information.
+
+The above problem statement text is copyrighted by the Transaction Processing Performance Council
+as part of their TPC Benchmark H Specification revision 2.18.0.
+"""
+
+import datafusion
+from datafusion import SessionContext, col, lit
+from datafusion import functions as F
+from util import get_data_path
+
+# This is the part we're looking for. Values selected here differ from the spec in order to run
+# unit tests on a small data set.
+SIZE_OF_INTEREST = 15
+TYPE_OF_INTEREST = "BRASS"
+REGION_OF_INTEREST = "EUROPE"
+
+# Load the dataframes we need
+
+ctx = SessionContext()
+
+df_part = ctx.read_parquet(get_data_path("part.parquet")).select(
+    "p_partkey", "p_mfgr", "p_type", "p_size"
+)
+df_supplier = ctx.read_parquet(get_data_path("supplier.parquet")).select(
+    "s_acctbal",
+    "s_name",
+    "s_address",
+    "s_phone",
+    "s_comment",
+    "s_nationkey",
+    "s_suppkey",
+)
+df_partsupp = ctx.read_parquet(get_data_path("partsupp.parquet")).select(
+    "ps_partkey", "ps_suppkey", "ps_supplycost"
+)
+df_nation = ctx.read_parquet(get_data_path("nation.parquet")).select(
+    "n_nationkey", "n_regionkey", "n_name"
+)
+df_region = ctx.read_parquet(get_data_path("region.parquet")).select(
+    "r_regionkey", "r_name"
+)
+
+# Filter down parts. Part names contain the type of interest, so we can use strpos to find where
+# in the p_type column the word is. `strpos` will return 0 if not found, otherwise the position
+# in the string where it is located.
+
+df_part = df_part.filter(
+    F.strpos(col("p_type"), lit(TYPE_OF_INTEREST)) > lit(0)
+).filter(col("p_size") == lit(SIZE_OF_INTEREST))
+
+# Filter regions down to the one of interest
+
+df_region = df_region.filter(col("r_name") == lit(REGION_OF_INTEREST))
+
+# Now that we have the region, find suppliers in that region. Suppliers are tied to their nation
+# and nations are tied to the region.
+
+df_nation = df_nation.join(
+    df_region, left_on=["n_regionkey"], right_on=["r_regionkey"], how="inner"
+)
+df_supplier = df_supplier.join(
+    df_nation, left_on=["s_nationkey"], right_on=["n_nationkey"], how="inner"
+)
+
+# Now that we know who the potential suppliers are for the part, we can limit out part
+# supplies table down. We can further join down to the specific parts we've identified
+# as matching the request
+
+df = df_partsupp.join(
+    df_supplier, left_on=["ps_suppkey"], right_on=["s_suppkey"], how="inner"
+)
+
+# Locate the minimum cost across all suppliers. There are multiple ways you could do this,
+# but one way is to create a window function across all suppliers, find the minimum, and
+# create a column of that value. We can then filter down any rows for which the cost and
+# minimum do not match.
+
+# The default window frame as of 5/6/2024 is from unbounded preceding to the current row.
+# We want to evaluate the entire data frame, so we specify this.
+window_frame = datafusion.WindowFrame("rows", None, None)
+df = df.with_column(
+    "min_cost",
+    F.window(
+        "min",
+        [col("ps_supplycost")],
+        partition_by=[col("ps_partkey")],
+        window_frame=window_frame,
+    ),
+)
+
+df = df.filter(col("min_cost") == col("ps_supplycost"))
+
+df = df.join(df_part, left_on=["ps_partkey"], right_on=["p_partkey"], how="inner")
+
+# From the problem statement, these are the values we wish to output
+
+df = df.select(
+    "s_acctbal",
+    "s_name",
+    "n_name",
+    "p_partkey",
+    "p_mfgr",
+    "s_address",
+    "s_phone",
+    "s_comment",
+)
+
+# Sort and display 100 entries
+df = df.sort(
+    col("s_acctbal").sort(ascending=False),
+    col("n_name").sort(),
+    col("s_name").sort(),
+    col("p_partkey").sort(),
+)
+
+df = df.limit(100)
+
+# Show results
+
+df.show()
diff --git a/examples/tpch/q03_shipping_priority.py b/examples/tpch/q03_shipping_priority.py
new file mode 100644
index 000000000..fc1231e0a
--- /dev/null
+++ b/examples/tpch/q03_shipping_priority.py
@@ -0,0 +1,88 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+TPC-H Problem Statement Query 3:
+
+The Shipping Priority Query retrieves the shipping priority and potential revenue, defined as the
+sum of l_extendedprice * (1-l_discount), of the orders having the largest revenue among those that
+had not been shipped as of a given date. Orders are listed in decreasing order of revenue. If more
+than 10 unshipped orders exist, only the 10 orders with the largest revenue are listed.
+
+The above problem statement text is copyrighted by the Transaction Processing Performance Council
+as part of their TPC Benchmark H Specification revision 2.18.0.
+"""
+
+from datafusion import SessionContext, col, lit
+from datafusion import functions as F
+from util import get_data_path
+
+SEGMENT_OF_INTEREST = "BUILDING"
+DATE_OF_INTEREST = "1995-03-15"
+
+# Load the dataframes we need
+
+ctx = SessionContext()
+
+df_customer = ctx.read_parquet(get_data_path("customer.parquet")).select(
+    "c_mktsegment", "c_custkey"
+)
+df_orders = ctx.read_parquet(get_data_path("orders.parquet")).select(
+    "o_orderdate", "o_shippriority", "o_custkey", "o_orderkey"
+)
+df_lineitem = ctx.read_parquet(get_data_path("lineitem.parquet")).select(
+    "l_orderkey", "l_extendedprice", "l_discount", "l_shipdate"
+)
+
+# Limit dataframes to the rows of interest
+
+df_customer = df_customer.filter(col("c_mktsegment") == lit(SEGMENT_OF_INTEREST))
+df_orders = df_orders.filter(col("o_orderdate") < lit(DATE_OF_INTEREST))
+df_lineitem = df_lineitem.filter(col("l_shipdate") > lit(DATE_OF_INTEREST))
+
+# Join all 3 dataframes
+
+df = df_customer.join(
+    df_orders, left_on=["c_custkey"], right_on=["o_custkey"], how="inner"
+).join(df_lineitem, left_on=["o_orderkey"], right_on=["l_orderkey"], how="inner")
+
+# Compute the revenue
+
+df = df.aggregate(
+    [col("l_orderkey")],
+    [
+        F.first_value(col("o_orderdate")).alias("o_orderdate"),
+        F.first_value(col("o_shippriority")).alias("o_shippriority"),
+        F.sum(col("l_extendedprice") * (lit(1.0) - col("l_discount"))).alias("revenue"),
+    ],
+)
+
+# Sort by priority
+
+df = df.sort(col("revenue").sort(ascending=False), col("o_orderdate").sort())
+
+# Only return 10 results
+
+df = df.limit(10)
+
+# Change the order that the columns are reported in just to match the spec
+
+df = df.select("l_orderkey", "revenue", "o_orderdate", "o_shippriority")
+
+# Show result
+
+df.show()
diff --git a/examples/tpch/q04_order_priority_checking.py b/examples/tpch/q04_order_priority_checking.py
new file mode 100644
index 000000000..426338aea
--- /dev/null
+++ b/examples/tpch/q04_order_priority_checking.py
@@ -0,0 +1,83 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+TPC-H Problem Statement Query 4:
+
+The Order Priority Checking Query counts the number of orders ordered in a given quarter of a given
+year in which at least one lineitem was received by the customer later than its committed date. The
+query lists the count of such orders for each order priority sorted in ascending priority order.
+
+The above problem statement text is copyrighted by the Transaction Processing Performance Council
+as part of their TPC Benchmark H Specification revision 2.18.0.
+"""
+
+from datetime import datetime
+
+import pyarrow as pa
+from datafusion import SessionContext, col, lit
+from datafusion import functions as F
+from util import get_data_path
+
+# Ideally we could put 3 months into the interval. See note below.
+INTERVAL_DAYS = 92
+DATE_OF_INTEREST = "1993-07-01"
+
+# Load the dataframes we need
+
+ctx = SessionContext()
+
+df_orders = ctx.read_parquet(get_data_path("orders.parquet")).select(
+    "o_orderdate", "o_orderpriority", "o_orderkey"
+)
+df_lineitem = ctx.read_parquet(get_data_path("lineitem.parquet")).select(
+    "l_orderkey", "l_commitdate", "l_receiptdate"
+)
+
+# Create a date object from the string
+date = datetime.strptime(DATE_OF_INTEREST, "%Y-%m-%d").date()
+
+interval = pa.scalar((0, INTERVAL_DAYS, 0), type=pa.month_day_nano_interval())
+
+# Limit results to cases where commitment date before receipt date
+# Aggregate the results so we only get one row to join with the order table.
+# Alternately, and likely more idiomatic is instead of `.aggregate` you could
+# do `.select("l_orderkey").distinct()`. The goal here is to show
+# multiple examples of how to use Data Fusion.
+df_lineitem = df_lineitem.filter(col("l_commitdate") < col("l_receiptdate")).aggregate(
+    [col("l_orderkey")], []
+)
+
+# Limit orders to date range of interest
+df_orders = df_orders.filter(col("o_orderdate") >= lit(date)).filter(
+    col("o_orderdate") < lit(date) + lit(interval)
+)
+
+# Perform the join to find only orders for which there are lineitems outside of expected range
+df = df_orders.join(
+    df_lineitem, left_on=["o_orderkey"], right_on=["l_orderkey"], how="inner"
+)
+
+# Based on priority, find the number of entries
+df = df.aggregate(
+    [col("o_orderpriority")], [F.count(col("o_orderpriority")).alias("order_count")]
+)
+
+# Sort the results
+df = df.sort(col("o_orderpriority").sort())
+
+df.show()
diff --git a/examples/tpch/q05_local_supplier_volume.py b/examples/tpch/q05_local_supplier_volume.py
new file mode 100644
index 000000000..fa2b01dea
--- /dev/null
+++ b/examples/tpch/q05_local_supplier_volume.py
@@ -0,0 +1,105 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+TPC-H Problem Statement Query 5:
+
+The Local Supplier Volume Query lists for each nation in a region the revenue volume that resulted
+from lineitem transactions in which the customer ordering parts and the supplier filling them were
+both within that nation. The query is run in order to determine whether to institute local
+distribution centers in a given region. The query considers only parts ordered in a given year. The
+query displays the nations and revenue volume in descending order by revenue. Revenue volume for all
+qualifying lineitems in a particular nation is defined as sum(l_extendedprice * (1 - l_discount)).
+
+The above problem statement text is copyrighted by the Transaction Processing Performance Council
+as part of their TPC Benchmark H Specification revision 2.18.0.
+"""
+
+from datetime import datetime
+
+import pyarrow as pa
+from datafusion import SessionContext, col, lit
+from datafusion import functions as F
+from util import get_data_path
+
+DATE_OF_INTEREST = "1994-01-01"
+INTERVAL_DAYS = 365
+REGION_OF_INTEREST = "ASIA"
+
+date = datetime.strptime(DATE_OF_INTEREST, "%Y-%m-%d").date()
+
+interval = pa.scalar((0, INTERVAL_DAYS, 0), type=pa.month_day_nano_interval())
+
+# Load the dataframes we need
+
+ctx = SessionContext()
+
+df_customer = ctx.read_parquet(get_data_path("customer.parquet")).select(
+    "c_custkey", "c_nationkey"
+)
+df_orders = ctx.read_parquet(get_data_path("orders.parquet")).select(
+    "o_custkey", "o_orderkey", "o_orderdate"
+)
+df_lineitem = ctx.read_parquet(get_data_path("lineitem.parquet")).select(
+    "l_orderkey", "l_suppkey", "l_extendedprice", "l_discount"
+)
+df_supplier = ctx.read_parquet(get_data_path("supplier.parquet")).select(
+    "s_suppkey", "s_nationkey"
+)
+df_nation = ctx.read_parquet(get_data_path("nation.parquet")).select(
+    "n_nationkey", "n_regionkey", "n_name"
+)
+df_region = ctx.read_parquet(get_data_path("region.parquet")).select(
+    "r_regionkey", "r_name"
+)
+
+# Restrict dataframes to cases of interest
+df_orders = df_orders.filter(col("o_orderdate") >= lit(date)).filter(
+    col("o_orderdate") < lit(date) + lit(interval)
+)
+
+df_region = df_region.filter(col("r_name") == lit(REGION_OF_INTEREST))
+
+# Join all the dataframes
+
+df = (
+    df_customer.join(
+        df_orders, left_on=["c_custkey"], right_on=["o_custkey"], how="inner"
+    )
+    .join(df_lineitem, left_on=["o_orderkey"], right_on=["l_orderkey"], how="inner")
+    .join(
+        df_supplier,
+        left_on=["l_suppkey", "c_nationkey"],
+        right_on=["s_suppkey", "s_nationkey"],
+        how="inner",
+    )
+    .join(df_nation, left_on=["s_nationkey"], right_on=["n_nationkey"], how="inner")
+    .join(df_region, left_on=["n_regionkey"], right_on=["r_regionkey"], how="inner")
+)
+
+# Compute the final result
+
+df = df.aggregate(
+    [col("n_name")],
+    [F.sum(col("l_extendedprice") * (lit(1.0) - col("l_discount"))).alias("revenue")],
+)
+
+# Sort in descending order
+
+df = df.sort(col("revenue").sort(ascending=False))
+
+df.show()
diff --git a/examples/tpch/q06_forecasting_revenue_change.py b/examples/tpch/q06_forecasting_revenue_change.py
new file mode 100644
index 000000000..1de5848b1
--- /dev/null
+++ b/examples/tpch/q06_forecasting_revenue_change.py
@@ -0,0 +1,88 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+TPC-H Problem Statement Query 6:
+
+The Forecasting Revenue Change Query considers all the lineitems shipped in a given year with
+discounts between DISCOUNT-0.01 and DISCOUNT+0.01. The query lists the amount by which the total
+revenue would have increased if these discounts had been eliminated for lineitems with l_quantity
+less than quantity. Note that the potential revenue increase is equal to the sum of
+[l_extendedprice * l_discount] for all lineitems with discounts and quantities in the qualifying
+range.
+
+The above problem statement text is copyrighted by the Transaction Processing Performance Council
+as part of their TPC Benchmark H Specification revision 2.18.0.
+"""
+
+from datetime import datetime
+
+import pyarrow as pa
+from datafusion import SessionContext, col, lit
+from datafusion import functions as F
+from util import get_data_path
+
+# Variables from the example query
+
+DATE_OF_INTEREST = "1994-01-01"
+DISCOUT = 0.06
+DELTA = 0.01
+QUANTITY = 24
+
+INTERVAL_DAYS = 365
+
+date = datetime.strptime(DATE_OF_INTEREST, "%Y-%m-%d").date()
+
+interval = pa.scalar((0, INTERVAL_DAYS, 0), type=pa.month_day_nano_interval())
+
+# Load the dataframes we need
+
+ctx = SessionContext()
+
+df_lineitem = ctx.read_parquet(get_data_path("lineitem.parquet")).select(
+    "l_shipdate", "l_quantity", "l_extendedprice", "l_discount"
+)
+
+# Filter down to lineitems of interest
+
+df = (
+    df_lineitem.filter(col("l_shipdate") >= lit(date))
+    .filter(col("l_shipdate") < lit(date) + lit(interval))
+    .filter(col("l_discount") >= lit(DISCOUT) - lit(DELTA))
+    .filter(col("l_discount") <= lit(DISCOUT) + lit(DELTA))
+    .filter(col("l_quantity") < lit(QUANTITY))
+)
+
+# Add up all the "lost" revenue
+
+df = df.aggregate(
+    [], [F.sum(col("l_extendedprice") * col("l_discount")).alias("revenue")]
+)
+
+# Show the single result. We could do a `show()` but since we want to demonstrate features of how
+# to use Data Fusion, instead collect the result as a python object and print it out.
+
+# collect() should give a list of record batches. This is a small query, so we should get a
+# single batch back, hence the index [0]. Within each record batch we only care about the
+# single column result `revenue`. Since we have only one row returned because we aggregated
+# over the entire dataframe, we can index it at 0. Then convert the DoubleScalar into a
+# simple python object.
+
+revenue = df.collect()[0]["revenue"][0].as_py()
+
+# Note: the output value from this query may be dependent on the size of the database generated
+print(f"Potential lost revenue: {revenue:.2f}")
diff --git a/examples/tpch/q07_volume_shipping.py b/examples/tpch/q07_volume_shipping.py
new file mode 100644
index 000000000..ff2f891f1
--- /dev/null
+++ b/examples/tpch/q07_volume_shipping.py
@@ -0,0 +1,128 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+TPC-H Problem Statement Query 7:
+
+The Volume Shipping Query finds, for two given nations, the gross discounted revenues derived from
+lineitems in which parts were shipped from a supplier in either nation to a customer in the other
+nation during 1995 and 1996. The query lists the supplier nation, the customer nation, the year,
+and the revenue from shipments that took place in that year. The query orders the answer by
+Supplier nation, Customer nation, and year (all ascending).
+
+The above problem statement text is copyrighted by the Transaction Processing Performance Council
+as part of their TPC Benchmark H Specification revision 2.18.0.
+"""
+
+from datetime import datetime
+
+import pyarrow as pa
+from datafusion import SessionContext, col, lit
+from datafusion import functions as F
+from util import get_data_path
+
+# Variables of interest to query over
+
+nation_1 = lit("FRANCE")
+nation_2 = lit("GERMANY")
+
+START_DATE = "1995-01-01"
+END_DATE = "1996-12-31"
+
+start_date = lit(datetime.strptime(START_DATE, "%Y-%m-%d").date())
+end_date = lit(datetime.strptime(END_DATE, "%Y-%m-%d").date())
+
+
+# Load the dataframes we need
+
+ctx = SessionContext()
+
+df_supplier = ctx.read_parquet(get_data_path("supplier.parquet")).select(
+    "s_suppkey", "s_nationkey"
+)
+df_lineitem = ctx.read_parquet(get_data_path("lineitem.parquet")).select(
+    "l_shipdate", "l_extendedprice", "l_discount", "l_suppkey", "l_orderkey"
+)
+df_orders = ctx.read_parquet(get_data_path("orders.parquet")).select(
+    "o_orderkey", "o_custkey"
+)
+df_customer = ctx.read_parquet(get_data_path("customer.parquet")).select(
+    "c_custkey", "c_nationkey"
+)
+df_nation = ctx.read_parquet(get_data_path("nation.parquet")).select(
+    "n_nationkey", "n_name"
+)
+
+
+# Filter to time of interest
+df_lineitem = df_lineitem.filter(col("l_shipdate") >= start_date).filter(
+    col("l_shipdate") <= end_date
+)
+
+
+# A simpler way to do the following operation is to use a filter, but we also want to demonstrate
+# how to use case statements. Here we are assigning `n_name` to be itself when it is either of
+# the two nations of interest. Since there is no `otherwise()` statement, any values that do
+# not match these will result in a null value and then get filtered out.
+#
+# To do the same using a simple filter would be:
+# df_nation = df_nation.filter((F.col("n_name") == nation_1) | (F.col("n_name") == nation_2)) # noqa: ERA001
+df_nation = df_nation.with_column(
+    "n_name",
+    F.case(col("n_name"))
+    .when(nation_1, col("n_name"))
+    .when(nation_2, col("n_name"))
+    .end(),
+).filter(~col("n_name").is_null())
+
+
+# Limit suppliers to either nation
+df_supplier = df_supplier.join(
+    df_nation, left_on=["s_nationkey"], right_on=["n_nationkey"], how="inner"
+).select(col("s_suppkey"), col("n_name").alias("supp_nation"))
+
+# Limit customers to either nation
+df_customer = df_customer.join(
+    df_nation, left_on=["c_nationkey"], right_on=["n_nationkey"], how="inner"
+).select(col("c_custkey"), col("n_name").alias("cust_nation"))
+
+# Join up all the data frames from line items, and make sure the supplier and customer are in
+# different nations.
+df = (
+    df_lineitem.join(
+        df_orders, left_on=["l_orderkey"], right_on=["o_orderkey"], how="inner"
+    )
+    .join(df_customer, left_on=["o_custkey"], right_on=["c_custkey"], how="inner")
+    .join(df_supplier, left_on=["l_suppkey"], right_on=["s_suppkey"], how="inner")
+    .filter(col("cust_nation") != col("supp_nation"))
+)
+
+# Extract out two values for every line item
+df = df.with_column(
+    "l_year", F.datepart(lit("year"), col("l_shipdate")).cast(pa.int32())
+).with_column("volume", col("l_extendedprice") * (lit(1.0) - col("l_discount")))
+
+# Aggregate the results
+df = df.aggregate(
+    [col("supp_nation"), col("cust_nation"), col("l_year")],
+    [F.sum(col("volume")).alias("revenue")],
+)
+
+# Sort based on problem statement requirements
+df = df.sort(col("supp_nation").sort(), col("cust_nation").sort(), col("l_year").sort())
+
+df.show()
diff --git a/examples/tpch/q08_market_share.py b/examples/tpch/q08_market_share.py
new file mode 100644
index 000000000..4bf50efba
--- /dev/null
+++ b/examples/tpch/q08_market_share.py
@@ -0,0 +1,178 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+TPC-H Problem Statement Query 8:
+
+The market share for a given nation within a given region is defined as the fraction of the
+revenue, the sum of [l_extendedprice * (1-l_discount)], from the products of a specified type in
+that region that was supplied by suppliers from the given nation. The query determines this for the
+years 1995 and 1996 presented in this order.
+
+The above problem statement text is copyrighted by the Transaction Processing Performance Council
+as part of their TPC Benchmark H Specification revision 2.18.0.
+"""
+
+from datetime import datetime
+
+import pyarrow as pa
+from datafusion import SessionContext, col, lit
+from datafusion import functions as F
+from util import get_data_path
+
+supplier_nation = lit("BRAZIL")
+customer_region = lit("AMERICA")
+part_of_interest = lit("ECONOMY ANODIZED STEEL")
+
+START_DATE = "1995-01-01"
+END_DATE = "1996-12-31"
+
+start_date = lit(datetime.strptime(START_DATE, "%Y-%m-%d").date())
+end_date = lit(datetime.strptime(END_DATE, "%Y-%m-%d").date())
+
+
+# Load the dataframes we need
+
+ctx = SessionContext()
+
+df_part = ctx.read_parquet(get_data_path("part.parquet")).select("p_partkey", "p_type")
+df_supplier = ctx.read_parquet(get_data_path("supplier.parquet")).select(
+    "s_suppkey", "s_nationkey"
+)
+df_lineitem = ctx.read_parquet(get_data_path("lineitem.parquet")).select(
+    "l_partkey", "l_extendedprice", "l_discount", "l_suppkey", "l_orderkey"
+)
+df_orders = ctx.read_parquet(get_data_path("orders.parquet")).select(
+    "o_orderkey", "o_custkey", "o_orderdate"
+)
+df_customer = ctx.read_parquet(get_data_path("customer.parquet")).select(
+    "c_custkey", "c_nationkey"
+)
+df_nation = ctx.read_parquet(get_data_path("nation.parquet")).select(
+    "n_nationkey", "n_name", "n_regionkey"
+)
+df_region = ctx.read_parquet(get_data_path("region.parquet")).select(
+    "r_regionkey", "r_name"
+)
+
+# Limit possible parts to the one specified
+df_part = df_part.filter(col("p_type") == part_of_interest)
+
+# Limit orders to those in the specified range
+
+df_orders = df_orders.filter(col("o_orderdate") >= start_date).filter(
+    col("o_orderdate") <= end_date
+)
+
+# Part 1: Find customers in the region
+
+# We want customers in region specified by region_of_interest. This will be used to compute
+# the total sales of the part of interest. We want to know of those sales what fraction
+# was supplied by the nation of interest. There is no guarantee that the nation of
+# interest is within the region of interest.
+
+# First we find all the sales that make up the basis.
+
+df_regional_customers = df_region.filter(col("r_name") == customer_region)
+
+# After this join we have all of the possible sales nations
+df_regional_customers = df_regional_customers.join(
+    df_nation, left_on=["r_regionkey"], right_on=["n_regionkey"], how="inner"
+)
+
+# Now find the possible customers
+df_regional_customers = df_regional_customers.join(
+    df_customer, left_on=["n_nationkey"], right_on=["c_nationkey"], how="inner"
+)
+
+# Next find orders for these customers
+df_regional_customers = df_regional_customers.join(
+    df_orders, left_on=["c_custkey"], right_on=["o_custkey"], how="inner"
+)
+
+# Find all line items from these orders
+df_regional_customers = df_regional_customers.join(
+    df_lineitem, left_on=["o_orderkey"], right_on=["l_orderkey"], how="inner"
+)
+
+# Limit to the part of interest
+df_regional_customers = df_regional_customers.join(
+    df_part, left_on=["l_partkey"], right_on=["p_partkey"], how="inner"
+)
+
+# Compute the volume for each line item
+df_regional_customers = df_regional_customers.with_column(
+    "volume", col("l_extendedprice") * (lit(1.0) - col("l_discount"))
+)
+
+# Part 2: Find suppliers from the nation
+
+# Now that we have all of the sales of that part in the specified region, we need
+# to determine which of those came from suppliers in the nation we are interested in.
+
+df_national_suppliers = df_nation.filter(col("n_name") == supplier_nation)
+
+# Determine the suppliers by the limited nation key we have in our single row df above
+df_national_suppliers = df_national_suppliers.join(
+    df_supplier, left_on=["n_nationkey"], right_on=["s_nationkey"], how="inner"
+)
+
+# When we join to the customer dataframe, we don't want to confuse other columns, so only
+# select the supplier key that we need
+df_national_suppliers = df_national_suppliers.select("s_suppkey")
+
+
+# Part 3: Combine suppliers and customers and compute the market share
+
+# Now we can do a left outer join on the suppkey. Those line items from other suppliers
+# will get a null value. We can check for the existence of this null to compute a volume
+# column only from suppliers in the nation we are evaluating.
+
+df = df_regional_customers.join(
+    df_national_suppliers, left_on=["l_suppkey"], right_on=["s_suppkey"], how="left"
+)
+
+# Use a case statement to compute the volume sold by suppliers in the nation of interest
+df = df.with_column(
+    "national_volume",
+    F.case(col("s_suppkey").is_null())
+    .when(lit(value=False), col("volume"))
+    .otherwise(lit(0.0)),
+)
+
+df = df.with_column(
+    "o_year", F.datepart(lit("year"), col("o_orderdate")).cast(pa.int32())
+)
+
+
+# Lastly, sum up the results
+
+df = df.aggregate(
+    [col("o_year")],
+    [
+        F.sum(col("volume")).alias("volume"),
+        F.sum(col("national_volume")).alias("national_volume"),
+    ],
+)
+
+df = df.select(
+    col("o_year"), (F.col("national_volume") / F.col("volume")).alias("mkt_share")
+)
+
+df = df.sort(col("o_year").sort())
+
+df.show()
diff --git a/examples/tpch/q09_product_type_profit_measure.py b/examples/tpch/q09_product_type_profit_measure.py
new file mode 100644
index 000000000..e2abbd095
--- /dev/null
+++ b/examples/tpch/q09_product_type_profit_measure.py
@@ -0,0 +1,98 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+TPC-H Problem Statement Query 9:
+
+The Product Type Profit Measure Query finds, for each nation and each year, the profit for all parts
+ordered in that year that contain a specified substring in their names and that were filled by a
+supplier in that nation. The profit is defined as the sum of
+[(l_extendedprice*(1-l_discount)) - (ps_supplycost * l_quantity)] for all lineitems describing
+parts in the specified line. The query lists the nations in ascending alphabetical order and, for
+each nation, the year and profit in descending order by year (most recent first).
+
+The above problem statement text is copyrighted by the Transaction Processing Performance Council
+as part of their TPC Benchmark H Specification revision 2.18.0.
+"""
+
+import pyarrow as pa
+from datafusion import SessionContext, col, lit
+from datafusion import functions as F
+from util import get_data_path
+
+part_color = lit("green")
+
+# Load the dataframes we need
+
+ctx = SessionContext()
+
+df_part = ctx.read_parquet(get_data_path("part.parquet")).select("p_partkey", "p_name")
+df_supplier = ctx.read_parquet(get_data_path("supplier.parquet")).select(
+    "s_suppkey", "s_nationkey"
+)
+df_partsupp = ctx.read_parquet(get_data_path("partsupp.parquet")).select(
+    "ps_suppkey", "ps_partkey", "ps_supplycost"
+)
+df_lineitem = ctx.read_parquet(get_data_path("lineitem.parquet")).select(
+    "l_partkey",
+    "l_extendedprice",
+    "l_discount",
+    "l_suppkey",
+    "l_orderkey",
+    "l_quantity",
+)
+df_orders = ctx.read_parquet(get_data_path("orders.parquet")).select(
+    "o_orderkey", "o_custkey", "o_orderdate"
+)
+df_nation = ctx.read_parquet(get_data_path("nation.parquet")).select(
+    "n_nationkey", "n_name", "n_regionkey"
+)
+
+# Limit possible parts to the color specified
+df = df_part.filter(F.strpos(col("p_name"), part_color) > lit(0))
+
+# We have a series of joins that get us to limit down to the line items we need
+df = df.join(df_lineitem, left_on=["p_partkey"], right_on=["l_partkey"], how="inner")
+df = df.join(df_supplier, left_on=["l_suppkey"], right_on=["s_suppkey"], how="inner")
+df = df.join(df_orders, left_on=["l_orderkey"], right_on=["o_orderkey"], how="inner")
+df = df.join(
+    df_partsupp,
+    left_on=["l_suppkey", "l_partkey"],
+    right_on=["ps_suppkey", "ps_partkey"],
+    how="inner",
+)
+df = df.join(df_nation, left_on=["s_nationkey"], right_on=["n_nationkey"], how="inner")
+
+# Compute the intermediate values and limit down to the expressions we need
+df = df.select(
+    col("n_name").alias("nation"),
+    F.datepart(lit("year"), col("o_orderdate")).cast(pa.int32()).alias("o_year"),
+    (
+        (col("l_extendedprice") * (lit(1) - col("l_discount")))
+        - (col("ps_supplycost") * col("l_quantity"))
+    ).alias("amount"),
+)
+
+# Sum up the values by nation and year
+df = df.aggregate(
+    [col("nation"), col("o_year")], [F.sum(col("amount")).alias("profit")]
+)
+
+# Sort according to the problem specification
+df = df.sort(col("nation").sort(), col("o_year").sort(ascending=False))
+
+df.show()
diff --git a/examples/tpch/q10_returned_item_reporting.py b/examples/tpch/q10_returned_item_reporting.py
new file mode 100644
index 000000000..ed822e264
--- /dev/null
+++ b/examples/tpch/q10_returned_item_reporting.py
@@ -0,0 +1,109 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+TPC-H Problem Statement Query 10:
+
+The Returned Item Reporting Query finds the top 20 customers, in terms of their effect on lost
+revenue for a given quarter, who have returned parts. The query considers only parts that were
+ordered in the specified quarter. The query lists the customer's name, address, nation, phone
+number, account balance, comment information and revenue lost. The customers are listed in
+descending order of lost revenue. Revenue lost is defined as
+sum(l_extendedprice*(1-l_discount)) for all qualifying lineitems.
+
+The above problem statement text is copyrighted by the Transaction Processing Performance Council
+as part of their TPC Benchmark H Specification revision 2.18.0.
+"""
+
+from datetime import datetime
+
+import pyarrow as pa
+from datafusion import SessionContext, col, lit
+from datafusion import functions as F
+from util import get_data_path
+
+DATE_START_OF_QUARTER = "1993-10-01"
+
+date_start_of_quarter = lit(datetime.strptime(DATE_START_OF_QUARTER, "%Y-%m-%d").date())
+
+interval_one_quarter = lit(pa.scalar((0, 92, 0), type=pa.month_day_nano_interval()))
+
+# Load the dataframes we need
+
+ctx = SessionContext()
+
+df_customer = ctx.read_parquet(get_data_path("customer.parquet")).select(
+    "c_custkey",
+    "c_nationkey",
+    "c_name",
+    "c_acctbal",
+    "c_address",
+    "c_phone",
+    "c_comment",
+)
+df_lineitem = ctx.read_parquet(get_data_path("lineitem.parquet")).select(
+    "l_extendedprice", "l_discount", "l_orderkey", "l_returnflag"
+)
+df_orders = ctx.read_parquet(get_data_path("orders.parquet")).select(
+    "o_orderkey", "o_custkey", "o_orderdate"
+)
+df_nation = ctx.read_parquet(get_data_path("nation.parquet")).select(
+    "n_nationkey", "n_name", "n_regionkey"
+)
+
+# limit to returns
+df_lineitem = df_lineitem.filter(col("l_returnflag") == lit("R"))
+
+
+# Rather than aggregate by all of the customer fields as you might do looking at the specification,
+# we can aggregate by o_custkey and then join in the customer data at the end.
+
+df = df_orders.filter(col("o_orderdate") >= date_start_of_quarter).filter(
+    col("o_orderdate") < date_start_of_quarter + interval_one_quarter
+)
+
+df = df.join(df_lineitem, left_on=["o_orderkey"], right_on=["l_orderkey"], how="inner")
+
+# Compute the revenue
+df = df.aggregate(
+    [col("o_custkey")],
+    [F.sum(col("l_extendedprice") * (lit(1) - col("l_discount"))).alias("revenue")],
+)
+
+# Now join in the customer data
+df = df.join(df_customer, left_on=["o_custkey"], right_on=["c_custkey"], how="inner")
+df = df.join(df_nation, left_on=["c_nationkey"], right_on=["n_nationkey"], how="inner")
+
+# These are the columns the problem statement requires
+df = df.select(
+    "c_custkey",
+    "c_name",
+    "revenue",
+    "c_acctbal",
+    "n_name",
+    "c_address",
+    "c_phone",
+    "c_comment",
+)
+
+# Sort the results in descending order
+df = df.sort(col("revenue").sort(ascending=False))
+
+# Only return the top 20 results
+df = df.limit(20)
+
+df.show()
diff --git a/examples/tpch/q11_important_stock_identification.py b/examples/tpch/q11_important_stock_identification.py
new file mode 100644
index 000000000..22829ab7c
--- /dev/null
+++ b/examples/tpch/q11_important_stock_identification.py
@@ -0,0 +1,86 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+TPC-H Problem Statement Query 11:
+
+The Important Stock Identification Query finds, from scanning the available stock of suppliers
+in a given nation, all the parts that represent a significant percentage of the total value of
+all available parts. The query displays the part number and the value of those parts in
+descending order of value.
+
+The above problem statement text is copyrighted by the Transaction Processing Performance Council
+as part of their TPC Benchmark H Specification revision 2.18.0.
+"""
+
+from datafusion import SessionContext, WindowFrame, col, lit
+from datafusion import functions as F
+from util import get_data_path
+
+NATION = "GERMANY"
+FRACTION = 0.0001
+
+# Load the dataframes we need
+
+ctx = SessionContext()
+
+df_supplier = ctx.read_parquet(get_data_path("supplier.parquet")).select(
+    "s_suppkey", "s_nationkey"
+)
+df_partsupp = ctx.read_parquet(get_data_path("partsupp.parquet")).select(
+    "ps_supplycost", "ps_availqty", "ps_suppkey", "ps_partkey"
+)
+df_nation = ctx.read_parquet(get_data_path("nation.parquet")).select(
+    "n_nationkey", "n_name"
+)
+
+# limit to returns
+df_nation = df_nation.filter(col("n_name") == lit(NATION))
+
+# Find part supplies of within this target nation
+
+df = df_nation.join(
+    df_supplier, left_on=["n_nationkey"], right_on=["s_nationkey"], how="inner"
+)
+
+df = df.join(df_partsupp, left_on=["s_suppkey"], right_on=["ps_suppkey"], how="inner")
+
+
+# Compute the value of individual parts
+df = df.with_column("value", col("ps_supplycost") * col("ps_availqty"))
+
+# Compute total value of specific parts
+df = df.aggregate([col("ps_partkey")], [F.sum(col("value")).alias("value")])
+
+# By default window functions go from unbounded preceding to current row, but we want
+# to compute this sum across all rows
+window_frame = WindowFrame("rows", None, None)
+
+df = df.with_column(
+    "total_value", F.window("sum", [col("value")], window_frame=window_frame)
+)
+
+# Limit to the parts for which there is a significant value based on the fraction of the total
+df = df.filter(col("value") / col("total_value") >= lit(FRACTION))
+
+# We only need to report on these two columns
+df = df.select("ps_partkey", "value")
+
+# Sort in descending order of value
+df = df.sort(col("value").sort(ascending=False))
+
+df.show()
diff --git a/examples/tpch/q12_ship_mode_order_priority.py b/examples/tpch/q12_ship_mode_order_priority.py
new file mode 100644
index 000000000..9071597f0
--- /dev/null
+++ b/examples/tpch/q12_ship_mode_order_priority.py
@@ -0,0 +1,113 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+TPC-H Problem Statement Query 12:
+
+The Shipping Modes and Order Priority Query counts, by ship mode, for lineitems actually received
+by customers in a given year, the number of lineitems belonging to orders for which the
+l_receiptdate exceeds the l_commitdate for two different specified ship modes. Only lineitems that
+were actually shipped before the l_commitdate are considered. The late lineitems are partitioned
+into two groups, those with priority URGENT or HIGH, and those with a priority other than URGENT or
+HIGH.
+
+The above problem statement text is copyrighted by the Transaction Processing Performance Council
+as part of their TPC Benchmark H Specification revision 2.18.0.
+"""
+
+from datetime import datetime
+
+import pyarrow as pa
+from datafusion import SessionContext, col, lit
+from datafusion import functions as F
+from util import get_data_path
+
+SHIP_MODE_1 = "MAIL"
+SHIP_MODE_2 = "SHIP"
+DATE_OF_INTEREST = "1994-01-01"
+
+# Load the dataframes we need
+
+ctx = SessionContext()
+
+df_orders = ctx.read_parquet(get_data_path("orders.parquet")).select(
+    "o_orderkey", "o_orderpriority"
+)
+df_lineitem = ctx.read_parquet(get_data_path("lineitem.parquet")).select(
+    "l_orderkey", "l_shipmode", "l_commitdate", "l_shipdate", "l_receiptdate"
+)
+
+date = datetime.strptime(DATE_OF_INTEREST, "%Y-%m-%d").date()
+
+interval = pa.scalar((0, 365, 0), type=pa.month_day_nano_interval())
+
+
+df = df_lineitem.filter(col("l_receiptdate") >= lit(date)).filter(
+    col("l_receiptdate") < lit(date) + lit(interval)
+)
+
+# Note: It is not recommended to use array_has because it treats the second argument as an argument
+# so if you pass it col("l_shipmode") it will pass the entire array to process which is very slow.
+# Instead check the position of the entry is not null.
+df = df.filter(
+    ~F.array_position(
+        F.make_array(lit(SHIP_MODE_1), lit(SHIP_MODE_2)), col("l_shipmode")
+    ).is_null()
+)
+
+# Since we have only two values, it's much easier to do this as a filter where the l_shipmode
+# matches either of the two values, but we want to show doing some array operations in this
+# example. If you want to see this done with filters, comment out the above line and uncomment
+# this one.
+# df = df.filter((col("l_shipmode") == lit(SHIP_MODE_1)) | (col("l_shipmode") == lit(SHIP_MODE_2))) # noqa: ERA001
+
+
+# We need order priority, so join order df to line item
+df = df.join(df_orders, left_on=["l_orderkey"], right_on=["o_orderkey"], how="inner")
+
+# Restrict to line items we care about based on the problem statement.
+df = df.filter(col("l_commitdate") < col("l_receiptdate"))
+
+df = df.filter(col("l_shipdate") < col("l_commitdate"))
+
+df = df.with_column(
+    "high_line_value",
+    F.case(col("o_orderpriority"))
+    .when(lit("1-URGENT"), lit(1))
+    .when(lit("2-HIGH"), lit(1))
+    .otherwise(lit(0)),
+)
+
+# Aggregate the results
+df = df.aggregate(
+    [col("l_shipmode")],
+    [
+        F.sum(col("high_line_value")).alias("high_line_count"),
+        F.count(col("high_line_value")).alias("all_lines_count"),
+    ],
+)
+
+# Compute the final output
+df = df.select(
+    col("l_shipmode"),
+    col("high_line_count"),
+    (col("all_lines_count") - col("high_line_count")).alias("low_line_count"),
+)
+
+df = df.sort(col("l_shipmode").sort())
+
+df.show()
diff --git a/examples/tpch/q13_customer_distribution.py b/examples/tpch/q13_customer_distribution.py
new file mode 100644
index 000000000..93f082ea3
--- /dev/null
+++ b/examples/tpch/q13_customer_distribution.py
@@ -0,0 +1,68 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+TPC-H Problem Statement Query 13:
+
+This query determines the distribution of customers by the number of orders they have made,
+including customers who have no record of orders, past or present. It counts and reports how many
+customers have no orders, how many have 1, 2, 3, etc. A check is made to ensure that the orders
+counted do not fall into one of several special categories of orders. Special categories are
+identified in the order comment column by looking for a particular pattern.
+
+The above problem statement text is copyrighted by the Transaction Processing Performance Council
+as part of their TPC Benchmark H Specification revision 2.18.0.
+"""
+
+from datafusion import SessionContext, col, lit
+from datafusion import functions as F
+from util import get_data_path
+
+WORD_1 = "special"
+WORD_2 = "requests"
+
+# Load the dataframes we need
+
+ctx = SessionContext()
+
+df_orders = ctx.read_parquet(get_data_path("orders.parquet")).select(
+    "o_custkey", "o_comment"
+)
+df_customer = ctx.read_parquet(get_data_path("customer.parquet")).select("c_custkey")
+
+# Use a regex to remove special cases
+df_orders = df_orders.filter(
+    F.regexp_match(col("o_comment"), lit(f"{WORD_1}.?*{WORD_2}")).is_null()
+)
+
+# Since we may have customers with no orders we must do a left join
+df = df_customer.join(
+    df_orders, left_on=["c_custkey"], right_on=["o_custkey"], how="left"
+)
+
+# Find the number of orders for each customer
+df = df.aggregate([col("c_custkey")], [F.count(col("o_custkey")).alias("c_count")])
+
+# Ultimately we want to know the number of customers that have that customer count
+df = df.aggregate([col("c_count")], [F.count(col("c_count")).alias("custdist")])
+
+# We want to order the results by the highest number of customers per count
+df = df.sort(
+    col("custdist").sort(ascending=False), col("c_count").sort(ascending=False)
+)
+
+df.show()
diff --git a/examples/tpch/q14_promotion_effect.py b/examples/tpch/q14_promotion_effect.py
new file mode 100644
index 000000000..d62f76e3c
--- /dev/null
+++ b/examples/tpch/q14_promotion_effect.py
@@ -0,0 +1,85 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+TPC-H Problem Statement Query 14:
+
+The Promotion Effect Query determines what percentage of the revenue in a given year and month was
+derived from promotional parts. The query considers only parts actually shipped in that month and
+gives the percentage. Revenue is defined as (l_extendedprice * (1-l_discount)).
+
+The above problem statement text is copyrighted by the Transaction Processing Performance Council
+as part of their TPC Benchmark H Specification revision 2.18.0.
+"""
+
+from datetime import datetime
+
+import pyarrow as pa
+from datafusion import SessionContext, col, lit
+from datafusion import functions as F
+from util import get_data_path
+
+DATE = "1995-09-01"
+
+date_of_interest = lit(datetime.strptime(DATE, "%Y-%m-%d").date())
+
+interval_one_month = lit(pa.scalar((0, 30, 0), type=pa.month_day_nano_interval()))
+
+# Load the dataframes we need
+
+ctx = SessionContext()
+
+df_lineitem = ctx.read_parquet(get_data_path("lineitem.parquet")).select(
+    "l_partkey", "l_shipdate", "l_extendedprice", "l_discount"
+)
+df_part = ctx.read_parquet(get_data_path("part.parquet")).select("p_partkey", "p_type")
+
+
+# Check part type begins with PROMO
+df_part = df_part.filter(
+    F.substring(col("p_type"), lit(0), lit(6)) == lit("PROMO")
+).with_column("promo_factor", lit(1.0))
+
+df_lineitem = df_lineitem.filter(col("l_shipdate") >= date_of_interest).filter(
+    col("l_shipdate") < date_of_interest + interval_one_month
+)
+
+# Left join so we can sum up the promo parts different from other parts
+df = df_lineitem.join(
+    df_part, left_on=["l_partkey"], right_on=["p_partkey"], how="left"
+)
+
+# Make a factor of 1.0 if it is a promotion, 0.0 otherwise
+df = df.with_column("promo_factor", F.coalesce(col("promo_factor"), lit(0.0)))
+df = df.with_column("revenue", col("l_extendedprice") * (lit(1.0) - col("l_discount")))
+
+
+# Sum up the promo and total revenue
+df = df.aggregate(
+    [],
+    [
+        F.sum(col("promo_factor") * col("revenue")).alias("promo_revenue"),
+        F.sum(col("revenue")).alias("total_revenue"),
+    ],
+)
+
+# Return the percentage of revenue from promotions
+df = df.select(
+    (lit(100.0) * col("promo_revenue") / col("total_revenue")).alias("promo_revenue")
+)
+
+df.show()
diff --git a/examples/tpch/q15_top_supplier.py b/examples/tpch/q15_top_supplier.py
new file mode 100644
index 000000000..c321048f2
--- /dev/null
+++ b/examples/tpch/q15_top_supplier.py
@@ -0,0 +1,89 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+TPC-H Problem Statement Query 15:
+
+The Top Supplier Query finds the supplier who contributed the most to the overall revenue for parts
+shipped during a given quarter of a given year. In case of a tie, the query lists all suppliers
+whose contribution was equal to the maximum, presented in supplier number order.
+
+The above problem statement text is copyrighted by the Transaction Processing Performance Council
+as part of their TPC Benchmark H Specification revision 2.18.0.
+"""
+
+from datetime import datetime
+
+import pyarrow as pa
+from datafusion import SessionContext, WindowFrame, col, lit
+from datafusion import functions as F
+from util import get_data_path
+
+DATE = "1996-01-01"
+
+date_of_interest = lit(datetime.strptime(DATE, "%Y-%m-%d").date())
+
+interval_3_months = lit(pa.scalar((0, 91, 0), type=pa.month_day_nano_interval()))
+
+# Load the dataframes we need
+
+ctx = SessionContext()
+
+df_lineitem = ctx.read_parquet(get_data_path("lineitem.parquet")).select(
+    "l_suppkey", "l_shipdate", "l_extendedprice", "l_discount"
+)
+df_supplier = ctx.read_parquet(get_data_path("supplier.parquet")).select(
+    "s_suppkey",
+    "s_name",
+    "s_address",
+    "s_phone",
+)
+
+# Limit line items to the quarter of interest
+df_lineitem = df_lineitem.filter(col("l_shipdate") >= date_of_interest).filter(
+    col("l_shipdate") < date_of_interest + interval_3_months
+)
+
+df = df_lineitem.aggregate(
+    [col("l_suppkey")],
+    [
+        F.sum(col("l_extendedprice") * (lit(1) - col("l_discount"))).alias(
+            "total_revenue"
+        )
+    ],
+)
+
+# Use a window function to find the maximum revenue across the entire dataframe
+window_frame = WindowFrame("rows", None, None)
+df = df.with_column(
+    "max_revenue", F.window("max", [col("total_revenue")], window_frame=window_frame)
+)
+
+# Find all suppliers whose total revenue is the same as the maximum
+df = df.filter(col("total_revenue") == col("max_revenue"))
+
+# Now that we know the supplier(s) with maximum revenue, get the rest of their information
+# from the supplier table
+df = df.join(df_supplier, left_on=["l_suppkey"], right_on=["s_suppkey"], how="inner")
+
+# Return only the columns requested
+df = df.select("s_suppkey", "s_name", "s_address", "s_phone", "total_revenue")
+
+# If we have more than one, sort by supplier number (suppkey)
+df = df.sort(col("s_suppkey").sort())
+
+df.show()
diff --git a/examples/tpch/q16_part_supplier_relationship.py b/examples/tpch/q16_part_supplier_relationship.py
new file mode 100644
index 000000000..65043ffda
--- /dev/null
+++ b/examples/tpch/q16_part_supplier_relationship.py
@@ -0,0 +1,90 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+TPC-H Problem Statement Query 16:
+
+The Parts/Supplier Relationship Query counts the number of suppliers who can supply parts that
+satisfy a particular customer's requirements. The customer is interested in parts of eight
+different sizes as long as they are not of a given type, not of a given brand, and not from a
+supplier who has had complaints registered at the Better Business Bureau. Results must be presented
+in descending count and ascending brand, type, and size.
+
+The above problem statement text is copyrighted by the Transaction Processing Performance Council
+as part of their TPC Benchmark H Specification revision 2.18.0.
+"""
+
+import pyarrow as pa
+from datafusion import SessionContext, col, lit
+from datafusion import functions as F
+from util import get_data_path
+
+BRAND = "Brand#45"
+TYPE_TO_IGNORE = "MEDIUM POLISHED"
+SIZES_OF_INTEREST = [49, 14, 23, 45, 19, 3, 36, 9]
+
+# Load the dataframes we need
+
+ctx = SessionContext()
+
+df_part = ctx.read_parquet(get_data_path("part.parquet")).select(
+    "p_partkey", "p_brand", "p_type", "p_size"
+)
+df_partsupp = ctx.read_parquet(get_data_path("partsupp.parquet")).select(
+    "ps_suppkey", "ps_partkey"
+)
+df_supplier = ctx.read_parquet(get_data_path("supplier.parquet")).select(
+    "s_suppkey", "s_comment"
+)
+
+df_unwanted_suppliers = df_supplier.filter(
+    ~F.regexp_match(col("s_comment"), lit("Customer.?*Complaints")).is_null()
+)
+
+# Remove unwanted suppliers
+df_partsupp = df_partsupp.join(
+    df_unwanted_suppliers, left_on=["ps_suppkey"], right_on=["s_suppkey"], how="anti"
+)
+
+# Select the parts we are interested in
+df_part = df_part.filter(col("p_brand") != lit(BRAND))
+df_part = df_part.filter(
+    F.substring(col("p_type"), lit(0), lit(len(TYPE_TO_IGNORE) + 1))
+    != lit(TYPE_TO_IGNORE)
+)
+
+# Python conversion of integer to literal casts it to int64 but the data for
+# part size is stored as an int32, so perform a cast. Then check to find if the part
+# size is within the array of possible sizes by checking the position of it is not
+# null.
+p_sizes = F.make_array(*[lit(s).cast(pa.int32()) for s in SIZES_OF_INTEREST])
+df_part = df_part.filter(~F.array_position(p_sizes, col("p_size")).is_null())
+
+df = df_part.join(
+    df_partsupp, left_on=["p_partkey"], right_on=["ps_partkey"], how="inner"
+)
+
+df = df.select("p_brand", "p_type", "p_size", "ps_suppkey").distinct()
+
+df = df.aggregate(
+    [col("p_brand"), col("p_type"), col("p_size")],
+    [F.count(col("ps_suppkey")).alias("supplier_cnt")],
+)
+
+df = df.sort(col("supplier_cnt").sort(ascending=False))
+
+df.show()
diff --git a/examples/tpch/q17_small_quantity_order.py b/examples/tpch/q17_small_quantity_order.py
new file mode 100644
index 000000000..6d76fe506
--- /dev/null
+++ b/examples/tpch/q17_small_quantity_order.py
@@ -0,0 +1,77 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+TPC-H Problem Statement Query 17:
+
+The Small-Quantity-Order Revenue Query considers parts of a given brand and with a given container
+type and determines the average lineitem quantity of such parts ordered for all orders (past and
+pending) in the 7-year database. What would be the average yearly gross (undiscounted) loss in
+revenue if orders for these parts with a quantity of less than 20% of this average were no longer
+taken?
+
+The above problem statement text is copyrighted by the Transaction Processing Performance Council
+as part of their TPC Benchmark H Specification revision 2.18.0.
+"""
+
+from datafusion import SessionContext, WindowFrame, col, lit
+from datafusion import functions as F
+from util import get_data_path
+
+BRAND = "Brand#23"
+CONTAINER = "MED BOX"
+
+# Load the dataframes we need
+
+ctx = SessionContext()
+
+df_part = ctx.read_parquet(get_data_path("part.parquet")).select(
+    "p_partkey", "p_brand", "p_container"
+)
+df_lineitem = ctx.read_parquet(get_data_path("lineitem.parquet")).select(
+    "l_partkey", "l_quantity", "l_extendedprice"
+)
+
+# Limit to the problem statement's brand and container types
+df = df_part.filter(col("p_brand") == lit(BRAND)).filter(
+    col("p_container") == lit(CONTAINER)
+)
+
+# Combine data
+df = df.join(df_lineitem, left_on=["p_partkey"], right_on=["l_partkey"], how="inner")
+
+# Find the average quantity
+window_frame = WindowFrame("rows", None, None)
+df = df.with_column(
+    "avg_quantity",
+    F.window(
+        "avg",
+        [col("l_quantity")],
+        window_frame=window_frame,
+        partition_by=[col("l_partkey")],
+    ),
+)
+
+df = df.filter(col("l_quantity") < lit(0.2) * col("avg_quantity"))
+
+# Compute the total
+df = df.aggregate([], [F.sum(col("l_extendedprice")).alias("total")])
+
+# Divide by number of years in the problem statement to get average
+df = df.select((col("total") / lit(7)).alias("avg_yearly"))
+
+df.show()
diff --git a/examples/tpch/q18_large_volume_customer.py b/examples/tpch/q18_large_volume_customer.py
new file mode 100644
index 000000000..834d181c9
--- /dev/null
+++ b/examples/tpch/q18_large_volume_customer.py
@@ -0,0 +1,67 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+TPC-H Problem Statement Query 18:
+
+The Large Volume Customer Query finds a list of the top 100 customers who have ever placed large
+quantity orders. The query lists the customer name, customer key, the order key, date and total
+price and the quantity for the order.
+
+The above problem statement text is copyrighted by the Transaction Processing Performance Council
+as part of their TPC Benchmark H Specification revision 2.18.0.
+"""
+
+from datafusion import SessionContext, col, lit
+from datafusion import functions as F
+from util import get_data_path
+
+QUANTITY = 300
+
+# Load the dataframes we need
+
+ctx = SessionContext()
+
+df_customer = ctx.read_parquet(get_data_path("customer.parquet")).select(
+    "c_custkey", "c_name"
+)
+df_orders = ctx.read_parquet(get_data_path("orders.parquet")).select(
+    "o_orderkey", "o_custkey", "o_orderdate", "o_totalprice"
+)
+df_lineitem = ctx.read_parquet(get_data_path("lineitem.parquet")).select(
+    "l_orderkey", "l_quantity", "l_extendedprice"
+)
+
+df = df_lineitem.aggregate(
+    [col("l_orderkey")], [F.sum(col("l_quantity")).alias("total_quantity")]
+)
+
+# Limit to orders in which the total quantity is above a threshold
+df = df.filter(col("total_quantity") > lit(QUANTITY))
+
+# We've identified the orders of interest, now join the additional data
+# we are required to report on
+df = df.join(df_orders, left_on=["l_orderkey"], right_on=["o_orderkey"], how="inner")
+df = df.join(df_customer, left_on=["o_custkey"], right_on=["c_custkey"], how="inner")
+
+df = df.select(
+    "c_name", "c_custkey", "o_orderkey", "o_orderdate", "o_totalprice", "total_quantity"
+)
+
+df = df.sort(col("o_totalprice").sort(ascending=False), col("o_orderdate").sort())
+
+df.show()
diff --git a/examples/tpch/q19_discounted_revenue.py b/examples/tpch/q19_discounted_revenue.py
new file mode 100644
index 000000000..bd492aac0
--- /dev/null
+++ b/examples/tpch/q19_discounted_revenue.py
@@ -0,0 +1,138 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+TPC-H Problem Statement Query 19:
+
+The Discounted Revenue query finds the gross discounted revenue for all orders for three different
+types of parts that were shipped by air and delivered in person. Parts are selected based on the
+combination of specific brands, a list of containers, and a range of sizes.
+
+The above problem statement text is copyrighted by the Transaction Processing Performance Council
+as part of their TPC Benchmark H Specification revision 2.18.0.
+"""
+
+import pyarrow as pa
+from datafusion import SessionContext, col, lit, udf
+from datafusion import functions as F
+from util import get_data_path
+
+items_of_interest = {
+    "Brand#12": {
+        "min_quantity": 1,
+        "containers": ["SM CASE", "SM BOX", "SM PACK", "SM PKG"],
+        "max_size": 5,
+    },
+    "Brand#23": {
+        "min_quantity": 10,
+        "containers": ["MED BAG", "MED BOX", "MED PKG", "MED PACK"],
+        "max_size": 10,
+    },
+    "Brand#34": {
+        "min_quantity": 20,
+        "containers": ["LG CASE", "LG BOX", "LG PACK", "LG PKG"],
+        "max_size": 15,
+    },
+}
+
+# Load the dataframes we need
+
+ctx = SessionContext()
+
+df_part = ctx.read_parquet(get_data_path("part.parquet")).select(
+    "p_partkey", "p_brand", "p_container", "p_size"
+)
+df_lineitem = ctx.read_parquet(get_data_path("lineitem.parquet")).select(
+    "l_partkey",
+    "l_quantity",
+    "l_shipmode",
+    "l_shipinstruct",
+    "l_extendedprice",
+    "l_discount",
+)
+
+# These limitations apply to all line items, so go ahead and do them first
+
+df = df_lineitem.filter(col("l_shipinstruct") == lit("DELIVER IN PERSON"))
+
+df = df.filter(
+    (col("l_shipmode") == lit("AIR")) | (col("l_shipmode") == lit("AIR REG"))
+)
+
+df = df.join(df_part, left_on=["l_partkey"], right_on=["p_partkey"], how="inner")
+
+
+# Create the user defined function (UDF) definition that does the work
+def is_of_interest(
+    brand_arr: pa.Array,
+    container_arr: pa.Array,
+    quantity_arr: pa.Array,
+    size_arr: pa.Array,
+) -> pa.Array:
+    """
+    The purpose of this function is to demonstrate how a UDF works, taking as input a pyarrow Array
+    and generating a resultant Array. The length of the inputs should match and there should be the
+    same number of rows in the output.
+    """
+    result = []
+    for idx, brand_val in enumerate(brand_arr):
+        brand = brand_val.as_py()
+        if brand in items_of_interest:
+            values_of_interest = items_of_interest[brand]
+
+            container_matches = (
+                container_arr[idx].as_py() in values_of_interest["containers"]
+            )
+
+            quantity = quantity_arr[idx].as_py()
+            quantity_matches = (
+                values_of_interest["min_quantity"]
+                <= quantity
+                <= values_of_interest["min_quantity"] + 10
+            )
+
+            size = size_arr[idx].as_py()
+            size_matches = 1 <= size <= values_of_interest["max_size"]
+
+            result.append(container_matches and quantity_matches and size_matches)
+        else:
+            result.append(False)
+
+    return pa.array(result)
+
+
+# Turn the above function into a UDF that DataFusion can understand
+is_of_interest_udf = udf(
+    is_of_interest,
+    [pa.utf8(), pa.utf8(), pa.decimal128(15, 2), pa.int32()],
+    pa.bool_(),
+    "stable",
+)
+
+# Filter results using the above UDF
+df = df.filter(
+    is_of_interest_udf(
+        col("p_brand"), col("p_container"), col("l_quantity"), col("p_size")
+    )
+)
+
+df = df.aggregate(
+    [],
+    [F.sum(col("l_extendedprice") * (lit(1) - col("l_discount"))).alias("revenue")],
+)
+
+df.show()
diff --git a/examples/tpch/q20_potential_part_promotion.py b/examples/tpch/q20_potential_part_promotion.py
new file mode 100644
index 000000000..a25188d31
--- /dev/null
+++ b/examples/tpch/q20_potential_part_promotion.py
@@ -0,0 +1,101 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+TPC-H Problem Statement Query 20:
+
+The Potential Part Promotion query identifies suppliers who have an excess of a given part
+available; an excess is defined to be more than 50% of the parts like the given part that the
+supplier shipped in a given year for a given nation. Only parts whose names share a certain naming
+convention are considered.
+
+The above problem statement text is copyrighted by the Transaction Processing Performance Council
+as part of their TPC Benchmark H Specification revision 2.18.0.
+"""
+
+from datetime import datetime
+
+import pyarrow as pa
+from datafusion import SessionContext, col, lit
+from datafusion import functions as F
+from util import get_data_path
+
+COLOR_OF_INTEREST = "forest"
+DATE_OF_INTEREST = "1994-01-01"
+NATION_OF_INTEREST = "CANADA"
+
+# Load the dataframes we need
+
+ctx = SessionContext()
+
+df_part = ctx.read_parquet(get_data_path("part.parquet")).select("p_partkey", "p_name")
+df_lineitem = ctx.read_parquet(get_data_path("lineitem.parquet")).select(
+    "l_shipdate", "l_partkey", "l_suppkey", "l_quantity"
+)
+df_partsupp = ctx.read_parquet(get_data_path("partsupp.parquet")).select(
+    "ps_partkey", "ps_suppkey", "ps_availqty"
+)
+df_supplier = ctx.read_parquet(get_data_path("supplier.parquet")).select(
+    "s_suppkey", "s_address", "s_name", "s_nationkey"
+)
+df_nation = ctx.read_parquet(get_data_path("nation.parquet")).select(
+    "n_nationkey", "n_name"
+)
+
+date = datetime.strptime(DATE_OF_INTEREST, "%Y-%m-%d").date()
+
+interval = pa.scalar((0, 365, 0), type=pa.month_day_nano_interval())
+
+# Filter down dataframes
+df_nation = df_nation.filter(col("n_name") == lit(NATION_OF_INTEREST))
+df_part = df_part.filter(
+    F.substring(col("p_name"), lit(0), lit(len(COLOR_OF_INTEREST) + 1))
+    == lit(COLOR_OF_INTEREST)
+)
+
+df = df_lineitem.filter(col("l_shipdate") >= lit(date)).filter(
+    col("l_shipdate") < lit(date) + lit(interval)
+)
+
+# This will filter down the line items to the parts of interest
+df = df.join(df_part, left_on="l_partkey", right_on="p_partkey", how="inner")
+
+# Compute the total sold and limit ourselves to individual supplier/part combinations
+df = df.aggregate(
+    [col("l_partkey"), col("l_suppkey")], [F.sum(col("l_quantity")).alias("total_sold")]
+)
+
+df = df.join(
+    df_partsupp,
+    left_on=["l_partkey", "l_suppkey"],
+    right_on=["ps_partkey", "ps_suppkey"],
+    how="inner",
+)
+
+# Find cases of excess quantity
+df.filter(col("ps_availqty") > lit(0.5) * col("total_sold"))
+
+# We could do these joins earlier, but now limit to the nation of interest suppliers
+df = df.join(df_supplier, left_on=["ps_suppkey"], right_on=["s_suppkey"], how="inner")
+df = df.join(df_nation, left_on=["s_nationkey"], right_on=["n_nationkey"], how="inner")
+
+# Restrict to the requested data per the problem statement
+df = df.select("s_name", "s_address").distinct()
+
+df = df.sort(col("s_name").sort())
+
+df.show()
diff --git a/examples/tpch/q21_suppliers_kept_orders_waiting.py b/examples/tpch/q21_suppliers_kept_orders_waiting.py
new file mode 100644
index 000000000..619c4406b
--- /dev/null
+++ b/examples/tpch/q21_suppliers_kept_orders_waiting.py
@@ -0,0 +1,118 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+TPC-H Problem Statement Query 21:
+
+The Suppliers Who Kept Orders Waiting query identifies suppliers, for a given nation, whose product
+was part of a multi-supplier order (with current status of 'F') where they were the only supplier
+who failed to meet the committed delivery date.
+
+The above problem statement text is copyrighted by the Transaction Processing Performance Council
+as part of their TPC Benchmark H Specification revision 2.18.0.
+"""
+
+from datafusion import SessionContext, col, lit
+from datafusion import functions as F
+from util import get_data_path
+
+NATION_OF_INTEREST = "SAUDI ARABIA"
+
+# Load the dataframes we need
+
+ctx = SessionContext()
+
+df_orders = ctx.read_parquet(get_data_path("orders.parquet")).select(
+    "o_orderkey", "o_orderstatus"
+)
+df_lineitem = ctx.read_parquet(get_data_path("lineitem.parquet")).select(
+    "l_orderkey", "l_receiptdate", "l_commitdate", "l_suppkey"
+)
+df_supplier = ctx.read_parquet(get_data_path("supplier.parquet")).select(
+    "s_suppkey", "s_name", "s_nationkey"
+)
+df_nation = ctx.read_parquet(get_data_path("nation.parquet")).select(
+    "n_nationkey", "n_name"
+)
+
+# Limit to suppliers in the nation of interest
+df_suppliers_of_interest = df_nation.filter(col("n_name") == lit(NATION_OF_INTEREST))
+
+df_suppliers_of_interest = df_suppliers_of_interest.join(
+    df_supplier, left_on="n_nationkey", right_on="s_nationkey", how="inner"
+)
+
+# Find the failed orders and all their line items
+df = df_orders.filter(col("o_orderstatus") == lit("F"))
+
+df = df_lineitem.join(df, left_on="l_orderkey", right_on="o_orderkey", how="inner")
+
+# Identify the line items for which the order is failed due to.
+df = df.with_column(
+    "failed_supp",
+    F.case(col("l_receiptdate") > col("l_commitdate"))
+    .when(lit(value=True), col("l_suppkey"))
+    .end(),
+)
+
+# There are other ways we could do this but the purpose of this example is to work with rows where
+# an element is an array of values. In this case, we will create two columns of arrays. One will be
+# an array of all of the suppliers who made up this order. That way we can filter the dataframe for
+# only orders where this array is larger than one for multiple supplier orders. The second column
+# is all of the suppliers who failed to make their commitment. We can filter the second column for
+# arrays with size one. That combination will give us orders that had multiple suppliers where only
+# one failed. Use distinct=True in the blow aggregation so we don't get multiple line items from the
+# same supplier reported in either array.
+df = df.aggregate(
+    [col("o_orderkey")],
+    [
+        F.array_agg(col("l_suppkey"), distinct=True).alias("all_suppliers"),
+        F.array_agg(col("failed_supp"), distinct=True).alias("failed_suppliers"),
+    ],
+)
+
+# Remove the null entries that will get returned by array_agg so we can test to see where we only
+# have a single failed supplier in a multiple supplier order
+df = df.with_column(
+    "failed_suppliers", F.array_remove(col("failed_suppliers"), lit(None))
+)
+
+# This is the check described above which will identify single failed supplier in a multiple
+# supplier order.
+df = df.filter(F.array_length(col("failed_suppliers")) == lit(1)).filter(
+    F.array_length(col("all_suppliers")) > lit(1)
+)
+
+# Since we have an array we know is exactly one element long, we can extract that single value.
+df = df.select(
+    col("o_orderkey"), F.array_element(col("failed_suppliers"), lit(1)).alias("suppkey")
+)
+
+# Join to the supplier of interest list for the nation of interest
+df = df.join(
+    df_suppliers_of_interest, left_on=["suppkey"], right_on=["s_suppkey"], how="inner"
+)
+
+# Count how many orders that supplier is the only failed supplier for
+df = df.aggregate([col("s_name")], [F.count(col("o_orderkey")).alias("numwait")])
+
+# Return in descending order
+df = df.sort(col("numwait").sort(ascending=False), col("s_name").sort())
+
+df = df.limit(100)
+
+df.show()
diff --git a/examples/tpch/q22_global_sales_opportunity.py b/examples/tpch/q22_global_sales_opportunity.py
new file mode 100644
index 000000000..c4d115b74
--- /dev/null
+++ b/examples/tpch/q22_global_sales_opportunity.py
@@ -0,0 +1,79 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+TPC-H Problem Statement Query 22:
+
+This query counts how many customers within a specific range of country codes have not placed
+orders for 7 years but who have a greater than average “positive” account balance. It also reflects
+the magnitude of that balance. Country code is defined as the first two characters of c_phone.
+
+The above problem statement text is copyrighted by the Transaction Processing Performance Council
+as part of their TPC Benchmark H Specification revision 2.18.0.
+"""
+
+from datafusion import SessionContext, WindowFrame, col, lit
+from datafusion import functions as F
+from util import get_data_path
+
+NATION_CODES = [13, 31, 23, 29, 30, 18, 17]
+
+# Load the dataframes we need
+
+ctx = SessionContext()
+
+df_customer = ctx.read_parquet(get_data_path("customer.parquet")).select(
+    "c_phone", "c_acctbal", "c_custkey"
+)
+df_orders = ctx.read_parquet(get_data_path("orders.parquet")).select("o_custkey")
+
+# The nation code is a two digit number, but we need to convert it to a string literal
+nation_codes = F.make_array(*[lit(str(n)) for n in NATION_CODES])
+
+# Use the substring operation to extract the first two characters of the phone number
+df = df_customer.with_column("cntrycode", F.substring(col("c_phone"), lit(0), lit(3)))
+
+# Limit our search to customers with some balance and in the country code above
+df = df.filter(col("c_acctbal") > lit(0.0))
+df = df.filter(~F.array_position(nation_codes, col("cntrycode")).is_null())
+
+# Compute the average balance. By default, the window frame is from unbounded preceding to the
+# current row. We want our frame to cover the entire data frame.
+window_frame = WindowFrame("rows", None, None)
+df = df.with_column(
+    "avg_balance", F.window("avg", [col("c_acctbal")], window_frame=window_frame)
+)
+
+df.show()
+# Limit results to customers with above average balance
+df = df.filter(col("c_acctbal") > col("avg_balance"))
+
+# Limit results to customers with no orders
+df = df.join(df_orders, left_on="c_custkey", right_on="o_custkey", how="anti")
+
+# Count up the customers and the balances
+df = df.aggregate(
+    [col("cntrycode")],
+    [
+        F.count(col("c_custkey")).alias("numcust"),
+        F.sum(col("c_acctbal")).alias("totacctbal"),
+    ],
+)
+
+df = df.sort(col("cntrycode").sort())
+
+df.show()
diff --git a/examples/tpch/util.py b/examples/tpch/util.py
new file mode 100644
index 000000000..ec53bcd15
--- /dev/null
+++ b/examples/tpch/util.py
@@ -0,0 +1,34 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+Common utilities for running TPC-H examples.
+"""
+
+from pathlib import Path
+
+
+def get_data_path(filename: str) -> Path:
+    path = Path(__file__).resolve().parent
+
+    return path / "data" / filename
+
+
+def get_answer_file(answer_file: str) -> Path:
+    path = Path(__file__).resolve().parent
+
+    return path / "../../benchmarks/tpch/data/answers" / f"{answer_file}.out"
diff --git a/pyproject.toml b/pyproject.toml
index 6d8a9d213..b238e049e 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -16,48 +16,190 @@
 # under the License.
 
 [build-system]
-requires = ["maturin>=0.11,<0.15"]
+requires = ["maturin>=1.8.1"]
 build-backend = "maturin"
 
 [project]
 name = "datafusion"
 description = "Build and run queries against data"
 readme = "README.md"
-license = {file = "LICENSE.txt"}
-requires-python = ">=3.6"
-keywords = ["datafusion", "dataframe", "rust", "query-engine"]
-classifier = [
-    "Development Status :: 2 - Pre-Alpha",
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: Apache Software License",
-    "License :: OSI Approved",
-    "Operating System :: MacOS",
-    "Operating System :: Microsoft :: Windows",
-    "Operating System :: POSIX :: Linux",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.7",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python",
-    "Programming Language :: Rust",
+license = { file = "LICENSE.txt" }
+requires-python = ">=3.10"
+keywords = ["dataframe", "datafusion", "query-engine", "rust"]
+classifiers = [
+  "Development Status :: 2 - Pre-Alpha",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: Apache Software License",
+  "License :: OSI Approved",
+  "Operating System :: MacOS",
+  "Operating System :: Microsoft :: Windows",
+  "Operating System :: POSIX :: Linux",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python",
+  "Programming Language :: Rust",
 ]
 dependencies = [
-    "pyarrow>=6.0.1",
+  "pyarrow>=16.0.0;python_version<'3.14'",
+  "pyarrow>=22.0.0;python_version>='3.14'",
+  "typing-extensions;python_version<'3.13'",
 ]
+dynamic = ["version"]
 
 [project.urls]
-homepage = "https://arrow.apache.org/datafusion-python"
-documentation = "https://arrow.apache.org/datafusion-python"
-repository = "https://github.com/apache/arrow-datafusion-python"
+homepage = "https://datafusion.apache.org/python"
+documentation = "https://datafusion.apache.org/python"
+repository = "https://github.com/apache/datafusion-python"
 
 [tool.isort]
 profile = "black"
 
 [tool.maturin]
-include = [
-    { path = "Cargo.lock", format = "sdist" }
-]
-exclude = [".github/**", "ci/**", ".asf.yaml"]
+python-source = "python"
+module-name = "datafusion._internal"
+include = [{ path = "Cargo.lock", format = "sdist" }]
+exclude = [".asf.yaml", ".github/**", "ci/**"]
 # Require Cargo.lock is up to date
 locked = true
+features = ["substrait"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+addopts = "--doctest-modules"
+doctest_optionflags = ["NORMALIZE_WHITESPACE", "ELLIPSIS"]
+testpaths = ["python/tests", "python/datafusion"]
+
+# Enable docstring linting using the google style guide
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+  "A001",    # Allow using words like min as variable names
+  "A002",    # Allow using words like filter as variable names
+  "A005",    # Allow module named io
+  "ANN401",  # Allow Any for wrapper classes
+  "COM812",  # Recommended to ignore these rules when using with ruff-format
+  "FBT001",  # Allow boolean positional args
+  "FBT002",  # Allow boolean positional args
+  "FIX002",  # Allow TODO lines - consider removing at some point
+  "ISC001",  # Recommended to ignore these rules when using with ruff-format
+  "N812",    # Allow importing functions as `F`
+  "PD901",   # Allow variable name df
+  "PLR0913", # Allow many arguments in function definition
+  "SLF001",  # Allow accessing private members
+  "TD002",   # Do not require author names in TODO statements
+  "TD003",   # Allow TODO lines
+]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.ruff.lint.pycodestyle]
+max-doc-length = 88
+
+[tool.ruff.lint.flake8-boolean-trap]
+extend-allowed-calls = ["datafusion.lit", "lit"]
+
+# Disable docstring checking for these directories
+[tool.ruff.lint.per-file-ignores]
+"python/tests/*" = [
+  "ANN",
+  "ARG",
+  "BLE001",
+  "D",
+  "PD",
+  "PLC0415",
+  "PLR0913",
+  "PLR2004",
+  "PT004",
+  "PT011",
+  "RUF015",
+  "S101",
+  "S608",
+  "SLF",
+]
+"examples/*" = [
+  "ANN001",
+  "ANN202",
+  "D",
+  "DTZ007",
+  "E501",
+  "INP001",
+  "PLR2004",
+  "RUF015",
+  "S101",
+  "T201",
+  "W505",
+]
+"dev/*" = [
+  "ANN001",
+  "C",
+  "D",
+  "E",
+  "ERA001",
+  "EXE",
+  "N817",
+  "PLR",
+  "S",
+  "SIM",
+  "T",
+  "UP",
+]
+"benchmarks/*" = [
+  "ANN001",
+  "BLE",
+  "D",
+  "E",
+  "ERA001",
+  "EXE",
+  "F",
+  "FURB",
+  "INP001",
+  "PLR",
+  "S",
+  "SIM",
+  "T",
+  "TD",
+  "TRY",
+  "UP",
+]
+"docs/*" = ["D"]
+"docs/source/conf.py" = ["ANN001", "ERA001", "INP001"]
+
+[tool.codespell]
+skip = ["./python/tests/test_functions.py", "./target", "uv.lock"]
+count = true
+ignore-words-list = ["IST", "ans"]
+
+[dependency-groups]
+dev = [
+  "arro3-core==0.6.5",
+  "codespell==2.4.1",
+  "maturin>=1.8.1",
+  "nanoarrow==0.8.0",
+  "numpy>1.25.0;python_version<'3.14'",
+  "numpy>=2.3.2;python_version>='3.14'",
+  "pre-commit>=4.3.0",
+  "pyarrow>=19.0.0",
+  "pygithub==2.5.0",
+  "pytest-asyncio>=0.23.3",
+  "pytest>=7.4.4",
+  "pyyaml>=6.0.3",
+  "ruff>=0.9.1",
+  "toml>=0.10.2",
+]
+docs = [
+  "ipython>=8.12.3",
+  "jinja2>=3.1.5",
+  "myst-parser>=3.0.1",
+  "pandas>=2.0.3",
+  "pickleshare>=0.7.5",
+  "pydata-sphinx-theme==0.8.0",
+  "setuptools>=75.3.0",
+  "sphinx-autoapi>=3.4.0",
+  "sphinx>=7.1.2",
+]
diff --git a/python/datafusion/__init__.py b/python/datafusion/__init__.py
new file mode 100644
index 000000000..2e6f81166
--- /dev/null
+++ b/python/datafusion/__init__.py
@@ -0,0 +1,160 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""DataFusion python package.
+
+This is a Python library that binds to Apache Arrow in-memory query engine DataFusion.
+See https://datafusion.apache.org/python for more information.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+try:
+    import importlib.metadata as importlib_metadata
+except ImportError:
+    import importlib_metadata  # type: ignore[import]
+
+# Public submodules
+from . import functions, object_store, substrait, unparser
+
+# The following imports are okay to remain as opaque to the user.
+from ._internal import Config
+from .catalog import Catalog, Database, Table
+from .col import col, column
+from .common import DFSchema
+from .context import (
+    RuntimeEnvBuilder,
+    SessionConfig,
+    SessionContext,
+    SQLOptions,
+)
+from .dataframe import (
+    DataFrame,
+    DataFrameWriteOptions,
+    InsertOp,
+    ParquetColumnOptions,
+    ParquetWriterOptions,
+)
+from .dataframe_formatter import configure_formatter
+from .expr import Expr, WindowFrame
+from .io import read_avro, read_csv, read_json, read_parquet
+from .options import CsvReadOptions
+from .plan import ExecutionPlan, LogicalPlan
+from .record_batch import RecordBatch, RecordBatchStream
+from .user_defined import (
+    Accumulator,
+    AggregateUDF,
+    ScalarUDF,
+    TableFunction,
+    WindowUDF,
+    udaf,
+    udf,
+    udtf,
+    udwf,
+)
+
+__version__ = importlib_metadata.version(__name__)
+
+__all__ = [
+    "Accumulator",
+    "AggregateUDF",
+    "Catalog",
+    "Config",
+    "CsvReadOptions",
+    "DFSchema",
+    "DataFrame",
+    "DataFrameWriteOptions",
+    "Database",
+    "ExecutionPlan",
+    "Expr",
+    "InsertOp",
+    "LogicalPlan",
+    "ParquetColumnOptions",
+    "ParquetWriterOptions",
+    "RecordBatch",
+    "RecordBatchStream",
+    "RuntimeEnvBuilder",
+    "SQLOptions",
+    "ScalarUDF",
+    "SessionConfig",
+    "SessionContext",
+    "Table",
+    "TableFunction",
+    "WindowFrame",
+    "WindowUDF",
+    "catalog",
+    "col",
+    "column",
+    "common",
+    "configure_formatter",
+    "expr",
+    "functions",
+    "lit",
+    "literal",
+    "object_store",
+    "options",
+    "read_avro",
+    "read_csv",
+    "read_json",
+    "read_parquet",
+    "substrait",
+    "udaf",
+    "udf",
+    "udtf",
+    "udwf",
+    "unparser",
+]
+
+
+def literal(value: Any) -> Expr:
+    """Create a literal expression."""
+    return Expr.literal(value)
+
+
+def string_literal(value: str) -> Expr:
+    """Create a UTF8 literal expression.
+
+    It differs from `literal` which creates a UTF8view literal.
+    """
+    return Expr.string_literal(value)
+
+
+def str_lit(value: str) -> Expr:
+    """Alias for `string_literal`."""
+    return string_literal(value)
+
+
+def lit(value: Any) -> Expr:
+    """Create a literal expression."""
+    return Expr.literal(value)
+
+
+def literal_with_metadata(value: Any, metadata: dict[str, str]) -> Expr:
+    """Creates a new expression representing a scalar value with metadata.
+
+    Args:
+        value: A valid PyArrow scalar value or easily castable to one.
+        metadata: Metadata to attach to the expression.
+    """
+    return Expr.literal_with_metadata(value, metadata)
+
+
+def lit_with_metadata(value: Any, metadata: dict[str, str]) -> Expr:
+    """Alias for literal_with_metadata."""
+    return literal_with_metadata(value, metadata)
diff --git a/python/datafusion/catalog.py b/python/datafusion/catalog.py
new file mode 100644
index 000000000..bc43cf349
--- /dev/null
+++ b/python/datafusion/catalog.py
@@ -0,0 +1,371 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""Data catalog providers."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any, Protocol
+
+import datafusion._internal as df_internal
+
+if TYPE_CHECKING:
+    import pyarrow as pa
+
+    from datafusion import DataFrame, SessionContext
+    from datafusion.context import TableProviderExportable
+
+try:
+    from warnings import deprecated  # Python 3.13+
+except ImportError:
+    from typing_extensions import deprecated  # Python 3.12
+
+
+__all__ = [
+    "Catalog",
+    "CatalogList",
+    "CatalogProvider",
+    "CatalogProviderList",
+    "Schema",
+    "SchemaProvider",
+    "Table",
+]
+
+
+class CatalogList:
+    """DataFusion data catalog list."""
+
+    def __init__(self, catalog_list: df_internal.catalog.RawCatalogList) -> None:
+        """This constructor is not typically called by the end user."""
+        self.catalog_list = catalog_list
+
+    def __repr__(self) -> str:
+        """Print a string representation of the catalog list."""
+        return self.catalog_list.__repr__()
+
+    def names(self) -> set[str]:
+        """This is an alias for `catalog_names`."""
+        return self.catalog_names()
+
+    def catalog_names(self) -> set[str]:
+        """Returns the list of schemas in this catalog."""
+        return self.catalog_list.catalog_names()
+
+    @staticmethod
+    def memory_catalog(ctx: SessionContext | None = None) -> CatalogList:
+        """Create an in-memory catalog provider list."""
+        catalog_list = df_internal.catalog.RawCatalogList.memory_catalog(ctx)
+        return CatalogList(catalog_list)
+
+    def catalog(self, name: str = "datafusion") -> Catalog:
+        """Returns the catalog with the given ``name`` from this catalog."""
+        catalog = self.catalog_list.catalog(name)
+
+        return (
+            Catalog(catalog)
+            if isinstance(catalog, df_internal.catalog.RawCatalog)
+            else catalog
+        )
+
+    def register_catalog(
+        self,
+        name: str,
+        catalog: Catalog | CatalogProvider | CatalogProviderExportable,
+    ) -> Catalog | None:
+        """Register a catalog with this catalog list."""
+        if isinstance(catalog, Catalog):
+            return self.catalog_list.register_catalog(name, catalog.catalog)
+        return self.catalog_list.register_catalog(name, catalog)
+
+
+class Catalog:
+    """DataFusion data catalog."""
+
+    def __init__(self, catalog: df_internal.catalog.RawCatalog) -> None:
+        """This constructor is not typically called by the end user."""
+        self.catalog = catalog
+
+    def __repr__(self) -> str:
+        """Print a string representation of the catalog."""
+        return self.catalog.__repr__()
+
+    def names(self) -> set[str]:
+        """This is an alias for `schema_names`."""
+        return self.schema_names()
+
+    def schema_names(self) -> set[str]:
+        """Returns the list of schemas in this catalog."""
+        return self.catalog.schema_names()
+
+    @staticmethod
+    def memory_catalog(ctx: SessionContext | None = None) -> Catalog:
+        """Create an in-memory catalog provider."""
+        catalog = df_internal.catalog.RawCatalog.memory_catalog(ctx)
+        return Catalog(catalog)
+
+    def schema(self, name: str = "public") -> Schema:
+        """Returns the database with the given ``name`` from this catalog."""
+        schema = self.catalog.schema(name)
+
+        return (
+            Schema(schema)
+            if isinstance(schema, df_internal.catalog.RawSchema)
+            else schema
+        )
+
+    @deprecated("Use `schema` instead.")
+    def database(self, name: str = "public") -> Schema:
+        """Returns the database with the given ``name`` from this catalog."""
+        return self.schema(name)
+
+    def register_schema(
+        self,
+        name: str,
+        schema: Schema | SchemaProvider | SchemaProviderExportable,
+    ) -> Schema | None:
+        """Register a schema with this catalog."""
+        if isinstance(schema, Schema):
+            return self.catalog.register_schema(name, schema._raw_schema)
+        return self.catalog.register_schema(name, schema)
+
+    def deregister_schema(self, name: str, cascade: bool = True) -> Schema | None:
+        """Deregister a schema from this catalog."""
+        return self.catalog.deregister_schema(name, cascade)
+
+
+class Schema:
+    """DataFusion Schema."""
+
+    def __init__(self, schema: df_internal.catalog.RawSchema) -> None:
+        """This constructor is not typically called by the end user."""
+        self._raw_schema = schema
+
+    def __repr__(self) -> str:
+        """Print a string representation of the schema."""
+        return self._raw_schema.__repr__()
+
+    @staticmethod
+    def memory_schema(ctx: SessionContext | None = None) -> Schema:
+        """Create an in-memory schema provider."""
+        schema = df_internal.catalog.RawSchema.memory_schema(ctx)
+        return Schema(schema)
+
+    def names(self) -> set[str]:
+        """This is an alias for `table_names`."""
+        return self.table_names()
+
+    def table_names(self) -> set[str]:
+        """Returns the list of all tables in this schema."""
+        return self._raw_schema.table_names
+
+    def table(self, name: str) -> Table:
+        """Return the table with the given ``name`` from this schema."""
+        return Table(self._raw_schema.table(name))
+
+    def register_table(
+        self,
+        name: str,
+        table: Table | TableProviderExportable | DataFrame | pa.dataset.Dataset,
+    ) -> None:
+        """Register a table in this schema."""
+        return self._raw_schema.register_table(name, table)
+
+    def deregister_table(self, name: str) -> None:
+        """Deregister a table provider from this schema."""
+        return self._raw_schema.deregister_table(name)
+
+    def table_exist(self, name: str) -> bool:
+        """Determines if a table exists in this schema."""
+        return self._raw_schema.table_exist(name)
+
+
+@deprecated("Use `Schema` instead.")
+class Database(Schema):
+    """See `Schema`."""
+
+
+class Table:
+    """A DataFusion table.
+
+    Internally we currently support the following types of tables:
+
+    - Tables created using built-in DataFusion methods, such as
+      reading from CSV or Parquet
+    - pyarrow datasets
+    - DataFusion DataFrames, which will be converted into a view
+    - Externally provided tables implemented with the FFI PyCapsule
+      interface (advanced)
+    """
+
+    __slots__ = ("_inner",)
+
+    def __init__(
+        self,
+        table: Table | TableProviderExportable | DataFrame | pa.dataset.Dataset,
+        ctx: SessionContext | None = None,
+    ) -> None:
+        """Constructor."""
+        self._inner = df_internal.catalog.RawTable(table, ctx)
+
+    def __repr__(self) -> str:
+        """Print a string representation of the table."""
+        return repr(self._inner)
+
+    @staticmethod
+    @deprecated("Use Table() constructor instead.")
+    def from_dataset(dataset: pa.dataset.Dataset) -> Table:
+        """Turn a :mod:`pyarrow.dataset` ``Dataset`` into a :class:`Table`."""
+        return Table(dataset)
+
+    @property
+    def schema(self) -> pa.Schema:
+        """Returns the schema associated with this table."""
+        return self._inner.schema
+
+    @property
+    def kind(self) -> str:
+        """Returns the kind of table."""
+        return self._inner.kind
+
+
+class CatalogProviderList(ABC):
+    """Abstract class for defining a Python based Catalog Provider List."""
+
+    @abstractmethod
+    def catalog_names(self) -> set[str]:
+        """Set of the names of all catalogs in this catalog list."""
+        ...
+
+    @abstractmethod
+    def catalog(
+        self, name: str
+    ) -> CatalogProviderExportable | CatalogProvider | Catalog | None:
+        """Retrieve a specific catalog from this catalog list."""
+        ...
+
+    def register_catalog(  # noqa: B027
+        self, name: str, catalog: CatalogProviderExportable | CatalogProvider | Catalog
+    ) -> None:
+        """Add a catalog to this catalog list.
+
+        This method is optional. If your catalog provides a fixed list of catalogs, you
+        do not need to implement this method.
+        """
+
+
+class CatalogProviderListExportable(Protocol):
+    """Type hint for object that has __datafusion_catalog_provider_list__ PyCapsule.
+
+    https://docs.rs/datafusion/latest/datafusion/catalog/trait.CatalogProviderList.html
+    """
+
+    def __datafusion_catalog_provider_list__(self, session: Any) -> object: ...
+
+
+class CatalogProvider(ABC):
+    """Abstract class for defining a Python based Catalog Provider."""
+
+    @abstractmethod
+    def schema_names(self) -> set[str]:
+        """Set of the names of all schemas in this catalog."""
+        ...
+
+    @abstractmethod
+    def schema(self, name: str) -> Schema | None:
+        """Retrieve a specific schema from this catalog."""
+        ...
+
+    def register_schema(  # noqa: B027
+        self, name: str, schema: SchemaProviderExportable | SchemaProvider | Schema
+    ) -> None:
+        """Add a schema to this catalog.
+
+        This method is optional. If your catalog provides a fixed list of schemas, you
+        do not need to implement this method.
+        """
+
+    def deregister_schema(self, name: str, cascade: bool) -> None:  # noqa: B027
+        """Remove a schema from this catalog.
+
+        This method is optional. If your catalog provides a fixed list of schemas, you
+        do not need to implement this method.
+
+        Args:
+            name: The name of the schema to remove.
+            cascade: If true, deregister the tables within the schema.
+        """
+
+
+class CatalogProviderExportable(Protocol):
+    """Type hint for object that has __datafusion_catalog_provider__ PyCapsule.
+
+    https://docs.rs/datafusion/latest/datafusion/catalog/trait.CatalogProvider.html
+    """
+
+    def __datafusion_catalog_provider__(self, session: Any) -> object: ...
+
+
+class SchemaProvider(ABC):
+    """Abstract class for defining a Python based Schema Provider."""
+
+    def owner_name(self) -> str | None:
+        """Returns the owner of the schema.
+
+        This is an optional method. The default return is None.
+        """
+        return None
+
+    @abstractmethod
+    def table_names(self) -> set[str]:
+        """Set of the names of all tables in this schema."""
+        ...
+
+    @abstractmethod
+    def table(self, name: str) -> Table | None:
+        """Retrieve a specific table from this schema."""
+        ...
+
+    def register_table(  # noqa: B027
+        self, name: str, table: Table | TableProviderExportable | Any
+    ) -> None:
+        """Add a table to this schema.
+
+        This method is optional. If your schema provides a fixed list of tables, you do
+        not need to implement this method.
+        """
+
+    def deregister_table(self, name: str, cascade: bool) -> None:  # noqa: B027
+        """Remove a table from this schema.
+
+        This method is optional. If your schema provides a fixed list of tables, you do
+        not need to implement this method.
+        """
+
+    @abstractmethod
+    def table_exist(self, name: str) -> bool:
+        """Returns true if the table exists in this schema."""
+        ...
+
+
+class SchemaProviderExportable(Protocol):
+    """Type hint for object that has __datafusion_schema_provider__ PyCapsule.
+
+    https://docs.rs/datafusion/latest/datafusion/catalog/trait.SchemaProvider.html
+    """
+
+    def __datafusion_schema_provider__(self, session: Any) -> object: ...
diff --git a/conda/recipes/meta.yaml b/python/datafusion/col.py
similarity index 54%
rename from conda/recipes/meta.yaml
rename to python/datafusion/col.py
index cce614b2f..1141dc092 100644
--- a/conda/recipes/meta.yaml
+++ b/python/datafusion/col.py
@@ -15,36 +15,31 @@
 # specific language governing permissions and limitations
 # under the License.
 
-{% set version = environ.get('GIT_DESCRIBE_TAG', '0.0.0.dev').lstrip('v') + environ.get('VERSION_SUFFIX', '') %}
-{% set minor_version = version.split('.')[0] + '.' + version.split('.')[1] %}
-
-package:
-  name: datafusion
-  version: {{ version }}
-
-source:
-  git_url: ../..
-
-build:
-  noarch: python
-  number: 0
-
-requirements:
-  host:
-    - {{ compiler('rust') }}
-    - python
-    - setuptools
-    - maturin
-  run:
-    - python
-
-test:
-  imports:
-    - datafusion
-
-about:
-  home: https://arrow.apache.org/datafusion
-  license: Apache-2.0
-  license_family: APACHE
-  license_file: LICENSE.txt
-  summary: Apache Arrow DataFusion Python Bindings
+"""Col class."""
+
+from datafusion.expr import Expr
+
+
+class Col:
+    """Create a column expression.
+
+    This helper class allows an extra syntax of creating columns using the __getattr__
+    method.
+    """
+
+    def __call__(self, value: str) -> Expr:
+        """Create a column expression."""
+        return Expr.column(value)
+
+    def __getattr__(self, value: str) -> Expr:
+        """Create a column using attribute syntax."""
+        # For autocomplete to work with IPython
+        if value.startswith("__wrapped__"):
+            return getattr(type(self), value)
+
+        return Expr.column(value)
+
+
+col: Col = Col()
+column: Col = Col()
+__all__ = ["col", "column"]
diff --git a/python/datafusion/common.py b/python/datafusion/common.py
new file mode 100644
index 000000000..c689a816d
--- /dev/null
+++ b/python/datafusion/common.py
@@ -0,0 +1,69 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+"""Common data types used throughout the DataFusion project."""
+
+from enum import Enum
+
+from ._internal import common as common_internal
+
+# TODO: these should all have proper wrapper classes
+
+DFSchema = common_internal.DFSchema
+DataType = common_internal.DataType
+DataTypeMap = common_internal.DataTypeMap
+PythonType = common_internal.PythonType
+RexType = common_internal.RexType
+SqlFunction = common_internal.SqlFunction
+SqlSchema = common_internal.SqlSchema
+SqlStatistics = common_internal.SqlStatistics
+SqlTable = common_internal.SqlTable
+SqlType = common_internal.SqlType
+SqlView = common_internal.SqlView
+TableType = common_internal.TableType
+TableSource = common_internal.TableSource
+Constraints = common_internal.Constraints
+
+__all__ = [
+    "Constraints",
+    "DFSchema",
+    "DataType",
+    "DataTypeMap",
+    "NullTreatment",
+    "PythonType",
+    "RexType",
+    "SqlFunction",
+    "SqlSchema",
+    "SqlStatistics",
+    "SqlTable",
+    "SqlType",
+    "SqlView",
+    "TableSource",
+    "TableType",
+]
+
+
+class NullTreatment(Enum):
+    """Describe how null values are to be treated by functions.
+
+    This is used primarily by aggregate and window functions. It can be set on
+    these functions using the builder approach described in
+    ref:`_window_functions` and ref:`_aggregation` in the online documentation.
+
+    """
+
+    RESPECT_NULLS = common_internal.NullTreatment.RESPECT_NULLS
+    IGNORE_NULLS = common_internal.NullTreatment.IGNORE_NULLS
diff --git a/python/datafusion/context.py b/python/datafusion/context.py
new file mode 100644
index 000000000..0d8259774
--- /dev/null
+++ b/python/datafusion/context.py
@@ -0,0 +1,1386 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""Session Context and it's associated configuration."""
+
+from __future__ import annotations
+
+import uuid
+import warnings
+from typing import TYPE_CHECKING, Any, Protocol
+
+try:
+    from warnings import deprecated  # Python 3.13+
+except ImportError:
+    from typing_extensions import deprecated  # Python 3.12
+
+
+import pyarrow as pa
+
+from datafusion.catalog import (
+    Catalog,
+    CatalogList,
+    CatalogProviderExportable,
+    CatalogProviderList,
+    CatalogProviderListExportable,
+)
+from datafusion.dataframe import DataFrame
+from datafusion.expr import sort_list_to_raw_sort_list
+from datafusion.options import (
+    DEFAULT_MAX_INFER_SCHEMA,
+    CsvReadOptions,
+    _convert_table_partition_cols,
+)
+from datafusion.record_batch import RecordBatchStream
+
+from ._internal import RuntimeEnvBuilder as RuntimeEnvBuilderInternal
+from ._internal import SessionConfig as SessionConfigInternal
+from ._internal import SessionContext as SessionContextInternal
+from ._internal import SQLOptions as SQLOptionsInternal
+from ._internal import expr as expr_internal
+
+if TYPE_CHECKING:
+    import pathlib
+    from collections.abc import Sequence
+
+    import pandas as pd
+    import polars as pl  # type: ignore[import]
+
+    from datafusion.catalog import CatalogProvider, Table
+    from datafusion.expr import SortKey
+    from datafusion.plan import ExecutionPlan, LogicalPlan
+    from datafusion.user_defined import (
+        AggregateUDF,
+        ScalarUDF,
+        TableFunction,
+        WindowUDF,
+    )
+
+
+class ArrowStreamExportable(Protocol):
+    """Type hint for object exporting Arrow C Stream via Arrow PyCapsule Interface.
+
+    https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html
+    """
+
+    def __arrow_c_stream__(  # noqa: D105
+        self, requested_schema: object | None = None
+    ) -> object: ...
+
+
+class ArrowArrayExportable(Protocol):
+    """Type hint for object exporting Arrow C Array via Arrow PyCapsule Interface.
+
+    https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html
+    """
+
+    def __arrow_c_array__(  # noqa: D105
+        self, requested_schema: object | None = None
+    ) -> tuple[object, object]: ...
+
+
+class TableProviderExportable(Protocol):
+    """Type hint for object that has __datafusion_table_provider__ PyCapsule.
+
+    https://datafusion.apache.org/python/user-guide/io/table_provider.html
+    """
+
+    def __datafusion_table_provider__(self, session: Any) -> object: ...  # noqa: D105
+
+
+class SessionConfig:
+    """Session configuration options."""
+
+    def __init__(self, config_options: dict[str, str] | None = None) -> None:
+        """Create a new :py:class:`SessionConfig` with the given configuration options.
+
+        Args:
+            config_options: Configuration options.
+        """
+        self.config_internal = SessionConfigInternal(config_options)
+
+    def with_create_default_catalog_and_schema(
+        self, enabled: bool = True
+    ) -> SessionConfig:
+        """Control if the default catalog and schema will be automatically created.
+
+        Args:
+            enabled: Whether the default catalog and schema will be
+                automatically created.
+
+        Returns:
+            A new :py:class:`SessionConfig` object with the updated setting.
+        """
+        self.config_internal = (
+            self.config_internal.with_create_default_catalog_and_schema(enabled)
+        )
+        return self
+
+    def with_default_catalog_and_schema(
+        self, catalog: str, schema: str
+    ) -> SessionConfig:
+        """Select a name for the default catalog and schema.
+
+        Args:
+            catalog: Catalog name.
+            schema: Schema name.
+
+        Returns:
+            A new :py:class:`SessionConfig` object with the updated setting.
+        """
+        self.config_internal = self.config_internal.with_default_catalog_and_schema(
+            catalog, schema
+        )
+        return self
+
+    def with_information_schema(self, enabled: bool = True) -> SessionConfig:
+        """Enable or disable the inclusion of ``information_schema`` virtual tables.
+
+        Args:
+            enabled: Whether to include ``information_schema`` virtual tables.
+
+        Returns:
+            A new :py:class:`SessionConfig` object with the updated setting.
+        """
+        self.config_internal = self.config_internal.with_information_schema(enabled)
+        return self
+
+    def with_batch_size(self, batch_size: int) -> SessionConfig:
+        """Customize batch size.
+
+        Args:
+            batch_size: Batch size.
+
+        Returns:
+            A new :py:class:`SessionConfig` object with the updated setting.
+        """
+        self.config_internal = self.config_internal.with_batch_size(batch_size)
+        return self
+
+    def with_target_partitions(self, target_partitions: int) -> SessionConfig:
+        """Customize the number of target partitions for query execution.
+
+        Increasing partitions can increase concurrency.
+
+        Args:
+            target_partitions: Number of target partitions.
+
+        Returns:
+            A new :py:class:`SessionConfig` object with the updated setting.
+        """
+        self.config_internal = self.config_internal.with_target_partitions(
+            target_partitions
+        )
+        return self
+
+    def with_repartition_aggregations(self, enabled: bool = True) -> SessionConfig:
+        """Enable or disable the use of repartitioning for aggregations.
+
+        Enabling this improves parallelism.
+
+        Args:
+            enabled: Whether to use repartitioning for aggregations.
+
+        Returns:
+            A new :py:class:`SessionConfig` object with the updated setting.
+        """
+        self.config_internal = self.config_internal.with_repartition_aggregations(
+            enabled
+        )
+        return self
+
+    def with_repartition_joins(self, enabled: bool = True) -> SessionConfig:
+        """Enable or disable the use of repartitioning for joins to improve parallelism.
+
+        Args:
+            enabled: Whether to use repartitioning for joins.
+
+        Returns:
+            A new :py:class:`SessionConfig` object with the updated setting.
+        """
+        self.config_internal = self.config_internal.with_repartition_joins(enabled)
+        return self
+
+    def with_repartition_windows(self, enabled: bool = True) -> SessionConfig:
+        """Enable or disable the use of repartitioning for window functions.
+
+        This may improve parallelism.
+
+        Args:
+            enabled: Whether to use repartitioning for window functions.
+
+        Returns:
+            A new :py:class:`SessionConfig` object with the updated setting.
+        """
+        self.config_internal = self.config_internal.with_repartition_windows(enabled)
+        return self
+
+    def with_repartition_sorts(self, enabled: bool = True) -> SessionConfig:
+        """Enable or disable the use of repartitioning for window functions.
+
+        This may improve parallelism.
+
+        Args:
+            enabled: Whether to use repartitioning for window functions.
+
+        Returns:
+            A new :py:class:`SessionConfig` object with the updated setting.
+        """
+        self.config_internal = self.config_internal.with_repartition_sorts(enabled)
+        return self
+
+    def with_repartition_file_scans(self, enabled: bool = True) -> SessionConfig:
+        """Enable or disable the use of repartitioning for file scans.
+
+        Args:
+            enabled: Whether to use repartitioning for file scans.
+
+        Returns:
+            A new :py:class:`SessionConfig` object with the updated setting.
+        """
+        self.config_internal = self.config_internal.with_repartition_file_scans(enabled)
+        return self
+
+    def with_repartition_file_min_size(self, size: int) -> SessionConfig:
+        """Set minimum file range size for repartitioning scans.
+
+        Args:
+            size: Minimum file range size.
+
+        Returns:
+            A new :py:class:`SessionConfig` object with the updated setting.
+        """
+        self.config_internal = self.config_internal.with_repartition_file_min_size(size)
+        return self
+
+    def with_parquet_pruning(self, enabled: bool = True) -> SessionConfig:
+        """Enable or disable the use of pruning predicate for parquet readers.
+
+        Pruning predicates will enable the reader to skip row groups.
+
+        Args:
+            enabled: Whether to use pruning predicate for parquet readers.
+
+        Returns:
+            A new :py:class:`SessionConfig` object with the updated setting.
+        """
+        self.config_internal = self.config_internal.with_parquet_pruning(enabled)
+        return self
+
+    def set(self, key: str, value: str) -> SessionConfig:
+        """Set a configuration option.
+
+        Args:
+        key: Option key.
+        value: Option value.
+
+        Returns:
+            A new :py:class:`SessionConfig` object with the updated setting.
+        """
+        self.config_internal = self.config_internal.set(key, value)
+        return self
+
+
+class RuntimeEnvBuilder:
+    """Runtime configuration options."""
+
+    def __init__(self) -> None:
+        """Create a new :py:class:`RuntimeEnvBuilder` with default values."""
+        self.config_internal = RuntimeEnvBuilderInternal()
+
+    def with_disk_manager_disabled(self) -> RuntimeEnvBuilder:
+        """Disable the disk manager, attempts to create temporary files will error.
+
+        Returns:
+            A new :py:class:`RuntimeEnvBuilder` object with the updated setting.
+        """
+        self.config_internal = self.config_internal.with_disk_manager_disabled()
+        return self
+
+    def with_disk_manager_os(self) -> RuntimeEnvBuilder:
+        """Use the operating system's temporary directory for disk manager.
+
+        Returns:
+            A new :py:class:`RuntimeEnvBuilder` object with the updated setting.
+        """
+        self.config_internal = self.config_internal.with_disk_manager_os()
+        return self
+
+    def with_disk_manager_specified(
+        self, *paths: str | pathlib.Path
+    ) -> RuntimeEnvBuilder:
+        """Use the specified paths for the disk manager's temporary files.
+
+        Args:
+            paths: Paths to use for the disk manager's temporary files.
+
+        Returns:
+            A new :py:class:`RuntimeEnvBuilder` object with the updated setting.
+        """
+        paths_list = [str(p) for p in paths]
+        self.config_internal = self.config_internal.with_disk_manager_specified(
+            paths_list
+        )
+        return self
+
+    def with_unbounded_memory_pool(self) -> RuntimeEnvBuilder:
+        """Use an unbounded memory pool.
+
+        Returns:
+            A new :py:class:`RuntimeEnvBuilder` object with the updated setting.
+        """
+        self.config_internal = self.config_internal.with_unbounded_memory_pool()
+        return self
+
+    def with_fair_spill_pool(self, size: int) -> RuntimeEnvBuilder:
+        """Use a fair spill pool with the specified size.
+
+        This pool works best when you know beforehand the query has multiple spillable
+        operators that will likely all need to spill. Sometimes it will cause spills
+        even when there was sufficient memory (reserved for other operators) to avoid
+        doing so::
+
+            ┌───────────────────────z──────────────────────z───────────────┐
+            │                       z                      z               │
+            │                       z                      z               │
+            │       Spillable       z       Unspillable    z     Free      │
+            │        Memory         z        Memory        z    Memory     │
+            │                       z                      z               │
+            │                       z                      z               │
+            └───────────────────────z──────────────────────z───────────────┘
+
+        Args:
+            size: Size of the memory pool in bytes.
+
+        Returns:
+            A new :py:class:`RuntimeEnvBuilder` object with the updated setting.
+
+        Examples usage::
+
+            config = RuntimeEnvBuilder().with_fair_spill_pool(1024)
+        """
+        self.config_internal = self.config_internal.with_fair_spill_pool(size)
+        return self
+
+    def with_greedy_memory_pool(self, size: int) -> RuntimeEnvBuilder:
+        """Use a greedy memory pool with the specified size.
+
+        This pool works well for queries that do not need to spill or have a single
+        spillable operator. See :py:func:`with_fair_spill_pool` if there are
+        multiple spillable operators that all will spill.
+
+        Args:
+            size: Size of the memory pool in bytes.
+
+        Returns:
+            A new :py:class:`RuntimeEnvBuilder` object with the updated setting.
+
+        Example usage::
+
+            config = RuntimeEnvBuilder().with_greedy_memory_pool(1024)
+        """
+        self.config_internal = self.config_internal.with_greedy_memory_pool(size)
+        return self
+
+    def with_temp_file_path(self, path: str | pathlib.Path) -> RuntimeEnvBuilder:
+        """Use the specified path to create any needed temporary files.
+
+        Args:
+            path: Path to use for temporary files.
+
+        Returns:
+            A new :py:class:`RuntimeEnvBuilder` object with the updated setting.
+
+        Example usage::
+
+            config = RuntimeEnvBuilder().with_temp_file_path("/tmp")
+        """
+        self.config_internal = self.config_internal.with_temp_file_path(str(path))
+        return self
+
+
+@deprecated("Use `RuntimeEnvBuilder` instead.")
+class RuntimeConfig(RuntimeEnvBuilder):
+    """See `RuntimeEnvBuilder`."""
+
+
+class SQLOptions:
+    """Options to be used when performing SQL queries."""
+
+    def __init__(self) -> None:
+        """Create a new :py:class:`SQLOptions` with default values.
+
+        The default values are:
+        - DDL commands are allowed
+        - DML commands are allowed
+        - Statements are allowed
+        """
+        self.options_internal = SQLOptionsInternal()
+
+    def with_allow_ddl(self, allow: bool = True) -> SQLOptions:
+        """Should DDL (Data Definition Language) commands be run?
+
+        Examples of DDL commands include ``CREATE TABLE`` and ``DROP TABLE``.
+
+        Args:
+            allow: Allow DDL commands to be run.
+
+        Returns:
+            A new :py:class:`SQLOptions` object with the updated setting.
+
+        Example usage::
+
+            options = SQLOptions().with_allow_ddl(True)
+        """
+        self.options_internal = self.options_internal.with_allow_ddl(allow)
+        return self
+
+    def with_allow_dml(self, allow: bool = True) -> SQLOptions:
+        """Should DML (Data Manipulation Language) commands be run?
+
+        Examples of DML commands include ``INSERT INTO`` and ``DELETE``.
+
+        Args:
+            allow: Allow DML commands to be run.
+
+        Returns:
+            A new :py:class:`SQLOptions` object with the updated setting.
+
+        Example usage::
+
+            options = SQLOptions().with_allow_dml(True)
+        """
+        self.options_internal = self.options_internal.with_allow_dml(allow)
+        return self
+
+    def with_allow_statements(self, allow: bool = True) -> SQLOptions:
+        """Should statements such as ``SET VARIABLE`` and ``BEGIN TRANSACTION`` be run?
+
+        Args:
+            allow: Allow statements to be run.
+
+        Returns:
+            A new :py:class:SQLOptions` object with the updated setting.
+
+        Example usage::
+
+            options = SQLOptions().with_allow_statements(True)
+        """
+        self.options_internal = self.options_internal.with_allow_statements(allow)
+        return self
+
+
+class SessionContext:
+    """This is the main interface for executing queries and creating DataFrames.
+
+    See :ref:`user_guide_concepts` in the online documentation for more information.
+    """
+
+    def __init__(
+        self,
+        config: SessionConfig | None = None,
+        runtime: RuntimeEnvBuilder | None = None,
+    ) -> None:
+        """Main interface for executing queries with DataFusion.
+
+        Maintains the state of the connection between a user and an instance
+        of the connection between a user and an instance of the DataFusion
+        engine.
+
+        Args:
+            config: Session configuration options.
+            runtime: Runtime configuration options.
+
+        Example usage:
+
+        The following example demonstrates how to use the context to execute
+        a query against a CSV data source using the :py:class:`DataFrame` API::
+
+            from datafusion import SessionContext
+
+            ctx = SessionContext()
+            df = ctx.read_csv("data.csv")
+        """
+        config = config.config_internal if config is not None else None
+        runtime = runtime.config_internal if runtime is not None else None
+
+        self.ctx = SessionContextInternal(config, runtime)
+
+    def __repr__(self) -> str:
+        """Print a string representation of the Session Context."""
+        return self.ctx.__repr__()
+
+    @classmethod
+    def global_ctx(cls) -> SessionContext:
+        """Retrieve the global context as a `SessionContext` wrapper.
+
+        Returns:
+            A `SessionContext` object that wraps the global `SessionContextInternal`.
+        """
+        internal_ctx = SessionContextInternal.global_ctx()
+        wrapper = cls()
+        wrapper.ctx = internal_ctx
+        return wrapper
+
+    def enable_url_table(self) -> SessionContext:
+        """Control if local files can be queried as tables.
+
+        Returns:
+            A new :py:class:`SessionContext` object with url table enabled.
+        """
+        klass = self.__class__
+        obj = klass.__new__(klass)
+        obj.ctx = self.ctx.enable_url_table()
+        return obj
+
+    def register_object_store(
+        self, schema: str, store: Any, host: str | None = None
+    ) -> None:
+        """Add a new object store into the session.
+
+        Args:
+            schema: The data source schema.
+            store: The :py:class:`~datafusion.object_store.ObjectStore` to register.
+            host: URL for the host.
+        """
+        self.ctx.register_object_store(schema, store, host)
+
+    def register_listing_table(
+        self,
+        name: str,
+        path: str | pathlib.Path,
+        table_partition_cols: list[tuple[str, str | pa.DataType]] | None = None,
+        file_extension: str = ".parquet",
+        schema: pa.Schema | None = None,
+        file_sort_order: Sequence[Sequence[SortKey]] | None = None,
+    ) -> None:
+        """Register multiple files as a single table.
+
+        Registers a :py:class:`~datafusion.catalog.Table` that can assemble multiple
+        files from locations in an :py:class:`~datafusion.object_store.ObjectStore`
+        instance.
+
+        Args:
+            name: Name of the resultant table.
+            path: Path to the file to register.
+            table_partition_cols: Partition columns.
+            file_extension: File extension of the provided table.
+            schema: The data source schema.
+            file_sort_order: Sort order for the file. Each sort key can be
+                specified as a column name (``str``), an expression
+                (``Expr``), or a ``SortExpr``.
+        """
+        if table_partition_cols is None:
+            table_partition_cols = []
+        table_partition_cols = _convert_table_partition_cols(table_partition_cols)
+        self.ctx.register_listing_table(
+            name,
+            str(path),
+            table_partition_cols,
+            file_extension,
+            schema,
+            self._convert_file_sort_order(file_sort_order),
+        )
+
+    def sql(
+        self,
+        query: str,
+        options: SQLOptions | None = None,
+        param_values: dict[str, Any] | None = None,
+        **named_params: Any,
+    ) -> DataFrame:
+        """Create a :py:class:`~datafusion.DataFrame` from SQL query text.
+
+        See the online documentation for a description of how to perform
+        parameterized substitution via either the ``param_values`` option
+        or passing in ``named_params``.
+
+        Note: This API implements DDL statements such as ``CREATE TABLE`` and
+        ``CREATE VIEW`` and DML statements such as ``INSERT INTO`` with in-memory
+        default implementation.See
+        :py:func:`~datafusion.context.SessionContext.sql_with_options`.
+
+        Args:
+            query: SQL query text.
+            options: If provided, the query will be validated against these options.
+            param_values: Provides substitution of scalar values in the query
+                after parsing.
+            named_params: Provides string or DataFrame substitution in the query string.
+
+        Returns:
+            DataFrame representation of the SQL query.
+        """
+
+        def value_to_scalar(value: Any) -> pa.Scalar:
+            if isinstance(value, pa.Scalar):
+                return value
+            return pa.scalar(value)
+
+        def value_to_string(value: Any) -> str:
+            if isinstance(value, DataFrame):
+                view_name = str(uuid.uuid4()).replace("-", "_")
+                view_name = f"view_{view_name}"
+                view = value.df.into_view(temporary=True)
+                self.ctx.register_table(view_name, view)
+                return view_name
+            return str(value)
+
+        param_values = (
+            {name: value_to_scalar(value) for (name, value) in param_values.items()}
+            if param_values is not None
+            else {}
+        )
+        param_strings = (
+            {name: value_to_string(value) for (name, value) in named_params.items()}
+            if named_params is not None
+            else {}
+        )
+
+        options_raw = options.options_internal if options is not None else None
+
+        return DataFrame(
+            self.ctx.sql_with_options(
+                query,
+                options=options_raw,
+                param_values=param_values,
+                param_strings=param_strings,
+            )
+        )
+
+    def sql_with_options(
+        self,
+        query: str,
+        options: SQLOptions,
+        param_values: dict[str, Any] | None = None,
+        **named_params: Any,
+    ) -> DataFrame:
+        """Create a :py:class:`~datafusion.dataframe.DataFrame` from SQL query text.
+
+        This function will first validate that the query is allowed by the
+        provided options.
+
+        Args:
+            query: SQL query text.
+            options: SQL options.
+            param_values: Provides substitution of scalar values in the query
+                after parsing.
+            named_params: Provides string or DataFrame substitution in the query string.
+
+        Returns:
+            DataFrame representation of the SQL query.
+        """
+        return self.sql(
+            query, options=options, param_values=param_values, **named_params
+        )
+
+    def create_dataframe(
+        self,
+        partitions: list[list[pa.RecordBatch]],
+        name: str | None = None,
+        schema: pa.Schema | None = None,
+    ) -> DataFrame:
+        """Create and return a dataframe using the provided partitions.
+
+        Args:
+            partitions: :py:class:`pa.RecordBatch` partitions to register.
+            name: Resultant dataframe name.
+            schema: Schema for the partitions.
+
+        Returns:
+            DataFrame representation of the SQL query.
+        """
+        return DataFrame(self.ctx.create_dataframe(partitions, name, schema))
+
+    def create_dataframe_from_logical_plan(self, plan: LogicalPlan) -> DataFrame:
+        """Create a :py:class:`~datafusion.dataframe.DataFrame` from an existing plan.
+
+        Args:
+            plan: Logical plan.
+
+        Returns:
+            DataFrame representation of the logical plan.
+        """
+        return DataFrame(self.ctx.create_dataframe_from_logical_plan(plan._raw_plan))
+
+    def from_pylist(
+        self, data: list[dict[str, Any]], name: str | None = None
+    ) -> DataFrame:
+        """Create a :py:class:`~datafusion.dataframe.DataFrame` from a list.
+
+        Args:
+            data: List of dictionaries.
+            name: Name of the DataFrame.
+
+        Returns:
+            DataFrame representation of the list of dictionaries.
+        """
+        return DataFrame(self.ctx.from_pylist(data, name))
+
+    def from_pydict(
+        self, data: dict[str, list[Any]], name: str | None = None
+    ) -> DataFrame:
+        """Create a :py:class:`~datafusion.dataframe.DataFrame` from a dictionary.
+
+        Args:
+            data: Dictionary of lists.
+            name: Name of the DataFrame.
+
+        Returns:
+            DataFrame representation of the dictionary of lists.
+        """
+        return DataFrame(self.ctx.from_pydict(data, name))
+
+    def from_arrow(
+        self,
+        data: ArrowStreamExportable | ArrowArrayExportable,
+        name: str | None = None,
+    ) -> DataFrame:
+        """Create a :py:class:`~datafusion.dataframe.DataFrame` from an Arrow source.
+
+        The Arrow data source can be any object that implements either
+        ``__arrow_c_stream__`` or ``__arrow_c_array__``. For the latter, it must return
+        a struct array.
+
+        Arrow data can be Polars, Pandas, Pyarrow etc.
+
+        Args:
+            data: Arrow data source.
+            name: Name of the DataFrame.
+
+        Returns:
+            DataFrame representation of the Arrow table.
+        """
+        return DataFrame(self.ctx.from_arrow(data, name))
+
+    @deprecated("Use ``from_arrow`` instead.")
+    def from_arrow_table(self, data: pa.Table, name: str | None = None) -> DataFrame:
+        """Create a :py:class:`~datafusion.dataframe.DataFrame` from an Arrow table.
+
+        This is an alias for :py:func:`from_arrow`.
+        """
+        return self.from_arrow(data, name)
+
+    def from_pandas(self, data: pd.DataFrame, name: str | None = None) -> DataFrame:
+        """Create a :py:class:`~datafusion.dataframe.DataFrame` from a Pandas DataFrame.
+
+        Args:
+            data: Pandas DataFrame.
+            name: Name of the DataFrame.
+
+        Returns:
+            DataFrame representation of the Pandas DataFrame.
+        """
+        return DataFrame(self.ctx.from_pandas(data, name))
+
+    def from_polars(self, data: pl.DataFrame, name: str | None = None) -> DataFrame:
+        """Create a :py:class:`~datafusion.dataframe.DataFrame` from a Polars DataFrame.
+
+        Args:
+            data: Polars DataFrame.
+            name: Name of the DataFrame.
+
+        Returns:
+            DataFrame representation of the Polars DataFrame.
+        """
+        return DataFrame(self.ctx.from_polars(data, name))
+
+    # https://github.com/apache/datafusion-python/pull/1016#discussion_r1983239116
+    # is the discussion on how we arrived at adding register_view
+    def register_view(self, name: str, df: DataFrame) -> None:
+        """Register a :py:class:`~datafusion.dataframe.DataFrame` as a view.
+
+        Args:
+            name (str): The name to register the view under.
+            df (DataFrame): The DataFrame to be converted into a view and registered.
+        """
+        view = df.into_view()
+        self.ctx.register_table(name, view)
+
+    def register_table(
+        self,
+        name: str,
+        table: Table | TableProviderExportable | DataFrame | pa.dataset.Dataset,
+    ) -> None:
+        """Register a :py:class:`~datafusion.Table` with this context.
+
+        The registered table can be referenced from SQL statements executed against
+        this context.
+
+        Args:
+            name: Name of the resultant table.
+            table: Any object that can be converted into a :class:`Table`.
+        """
+        self.ctx.register_table(name, table)
+
+    def deregister_table(self, name: str) -> None:
+        """Remove a table from the session."""
+        self.ctx.deregister_table(name)
+
+    def catalog_names(self) -> set[str]:
+        """Returns the list of catalogs in this context."""
+        return self.ctx.catalog_names()
+
+    def register_catalog_provider_list(
+        self,
+        provider: CatalogProviderListExportable | CatalogProviderList | CatalogList,
+    ) -> None:
+        """Register a catalog provider list."""
+        if isinstance(provider, CatalogList):
+            self.ctx.register_catalog_provider_list(provider.catalog)
+        else:
+            self.ctx.register_catalog_provider_list(provider)
+
+    def register_catalog_provider(
+        self, name: str, provider: CatalogProviderExportable | CatalogProvider | Catalog
+    ) -> None:
+        """Register a catalog provider."""
+        if isinstance(provider, Catalog):
+            self.ctx.register_catalog_provider(name, provider.catalog)
+        else:
+            self.ctx.register_catalog_provider(name, provider)
+
+    @deprecated("Use register_table() instead.")
+    def register_table_provider(
+        self,
+        name: str,
+        provider: Table | TableProviderExportable | DataFrame | pa.dataset.Dataset,
+    ) -> None:
+        """Register a table provider.
+
+        Deprecated: use :meth:`register_table` instead.
+        """
+        self.register_table(name, provider)
+
+    def register_udtf(self, func: TableFunction) -> None:
+        """Register a user defined table function."""
+        self.ctx.register_udtf(func._udtf)
+
+    def register_record_batches(
+        self, name: str, partitions: list[list[pa.RecordBatch]]
+    ) -> None:
+        """Register record batches as a table.
+
+        This function will convert the provided partitions into a table and
+        register it into the session using the given name.
+
+        Args:
+            name: Name of the resultant table.
+            partitions: Record batches to register as a table.
+        """
+        self.ctx.register_record_batches(name, partitions)
+
+    def register_parquet(
+        self,
+        name: str,
+        path: str | pathlib.Path,
+        table_partition_cols: list[tuple[str, str | pa.DataType]] | None = None,
+        parquet_pruning: bool = True,
+        file_extension: str = ".parquet",
+        skip_metadata: bool = True,
+        schema: pa.Schema | None = None,
+        file_sort_order: Sequence[Sequence[SortKey]] | None = None,
+    ) -> None:
+        """Register a Parquet file as a table.
+
+        The registered table can be referenced from SQL statement executed
+        against this context.
+
+        Args:
+            name: Name of the table to register.
+            path: Path to the Parquet file.
+            table_partition_cols: Partition columns.
+            parquet_pruning: Whether the parquet reader should use the
+                predicate to prune row groups.
+            file_extension: File extension; only files with this extension are
+                selected for data input.
+            skip_metadata: Whether the parquet reader should skip any metadata
+                that may be in the file schema. This can help avoid schema
+                conflicts due to metadata.
+            schema: The data source schema.
+            file_sort_order: Sort order for the file. Each sort key can be
+                specified as a column name (``str``), an expression
+                (``Expr``), or a ``SortExpr``.
+        """
+        if table_partition_cols is None:
+            table_partition_cols = []
+        table_partition_cols = _convert_table_partition_cols(table_partition_cols)
+        self.ctx.register_parquet(
+            name,
+            str(path),
+            table_partition_cols,
+            parquet_pruning,
+            file_extension,
+            skip_metadata,
+            schema,
+            self._convert_file_sort_order(file_sort_order),
+        )
+
+    def register_csv(
+        self,
+        name: str,
+        path: str | pathlib.Path | list[str | pathlib.Path],
+        schema: pa.Schema | None = None,
+        has_header: bool = True,
+        delimiter: str = ",",
+        schema_infer_max_records: int = DEFAULT_MAX_INFER_SCHEMA,
+        file_extension: str = ".csv",
+        file_compression_type: str | None = None,
+        options: CsvReadOptions | None = None,
+    ) -> None:
+        """Register a CSV file as a table.
+
+        The registered table can be referenced from SQL statement executed against.
+
+        Args:
+            name: Name of the table to register.
+            path: Path to the CSV file. It also accepts a list of Paths.
+            schema: An optional schema representing the CSV file. If None, the
+                CSV reader will try to infer it based on data in file.
+            has_header: Whether the CSV file have a header. If schema inference
+                is run on a file with no headers, default column names are
+                created.
+            delimiter: An optional column delimiter.
+            schema_infer_max_records: Maximum number of rows to read from CSV
+                files for schema inference if needed.
+            file_extension: File extension; only files with this extension are
+                selected for data input.
+            file_compression_type: File compression type.
+            options: Set advanced options for CSV reading. This cannot be
+                combined with any of the other options in this method.
+        """
+        path_arg = [str(p) for p in path] if isinstance(path, list) else str(path)
+
+        if options is not None and (
+            schema is not None
+            or not has_header
+            or delimiter != ","
+            or schema_infer_max_records != DEFAULT_MAX_INFER_SCHEMA
+            or file_extension != ".csv"
+            or file_compression_type is not None
+        ):
+            message = (
+                "Combining CsvReadOptions parameter with additional options "
+                "is not supported. Use CsvReadOptions to set parameters."
+            )
+            warnings.warn(
+                message,
+                category=UserWarning,
+                stacklevel=2,
+            )
+
+        options = (
+            options
+            if options is not None
+            else CsvReadOptions(
+                schema=schema,
+                has_header=has_header,
+                delimiter=delimiter,
+                schema_infer_max_records=schema_infer_max_records,
+                file_extension=file_extension,
+                file_compression_type=file_compression_type,
+            )
+        )
+
+        self.ctx.register_csv(
+            name,
+            path_arg,
+            options.to_inner(),
+        )
+
+    def register_json(
+        self,
+        name: str,
+        path: str | pathlib.Path,
+        schema: pa.Schema | None = None,
+        schema_infer_max_records: int = 1000,
+        file_extension: str = ".json",
+        table_partition_cols: list[tuple[str, str | pa.DataType]] | None = None,
+        file_compression_type: str | None = None,
+    ) -> None:
+        """Register a JSON file as a table.
+
+        The registered table can be referenced from SQL statement executed
+        against this context.
+
+        Args:
+            name: Name of the table to register.
+            path: Path to the JSON file.
+            schema: The data source schema.
+            schema_infer_max_records: Maximum number of rows to read from JSON
+                files for schema inference if needed.
+            file_extension: File extension; only files with this extension are
+                selected for data input.
+            table_partition_cols: Partition columns.
+            file_compression_type: File compression type.
+        """
+        if table_partition_cols is None:
+            table_partition_cols = []
+        table_partition_cols = _convert_table_partition_cols(table_partition_cols)
+        self.ctx.register_json(
+            name,
+            str(path),
+            schema,
+            schema_infer_max_records,
+            file_extension,
+            table_partition_cols,
+            file_compression_type,
+        )
+
+    def register_avro(
+        self,
+        name: str,
+        path: str | pathlib.Path,
+        schema: pa.Schema | None = None,
+        file_extension: str = ".avro",
+        table_partition_cols: list[tuple[str, str | pa.DataType]] | None = None,
+    ) -> None:
+        """Register an Avro file as a table.
+
+        The registered table can be referenced from SQL statement executed against
+        this context.
+
+        Args:
+            name: Name of the table to register.
+            path: Path to the Avro file.
+            schema: The data source schema.
+            file_extension: File extension to select.
+            table_partition_cols:  Partition columns.
+        """
+        if table_partition_cols is None:
+            table_partition_cols = []
+        table_partition_cols = _convert_table_partition_cols(table_partition_cols)
+        self.ctx.register_avro(
+            name, str(path), schema, file_extension, table_partition_cols
+        )
+
+    def register_dataset(self, name: str, dataset: pa.dataset.Dataset) -> None:
+        """Register a :py:class:`pa.dataset.Dataset` as a table.
+
+        Args:
+            name: Name of the table to register.
+            dataset: PyArrow dataset.
+        """
+        self.ctx.register_dataset(name, dataset)
+
+    def register_udf(self, udf: ScalarUDF) -> None:
+        """Register a user-defined function (UDF) with the context."""
+        self.ctx.register_udf(udf._udf)
+
+    def register_udaf(self, udaf: AggregateUDF) -> None:
+        """Register a user-defined aggregation function (UDAF) with the context."""
+        self.ctx.register_udaf(udaf._udaf)
+
+    def register_udwf(self, udwf: WindowUDF) -> None:
+        """Register a user-defined window function (UDWF) with the context."""
+        self.ctx.register_udwf(udwf._udwf)
+
+    def catalog(self, name: str = "datafusion") -> Catalog:
+        """Retrieve a catalog by name."""
+        return Catalog(self.ctx.catalog(name))
+
+    @deprecated(
+        "Use the catalog provider interface ``SessionContext.Catalog`` to "
+        "examine available catalogs, schemas and tables"
+    )
+    def tables(self) -> set[str]:
+        """Deprecated."""
+        return self.ctx.tables()
+
+    def table(self, name: str) -> DataFrame:
+        """Retrieve a previously registered table by name."""
+        return DataFrame(self.ctx.table(name))
+
+    def table_exist(self, name: str) -> bool:
+        """Return whether a table with the given name exists."""
+        return self.ctx.table_exist(name)
+
+    def empty_table(self) -> DataFrame:
+        """Create an empty :py:class:`~datafusion.dataframe.DataFrame`."""
+        return DataFrame(self.ctx.empty_table())
+
+    def session_id(self) -> str:
+        """Return an id that uniquely identifies this :py:class:`SessionContext`."""
+        return self.ctx.session_id()
+
+    def read_json(
+        self,
+        path: str | pathlib.Path,
+        schema: pa.Schema | None = None,
+        schema_infer_max_records: int = 1000,
+        file_extension: str = ".json",
+        table_partition_cols: list[tuple[str, str | pa.DataType]] | None = None,
+        file_compression_type: str | None = None,
+    ) -> DataFrame:
+        """Read a line-delimited JSON data source.
+
+        Args:
+            path: Path to the JSON file.
+            schema: The data source schema.
+            schema_infer_max_records: Maximum number of rows to read from JSON
+                files for schema inference if needed.
+            file_extension: File extension; only files with this extension are
+                selected for data input.
+            table_partition_cols: Partition columns.
+            file_compression_type: File compression type.
+
+        Returns:
+            DataFrame representation of the read JSON files.
+        """
+        if table_partition_cols is None:
+            table_partition_cols = []
+        table_partition_cols = _convert_table_partition_cols(table_partition_cols)
+        return DataFrame(
+            self.ctx.read_json(
+                str(path),
+                schema,
+                schema_infer_max_records,
+                file_extension,
+                table_partition_cols,
+                file_compression_type,
+            )
+        )
+
+    def read_csv(
+        self,
+        path: str | pathlib.Path | list[str] | list[pathlib.Path],
+        schema: pa.Schema | None = None,
+        has_header: bool = True,
+        delimiter: str = ",",
+        schema_infer_max_records: int = DEFAULT_MAX_INFER_SCHEMA,
+        file_extension: str = ".csv",
+        table_partition_cols: list[tuple[str, str | pa.DataType]] | None = None,
+        file_compression_type: str | None = None,
+        options: CsvReadOptions | None = None,
+    ) -> DataFrame:
+        """Read a CSV data source.
+
+        Args:
+            path: Path to the CSV file
+            schema: An optional schema representing the CSV files. If None, the
+                CSV reader will try to infer it based on data in file.
+            has_header: Whether the CSV file have a header. If schema inference
+                is run on a file with no headers, default column names are
+                created.
+            delimiter: An optional column delimiter.
+            schema_infer_max_records: Maximum number of rows to read from CSV
+                files for schema inference if needed.
+            file_extension:  File extension; only files with this extension are
+                selected for data input.
+            table_partition_cols:  Partition columns.
+            file_compression_type:  File compression type.
+            options: Set advanced options for CSV reading. This cannot be
+                combined with any of the other options in this method.
+
+        Returns:
+            DataFrame representation of the read CSV files
+        """
+        path_arg = [str(p) for p in path] if isinstance(path, list) else str(path)
+
+        if options is not None and (
+            schema is not None
+            or not has_header
+            or delimiter != ","
+            or schema_infer_max_records != DEFAULT_MAX_INFER_SCHEMA
+            or file_extension != ".csv"
+            or table_partition_cols is not None
+            or file_compression_type is not None
+        ):
+            message = (
+                "Combining CsvReadOptions parameter with additional options "
+                "is not supported. Use CsvReadOptions to set parameters."
+            )
+            warnings.warn(
+                message,
+                category=UserWarning,
+                stacklevel=2,
+            )
+
+        options = (
+            options
+            if options is not None
+            else CsvReadOptions(
+                schema=schema,
+                has_header=has_header,
+                delimiter=delimiter,
+                schema_infer_max_records=schema_infer_max_records,
+                file_extension=file_extension,
+                table_partition_cols=table_partition_cols,
+                file_compression_type=file_compression_type,
+            )
+        )
+
+        return DataFrame(
+            self.ctx.read_csv(
+                path_arg,
+                options.to_inner(),
+            )
+        )
+
+    def read_parquet(
+        self,
+        path: str | pathlib.Path,
+        table_partition_cols: list[tuple[str, str | pa.DataType]] | None = None,
+        parquet_pruning: bool = True,
+        file_extension: str = ".parquet",
+        skip_metadata: bool = True,
+        schema: pa.Schema | None = None,
+        file_sort_order: Sequence[Sequence[SortKey]] | None = None,
+    ) -> DataFrame:
+        """Read a Parquet source into a :py:class:`~datafusion.dataframe.Dataframe`.
+
+        Args:
+            path: Path to the Parquet file.
+            table_partition_cols: Partition columns.
+            parquet_pruning: Whether the parquet reader should use the predicate
+                to prune row groups.
+            file_extension: File extension; only files with this extension are
+                selected for data input.
+            skip_metadata: Whether the parquet reader should skip any metadata
+                that may be in the file schema. This can help avoid schema
+                conflicts due to metadata.
+            schema: An optional schema representing the parquet files. If None,
+                the parquet reader will try to infer it based on data in the
+                file.
+            file_sort_order: Sort order for the file. Each sort key can be
+                specified as a column name (``str``), an expression
+                (``Expr``), or a ``SortExpr``.
+
+        Returns:
+            DataFrame representation of the read Parquet files
+        """
+        if table_partition_cols is None:
+            table_partition_cols = []
+        table_partition_cols = _convert_table_partition_cols(table_partition_cols)
+        file_sort_order = self._convert_file_sort_order(file_sort_order)
+        return DataFrame(
+            self.ctx.read_parquet(
+                str(path),
+                table_partition_cols,
+                parquet_pruning,
+                file_extension,
+                skip_metadata,
+                schema,
+                file_sort_order,
+            )
+        )
+
+    def read_avro(
+        self,
+        path: str | pathlib.Path,
+        schema: pa.Schema | None = None,
+        file_partition_cols: list[tuple[str, str | pa.DataType]] | None = None,
+        file_extension: str = ".avro",
+    ) -> DataFrame:
+        """Create a :py:class:`DataFrame` for reading Avro data source.
+
+        Args:
+            path: Path to the Avro file.
+            schema: The data source schema.
+            file_partition_cols: Partition columns.
+            file_extension: File extension to select.
+
+        Returns:
+            DataFrame representation of the read Avro file
+        """
+        if file_partition_cols is None:
+            file_partition_cols = []
+        file_partition_cols = _convert_table_partition_cols(file_partition_cols)
+        return DataFrame(
+            self.ctx.read_avro(str(path), schema, file_partition_cols, file_extension)
+        )
+
+    def read_table(
+        self, table: Table | TableProviderExportable | DataFrame | pa.dataset.Dataset
+    ) -> DataFrame:
+        """Creates a :py:class:`~datafusion.dataframe.DataFrame` from a table."""
+        return DataFrame(self.ctx.read_table(table))
+
+    def execute(self, plan: ExecutionPlan, partitions: int) -> RecordBatchStream:
+        """Execute the ``plan`` and return the results."""
+        return RecordBatchStream(self.ctx.execute(plan._raw_plan, partitions))
+
+    @staticmethod
+    def _convert_file_sort_order(
+        file_sort_order: Sequence[Sequence[SortKey]] | None,
+    ) -> list[list[expr_internal.SortExpr]] | None:
+        """Convert nested ``SortKey`` sequences into raw sort expressions.
+
+        Each ``SortKey`` can be a column name string, an ``Expr``, or a
+        ``SortExpr`` and will be converted using
+        :func:`datafusion.expr.sort_list_to_raw_sort_list`.
+        """
+        # Convert each ``SortKey`` in the provided sort order to the low-level
+        # representation expected by the Rust bindings.
+        return (
+            [sort_list_to_raw_sort_list(f) for f in file_sort_order]
+            if file_sort_order is not None
+            else None
+        )
+
+    @staticmethod
+    def _convert_table_partition_cols(
+        table_partition_cols: list[tuple[str, str | pa.DataType]],
+    ) -> list[tuple[str, pa.DataType]]:
+        warn = False
+        converted_table_partition_cols = []
+
+        for col, data_type in table_partition_cols:
+            if isinstance(data_type, str):
+                warn = True
+                if data_type == "string":
+                    converted_data_type = pa.string()
+                elif data_type == "int":
+                    converted_data_type = pa.int32()
+                else:
+                    message = (
+                        f"Unsupported literal data type '{data_type}' for partition "
+                        "column. Supported types are 'string' and 'int'"
+                    )
+                    raise ValueError(message)
+            else:
+                converted_data_type = data_type
+
+            converted_table_partition_cols.append((col, converted_data_type))
+
+        if warn:
+            message = (
+                "using literals for table_partition_cols data types is deprecated,"
+                "use pyarrow types instead"
+            )
+            warnings.warn(
+                message,
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
+
+        return converted_table_partition_cols
+
+    def __datafusion_task_context_provider__(self) -> Any:
+        """Access the PyCapsule FFI_TaskContextProvider."""
+        return self.ctx.__datafusion_task_context_provider__()
+
+    def __datafusion_logical_extension_codec__(self) -> Any:
+        """Access the PyCapsule FFI_LogicalExtensionCodec."""
+        return self.ctx.__datafusion_logical_extension_codec__()
+
+    def with_logical_extension_codec(self, codec: Any) -> SessionContext:
+        """Create a new session context with specified codec.
+
+        This only supports codecs that have been implemented using the
+        FFI interface.
+        """
+        return self.ctx.with_logical_extension_codec(codec)
diff --git a/python/datafusion/dataframe.py b/python/datafusion/dataframe.py
new file mode 100644
index 000000000..214d44a42
--- /dev/null
+++ b/python/datafusion/dataframe.py
@@ -0,0 +1,1441 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+""":py:class:`DataFrame` is one of the core concepts in DataFusion.
+
+See :ref:`user_guide_concepts` in the online documentation for more information.
+"""
+
+from __future__ import annotations
+
+import warnings
+from collections.abc import AsyncIterator, Iterable, Iterator, Sequence
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Literal,
+    overload,
+)
+
+try:
+    from warnings import deprecated  # Python 3.13+
+except ImportError:
+    from typing_extensions import deprecated  # Python 3.12
+
+from datafusion._internal import DataFrame as DataFrameInternal
+from datafusion._internal import DataFrameWriteOptions as DataFrameWriteOptionsInternal
+from datafusion._internal import InsertOp as InsertOpInternal
+from datafusion._internal import ParquetColumnOptions as ParquetColumnOptionsInternal
+from datafusion._internal import ParquetWriterOptions as ParquetWriterOptionsInternal
+from datafusion.expr import (
+    Expr,
+    SortExpr,
+    SortKey,
+    ensure_expr,
+    ensure_expr_list,
+    expr_list_to_raw_expr_list,
+    sort_list_to_raw_sort_list,
+)
+from datafusion.plan import ExecutionPlan, LogicalPlan
+from datafusion.record_batch import RecordBatch, RecordBatchStream
+
+if TYPE_CHECKING:
+    import pathlib
+    from collections.abc import Callable
+
+    import pandas as pd
+    import polars as pl
+    import pyarrow as pa
+
+    from datafusion.catalog import Table
+
+from enum import Enum
+
+
+# excerpt from deltalake
+# https://github.com/apache/datafusion-python/pull/981#discussion_r1905619163
+class Compression(Enum):
+    """Enum representing the available compression types for Parquet files."""
+
+    UNCOMPRESSED = "uncompressed"
+    SNAPPY = "snappy"
+    GZIP = "gzip"
+    BROTLI = "brotli"
+    LZ4 = "lz4"
+    # lzo is not implemented yet
+    # https://github.com/apache/arrow-rs/issues/6970
+    # LZO = "lzo"  # noqa: ERA001
+    ZSTD = "zstd"
+    LZ4_RAW = "lz4_raw"
+
+    @classmethod
+    def from_str(cls: type[Compression], value: str) -> Compression:
+        """Convert a string to a Compression enum value.
+
+        Args:
+            value: The string representation of the compression type.
+
+        Returns:
+            The Compression enum lowercase value.
+
+        Raises:
+            ValueError: If the string does not match any Compression enum value.
+        """
+        try:
+            return cls(value.lower())
+        except ValueError as err:
+            valid_values = str([item.value for item in Compression])
+            error_msg = f"""
+                {value} is not a valid Compression.
+                Valid values are: {valid_values}
+                """
+            raise ValueError(error_msg) from err
+
+    def get_default_level(self) -> int | None:
+        """Get the default compression level for the compression type.
+
+        Returns:
+            The default compression level for the compression type.
+        """
+        # GZIP, BROTLI default values from deltalake repo
+        # https://github.com/apache/datafusion-python/pull/981#discussion_r1905619163
+        # ZSTD default value from delta-rs
+        # https://github.com/apache/datafusion-python/pull/981#discussion_r1904789223
+        if self == Compression.GZIP:
+            return 6
+        if self == Compression.BROTLI:
+            return 1
+        if self == Compression.ZSTD:
+            return 4
+        return None
+
+
+class ParquetWriterOptions:
+    """Advanced parquet writer options.
+
+    Allows settings the writer options that apply to the entire file. Some options can
+    also be set on a column by column basis, with the field ``column_specific_options``
+    (see ``ParquetColumnOptions``).
+    """
+
+    def __init__(
+        self,
+        data_pagesize_limit: int = 1024 * 1024,
+        write_batch_size: int = 1024,
+        writer_version: str = "1.0",
+        skip_arrow_metadata: bool = False,
+        compression: str | None = "zstd(3)",
+        compression_level: int | None = None,
+        dictionary_enabled: bool | None = True,
+        dictionary_page_size_limit: int = 1024 * 1024,
+        statistics_enabled: str | None = "page",
+        max_row_group_size: int = 1024 * 1024,
+        created_by: str = "datafusion-python",
+        column_index_truncate_length: int | None = 64,
+        statistics_truncate_length: int | None = None,
+        data_page_row_count_limit: int = 20_000,
+        encoding: str | None = None,
+        bloom_filter_on_write: bool = False,
+        bloom_filter_fpp: float | None = None,
+        bloom_filter_ndv: int | None = None,
+        allow_single_file_parallelism: bool = True,
+        maximum_parallel_row_group_writers: int = 1,
+        maximum_buffered_record_batches_per_stream: int = 2,
+        column_specific_options: dict[str, ParquetColumnOptions] | None = None,
+    ) -> None:
+        """Initialize the ParquetWriterOptions.
+
+        Args:
+            data_pagesize_limit: Sets best effort maximum size of data page in bytes.
+            write_batch_size: Sets write_batch_size in bytes.
+            writer_version: Sets parquet writer version. Valid values are ``1.0`` and
+                ``2.0``.
+            skip_arrow_metadata: Skip encoding the embedded arrow metadata in the
+                KV_meta.
+            compression: Compression type to use. Default is ``zstd(3)``.
+                Available compression types are
+
+                - ``uncompressed``: No compression.
+                - ``snappy``: Snappy compression.
+                - ``gzip(n)``: Gzip compression with level n.
+                - ``brotli(n)``: Brotli compression with level n.
+                - ``lz4``: LZ4 compression.
+                - ``lz4_raw``: LZ4_RAW compression.
+                - ``zstd(n)``: Zstandard compression with level n.
+            compression_level: Compression level to set.
+            dictionary_enabled: Sets if dictionary encoding is enabled. If ``None``,
+                uses the default parquet writer setting.
+            dictionary_page_size_limit: Sets best effort maximum dictionary page size,
+                in bytes.
+            statistics_enabled: Sets if statistics are enabled for any column Valid
+                values are ``none``, ``chunk``, and ``page``. If ``None``, uses the
+                default parquet writer setting.
+            max_row_group_size: Target maximum number of rows in each row group
+                (defaults to 1M rows). Writing larger row groups requires more memory
+                to write, but can get better compression and be faster to read.
+            created_by: Sets "created by" property.
+            column_index_truncate_length: Sets column index truncate length.
+            statistics_truncate_length: Sets statistics truncate length. If ``None``,
+                uses the default parquet writer setting.
+            data_page_row_count_limit: Sets best effort maximum number of rows in a data
+                page.
+            encoding: Sets default encoding for any column. Valid values are ``plain``,
+                ``plain_dictionary``, ``rle``, ``bit_packed``, ``delta_binary_packed``,
+                ``delta_length_byte_array``, ``delta_byte_array``, ``rle_dictionary``,
+                and ``byte_stream_split``. If ``None``, uses the default parquet writer
+                setting.
+            bloom_filter_on_write: Write bloom filters for all columns when creating
+                parquet files.
+            bloom_filter_fpp: Sets bloom filter false positive probability. If ``None``,
+                uses the default parquet writer setting
+            bloom_filter_ndv: Sets bloom filter number of distinct values. If ``None``,
+                uses the default parquet writer setting.
+            allow_single_file_parallelism: Controls whether DataFusion will attempt to
+                speed up writing parquet files by serializing them in parallel. Each
+                column in each row group in each output file are serialized in parallel
+                leveraging a maximum possible core count of
+                ``n_files * n_row_groups * n_columns``.
+            maximum_parallel_row_group_writers: By default parallel parquet writer is
+                tuned for minimum memory usage in a streaming execution plan. You may
+                see a performance benefit when writing large parquet files by increasing
+                ``maximum_parallel_row_group_writers`` and
+                ``maximum_buffered_record_batches_per_stream`` if your system has idle
+                cores and can tolerate additional memory usage. Boosting these values is
+                likely worthwhile when writing out already in-memory data, such as from
+                a cached data frame.
+            maximum_buffered_record_batches_per_stream: See
+                ``maximum_parallel_row_group_writers``.
+            column_specific_options: Overrides options for specific columns. If a column
+                is not a part of this dictionary, it will use the parameters provided
+                here.
+        """
+        self.data_pagesize_limit = data_pagesize_limit
+        self.write_batch_size = write_batch_size
+        self.writer_version = writer_version
+        self.skip_arrow_metadata = skip_arrow_metadata
+        if compression_level is not None:
+            self.compression = f"{compression}({compression_level})"
+        else:
+            self.compression = compression
+        self.dictionary_enabled = dictionary_enabled
+        self.dictionary_page_size_limit = dictionary_page_size_limit
+        self.statistics_enabled = statistics_enabled
+        self.max_row_group_size = max_row_group_size
+        self.created_by = created_by
+        self.column_index_truncate_length = column_index_truncate_length
+        self.statistics_truncate_length = statistics_truncate_length
+        self.data_page_row_count_limit = data_page_row_count_limit
+        self.encoding = encoding
+        self.bloom_filter_on_write = bloom_filter_on_write
+        self.bloom_filter_fpp = bloom_filter_fpp
+        self.bloom_filter_ndv = bloom_filter_ndv
+        self.allow_single_file_parallelism = allow_single_file_parallelism
+        self.maximum_parallel_row_group_writers = maximum_parallel_row_group_writers
+        self.maximum_buffered_record_batches_per_stream = (
+            maximum_buffered_record_batches_per_stream
+        )
+        self.column_specific_options = column_specific_options
+
+
+class ParquetColumnOptions:
+    """Parquet options for individual columns.
+
+    Contains the available options that can be applied for an individual Parquet column,
+    replacing the global options in ``ParquetWriterOptions``.
+    """
+
+    def __init__(
+        self,
+        encoding: str | None = None,
+        dictionary_enabled: bool | None = None,
+        compression: str | None = None,
+        statistics_enabled: str | None = None,
+        bloom_filter_enabled: bool | None = None,
+        bloom_filter_fpp: float | None = None,
+        bloom_filter_ndv: int | None = None,
+    ) -> None:
+        """Initialize the ParquetColumnOptions.
+
+        Args:
+            encoding: Sets encoding for the column path. Valid values are: ``plain``,
+                ``plain_dictionary``, ``rle``, ``bit_packed``, ``delta_binary_packed``,
+                ``delta_length_byte_array``, ``delta_byte_array``, ``rle_dictionary``,
+                and ``byte_stream_split``. These values are not case-sensitive. If
+                ``None``, uses the default parquet options
+            dictionary_enabled: Sets if dictionary encoding is enabled for the column
+                path. If `None`, uses the default parquet options
+            compression: Sets default parquet compression codec for the column path.
+                Valid values are ``uncompressed``, ``snappy``, ``gzip(level)``, ``lzo``,
+                ``brotli(level)``, ``lz4``, ``zstd(level)``, and ``lz4_raw``. These
+                values are not case-sensitive. If ``None``, uses the default parquet
+                options.
+            statistics_enabled: Sets if statistics are enabled for the column Valid
+                values are: ``none``, ``chunk``, and ``page`` These values are not case
+                sensitive. If ``None``, uses the default parquet options.
+            bloom_filter_enabled: Sets if bloom filter is enabled for the column path.
+                If ``None``, uses the default parquet options.
+            bloom_filter_fpp: Sets bloom filter false positive probability for the
+                column path. If ``None``, uses the default parquet options.
+            bloom_filter_ndv: Sets bloom filter number of distinct values. If ``None``,
+                uses the default parquet options.
+        """
+        self.encoding = encoding
+        self.dictionary_enabled = dictionary_enabled
+        self.compression = compression
+        self.statistics_enabled = statistics_enabled
+        self.bloom_filter_enabled = bloom_filter_enabled
+        self.bloom_filter_fpp = bloom_filter_fpp
+        self.bloom_filter_ndv = bloom_filter_ndv
+
+
+class DataFrame:
+    """Two dimensional table representation of data.
+
+    DataFrame objects are iterable; iterating over a DataFrame yields
+    :class:`datafusion.RecordBatch` instances lazily.
+
+    See :ref:`user_guide_concepts` in the online documentation for more information.
+    """
+
+    def __init__(self, df: DataFrameInternal) -> None:
+        """This constructor is not to be used by the end user.
+
+        See :py:class:`~datafusion.context.SessionContext` for methods to
+        create a :py:class:`DataFrame`.
+        """
+        self.df = df
+
+    def into_view(self, temporary: bool = False) -> Table:
+        """Convert ``DataFrame`` into a :class:`~datafusion.Table`.
+
+        Examples:
+            >>> from datafusion import SessionContext
+            >>> ctx = SessionContext()
+            >>> df = ctx.sql("SELECT 1 AS value")
+            >>> view = df.into_view()
+            >>> ctx.register_table("values_view", view)
+            >>> result = ctx.sql("SELECT value FROM values_view").collect()
+            >>> result[0].column("value").to_pylist()
+            [1]
+        """
+        from datafusion.catalog import Table as _Table
+
+        return _Table(self.df.into_view(temporary))
+
+    def __getitem__(self, key: str | list[str]) -> DataFrame:
+        """Return a new :py:class:`DataFrame` with the specified column or columns.
+
+        Args:
+            key: Column name or list of column names to select.
+
+        Returns:
+            DataFrame with the specified column or columns.
+        """
+        return DataFrame(self.df.__getitem__(key))
+
+    def __repr__(self) -> str:
+        """Return a string representation of the DataFrame.
+
+        Returns:
+            String representation of the DataFrame.
+        """
+        return self.df.__repr__()
+
+    def _repr_html_(self) -> str:
+        return self.df._repr_html_()
+
+    @staticmethod
+    def default_str_repr(
+        batches: list[pa.RecordBatch],
+        schema: pa.Schema,
+        has_more: bool,
+        table_uuid: str | None = None,
+    ) -> str:
+        """Return the default string representation of a DataFrame.
+
+        This method is used by the default formatter and implemented in Rust for
+        performance reasons.
+        """
+        return DataFrameInternal.default_str_repr(batches, schema, has_more, table_uuid)
+
+    def describe(self) -> DataFrame:
+        """Return the statistics for this DataFrame.
+
+        Only summarized numeric datatypes at the moments and returns nulls
+        for non-numeric datatypes.
+
+        The output format is modeled after pandas.
+
+        Returns:
+            A summary DataFrame containing statistics.
+        """
+        return DataFrame(self.df.describe())
+
+    def schema(self) -> pa.Schema:
+        """Return the :py:class:`pyarrow.Schema` of this DataFrame.
+
+        The output schema contains information on the name, data type, and
+        nullability for each column.
+
+        Returns:
+            Describing schema of the DataFrame
+        """
+        return self.df.schema()
+
+    @deprecated(
+        "select_columns() is deprecated. Use :py:meth:`~DataFrame.select` instead"
+    )
+    def select_columns(self, *args: str) -> DataFrame:
+        """Filter the DataFrame by columns.
+
+        Returns:
+            DataFrame only containing the specified columns.
+        """
+        return self.select(*args)
+
+    def select_exprs(self, *args: str) -> DataFrame:
+        """Project arbitrary list of expression strings into a new DataFrame.
+
+        This method will parse string expressions into logical plan expressions.
+        The output DataFrame has one column for each expression.
+
+        Returns:
+            DataFrame only containing the specified columns.
+        """
+        return self.df.select_exprs(*args)
+
+    def select(self, *exprs: Expr | str) -> DataFrame:
+        """Project arbitrary expressions into a new :py:class:`DataFrame`.
+
+        Args:
+            exprs: Either column names or :py:class:`~datafusion.expr.Expr` to select.
+
+        Returns:
+            DataFrame after projection. It has one column for each expression.
+
+        Example usage:
+
+        The following example will return 3 columns from the original dataframe.
+        The first two columns will be the original column ``a`` and ``b`` since the
+        string "a" is assumed to refer to column selection. Also a duplicate of
+        column ``a`` will be returned with the column name ``alternate_a``::
+
+            df = df.select("a", col("b"), col("a").alias("alternate_a"))
+
+        """
+        exprs_internal = expr_list_to_raw_expr_list(exprs)
+        return DataFrame(self.df.select(*exprs_internal))
+
+    def drop(self, *columns: str) -> DataFrame:
+        """Drop arbitrary amount of columns.
+
+        Column names are case-sensitive and require double quotes to be dropped
+        if the original name is not strictly lower case.
+
+        Args:
+            columns: Column names to drop from the dataframe.
+
+        Returns:
+            DataFrame with those columns removed in the projection.
+
+        Example Usage::
+            df.drop('a')                    # To drop a lower-cased column 'a'
+            df.drop('"a"')                  # To drop an upper-cased column 'A'
+        """
+        return DataFrame(self.df.drop(*columns))
+
+    def filter(self, *predicates: Expr | str) -> DataFrame:
+        """Return a DataFrame for which ``predicate`` evaluates to ``True``.
+
+        Rows for which ``predicate`` evaluates to ``False`` or ``None`` are filtered
+        out. If more than one predicate is provided, these predicates will be
+        combined as a logical AND. Each ``predicate`` can be an
+        :class:`~datafusion.expr.Expr` created using helper functions such as
+        :func:`datafusion.col` or :func:`datafusion.lit`, or a SQL expression string
+        that will be parsed against the DataFrame schema. If more complex logic is
+        required, see the logical operations in :py:mod:`~datafusion.functions`.
+
+        Example::
+
+            from datafusion import col, lit
+            df.filter(col("a") > lit(1))
+            df.filter("a > 1")
+
+        Args:
+            predicates: Predicate expression(s) or SQL strings to filter the DataFrame.
+
+        Returns:
+            DataFrame after filtering.
+        """
+        df = self.df
+        for predicate in predicates:
+            expr = (
+                self.parse_sql_expr(predicate)
+                if isinstance(predicate, str)
+                else predicate
+            )
+            df = df.filter(ensure_expr(expr))
+        return DataFrame(df)
+
+    def parse_sql_expr(self, expr: str) -> Expr:
+        """Creates logical expression from a SQL query text.
+
+        The expression is created and processed against the current schema.
+
+        Example::
+
+            from datafusion import col, lit
+            df.parse_sql_expr("a > 1")
+
+            should produce:
+
+            col("a") > lit(1)
+
+        Args:
+            expr: Expression string to be converted to datafusion expression
+
+        Returns:
+            Logical expression .
+        """
+        return Expr(self.df.parse_sql_expr(expr))
+
+    def with_column(self, name: str, expr: Expr | str) -> DataFrame:
+        """Add an additional column to the DataFrame.
+
+        The ``expr`` must be an :class:`~datafusion.expr.Expr` constructed with
+        :func:`datafusion.col` or :func:`datafusion.lit`, or a SQL expression
+        string that will be parsed against the DataFrame schema.
+
+        Example::
+
+            from datafusion import col, lit
+            df.with_column("b", col("a") + lit(1))
+
+        Args:
+            name: Name of the column to add.
+            expr: Expression to compute the column.
+
+        Returns:
+            DataFrame with the new column.
+        """
+        expr = self.parse_sql_expr(expr) if isinstance(expr, str) else expr
+
+        return DataFrame(self.df.with_column(name, ensure_expr(expr)))
+
+    def with_columns(
+        self, *exprs: Expr | str | Iterable[Expr | str], **named_exprs: Expr | str
+    ) -> DataFrame:
+        """Add columns to the DataFrame.
+
+        By passing expressions, iterables of expressions, string SQL expressions,
+        or named expressions.
+        All expressions must be :class:`~datafusion.expr.Expr` objects created via
+        :func:`datafusion.col` or :func:`datafusion.lit`, or SQL expression strings.
+        To pass named expressions use the form ``name=Expr``.
+
+        Example usage: The following will add 4 columns labeled ``a``, ``b``, ``c``,
+        and ``d``::
+
+            from datafusion import col, lit
+            df = df.with_columns(
+                col("x").alias("a"),
+                [lit(1).alias("b"), col("y").alias("c")],
+                d=lit(3)
+            )
+
+            Equivalent example using just SQL strings:
+
+            df = df.with_columns(
+                "x as a",
+                ["1 as b", "y as c"],
+                d="3"
+            )
+
+        Args:
+            exprs: Either a single expression, an iterable of expressions to add or
+                   SQL expression strings.
+            named_exprs: Named expressions in the form of ``name=expr``
+
+        Returns:
+            DataFrame with the new columns added.
+        """
+        expressions = []
+        for expr in exprs:
+            if isinstance(expr, str):
+                expressions.append(self.parse_sql_expr(expr).expr)
+            elif isinstance(expr, Iterable) and not isinstance(
+                expr, Expr | str | bytes | bytearray
+            ):
+                expressions.extend(
+                    [
+                        self.parse_sql_expr(e).expr
+                        if isinstance(e, str)
+                        else ensure_expr(e)
+                        for e in expr
+                    ]
+                )
+            else:
+                expressions.append(ensure_expr(expr))
+
+        for alias, expr in named_exprs.items():
+            e = self.parse_sql_expr(expr) if isinstance(expr, str) else expr
+            ensure_expr(e)
+            expressions.append(e.alias(alias).expr)
+
+        return DataFrame(self.df.with_columns(expressions))
+
+    def with_column_renamed(self, old_name: str, new_name: str) -> DataFrame:
+        r"""Rename one column by applying a new projection.
+
+        This is a no-op if the column to be renamed does not exist.
+
+        The method supports case sensitive rename with wrapping column name
+        into one the following symbols (" or ' or \`).
+
+        Args:
+            old_name: Old column name.
+            new_name: New column name.
+
+        Returns:
+            DataFrame with the column renamed.
+        """
+        return DataFrame(self.df.with_column_renamed(old_name, new_name))
+
+    def aggregate(
+        self,
+        group_by: Sequence[Expr | str] | Expr | str,
+        aggs: Sequence[Expr] | Expr,
+    ) -> DataFrame:
+        """Aggregates the rows of the current DataFrame.
+
+        Args:
+            group_by: Sequence of expressions or column names to group by.
+            aggs: Sequence of expressions to aggregate.
+
+        Returns:
+            DataFrame after aggregation.
+        """
+        group_by_list = (
+            list(group_by)
+            if isinstance(group_by, Sequence) and not isinstance(group_by, Expr | str)
+            else [group_by]
+        )
+        aggs_list = (
+            list(aggs)
+            if isinstance(aggs, Sequence) and not isinstance(aggs, Expr)
+            else [aggs]
+        )
+
+        group_by_exprs = expr_list_to_raw_expr_list(group_by_list)
+        aggs_exprs = ensure_expr_list(aggs_list)
+        return DataFrame(self.df.aggregate(group_by_exprs, aggs_exprs))
+
+    def sort(self, *exprs: SortKey) -> DataFrame:
+        """Sort the DataFrame by the specified sorting expressions or column names.
+
+        Note that any expression can be turned into a sort expression by
+        calling its ``sort`` method.
+
+        Args:
+            exprs: Sort expressions or column names, applied in order.
+
+        Returns:
+            DataFrame after sorting.
+        """
+        exprs_raw = sort_list_to_raw_sort_list(exprs)
+        return DataFrame(self.df.sort(*exprs_raw))
+
+    def cast(self, mapping: dict[str, pa.DataType[Any]]) -> DataFrame:
+        """Cast one or more columns to a different data type.
+
+        Args:
+            mapping: Mapped with column as key and column dtype as value.
+
+        Returns:
+            DataFrame after casting columns
+        """
+        exprs = [Expr.column(col).cast(dtype) for col, dtype in mapping.items()]
+        return self.with_columns(exprs)
+
+    def limit(self, count: int, offset: int = 0) -> DataFrame:
+        """Return a new :py:class:`DataFrame` with a limited number of rows.
+
+        Args:
+            count: Number of rows to limit the DataFrame to.
+            offset: Number of rows to skip.
+
+        Returns:
+            DataFrame after limiting.
+        """
+        return DataFrame(self.df.limit(count, offset))
+
+    def head(self, n: int = 5) -> DataFrame:
+        """Return a new :py:class:`DataFrame` with a limited number of rows.
+
+        Args:
+            n: Number of rows to take from the head of the DataFrame.
+
+        Returns:
+            DataFrame after limiting.
+        """
+        return DataFrame(self.df.limit(n, 0))
+
+    def tail(self, n: int = 5) -> DataFrame:
+        """Return a new :py:class:`DataFrame` with a limited number of rows.
+
+        Be aware this could be potentially expensive since the row size needs to be
+        determined of the dataframe. This is done by collecting it.
+
+        Args:
+            n: Number of rows to take from the tail of the DataFrame.
+
+        Returns:
+            DataFrame after limiting.
+        """
+        return DataFrame(self.df.limit(n, max(0, self.count() - n)))
+
+    def collect(self) -> list[pa.RecordBatch]:
+        """Execute this :py:class:`DataFrame` and collect results into memory.
+
+        Prior to calling ``collect``, modifying a DataFrame simply updates a plan
+        (no actual computation is performed). Calling ``collect`` triggers the
+        computation.
+
+        Returns:
+            List of :py:class:`pyarrow.RecordBatch` collected from the DataFrame.
+        """
+        return self.df.collect()
+
+    def collect_column(self, column_name: str) -> pa.Array | pa.ChunkedArray:
+        """Executes this :py:class:`DataFrame` for a single column."""
+        return self.df.collect_column(column_name)
+
+    def cache(self) -> DataFrame:
+        """Cache the DataFrame as a memory table.
+
+        Returns:
+            Cached DataFrame.
+        """
+        return DataFrame(self.df.cache())
+
+    def collect_partitioned(self) -> list[list[pa.RecordBatch]]:
+        """Execute this DataFrame and collect all partitioned results.
+
+        This operation returns :py:class:`pyarrow.RecordBatch` maintaining the input
+        partitioning.
+
+        Returns:
+            List of list of :py:class:`RecordBatch` collected from the
+                DataFrame.
+        """
+        return self.df.collect_partitioned()
+
+    def show(self, num: int = 20) -> None:
+        """Execute the DataFrame and print the result to the console.
+
+        Args:
+            num: Number of lines to show.
+        """
+        self.df.show(num)
+
+    def distinct(self) -> DataFrame:
+        """Return a new :py:class:`DataFrame` with all duplicated rows removed.
+
+        Returns:
+            DataFrame after removing duplicates.
+        """
+        return DataFrame(self.df.distinct())
+
+    @overload
+    def join(
+        self,
+        right: DataFrame,
+        on: str | Sequence[str],
+        how: Literal["inner", "left", "right", "full", "semi", "anti"] = "inner",
+        *,
+        left_on: None = None,
+        right_on: None = None,
+        join_keys: None = None,
+        coalesce_duplicate_keys: bool = True,
+    ) -> DataFrame: ...
+
+    @overload
+    def join(
+        self,
+        right: DataFrame,
+        on: None = None,
+        how: Literal["inner", "left", "right", "full", "semi", "anti"] = "inner",
+        *,
+        left_on: str | Sequence[str],
+        right_on: str | Sequence[str],
+        join_keys: tuple[list[str], list[str]] | None = None,
+        coalesce_duplicate_keys: bool = True,
+    ) -> DataFrame: ...
+
+    @overload
+    def join(
+        self,
+        right: DataFrame,
+        on: None = None,
+        how: Literal["inner", "left", "right", "full", "semi", "anti"] = "inner",
+        *,
+        join_keys: tuple[list[str], list[str]],
+        left_on: None = None,
+        right_on: None = None,
+        coalesce_duplicate_keys: bool = True,
+    ) -> DataFrame: ...
+
+    def join(
+        self,
+        right: DataFrame,
+        on: str | Sequence[str] | tuple[list[str], list[str]] | None = None,
+        how: Literal["inner", "left", "right", "full", "semi", "anti"] = "inner",
+        *,
+        left_on: str | Sequence[str] | None = None,
+        right_on: str | Sequence[str] | None = None,
+        join_keys: tuple[list[str], list[str]] | None = None,
+        coalesce_duplicate_keys: bool = True,
+    ) -> DataFrame:
+        """Join this :py:class:`DataFrame` with another :py:class:`DataFrame`.
+
+        `on` has to be provided or both `left_on` and `right_on` in conjunction.
+
+        Args:
+            right: Other DataFrame to join with.
+            on: Column names to join on in both dataframes.
+            how: Type of join to perform. Supported types are "inner", "left",
+                "right", "full", "semi", "anti".
+            left_on: Join column of the left dataframe.
+            right_on: Join column of the right dataframe.
+            coalesce_duplicate_keys: When True, coalesce the columns
+                from the right DataFrame and left DataFrame
+                that have identical names in the ``on`` fields.
+            join_keys: Tuple of two lists of column names to join on. [Deprecated]
+
+        Returns:
+            DataFrame after join.
+        """
+        if join_keys is not None:
+            warnings.warn(
+                "`join_keys` is deprecated, use `on` or `left_on` with `right_on`",
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
+            left_on = join_keys[0]
+            right_on = join_keys[1]
+
+        # This check is to prevent breaking API changes where users prior to
+        # DF 43.0.0 would  pass the join_keys as a positional argument instead
+        # of a keyword argument.
+        if (
+            isinstance(on, tuple)
+            and len(on) == 2  # noqa: PLR2004
+            and isinstance(on[0], list)
+            and isinstance(on[1], list)
+        ):
+            # We know this is safe because we've checked the types
+            left_on = on[0]
+            right_on = on[1]
+            on = None
+
+        if on is not None:
+            if left_on is not None or right_on is not None:
+                error_msg = "`left_on` or `right_on` should not provided with `on`"
+                raise ValueError(error_msg)
+            left_on = on
+            right_on = on
+        elif left_on is not None or right_on is not None:
+            if left_on is None or right_on is None:
+                error_msg = "`left_on` and `right_on` should both be provided."
+                raise ValueError(error_msg)
+        else:
+            error_msg = "either `on` or `left_on` and `right_on` should be provided."
+            raise ValueError(error_msg)
+        if isinstance(left_on, str):
+            left_on = [left_on]
+        if isinstance(right_on, str):
+            right_on = [right_on]
+
+        return DataFrame(
+            self.df.join(right.df, how, left_on, right_on, coalesce_duplicate_keys)
+        )
+
+    def join_on(
+        self,
+        right: DataFrame,
+        *on_exprs: Expr,
+        how: Literal["inner", "left", "right", "full", "semi", "anti"] = "inner",
+    ) -> DataFrame:
+        """Join two :py:class:`DataFrame` using the specified expressions.
+
+        Join predicates must be :class:`~datafusion.expr.Expr` objects, typically
+        built with :func:`datafusion.col`. On expressions are used to support
+        in-equality predicates. Equality predicates are correctly optimized.
+
+        Example::
+
+            from datafusion import col
+            df.join_on(other_df, col("id") == col("other_id"))
+
+        Args:
+            right: Other DataFrame to join with.
+            on_exprs: single or multiple (in)-equality predicates.
+            how: Type of join to perform. Supported types are "inner", "left",
+                "right", "full", "semi", "anti".
+
+        Returns:
+            DataFrame after join.
+        """
+        exprs = [ensure_expr(expr) for expr in on_exprs]
+        return DataFrame(self.df.join_on(right.df, exprs, how))
+
+    def explain(self, verbose: bool = False, analyze: bool = False) -> None:
+        """Print an explanation of the DataFrame's plan so far.
+
+        If ``analyze`` is specified, runs the plan and reports metrics.
+
+        Args:
+            verbose: If ``True``, more details will be included.
+            analyze: If ``True``, the plan will run and metrics reported.
+        """
+        self.df.explain(verbose, analyze)
+
+    def logical_plan(self) -> LogicalPlan:
+        """Return the unoptimized ``LogicalPlan``.
+
+        Returns:
+            Unoptimized logical plan.
+        """
+        return LogicalPlan(self.df.logical_plan())
+
+    def optimized_logical_plan(self) -> LogicalPlan:
+        """Return the optimized ``LogicalPlan``.
+
+        Returns:
+            Optimized logical plan.
+        """
+        return LogicalPlan(self.df.optimized_logical_plan())
+
+    def execution_plan(self) -> ExecutionPlan:
+        """Return the execution/physical plan.
+
+        Returns:
+            Execution plan.
+        """
+        return ExecutionPlan(self.df.execution_plan())
+
+    def repartition(self, num: int) -> DataFrame:
+        """Repartition a DataFrame into ``num`` partitions.
+
+        The batches allocation uses a round-robin algorithm.
+
+        Args:
+            num: Number of partitions to repartition the DataFrame into.
+
+        Returns:
+            Repartitioned DataFrame.
+        """
+        return DataFrame(self.df.repartition(num))
+
+    def repartition_by_hash(self, *exprs: Expr | str, num: int) -> DataFrame:
+        """Repartition a DataFrame using a hash partitioning scheme.
+
+        Args:
+            exprs: Expressions or a SQL expression string to evaluate
+                   and perform hashing on.
+            num: Number of partitions to repartition the DataFrame into.
+
+        Returns:
+            Repartitioned DataFrame.
+        """
+        exprs = [self.parse_sql_expr(e) if isinstance(e, str) else e for e in exprs]
+        exprs = expr_list_to_raw_expr_list(exprs)
+
+        return DataFrame(self.df.repartition_by_hash(*exprs, num=num))
+
+    def union(self, other: DataFrame, distinct: bool = False) -> DataFrame:
+        """Calculate the union of two :py:class:`DataFrame`.
+
+        The two :py:class:`DataFrame` must have exactly the same schema.
+
+        Args:
+            other: DataFrame to union with.
+            distinct: If ``True``, duplicate rows will be removed.
+
+        Returns:
+            DataFrame after union.
+        """
+        return DataFrame(self.df.union(other.df, distinct))
+
+    def union_distinct(self, other: DataFrame) -> DataFrame:
+        """Calculate the distinct union of two :py:class:`DataFrame`.
+
+        The two :py:class:`DataFrame` must have exactly the same schema.
+        Any duplicate rows are discarded.
+
+        Args:
+            other: DataFrame to union with.
+
+        Returns:
+            DataFrame after union.
+        """
+        return DataFrame(self.df.union_distinct(other.df))
+
+    def intersect(self, other: DataFrame) -> DataFrame:
+        """Calculate the intersection of two :py:class:`DataFrame`.
+
+        The two :py:class:`DataFrame` must have exactly the same schema.
+
+        Args:
+            other:  DataFrame to intersect with.
+
+        Returns:
+            DataFrame after intersection.
+        """
+        return DataFrame(self.df.intersect(other.df))
+
+    def except_all(self, other: DataFrame) -> DataFrame:
+        """Calculate the exception of two :py:class:`DataFrame`.
+
+        The two :py:class:`DataFrame` must have exactly the same schema.
+
+        Args:
+            other: DataFrame to calculate exception with.
+
+        Returns:
+            DataFrame after exception.
+        """
+        return DataFrame(self.df.except_all(other.df))
+
+    def write_csv(
+        self,
+        path: str | pathlib.Path,
+        with_header: bool = False,
+        write_options: DataFrameWriteOptions | None = None,
+    ) -> None:
+        """Execute the :py:class:`DataFrame`  and write the results to a CSV file.
+
+        Args:
+            path: Path of the CSV file to write.
+            with_header: If true, output the CSV header row.
+            write_options: Options that impact how the DataFrame is written.
+        """
+        raw_write_options = (
+            write_options._raw_write_options if write_options is not None else None
+        )
+        self.df.write_csv(str(path), with_header, raw_write_options)
+
+    @overload
+    def write_parquet(
+        self,
+        path: str | pathlib.Path,
+        compression: str,
+        compression_level: int | None = None,
+        write_options: DataFrameWriteOptions | None = None,
+    ) -> None: ...
+
+    @overload
+    def write_parquet(
+        self,
+        path: str | pathlib.Path,
+        compression: Compression = Compression.ZSTD,
+        compression_level: int | None = None,
+        write_options: DataFrameWriteOptions | None = None,
+    ) -> None: ...
+
+    @overload
+    def write_parquet(
+        self,
+        path: str | pathlib.Path,
+        compression: ParquetWriterOptions,
+        compression_level: None = None,
+        write_options: DataFrameWriteOptions | None = None,
+    ) -> None: ...
+
+    def write_parquet(
+        self,
+        path: str | pathlib.Path,
+        compression: str | Compression | ParquetWriterOptions = Compression.ZSTD,
+        compression_level: int | None = None,
+        write_options: DataFrameWriteOptions | None = None,
+    ) -> None:
+        """Execute the :py:class:`DataFrame` and write the results to a Parquet file.
+
+        Available compression types are:
+
+        - "uncompressed": No compression.
+        - "snappy": Snappy compression.
+        - "gzip": Gzip compression.
+        - "brotli": Brotli compression.
+        - "lz4": LZ4 compression.
+        - "lz4_raw": LZ4_RAW compression.
+        - "zstd": Zstandard compression.
+
+        LZO compression is not yet implemented in arrow-rs and is therefore
+        excluded.
+
+        Args:
+            path: Path of the Parquet file to write.
+            compression: Compression type to use. Default is "ZSTD".
+            compression_level: Compression level to use. For ZSTD, the
+                recommended range is 1 to 22, with the default being 4. Higher levels
+                provide better compression but slower speed.
+            write_options: Options that impact how the DataFrame is written.
+        """
+        if isinstance(compression, ParquetWriterOptions):
+            if compression_level is not None:
+                msg = "compression_level should be None when using ParquetWriterOptions"
+                raise ValueError(msg)
+            self.write_parquet_with_options(path, compression)
+            return
+
+        if isinstance(compression, str):
+            compression = Compression.from_str(compression)
+
+        if (
+            compression in {Compression.GZIP, Compression.BROTLI, Compression.ZSTD}
+            and compression_level is None
+        ):
+            compression_level = compression.get_default_level()
+
+        raw_write_options = (
+            write_options._raw_write_options if write_options is not None else None
+        )
+        self.df.write_parquet(
+            str(path),
+            compression.value,
+            compression_level,
+            raw_write_options,
+        )
+
+    def write_parquet_with_options(
+        self,
+        path: str | pathlib.Path,
+        options: ParquetWriterOptions,
+        write_options: DataFrameWriteOptions | None = None,
+    ) -> None:
+        """Execute the :py:class:`DataFrame` and write the results to a Parquet file.
+
+        Allows advanced writer options to be set with `ParquetWriterOptions`.
+
+        Args:
+            path: Path of the Parquet file to write.
+            options: Sets the writer parquet options (see `ParquetWriterOptions`).
+            write_options: Options that impact how the DataFrame is written.
+        """
+        options_internal = ParquetWriterOptionsInternal(
+            options.data_pagesize_limit,
+            options.write_batch_size,
+            options.writer_version,
+            options.skip_arrow_metadata,
+            options.compression,
+            options.dictionary_enabled,
+            options.dictionary_page_size_limit,
+            options.statistics_enabled,
+            options.max_row_group_size,
+            options.created_by,
+            options.column_index_truncate_length,
+            options.statistics_truncate_length,
+            options.data_page_row_count_limit,
+            options.encoding,
+            options.bloom_filter_on_write,
+            options.bloom_filter_fpp,
+            options.bloom_filter_ndv,
+            options.allow_single_file_parallelism,
+            options.maximum_parallel_row_group_writers,
+            options.maximum_buffered_record_batches_per_stream,
+        )
+
+        column_specific_options_internal = {}
+        for column, opts in (options.column_specific_options or {}).items():
+            column_specific_options_internal[column] = ParquetColumnOptionsInternal(
+                bloom_filter_enabled=opts.bloom_filter_enabled,
+                encoding=opts.encoding,
+                dictionary_enabled=opts.dictionary_enabled,
+                compression=opts.compression,
+                statistics_enabled=opts.statistics_enabled,
+                bloom_filter_fpp=opts.bloom_filter_fpp,
+                bloom_filter_ndv=opts.bloom_filter_ndv,
+            )
+
+        raw_write_options = (
+            write_options._raw_write_options if write_options is not None else None
+        )
+        self.df.write_parquet_with_options(
+            str(path),
+            options_internal,
+            column_specific_options_internal,
+            raw_write_options,
+        )
+
+    def write_json(
+        self,
+        path: str | pathlib.Path,
+        write_options: DataFrameWriteOptions | None = None,
+    ) -> None:
+        """Execute the :py:class:`DataFrame` and write the results to a JSON file.
+
+        Args:
+            path: Path of the JSON file to write.
+            write_options: Options that impact how the DataFrame is written.
+        """
+        raw_write_options = (
+            write_options._raw_write_options if write_options is not None else None
+        )
+        self.df.write_json(str(path), write_options=raw_write_options)
+
+    def write_table(
+        self, table_name: str, write_options: DataFrameWriteOptions | None = None
+    ) -> None:
+        """Execute the :py:class:`DataFrame` and write the results to a table.
+
+        The table must be registered with the session to perform this operation.
+        Not all table providers support writing operations. See the individual
+        implementations for details.
+        """
+        raw_write_options = (
+            write_options._raw_write_options if write_options is not None else None
+        )
+        self.df.write_table(table_name, raw_write_options)
+
+    def to_arrow_table(self) -> pa.Table:
+        """Execute the :py:class:`DataFrame` and convert it into an Arrow Table.
+
+        Returns:
+            Arrow Table.
+        """
+        return self.df.to_arrow_table()
+
+    def execute_stream(self) -> RecordBatchStream:
+        """Executes this DataFrame and returns a stream over a single partition.
+
+        Returns:
+            Record Batch Stream over a single partition.
+        """
+        return RecordBatchStream(self.df.execute_stream())
+
+    def execute_stream_partitioned(self) -> list[RecordBatchStream]:
+        """Executes this DataFrame and returns a stream for each partition.
+
+        Returns:
+            One record batch stream per partition.
+        """
+        streams = self.df.execute_stream_partitioned()
+        return [RecordBatchStream(rbs) for rbs in streams]
+
+    def to_pandas(self) -> pd.DataFrame:
+        """Execute the :py:class:`DataFrame` and convert it into a Pandas DataFrame.
+
+        Returns:
+            Pandas DataFrame.
+        """
+        return self.df.to_pandas()
+
+    def to_pylist(self) -> list[dict[str, Any]]:
+        """Execute the :py:class:`DataFrame` and convert it into a list of dictionaries.
+
+        Returns:
+            List of dictionaries.
+        """
+        return self.df.to_pylist()
+
+    def to_pydict(self) -> dict[str, list[Any]]:
+        """Execute the :py:class:`DataFrame` and convert it into a dictionary of lists.
+
+        Returns:
+            Dictionary of lists.
+        """
+        return self.df.to_pydict()
+
+    def to_polars(self) -> pl.DataFrame:
+        """Execute the :py:class:`DataFrame` and convert it into a Polars DataFrame.
+
+        Returns:
+            Polars DataFrame.
+        """
+        return self.df.to_polars()
+
+    def count(self) -> int:
+        """Return the total number of rows in this :py:class:`DataFrame`.
+
+        Note that this method will actually run a plan to calculate the
+        count, which may be slow for large or complicated DataFrames.
+
+        Returns:
+            Number of rows in the DataFrame.
+        """
+        return self.df.count()
+
+    @deprecated("Use :py:func:`unnest_columns` instead.")
+    def unnest_column(self, column: str, preserve_nulls: bool = True) -> DataFrame:
+        """See :py:func:`unnest_columns`."""
+        return DataFrame(self.df.unnest_column(column, preserve_nulls=preserve_nulls))
+
+    def unnest_columns(self, *columns: str, preserve_nulls: bool = True) -> DataFrame:
+        """Expand columns of arrays into a single row per array element.
+
+        Args:
+            columns: Column names to perform unnest operation on.
+            preserve_nulls: If False, rows with null entries will not be
+                returned.
+
+        Returns:
+            A DataFrame with the columns expanded.
+        """
+        columns = list(columns)
+        return DataFrame(self.df.unnest_columns(columns, preserve_nulls=preserve_nulls))
+
+    def __arrow_c_stream__(self, requested_schema: object | None = None) -> object:
+        """Export the DataFrame as an Arrow C Stream.
+
+        The DataFrame is executed using DataFusion's streaming APIs and exposed via
+        Arrow's C Stream interface. Record batches are produced incrementally, so the
+        full result set is never materialized in memory.
+
+        When ``requested_schema`` is provided, DataFusion applies only simple
+        projections such as selecting a subset of existing columns or reordering
+        them. Column renaming, computed expressions, or type coercion are not
+        supported through this interface.
+
+        Args:
+            requested_schema: Either a :py:class:`pyarrow.Schema` or an Arrow C
+                Schema capsule (``PyCapsule``) produced by
+                ``schema._export_to_c_capsule()``. The DataFrame will attempt to
+                align its output with the fields and order specified by this schema.
+
+        Returns:
+            Arrow ``PyCapsule`` object representing an ``ArrowArrayStream``.
+
+        For practical usage patterns, see the Apache Arrow streaming
+        documentation: https://arrow.apache.org/docs/python/ipc.html#streaming.
+
+        For details on DataFusion's Arrow integration and DataFrame streaming,
+        see the user guide (user-guide/io/arrow and user-guide/dataframe/index).
+
+        Notes:
+            The Arrow C Data Interface PyCapsule details are documented by Apache
+            Arrow and can be found at:
+            https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html
+        """
+        # ``DataFrame.__arrow_c_stream__`` in the Rust extension leverages
+        # ``execute_stream_partitioned`` under the hood to stream batches while
+        # preserving the original partition order.
+        return self.df.__arrow_c_stream__(requested_schema)
+
+    def __iter__(self) -> Iterator[RecordBatch]:
+        """Return an iterator over this DataFrame's record batches."""
+        return iter(self.execute_stream())
+
+    def __aiter__(self) -> AsyncIterator[RecordBatch]:
+        """Return an async iterator over this DataFrame's record batches.
+
+        We're using __aiter__ because we support Python < 3.10 where aiter() is not
+        available.
+        """
+        return self.execute_stream().__aiter__()
+
+    def transform(self, func: Callable[..., DataFrame], *args: Any) -> DataFrame:
+        """Apply a function to the current DataFrame which returns another DataFrame.
+
+        This is useful for chaining together multiple functions. For example::
+
+            def add_3(df: DataFrame) -> DataFrame:
+                return df.with_column("modified", lit(3))
+
+            def within_limit(df: DataFrame, limit: int) -> DataFrame:
+                return df.filter(col("a") < lit(limit)).distinct()
+
+            df = df.transform(modify_df).transform(within_limit, 4)
+
+        Args:
+            func: A callable function that takes a DataFrame as it's first argument
+            args: Zero or more arguments to pass to `func`
+
+        Returns:
+            DataFrame: After applying func to the original dataframe.
+        """
+        return func(self, *args)
+
+    def fill_null(self, value: Any, subset: list[str] | None = None) -> DataFrame:
+        """Fill null values in specified columns with a value.
+
+        Args:
+            value: Value to replace nulls with. Will be cast to match column type.
+            subset: Optional list of column names to fill. If None, fills all columns.
+
+        Returns:
+            DataFrame with null values replaced where type casting is possible
+
+        Examples:
+            >>> from datafusion import SessionContext, col
+            >>> ctx = SessionContext()
+            >>> df = ctx.from_pydict({"a": [1, None, 3], "b": [None, 5, 6]})
+            >>> filled = df.fill_null(0)
+            >>> filled.sort(col("a")).collect()[0].column("a").to_pylist()
+            [0, 1, 3]
+
+        Notes:
+            - Only fills nulls in columns where the value can be cast to the column type
+            - For columns where casting fails, the original column is kept unchanged
+            - For columns not in subset, the original column is kept unchanged
+        """
+        return DataFrame(self.df.fill_null(value, subset))
+
+
+class InsertOp(Enum):
+    """Insert operation mode.
+
+    These modes are used by the table writing feature to define how record
+    batches should be written to a table.
+    """
+
+    APPEND = InsertOpInternal.APPEND
+    """Appends new rows to the existing table without modifying any existing rows."""
+
+    REPLACE = InsertOpInternal.REPLACE
+    """Replace existing rows that collide with the inserted rows.
+
+    Replacement is typically based on a unique key or primary key.
+    """
+
+    OVERWRITE = InsertOpInternal.OVERWRITE
+    """Overwrites all existing rows in the table with the new rows."""
+
+
+class DataFrameWriteOptions:
+    """Writer options for DataFrame.
+
+    There is no guarantee the table provider supports all writer options.
+    See the individual implementation and documentation for details.
+    """
+
+    def __init__(
+        self,
+        insert_operation: InsertOp | None = None,
+        single_file_output: bool = False,
+        partition_by: str | Sequence[str] | None = None,
+        sort_by: Expr | SortExpr | Sequence[Expr] | Sequence[SortExpr] | None = None,
+    ) -> None:
+        """Instantiate writer options for DataFrame."""
+        if isinstance(partition_by, str):
+            partition_by = [partition_by]
+
+        sort_by_raw = sort_list_to_raw_sort_list(sort_by)
+        insert_op = insert_operation.value if insert_operation is not None else None
+
+        self._raw_write_options = DataFrameWriteOptionsInternal(
+            insert_op, single_file_output, partition_by, sort_by_raw
+        )
diff --git a/python/datafusion/dataframe_formatter.py b/python/datafusion/dataframe_formatter.py
new file mode 100644
index 000000000..b8af45a1b
--- /dev/null
+++ b/python/datafusion/dataframe_formatter.py
@@ -0,0 +1,843 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+"""HTML formatting utilities for DataFusion DataFrames."""
+
+from __future__ import annotations
+
+import warnings
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Protocol,
+    runtime_checkable,
+)
+
+from datafusion._internal import DataFrame as DataFrameInternal
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+def _validate_positive_int(value: Any, param_name: str) -> None:
+    """Validate that a parameter is a positive integer.
+
+    Args:
+        value: The value to validate
+        param_name: Name of the parameter (used in error message)
+
+    Raises:
+        ValueError: If the value is not a positive integer
+    """
+    if not isinstance(value, int) or value <= 0:
+        msg = f"{param_name} must be a positive integer"
+        raise ValueError(msg)
+
+
+def _validate_bool(value: Any, param_name: str) -> None:
+    """Validate that a parameter is a boolean.
+
+    Args:
+        value: The value to validate
+        param_name: Name of the parameter (used in error message)
+
+    Raises:
+        TypeError: If the value is not a boolean
+    """
+    if not isinstance(value, bool):
+        msg = f"{param_name} must be a boolean"
+        raise TypeError(msg)
+
+
+def _validate_formatter_parameters(
+    max_cell_length: int,
+    max_width: int,
+    max_height: int,
+    max_memory_bytes: int,
+    min_rows: int,
+    max_rows: int | None,
+    repr_rows: int | None,
+    enable_cell_expansion: bool,
+    show_truncation_message: bool,
+    use_shared_styles: bool,
+    custom_css: str | None,
+    style_provider: Any,
+) -> int:
+    """Validate all formatter parameters and return resolved max_rows value.
+
+    Args:
+        max_cell_length: Maximum cell length value to validate
+        max_width: Maximum width value to validate
+        max_height: Maximum height value to validate
+        max_memory_bytes: Maximum memory bytes value to validate
+        min_rows: Minimum rows to display value to validate
+        max_rows: Maximum rows value to validate (None means use default)
+        repr_rows: Deprecated repr_rows value to validate
+        enable_cell_expansion: Boolean expansion flag to validate
+        show_truncation_message: Boolean message flag to validate
+        use_shared_styles: Boolean styles flag to validate
+        custom_css: Custom CSS string to validate
+        style_provider: Style provider object to validate
+
+    Returns:
+        The resolved max_rows value after handling repr_rows deprecation
+
+    Raises:
+        ValueError: If any numeric parameter is invalid or constraints are violated
+        TypeError: If any parameter has invalid type
+        DeprecationWarning: If repr_rows parameter is used
+    """
+    # Validate numeric parameters
+    _validate_positive_int(max_cell_length, "max_cell_length")
+    _validate_positive_int(max_width, "max_width")
+    _validate_positive_int(max_height, "max_height")
+    _validate_positive_int(max_memory_bytes, "max_memory_bytes")
+    _validate_positive_int(min_rows, "min_rows")
+
+    # Handle deprecated repr_rows parameter
+    if repr_rows is not None:
+        warnings.warn(
+            "repr_rows parameter is deprecated, use max_rows instead",
+            DeprecationWarning,
+            stacklevel=4,
+        )
+        _validate_positive_int(repr_rows, "repr_rows")
+        if max_rows is not None and repr_rows != max_rows:
+            msg = "Cannot specify both repr_rows and max_rows; use max_rows only"
+            raise ValueError(msg)
+        max_rows = repr_rows
+
+    # Use default if max_rows was not provided
+    if max_rows is None:
+        max_rows = 10
+
+    _validate_positive_int(max_rows, "max_rows")
+
+    # Validate constraint: min_rows <= max_rows
+    if min_rows > max_rows:
+        msg = "min_rows must be less than or equal to max_rows"
+        raise ValueError(msg)
+
+    # Validate boolean parameters
+    _validate_bool(enable_cell_expansion, "enable_cell_expansion")
+    _validate_bool(show_truncation_message, "show_truncation_message")
+    _validate_bool(use_shared_styles, "use_shared_styles")
+
+    # Validate custom_css
+    if custom_css is not None and not isinstance(custom_css, str):
+        msg = "custom_css must be None or a string"
+        raise TypeError(msg)
+
+    # Validate style_provider
+    if style_provider is not None and not isinstance(style_provider, StyleProvider):
+        msg = "style_provider must implement the StyleProvider protocol"
+        raise TypeError(msg)
+
+    return max_rows
+
+
+@runtime_checkable
+class CellFormatter(Protocol):
+    """Protocol for cell value formatters."""
+
+    def __call__(self, value: Any) -> str:
+        """Format a cell value to string representation."""
+        ...
+
+
+@runtime_checkable
+class StyleProvider(Protocol):
+    """Protocol for HTML style providers."""
+
+    def get_cell_style(self) -> str:
+        """Get the CSS style for table cells."""
+        ...
+
+    def get_header_style(self) -> str:
+        """Get the CSS style for header cells."""
+        ...
+
+
+class DefaultStyleProvider:
+    """Default implementation of StyleProvider."""
+
+    def get_cell_style(self) -> str:
+        """Get the CSS style for table cells.
+
+        Returns:
+            CSS style string
+        """
+        return (
+            "border: 1px solid black; padding: 8px; text-align: left; "
+            "white-space: nowrap;"
+        )
+
+    def get_header_style(self) -> str:
+        """Get the CSS style for header cells.
+
+        Returns:
+            CSS style string
+        """
+        return (
+            "border: 1px solid black; padding: 8px; text-align: left; "
+            "background-color: #f2f2f2; white-space: nowrap; min-width: fit-content; "
+            "max-width: fit-content;"
+        )
+
+
+class DataFrameHtmlFormatter:
+    """Configurable HTML formatter for DataFusion DataFrames.
+
+    This class handles the HTML rendering of DataFrames for display in
+    Jupyter notebooks and other rich display contexts.
+
+    This class supports extension through composition. Key extension points:
+    - Provide a custom StyleProvider for styling cells and headers
+    - Register custom formatters for specific types
+    - Provide custom cell builders for specialized cell rendering
+
+    Args:
+        max_cell_length: Maximum characters to display in a cell before truncation
+        max_width: Maximum width of the HTML table in pixels
+        max_height: Maximum height of the HTML table in pixels
+        max_memory_bytes: Maximum memory in bytes for rendered data (default: 2MB)
+        min_rows: Minimum number of rows to display (must be <= max_rows)
+        max_rows: Maximum number of rows to display in repr output
+        repr_rows: Deprecated alias for max_rows
+        enable_cell_expansion: Whether to add expand/collapse buttons for long cell
+          values
+        custom_css: Additional CSS to include in the HTML output
+        show_truncation_message: Whether to display a message when data is truncated
+        style_provider: Custom provider for cell and header styles
+        use_shared_styles: Whether to load styles and scripts only once per notebook
+          session
+    """
+
+    def __init__(
+        self,
+        max_cell_length: int = 25,
+        max_width: int = 1000,
+        max_height: int = 300,
+        max_memory_bytes: int = 2 * 1024 * 1024,  # 2 MB
+        min_rows: int = 10,
+        max_rows: int | None = None,
+        repr_rows: int | None = None,
+        enable_cell_expansion: bool = True,
+        custom_css: str | None = None,
+        show_truncation_message: bool = True,
+        style_provider: StyleProvider | None = None,
+        use_shared_styles: bool = True,
+    ) -> None:
+        """Initialize the HTML formatter.
+
+        Parameters
+        ----------
+        max_cell_length
+            Maximum length of cell content before truncation.
+        max_width
+            Maximum width of the displayed table in pixels.
+        max_height
+            Maximum height of the displayed table in pixels.
+        max_memory_bytes
+            Maximum memory in bytes for rendered data. Helps prevent performance
+            issues with large datasets.
+        min_rows
+            Minimum number of rows to display even if memory limit is reached.
+            Must not exceed ``max_rows``.
+        max_rows
+            Maximum number of rows to display. Takes precedence over memory limits
+            when fewer rows are requested.
+        repr_rows
+            Deprecated alias for ``max_rows``. Use ``max_rows`` instead.
+        enable_cell_expansion
+            Whether to allow cells to expand when clicked.
+        custom_css
+            Custom CSS to apply to the HTML table.
+        show_truncation_message
+            Whether to show a message indicating that content has been truncated.
+        style_provider
+            Provider of CSS styles for the HTML table. If None, DefaultStyleProvider
+            is used.
+        use_shared_styles
+            Whether to use shared styles across multiple tables. This improves
+            performance when displaying many DataFrames in a single notebook.
+
+        Raises:
+        ------
+        ValueError
+            If max_cell_length, max_width, max_height, max_memory_bytes,
+            min_rows or max_rows is not a positive integer, or if min_rows
+            exceeds max_rows.
+        TypeError
+            If enable_cell_expansion, show_truncation_message, or use_shared_styles is
+            not a boolean, or if custom_css is provided but is not a string, or if
+            style_provider is provided but does not implement the StyleProvider
+            protocol.
+        """
+        # Validate all parameters and get resolved max_rows
+        resolved_max_rows = _validate_formatter_parameters(
+            max_cell_length,
+            max_width,
+            max_height,
+            max_memory_bytes,
+            min_rows,
+            max_rows,
+            repr_rows,
+            enable_cell_expansion,
+            show_truncation_message,
+            use_shared_styles,
+            custom_css,
+            style_provider,
+        )
+
+        self.max_cell_length = max_cell_length
+        self.max_width = max_width
+        self.max_height = max_height
+        self.max_memory_bytes = max_memory_bytes
+        self.min_rows = min_rows
+        self._max_rows = resolved_max_rows
+        self.enable_cell_expansion = enable_cell_expansion
+        self.custom_css = custom_css
+        self.show_truncation_message = show_truncation_message
+        self.style_provider = style_provider or DefaultStyleProvider()
+        self.use_shared_styles = use_shared_styles
+        # Registry for custom type formatters
+        self._type_formatters: dict[type, CellFormatter] = {}
+        # Custom cell builders
+        self._custom_cell_builder: Callable[[Any, int, int, str], str] | None = None
+        self._custom_header_builder: Callable[[Any], str] | None = None
+
+    @property
+    def max_rows(self) -> int:
+        """Get the maximum number of rows to display.
+
+        Returns:
+            The maximum number of rows to display in repr output
+        """
+        return self._max_rows
+
+    @max_rows.setter
+    def max_rows(self, value: int) -> None:
+        """Set the maximum number of rows to display.
+
+        Args:
+            value: The maximum number of rows
+        """
+        self._max_rows = value
+
+    @property
+    def repr_rows(self) -> int:
+        """Get the maximum number of rows (deprecated name).
+
+        .. deprecated::
+            Use :attr:`max_rows` instead. This property is provided for
+            backward compatibility.
+
+        Returns:
+            The maximum number of rows to display
+        """
+        return self._max_rows
+
+    @repr_rows.setter
+    def repr_rows(self, value: int) -> None:
+        """Set the maximum number of rows using deprecated name.
+
+        .. deprecated::
+            Use :attr:`max_rows` setter instead. This property is provided for
+            backward compatibility.
+
+        Args:
+            value: The maximum number of rows
+        """
+        warnings.warn(
+            "repr_rows is deprecated, use max_rows instead",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        self._max_rows = value
+
+    def register_formatter(self, type_class: type, formatter: CellFormatter) -> None:
+        """Register a custom formatter for a specific data type.
+
+        Args:
+            type_class: The type to register a formatter for
+            formatter: Function that takes a value of the given type and returns
+                a formatted string
+        """
+        self._type_formatters[type_class] = formatter
+
+    def set_custom_cell_builder(
+        self, builder: Callable[[Any, int, int, str], str]
+    ) -> None:
+        """Set a custom cell builder function.
+
+        Args:
+            builder: Function that takes (value, row, col, table_id) and returns HTML
+        """
+        self._custom_cell_builder = builder
+
+    def set_custom_header_builder(self, builder: Callable[[Any], str]) -> None:
+        """Set a custom header builder function.
+
+        Args:
+            builder: Function that takes a field and returns HTML
+        """
+        self._custom_header_builder = builder
+
+    def format_html(
+        self,
+        batches: list,
+        schema: Any,
+        has_more: bool = False,
+        table_uuid: str | None = None,
+    ) -> str:
+        """Format record batches as HTML.
+
+        This method is used by DataFrame's _repr_html_ implementation and can be
+        called directly when custom HTML rendering is needed.
+
+        Args:
+            batches: List of Arrow RecordBatch objects
+            schema: Arrow Schema object
+            has_more: Whether there are more batches not shown
+            table_uuid: Unique ID for the table, used for JavaScript interactions
+
+        Returns:
+            HTML string representation of the data
+
+        Raises:
+            TypeError: If schema is invalid and no batches are provided
+        """
+        if not batches:
+            return "No data to display"
+
+        # Validate schema
+        if schema is None or not hasattr(schema, "__iter__"):
+            msg = "Schema must be provided"
+            raise TypeError(msg)
+
+        # Generate a unique ID if none provided
+        table_uuid = table_uuid or f"df-{id(batches)}"
+
+        # Build HTML components
+        html = []
+
+        html.extend(self._build_html_header())
+
+        html.extend(self._build_table_container_start())
+
+        # Add table header and body
+        html.extend(self._build_table_header(schema))
+        html.extend(self._build_table_body(batches, table_uuid))
+
+        html.append("</table>")
+        html.append("</div>")
+
+        # Add footer (JavaScript and messages)
+        if self.enable_cell_expansion:
+            html.append(self._get_javascript())
+
+        # Always add truncation message if needed (independent of styles)
+        if has_more and self.show_truncation_message:
+            html.append("<div>Data truncated due to size.</div>")
+
+        return "\n".join(html)
+
+    def format_str(
+        self,
+        batches: list,
+        schema: Any,
+        has_more: bool = False,
+        table_uuid: str | None = None,
+    ) -> str:
+        """Format record batches as a string.
+
+        This method is used by DataFrame's __repr__ implementation and can be
+        called directly when string rendering is needed.
+
+        Args:
+            batches: List of Arrow RecordBatch objects
+            schema: Arrow Schema object
+            has_more: Whether there are more batches not shown
+            table_uuid: Unique ID for the table, used for JavaScript interactions
+
+        Returns:
+            String representation of the data
+
+        Raises:
+            TypeError: If schema is invalid and no batches are provided
+        """
+        return DataFrameInternal.default_str_repr(batches, schema, has_more, table_uuid)
+
+    def _build_html_header(self) -> list[str]:
+        """Build the HTML header with CSS styles."""
+        default_css = self._get_default_css() if self.enable_cell_expansion else ""
+        script = f"""
+<script>
+if (!document.getElementById('df-styles')) {{
+  const style = document.createElement('style');
+  style.id = 'df-styles';
+  style.textContent = `{default_css}`;
+  document.head.appendChild(style);
+}}
+</script>
+"""
+        html = [script]
+        if self.custom_css:
+            html.append(f"<style>{self.custom_css}</style>")
+        return html
+
+    def _build_table_container_start(self) -> list[str]:
+        """Build the opening tags for the table container."""
+        html = []
+        html.append(
+            f'<div style="width: 100%; max-width: {self.max_width}px; '
+            f"max-height: {self.max_height}px; overflow: auto; border: "
+            '1px solid #ccc;">'
+        )
+        html.append('<table style="border-collapse: collapse">')
+        return html
+
+    def _build_table_header(self, schema: Any) -> list[str]:
+        """Build the HTML table header with column names."""
+        html = []
+        html.append("<thead>")
+        html.append("<tr>")
+        for field in schema:
+            if self._custom_header_builder:
+                html.append(self._custom_header_builder(field))
+            else:
+                html.append(
+                    f"<th style='{self.style_provider.get_header_style()}'>"
+                    f"{field.name}</th>"
+                )
+        html.append("</tr>")
+        html.append("</thead>")
+        return html
+
+    def _build_table_body(self, batches: list, table_uuid: str) -> list[str]:
+        """Build the HTML table body with data rows."""
+        html = []
+        html.append("<tbody>")
+
+        row_count = 0
+        for batch in batches:
+            for row_idx in range(batch.num_rows):
+                row_count += 1
+                html.append("<tr>")
+
+                for col_idx, column in enumerate(batch.columns):
+                    # Get the raw value from the column
+                    raw_value = self._get_cell_value(column, row_idx)
+
+                    # Always check for type formatters first to format the value
+                    formatted_value = self._format_cell_value(raw_value)
+
+                    # Then apply either custom cell builder or standard cell formatting
+                    if self._custom_cell_builder:
+                        # Pass both the raw value and formatted value to let the
+                        # builder decide
+                        cell_html = self._custom_cell_builder(
+                            raw_value, row_count, col_idx, table_uuid
+                        )
+                        html.append(cell_html)
+                    else:
+                        # Standard cell formatting with formatted value
+                        if (
+                            len(str(raw_value)) > self.max_cell_length
+                            and self.enable_cell_expansion
+                        ):
+                            cell_html = self._build_expandable_cell(
+                                formatted_value, row_count, col_idx, table_uuid
+                            )
+                        else:
+                            cell_html = self._build_regular_cell(formatted_value)
+                        html.append(cell_html)
+
+                html.append("</tr>")
+
+        html.append("</tbody>")
+        return html
+
+    def _get_cell_value(self, column: Any, row_idx: int) -> Any:
+        """Extract a cell value from a column.
+
+        Args:
+            column: Arrow array
+            row_idx: Row index
+
+        Returns:
+            The raw cell value
+        """
+        try:
+            value = column[row_idx]
+
+            if hasattr(value, "as_py"):
+                return value.as_py()
+        except (AttributeError, TypeError):
+            pass
+        else:
+            return value
+
+    def _format_cell_value(self, value: Any) -> str:
+        """Format a cell value for display.
+
+        Uses registered type formatters if available.
+
+        Args:
+            value: The cell value to format
+
+        Returns:
+            Formatted cell value as string
+        """
+        # Check for custom type formatters
+        for type_cls, formatter in self._type_formatters.items():
+            if isinstance(value, type_cls):
+                return formatter(value)
+
+        # If no formatter matched, return string representation
+        return str(value)
+
+    def _build_expandable_cell(
+        self, formatted_value: str, row_count: int, col_idx: int, table_uuid: str
+    ) -> str:
+        """Build an expandable cell for long content."""
+        short_value = str(formatted_value)[: self.max_cell_length]
+        return (
+            f"<td style='{self.style_provider.get_cell_style()}'>"
+            f"<div class='expandable-container'>"
+            "<span class='expandable' "
+            f"id='{table_uuid}-min-text-{row_count}-{col_idx}'>"
+            f"{short_value}</span>"
+            "<span class='full-text' "
+            f"id='{table_uuid}-full-text-{row_count}-{col_idx}'>"
+            f"{formatted_value}</span>"
+            f"<button class='expand-btn' "
+            f"onclick=\"toggleDataFrameCellText('{table_uuid}',{row_count},{col_idx})\">"
+            f"...</button>"
+            f"</div>"
+            f"</td>"
+        )
+
+    def _build_regular_cell(self, formatted_value: str) -> str:
+        """Build a regular table cell."""
+        return (
+            f"<td style='{self.style_provider.get_cell_style()}'>{formatted_value}</td>"
+        )
+
+    def _build_html_footer(self, has_more: bool) -> list[str]:
+        """Build the HTML footer with JavaScript and messages."""
+        html = []
+
+        # Add JavaScript for interactivity only if cell expansion is enabled
+        # and we're not using the shared styles approach
+        if self.enable_cell_expansion and not self.use_shared_styles:
+            html.append(self._get_javascript())
+
+        # Add truncation message if needed
+        if has_more and self.show_truncation_message:
+            html.append("<div>Data truncated due to size.</div>")
+
+        return html
+
+    def _get_default_css(self) -> str:
+        """Get default CSS styles for the HTML table."""
+        return """
+            .expandable-container {
+                display: inline-block;
+                max-width: 200px;
+            }
+            .expandable {
+                white-space: nowrap;
+                overflow: hidden;
+                text-overflow: ellipsis;
+                display: block;
+            }
+            .full-text {
+                display: none;
+                white-space: normal;
+            }
+            .expand-btn {
+                cursor: pointer;
+                color: blue;
+                text-decoration: underline;
+                border: none;
+                background: none;
+                font-size: inherit;
+                display: block;
+                margin-top: 5px;
+            }
+        """
+
+    def _get_javascript(self) -> str:
+        """Get JavaScript code for interactive elements."""
+        return """
+<script>
+if (!window.__df_formatter_js_loaded__) {
+  window.__df_formatter_js_loaded__ = true;
+  window.toggleDataFrameCellText = function (table_uuid, row, col) {
+    var shortText = document.getElementById(
+      table_uuid + "-min-text-" + row + "-" + col
+    );
+    var fullText = document.getElementById(
+      table_uuid + "-full-text-" + row + "-" + col
+    );
+    var button = event.target;
+
+    if (fullText.style.display === "none") {
+      shortText.style.display = "none";
+      fullText.style.display = "inline";
+      button.textContent = "(less)";
+    } else {
+      shortText.style.display = "inline";
+      fullText.style.display = "none";
+      button.textContent = "...";
+    }
+  };
+}
+</script>
+"""
+
+
+class FormatterManager:
+    """Manager class for the global DataFrame HTML formatter instance."""
+
+    _default_formatter: DataFrameHtmlFormatter = DataFrameHtmlFormatter()
+
+    @classmethod
+    def set_formatter(cls, formatter: DataFrameHtmlFormatter) -> None:
+        """Set the global DataFrame HTML formatter.
+
+        Args:
+            formatter: The formatter instance to use globally
+        """
+        cls._default_formatter = formatter
+        _refresh_formatter_reference()
+
+    @classmethod
+    def get_formatter(cls) -> DataFrameHtmlFormatter:
+        """Get the current global DataFrame HTML formatter.
+
+        Returns:
+            The global HTML formatter instance
+        """
+        return cls._default_formatter
+
+
+def get_formatter() -> DataFrameHtmlFormatter:
+    """Get the current global DataFrame HTML formatter.
+
+    This function is used by the DataFrame._repr_html_ implementation to access
+    the shared formatter instance. It can also be used directly when custom
+    HTML rendering is needed.
+
+    Returns:
+        The global HTML formatter instance
+
+    Example:
+        >>> from datafusion.html_formatter import get_formatter
+        >>> formatter = get_formatter()
+        >>> formatter.max_cell_length = 50  # Increase cell length
+    """
+    return FormatterManager.get_formatter()
+
+
+def set_formatter(formatter: DataFrameHtmlFormatter) -> None:
+    """Set the global DataFrame HTML formatter.
+
+    Args:
+        formatter: The formatter instance to use globally
+
+    Example:
+        >>> from datafusion.html_formatter import get_formatter, set_formatter
+        >>> custom_formatter = DataFrameHtmlFormatter(max_cell_length=100)
+        >>> set_formatter(custom_formatter)
+    """
+    FormatterManager.set_formatter(formatter)
+
+
+def configure_formatter(**kwargs: Any) -> None:
+    """Configure the global DataFrame HTML formatter.
+
+    This function creates a new formatter with the provided configuration
+    and sets it as the global formatter for all DataFrames.
+
+    Args:
+        **kwargs: Formatter configuration parameters like max_cell_length,
+                 max_width, max_height, enable_cell_expansion, etc.
+
+    Raises:
+        ValueError: If any invalid parameters are provided
+
+    Example:
+        >>> from datafusion.html_formatter import configure_formatter
+        >>> configure_formatter(
+        ...     max_cell_length=50,
+        ...     max_height=500,
+        ...     enable_cell_expansion=True,
+        ...     use_shared_styles=True
+        ... )
+    """
+    # Valid parameters accepted by DataFrameHtmlFormatter
+    valid_params = {
+        "max_cell_length",
+        "max_width",
+        "max_height",
+        "max_memory_bytes",
+        "min_rows",
+        "max_rows",
+        "repr_rows",
+        "enable_cell_expansion",
+        "custom_css",
+        "show_truncation_message",
+        "style_provider",
+        "use_shared_styles",
+    }
+
+    # Check for invalid parameters
+    invalid_params = set(kwargs) - valid_params
+    if invalid_params:
+        msg = (
+            f"Invalid formatter parameters: {', '.join(invalid_params)}. "
+            f"Valid parameters are: {', '.join(valid_params)}"
+        )
+        raise ValueError(msg)
+
+    # Create and set formatter with validated parameters
+    set_formatter(DataFrameHtmlFormatter(**kwargs))
+
+
+def reset_formatter() -> None:
+    """Reset the global DataFrame HTML formatter to default settings.
+
+    This function creates a new formatter with default configuration
+    and sets it as the global formatter for all DataFrames.
+
+    Example:
+        >>> from datafusion.html_formatter import reset_formatter
+        >>> reset_formatter()  # Reset formatter to default settings
+    """
+    formatter = DataFrameHtmlFormatter()
+    set_formatter(formatter)
+
+
+def _refresh_formatter_reference() -> None:
+    """Refresh formatter reference in any modules using it.
+
+    This helps ensure that changes to the formatter are reflected in existing
+    DataFrames that might be caching the formatter reference.
+    """
+    # This is a no-op but signals modules to refresh their reference
diff --git a/python/datafusion/expr.py b/python/datafusion/expr.py
new file mode 100644
index 000000000..5760b8948
--- /dev/null
+++ b/python/datafusion/expr.py
@@ -0,0 +1,1430 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""This module supports expressions, one of the core concepts in DataFusion.
+
+See :ref:`Expressions` in the online documentation for more details.
+"""
+
+# ruff: noqa: PLC0415
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
+from typing import TYPE_CHECKING, Any, ClassVar
+
+try:
+    from warnings import deprecated  # Python 3.13+
+except ImportError:
+    from typing_extensions import deprecated  # Python 3.12
+
+import pyarrow as pa
+
+from ._internal import expr as expr_internal
+from ._internal import functions as functions_internal
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from datafusion.common import (  # type: ignore[import]
+        DataTypeMap,
+        NullTreatment,
+        RexType,
+    )
+    from datafusion.plan import LogicalPlan
+
+
+# Standard error message for invalid expression types
+# Mention both alias forms of column and literal helpers
+EXPR_TYPE_ERROR = "Use col()/column() or lit()/literal() to construct expressions"
+
+# The following are imported from the internal representation. We may choose to
+# give these all proper wrappers, or to simply leave as is. These were added
+# in order to support passing the `test_imports` unit test.
+# Tim Saucer note: It is not clear to me what the use case is for exposing
+# these definitions to the end user.
+
+Alias = expr_internal.Alias
+Analyze = expr_internal.Analyze
+Aggregate = expr_internal.Aggregate
+AggregateFunction = expr_internal.AggregateFunction
+Between = expr_internal.Between
+BinaryExpr = expr_internal.BinaryExpr
+Case = expr_internal.Case
+Cast = expr_internal.Cast
+Column = expr_internal.Column
+CopyTo = expr_internal.CopyTo
+CreateCatalog = expr_internal.CreateCatalog
+CreateCatalogSchema = expr_internal.CreateCatalogSchema
+CreateExternalTable = expr_internal.CreateExternalTable
+CreateFunction = expr_internal.CreateFunction
+CreateFunctionBody = expr_internal.CreateFunctionBody
+CreateIndex = expr_internal.CreateIndex
+CreateMemoryTable = expr_internal.CreateMemoryTable
+CreateView = expr_internal.CreateView
+Deallocate = expr_internal.Deallocate
+DescribeTable = expr_internal.DescribeTable
+Distinct = expr_internal.Distinct
+DmlStatement = expr_internal.DmlStatement
+DropCatalogSchema = expr_internal.DropCatalogSchema
+DropFunction = expr_internal.DropFunction
+DropTable = expr_internal.DropTable
+DropView = expr_internal.DropView
+EmptyRelation = expr_internal.EmptyRelation
+Execute = expr_internal.Execute
+Exists = expr_internal.Exists
+Explain = expr_internal.Explain
+Extension = expr_internal.Extension
+FileType = expr_internal.FileType
+Filter = expr_internal.Filter
+GroupingSet = expr_internal.GroupingSet
+Join = expr_internal.Join
+ILike = expr_internal.ILike
+InList = expr_internal.InList
+InSubquery = expr_internal.InSubquery
+IsFalse = expr_internal.IsFalse
+IsNotTrue = expr_internal.IsNotTrue
+IsNull = expr_internal.IsNull
+IsTrue = expr_internal.IsTrue
+IsUnknown = expr_internal.IsUnknown
+IsNotFalse = expr_internal.IsNotFalse
+IsNotNull = expr_internal.IsNotNull
+IsNotUnknown = expr_internal.IsNotUnknown
+JoinConstraint = expr_internal.JoinConstraint
+JoinType = expr_internal.JoinType
+Like = expr_internal.Like
+Limit = expr_internal.Limit
+Literal = expr_internal.Literal
+Negative = expr_internal.Negative
+Not = expr_internal.Not
+OperateFunctionArg = expr_internal.OperateFunctionArg
+Partitioning = expr_internal.Partitioning
+Placeholder = expr_internal.Placeholder
+Prepare = expr_internal.Prepare
+Projection = expr_internal.Projection
+RecursiveQuery = expr_internal.RecursiveQuery
+Repartition = expr_internal.Repartition
+ScalarSubquery = expr_internal.ScalarSubquery
+ScalarVariable = expr_internal.ScalarVariable
+SetVariable = expr_internal.SetVariable
+SimilarTo = expr_internal.SimilarTo
+Sort = expr_internal.Sort
+Subquery = expr_internal.Subquery
+SubqueryAlias = expr_internal.SubqueryAlias
+TableScan = expr_internal.TableScan
+TransactionAccessMode = expr_internal.TransactionAccessMode
+TransactionConclusion = expr_internal.TransactionConclusion
+TransactionEnd = expr_internal.TransactionEnd
+TransactionIsolationLevel = expr_internal.TransactionIsolationLevel
+TransactionStart = expr_internal.TransactionStart
+TryCast = expr_internal.TryCast
+Union = expr_internal.Union
+Unnest = expr_internal.Unnest
+UnnestExpr = expr_internal.UnnestExpr
+Values = expr_internal.Values
+WindowExpr = expr_internal.WindowExpr
+
+__all__ = [
+    "EXPR_TYPE_ERROR",
+    "Aggregate",
+    "AggregateFunction",
+    "Alias",
+    "Analyze",
+    "Between",
+    "BinaryExpr",
+    "Case",
+    "CaseBuilder",
+    "Cast",
+    "Column",
+    "CopyTo",
+    "CreateCatalog",
+    "CreateCatalogSchema",
+    "CreateExternalTable",
+    "CreateFunction",
+    "CreateFunctionBody",
+    "CreateIndex",
+    "CreateMemoryTable",
+    "CreateView",
+    "Deallocate",
+    "DescribeTable",
+    "Distinct",
+    "DmlStatement",
+    "DropCatalogSchema",
+    "DropFunction",
+    "DropTable",
+    "DropView",
+    "EmptyRelation",
+    "Execute",
+    "Exists",
+    "Explain",
+    "Expr",
+    "Extension",
+    "FileType",
+    "Filter",
+    "GroupingSet",
+    "ILike",
+    "InList",
+    "InSubquery",
+    "IsFalse",
+    "IsNotFalse",
+    "IsNotNull",
+    "IsNotTrue",
+    "IsNotUnknown",
+    "IsNull",
+    "IsTrue",
+    "IsUnknown",
+    "Join",
+    "JoinConstraint",
+    "JoinType",
+    "Like",
+    "Limit",
+    "Literal",
+    "Literal",
+    "Negative",
+    "Not",
+    "OperateFunctionArg",
+    "Partitioning",
+    "Placeholder",
+    "Prepare",
+    "Projection",
+    "RecursiveQuery",
+    "Repartition",
+    "ScalarSubquery",
+    "ScalarVariable",
+    "SetVariable",
+    "SimilarTo",
+    "Sort",
+    "SortExpr",
+    "SortKey",
+    "Subquery",
+    "SubqueryAlias",
+    "TableScan",
+    "TransactionAccessMode",
+    "TransactionConclusion",
+    "TransactionEnd",
+    "TransactionIsolationLevel",
+    "TransactionStart",
+    "TryCast",
+    "Union",
+    "Unnest",
+    "UnnestExpr",
+    "Values",
+    "Window",
+    "WindowExpr",
+    "WindowFrame",
+    "WindowFrameBound",
+    "ensure_expr",
+    "ensure_expr_list",
+]
+
+
+def ensure_expr(value: Expr | Any) -> expr_internal.Expr:
+    """Return the internal expression from ``Expr`` or raise ``TypeError``.
+
+    This helper rejects plain strings and other non-:class:`Expr` values so
+    higher level APIs consistently require explicit :func:`~datafusion.col` or
+    :func:`~datafusion.lit` expressions.
+
+    Args:
+        value: Candidate expression or other object.
+
+    Returns:
+        The internal expression representation.
+
+    Raises:
+        TypeError: If ``value`` is not an instance of :class:`Expr`.
+    """
+    if not isinstance(value, Expr):
+        raise TypeError(EXPR_TYPE_ERROR)
+    return value.expr
+
+
+def ensure_expr_list(
+    exprs: Iterable[Expr | Iterable[Expr]],
+) -> list[expr_internal.Expr]:
+    """Flatten an iterable of expressions, validating each via ``ensure_expr``.
+
+    Args:
+        exprs: Possibly nested iterable containing expressions.
+
+    Returns:
+        A flat list of raw expressions.
+
+    Raises:
+        TypeError: If any item is not an instance of :class:`Expr`.
+    """
+
+    def _iter(
+        items: Iterable[Expr | Iterable[Expr]],
+    ) -> Iterable[expr_internal.Expr]:
+        for expr in items:
+            if isinstance(expr, Iterable) and not isinstance(
+                expr, Expr | str | bytes | bytearray
+            ):
+                # Treat string-like objects as atomic to surface standard errors
+                yield from _iter(expr)
+            else:
+                yield ensure_expr(expr)
+
+    return list(_iter(exprs))
+
+
+def _to_raw_expr(value: Expr | str) -> expr_internal.Expr:
+    """Convert a Python expression or column name to its raw variant.
+
+    Args:
+        value: Candidate expression or column name.
+
+    Returns:
+        The internal :class:`~datafusion._internal.expr.Expr` representation.
+
+    Raises:
+        TypeError: If ``value`` is neither an :class:`Expr` nor ``str``.
+    """
+    if isinstance(value, str):
+        return Expr.column(value).expr
+    if isinstance(value, Expr):
+        return value.expr
+    error = (
+        "Expected Expr or column name, found:"
+        f" {type(value).__name__}. {EXPR_TYPE_ERROR}."
+    )
+    raise TypeError(error)
+
+
+def expr_list_to_raw_expr_list(
+    expr_list: list[Expr] | Expr | None,
+) -> list[expr_internal.Expr] | None:
+    """Convert a sequence of expressions or column names to raw expressions."""
+    if isinstance(expr_list, Expr | str):
+        expr_list = [expr_list]
+    if expr_list is None:
+        return None
+    return [_to_raw_expr(e) for e in expr_list]
+
+
+def sort_or_default(e: Expr | SortExpr) -> expr_internal.SortExpr:
+    """Helper function to return a default Sort if an Expr is provided."""
+    if isinstance(e, SortExpr):
+        return e.raw_sort
+    return SortExpr(e, ascending=True, nulls_first=True).raw_sort
+
+
+def sort_list_to_raw_sort_list(
+    sort_list: Sequence[SortKey] | SortKey | None,
+) -> list[expr_internal.SortExpr] | None:
+    """Helper function to return an optional sort list to raw variant."""
+    if isinstance(sort_list, Expr | SortExpr | str):
+        sort_list = [sort_list]
+    if sort_list is None:
+        return None
+    raw_sort_list = []
+    for item in sort_list:
+        if isinstance(item, SortExpr):
+            raw_sort_list.append(sort_or_default(item))
+        else:
+            raw_expr = _to_raw_expr(item)  # may raise ``TypeError``
+            raw_sort_list.append(sort_or_default(Expr(raw_expr)))
+    return raw_sort_list
+
+
+class Expr:
+    """Expression object.
+
+    Expressions are one of the core concepts in DataFusion. See
+    :ref:`Expressions` in the online documentation for more information.
+    """
+
+    def __init__(self, expr: expr_internal.RawExpr) -> None:
+        """This constructor should not be called by the end user."""
+        self.expr = expr
+
+    def to_variant(self) -> Any:
+        """Convert this expression into a python object if possible."""
+        return self.expr.to_variant()
+
+    @deprecated(
+        "display_name() is deprecated. Use :py:meth:`~Expr.schema_name` instead"
+    )
+    def display_name(self) -> str:
+        """Returns the name of this expression as it should appear in a schema.
+
+        This name will not include any CAST expressions.
+        """
+        return self.schema_name()
+
+    def schema_name(self) -> str:
+        """Returns the name of this expression as it should appear in a schema.
+
+        This name will not include any CAST expressions.
+        """
+        return self.expr.schema_name()
+
+    def canonical_name(self) -> str:
+        """Returns a complete string representation of this expression."""
+        return self.expr.canonical_name()
+
+    def variant_name(self) -> str:
+        """Returns the name of the Expr variant.
+
+        Ex: ``IsNotNull``, ``Literal``, ``BinaryExpr``, etc
+        """
+        return self.expr.variant_name()
+
+    def __richcmp__(self, other: Expr, op: int) -> Expr:
+        """Comparison operator."""
+        return Expr(self.expr.__richcmp__(other.expr, op))
+
+    def __repr__(self) -> str:
+        """Generate a string representation of this expression."""
+        return self.expr.__repr__()
+
+    def __add__(self, rhs: Any) -> Expr:
+        """Addition operator.
+
+        Accepts either an expression or any valid PyArrow scalar literal value.
+        """
+        if not isinstance(rhs, Expr):
+            rhs = Expr.literal(rhs)
+        return Expr(self.expr.__add__(rhs.expr))
+
+    def __sub__(self, rhs: Any) -> Expr:
+        """Subtraction operator.
+
+        Accepts either an expression or any valid PyArrow scalar literal value.
+        """
+        if not isinstance(rhs, Expr):
+            rhs = Expr.literal(rhs)
+        return Expr(self.expr.__sub__(rhs.expr))
+
+    def __truediv__(self, rhs: Any) -> Expr:
+        """Division operator.
+
+        Accepts either an expression or any valid PyArrow scalar literal value.
+        """
+        if not isinstance(rhs, Expr):
+            rhs = Expr.literal(rhs)
+        return Expr(self.expr.__truediv__(rhs.expr))
+
+    def __mul__(self, rhs: Any) -> Expr:
+        """Multiplication operator.
+
+        Accepts either an expression or any valid PyArrow scalar literal value.
+        """
+        if not isinstance(rhs, Expr):
+            rhs = Expr.literal(rhs)
+        return Expr(self.expr.__mul__(rhs.expr))
+
+    def __mod__(self, rhs: Any) -> Expr:
+        """Modulo operator (%).
+
+        Accepts either an expression or any valid PyArrow scalar literal value.
+        """
+        if not isinstance(rhs, Expr):
+            rhs = Expr.literal(rhs)
+        return Expr(self.expr.__mod__(rhs.expr))
+
+    def __and__(self, rhs: Expr) -> Expr:
+        """Logical AND."""
+        if not isinstance(rhs, Expr):
+            rhs = Expr.literal(rhs)
+        return Expr(self.expr.__and__(rhs.expr))
+
+    def __or__(self, rhs: Expr) -> Expr:
+        """Logical OR."""
+        if not isinstance(rhs, Expr):
+            rhs = Expr.literal(rhs)
+        return Expr(self.expr.__or__(rhs.expr))
+
+    def __invert__(self) -> Expr:
+        """Binary not (~)."""
+        return Expr(self.expr.__invert__())
+
+    def __getitem__(self, key: str | int) -> Expr:
+        """Retrieve sub-object.
+
+        If ``key`` is a string, returns the subfield of the struct.
+        If ``key`` is an integer, retrieves the element in the array. Note that the
+        element index begins at ``0``, unlike
+        :py:func:`~datafusion.functions.array_element` which begins at ``1``.
+        If ``key`` is a slice, returns an array that contains a slice of the
+        original array. Similar to integer indexing, this follows Python convention
+        where the index begins at ``0`` unlike
+        :py:func:`~datafusion.functions.array_slice` which begins at ``1``.
+        """
+        if isinstance(key, int):
+            return Expr(
+                functions_internal.array_element(self.expr, Expr.literal(key + 1).expr)
+            )
+        if isinstance(key, slice):
+            if isinstance(key.start, int):
+                start = Expr.literal(key.start + 1).expr
+            elif isinstance(key.start, Expr):
+                start = (key.start + Expr.literal(1)).expr
+            else:
+                # Default start at the first element, index 1
+                start = Expr.literal(1).expr
+
+            if isinstance(key.stop, int):
+                stop = Expr.literal(key.stop).expr
+            else:
+                stop = key.stop.expr
+
+            if isinstance(key.step, int):
+                step = Expr.literal(key.step).expr
+            elif isinstance(key.step, Expr):
+                step = key.step.expr
+            else:
+                step = key.step
+
+            return Expr(functions_internal.array_slice(self.expr, start, stop, step))
+        return Expr(self.expr.__getitem__(key))
+
+    def __eq__(self, rhs: object) -> Expr:
+        """Equal to.
+
+        Accepts either an expression or any valid PyArrow scalar literal value.
+        """
+        if not isinstance(rhs, Expr):
+            rhs = Expr.literal(rhs)
+        return Expr(self.expr.__eq__(rhs.expr))
+
+    def __ne__(self, rhs: object) -> Expr:
+        """Not equal to.
+
+        Accepts either an expression or any valid PyArrow scalar literal value.
+        """
+        if not isinstance(rhs, Expr):
+            rhs = Expr.literal(rhs)
+        return Expr(self.expr.__ne__(rhs.expr))
+
+    def __ge__(self, rhs: Any) -> Expr:
+        """Greater than or equal to.
+
+        Accepts either an expression or any valid PyArrow scalar literal value.
+        """
+        if not isinstance(rhs, Expr):
+            rhs = Expr.literal(rhs)
+        return Expr(self.expr.__ge__(rhs.expr))
+
+    def __gt__(self, rhs: Any) -> Expr:
+        """Greater than.
+
+        Accepts either an expression or any valid PyArrow scalar literal value.
+        """
+        if not isinstance(rhs, Expr):
+            rhs = Expr.literal(rhs)
+        return Expr(self.expr.__gt__(rhs.expr))
+
+    def __le__(self, rhs: Any) -> Expr:
+        """Less than or equal to.
+
+        Accepts either an expression or any valid PyArrow scalar literal value.
+        """
+        if not isinstance(rhs, Expr):
+            rhs = Expr.literal(rhs)
+        return Expr(self.expr.__le__(rhs.expr))
+
+    def __lt__(self, rhs: Any) -> Expr:
+        """Less than.
+
+        Accepts either an expression or any valid PyArrow scalar literal value.
+        """
+        if not isinstance(rhs, Expr):
+            rhs = Expr.literal(rhs)
+        return Expr(self.expr.__lt__(rhs.expr))
+
+    __radd__ = __add__
+    __rand__ = __and__
+    __rmod__ = __mod__
+    __rmul__ = __mul__
+    __ror__ = __or__
+    __rsub__ = __sub__
+    __rtruediv__ = __truediv__
+
+    @staticmethod
+    def literal(value: Any) -> Expr:
+        """Creates a new expression representing a scalar value.
+
+        ``value`` must be a valid PyArrow scalar value or easily castable to one.
+        """
+        if isinstance(value, str):
+            value = pa.scalar(value, type=pa.string_view())
+        return Expr(expr_internal.RawExpr.literal(value))
+
+    @staticmethod
+    def literal_with_metadata(value: Any, metadata: dict[str, str]) -> Expr:
+        """Creates a new expression representing a scalar value with metadata.
+
+        Args:
+            value: A valid PyArrow scalar value or easily castable to one.
+            metadata: Metadata to attach to the expression.
+        """
+        if isinstance(value, str):
+            value = pa.scalar(value, type=pa.string_view())
+
+        return Expr(expr_internal.RawExpr.literal_with_metadata(value, metadata))
+
+    @staticmethod
+    def string_literal(value: str) -> Expr:
+        """Creates a new expression representing a UTF8 literal value.
+
+        It is different from `literal` because it is pa.string() instead of
+        pa.string_view()
+
+        This is needed for cases where DataFusion is expecting a UTF8 instead of
+        UTF8View literal, like in:
+        https://github.com/apache/datafusion/blob/86740bfd3d9831d6b7c1d0e1bf4a21d91598a0ac/datafusion/functions/src/core/arrow_cast.rs#L179
+        """
+        if isinstance(value, str):
+            value = pa.scalar(value, type=pa.string())
+            return Expr(expr_internal.RawExpr.literal(value))
+        return Expr.literal(value)
+
+    @staticmethod
+    def column(value: str) -> Expr:
+        """Creates a new expression representing a column."""
+        return Expr(expr_internal.RawExpr.column(value))
+
+    def alias(self, name: str, metadata: dict[str, str] | None = None) -> Expr:
+        """Assign a name to the expression.
+
+        Args:
+            name: The name to assign to the expression.
+            metadata: Optional metadata to attach to the expression.
+
+        Returns:
+            A new expression with the assigned name.
+        """
+        return Expr(self.expr.alias(name, metadata))
+
+    def sort(self, ascending: bool = True, nulls_first: bool = True) -> SortExpr:
+        """Creates a sort :py:class:`Expr` from an existing :py:class:`Expr`.
+
+        Args:
+            ascending: If true, sort in ascending order.
+            nulls_first: Return null values first.
+        """
+        return SortExpr(self, ascending=ascending, nulls_first=nulls_first)
+
+    def is_null(self) -> Expr:
+        """Returns ``True`` if this expression is null."""
+        return Expr(self.expr.is_null())
+
+    def is_not_null(self) -> Expr:
+        """Returns ``True`` if this expression is not null."""
+        return Expr(self.expr.is_not_null())
+
+    def fill_nan(self, value: Any | Expr | None = None) -> Expr:
+        """Fill NaN values with a provided value."""
+        if not isinstance(value, Expr):
+            value = Expr.literal(value)
+        return Expr(functions_internal.nanvl(self.expr, value.expr))
+
+    def fill_null(self, value: Any | Expr | None = None) -> Expr:
+        """Fill NULL values with a provided value."""
+        if not isinstance(value, Expr):
+            value = Expr.literal(value)
+        return Expr(functions_internal.nvl(self.expr, value.expr))
+
+    _to_pyarrow_types: ClassVar[dict[type, pa.DataType]] = {
+        float: pa.float64(),
+        int: pa.int64(),
+        str: pa.string(),
+        bool: pa.bool_(),
+    }
+
+    def cast(self, to: pa.DataType[Any] | type) -> Expr:
+        """Cast to a new data type."""
+        if not isinstance(to, pa.DataType):
+            try:
+                to = self._to_pyarrow_types[to]
+            except KeyError as err:
+                error_msg = "Expected instance of pyarrow.DataType or builtins.type"
+                raise TypeError(error_msg) from err
+
+        return Expr(self.expr.cast(to))
+
+    def between(self, low: Any, high: Any, negated: bool = False) -> Expr:
+        """Returns ``True`` if this expression is between a given range.
+
+        Args:
+            low: lower bound of the range (inclusive).
+            high: higher bound of the range (inclusive).
+            negated: negates whether the expression is between a given range
+        """
+        if not isinstance(low, Expr):
+            low = Expr.literal(low)
+
+        if not isinstance(high, Expr):
+            high = Expr.literal(high)
+
+        return Expr(self.expr.between(low.expr, high.expr, negated=negated))
+
+    def rex_type(self) -> RexType:
+        """Return the Rex Type of this expression.
+
+        A Rex (Row Expression) specifies a single row of data.That specification
+        could include user defined functions or types. RexType identifies the
+        row as one of the possible valid ``RexType``.
+        """
+        return self.expr.rex_type()
+
+    def types(self) -> DataTypeMap:
+        """Return the ``DataTypeMap``.
+
+        Returns:
+            DataTypeMap which represents the PythonType, Arrow DataType, and
+            SqlType Enum which this expression represents.
+        """
+        return self.expr.types()
+
+    def python_value(self) -> Any:
+        """Extracts the Expr value into `Any`.
+
+        This is only valid for literal expressions.
+
+        Returns:
+            Python object representing literal value of the expression.
+        """
+        return self.expr.python_value()
+
+    def rex_call_operands(self) -> list[Expr]:
+        """Return the operands of the expression based on it's variant type.
+
+        Row expressions, Rex(s), operate on the concept of operands. Different
+        variants of Expressions, Expr(s), store those operands in different
+        datastructures. This function examines the Expr variant and returns
+        the operands to the calling logic.
+        """
+        return [Expr(e) for e in self.expr.rex_call_operands()]
+
+    def rex_call_operator(self) -> str:
+        """Extracts the operator associated with a row expression type call."""
+        return self.expr.rex_call_operator()
+
+    def column_name(self, plan: LogicalPlan) -> str:
+        """Compute the output column name based on the provided logical plan."""
+        return self.expr.column_name(plan._raw_plan)
+
+    def order_by(self, *exprs: Expr | SortExpr) -> ExprFuncBuilder:
+        """Set the ordering for a window or aggregate function.
+
+        This function will create an :py:class:`ExprFuncBuilder` that can be used to
+        set parameters for either window or aggregate functions. If used on any other
+        type of expression, an error will be generated when ``build()`` is called.
+        """
+        return ExprFuncBuilder(self.expr.order_by([sort_or_default(e) for e in exprs]))
+
+    def filter(self, filter: Expr) -> ExprFuncBuilder:
+        """Filter an aggregate function.
+
+        This function will create an :py:class:`ExprFuncBuilder` that can be used to
+        set parameters for either window or aggregate functions. If used on any other
+        type of expression, an error will be generated when ``build()`` is called.
+        """
+        return ExprFuncBuilder(self.expr.filter(filter.expr))
+
+    def distinct(self) -> ExprFuncBuilder:
+        """Only evaluate distinct values for an aggregate function.
+
+        This function will create an :py:class:`ExprFuncBuilder` that can be used to
+        set parameters for either window or aggregate functions. If used on any other
+        type of expression, an error will be generated when ``build()`` is called.
+        """
+        return ExprFuncBuilder(self.expr.distinct())
+
+    def null_treatment(self, null_treatment: NullTreatment) -> ExprFuncBuilder:
+        """Set the treatment for ``null`` values for a window or aggregate function.
+
+        This function will create an :py:class:`ExprFuncBuilder` that can be used to
+        set parameters for either window or aggregate functions. If used on any other
+        type of expression, an error will be generated when ``build()`` is called.
+        """
+        return ExprFuncBuilder(self.expr.null_treatment(null_treatment.value))
+
+    def partition_by(self, *partition_by: Expr) -> ExprFuncBuilder:
+        """Set the partitioning for a window function.
+
+        This function will create an :py:class:`ExprFuncBuilder` that can be used to
+        set parameters for either window or aggregate functions. If used on any other
+        type of expression, an error will be generated when ``build()`` is called.
+        """
+        return ExprFuncBuilder(self.expr.partition_by([e.expr for e in partition_by]))
+
+    def window_frame(self, window_frame: WindowFrame) -> ExprFuncBuilder:
+        """Set the frame fora  window function.
+
+        This function will create an :py:class:`ExprFuncBuilder` that can be used to
+        set parameters for either window or aggregate functions. If used on any other
+        type of expression, an error will be generated when ``build()`` is called.
+        """
+        return ExprFuncBuilder(self.expr.window_frame(window_frame.window_frame))
+
+    def over(self, window: Window) -> Expr:
+        """Turn an aggregate function into a window function.
+
+        This function turns any aggregate function into a window function. With the
+        exception of ``partition_by``, how each of the parameters is used is determined
+        by the underlying aggregate function.
+
+        Args:
+            window: Window definition
+        """
+        partition_by_raw = expr_list_to_raw_expr_list(window._partition_by)
+        order_by_raw = window._order_by
+        window_frame_raw = (
+            window._window_frame.window_frame
+            if window._window_frame is not None
+            else None
+        )
+        null_treatment_raw = (
+            window._null_treatment.value if window._null_treatment is not None else None
+        )
+
+        return Expr(
+            self.expr.over(
+                partition_by=partition_by_raw,
+                order_by=order_by_raw,
+                window_frame=window_frame_raw,
+                null_treatment=null_treatment_raw,
+            )
+        )
+
+    def asin(self) -> Expr:
+        """Returns the arc sine or inverse sine of a number."""
+        from . import functions as F
+
+        return F.asin(self)
+
+    def array_pop_back(self) -> Expr:
+        """Returns the array without the last element."""
+        from . import functions as F
+
+        return F.array_pop_back(self)
+
+    def reverse(self) -> Expr:
+        """Reverse the string argument."""
+        from . import functions as F
+
+        return F.reverse(self)
+
+    def bit_length(self) -> Expr:
+        """Returns the number of bits in the string argument."""
+        from . import functions as F
+
+        return F.bit_length(self)
+
+    def array_length(self) -> Expr:
+        """Returns the length of the array."""
+        from . import functions as F
+
+        return F.array_length(self)
+
+    def array_ndims(self) -> Expr:
+        """Returns the number of dimensions of the array."""
+        from . import functions as F
+
+        return F.array_ndims(self)
+
+    def to_hex(self) -> Expr:
+        """Converts an integer to a hexadecimal string."""
+        from . import functions as F
+
+        return F.to_hex(self)
+
+    def array_dims(self) -> Expr:
+        """Returns an array of the array's dimensions."""
+        from . import functions as F
+
+        return F.array_dims(self)
+
+    def from_unixtime(self) -> Expr:
+        """Converts an integer to RFC3339 timestamp format string."""
+        from . import functions as F
+
+        return F.from_unixtime(self)
+
+    def array_empty(self) -> Expr:
+        """Returns a boolean indicating whether the array is empty."""
+        from . import functions as F
+
+        return F.array_empty(self)
+
+    def sin(self) -> Expr:
+        """Returns the sine of the argument."""
+        from . import functions as F
+
+        return F.sin(self)
+
+    def log10(self) -> Expr:
+        """Base 10 logarithm of the argument."""
+        from . import functions as F
+
+        return F.log10(self)
+
+    def initcap(self) -> Expr:
+        """Set the initial letter of each word to capital.
+
+        Converts the first letter of each word in ``string`` to uppercase and the
+        remaining characters to lowercase.
+        """
+        from . import functions as F
+
+        return F.initcap(self)
+
+    def list_distinct(self) -> Expr:
+        """Returns distinct values from the array after removing duplicates.
+
+        This is an alias for :py:func:`array_distinct`.
+        """
+        from . import functions as F
+
+        return F.list_distinct(self)
+
+    def iszero(self) -> Expr:
+        """Returns true if a given number is +0.0 or -0.0 otherwise returns false."""
+        from . import functions as F
+
+        return F.iszero(self)
+
+    def array_distinct(self) -> Expr:
+        """Returns distinct values from the array after removing duplicates."""
+        from . import functions as F
+
+        return F.array_distinct(self)
+
+    def arrow_typeof(self) -> Expr:
+        """Returns the Arrow type of the expression."""
+        from . import functions as F
+
+        return F.arrow_typeof(self)
+
+    def length(self) -> Expr:
+        """The number of characters in the ``string``."""
+        from . import functions as F
+
+        return F.length(self)
+
+    def lower(self) -> Expr:
+        """Converts a string to lowercase."""
+        from . import functions as F
+
+        return F.lower(self)
+
+    def acos(self) -> Expr:
+        """Returns the arc cosine or inverse cosine of a number.
+
+        Returns:
+        --------
+        Expr
+            A new expression representing the arc cosine of the input expression.
+        """
+        from . import functions as F
+
+        return F.acos(self)
+
+    def ascii(self) -> Expr:
+        """Returns the numeric code of the first character of the argument."""
+        from . import functions as F
+
+        return F.ascii(self)
+
+    def sha384(self) -> Expr:
+        """Computes the SHA-384 hash of a binary string."""
+        from . import functions as F
+
+        return F.sha384(self)
+
+    def isnan(self) -> Expr:
+        """Returns true if a given number is +NaN or -NaN otherwise returns false."""
+        from . import functions as F
+
+        return F.isnan(self)
+
+    def degrees(self) -> Expr:
+        """Converts the argument from radians to degrees."""
+        from . import functions as F
+
+        return F.degrees(self)
+
+    def cardinality(self) -> Expr:
+        """Returns the total number of elements in the array."""
+        from . import functions as F
+
+        return F.cardinality(self)
+
+    def sha224(self) -> Expr:
+        """Computes the SHA-224 hash of a binary string."""
+        from . import functions as F
+
+        return F.sha224(self)
+
+    def asinh(self) -> Expr:
+        """Returns inverse hyperbolic sine."""
+        from . import functions as F
+
+        return F.asinh(self)
+
+    def flatten(self) -> Expr:
+        """Flattens an array of arrays into a single array."""
+        from . import functions as F
+
+        return F.flatten(self)
+
+    def exp(self) -> Expr:
+        """Returns the exponential of the argument."""
+        from . import functions as F
+
+        return F.exp(self)
+
+    def abs(self) -> Expr:
+        """Return the absolute value of a given number.
+
+        Returns:
+        --------
+        Expr
+            A new expression representing the absolute value of the input expression.
+        """
+        from . import functions as F
+
+        return F.abs(self)
+
+    def btrim(self) -> Expr:
+        """Removes all characters, spaces by default, from both sides of a string."""
+        from . import functions as F
+
+        return F.btrim(self)
+
+    def md5(self) -> Expr:
+        """Computes an MD5 128-bit checksum for a string expression."""
+        from . import functions as F
+
+        return F.md5(self)
+
+    def octet_length(self) -> Expr:
+        """Returns the number of bytes of a string."""
+        from . import functions as F
+
+        return F.octet_length(self)
+
+    def cosh(self) -> Expr:
+        """Returns the hyperbolic cosine of the argument."""
+        from . import functions as F
+
+        return F.cosh(self)
+
+    def radians(self) -> Expr:
+        """Converts the argument from degrees to radians."""
+        from . import functions as F
+
+        return F.radians(self)
+
+    def sqrt(self) -> Expr:
+        """Returns the square root of the argument."""
+        from . import functions as F
+
+        return F.sqrt(self)
+
+    def character_length(self) -> Expr:
+        """Returns the number of characters in the argument."""
+        from . import functions as F
+
+        return F.character_length(self)
+
+    def tanh(self) -> Expr:
+        """Returns the hyperbolic tangent of the argument."""
+        from . import functions as F
+
+        return F.tanh(self)
+
+    def atan(self) -> Expr:
+        """Returns inverse tangent of a number."""
+        from . import functions as F
+
+        return F.atan(self)
+
+    def rtrim(self) -> Expr:
+        """Removes all characters, spaces by default, from the end of a string."""
+        from . import functions as F
+
+        return F.rtrim(self)
+
+    def atanh(self) -> Expr:
+        """Returns inverse hyperbolic tangent."""
+        from . import functions as F
+
+        return F.atanh(self)
+
+    def list_dims(self) -> Expr:
+        """Returns an array of the array's dimensions.
+
+        This is an alias for :py:func:`array_dims`.
+        """
+        from . import functions as F
+
+        return F.list_dims(self)
+
+    def sha256(self) -> Expr:
+        """Computes the SHA-256 hash of a binary string."""
+        from . import functions as F
+
+        return F.sha256(self)
+
+    def factorial(self) -> Expr:
+        """Returns the factorial of the argument."""
+        from . import functions as F
+
+        return F.factorial(self)
+
+    def acosh(self) -> Expr:
+        """Returns inverse hyperbolic cosine."""
+        from . import functions as F
+
+        return F.acosh(self)
+
+    def floor(self) -> Expr:
+        """Returns the nearest integer less than or equal to the argument."""
+        from . import functions as F
+
+        return F.floor(self)
+
+    def ceil(self) -> Expr:
+        """Returns the nearest integer greater than or equal to argument."""
+        from . import functions as F
+
+        return F.ceil(self)
+
+    def list_length(self) -> Expr:
+        """Returns the length of the array.
+
+        This is an alias for :py:func:`array_length`.
+        """
+        from . import functions as F
+
+        return F.list_length(self)
+
+    def upper(self) -> Expr:
+        """Converts a string to uppercase."""
+        from . import functions as F
+
+        return F.upper(self)
+
+    def chr(self) -> Expr:
+        """Converts the Unicode code point to a UTF8 character."""
+        from . import functions as F
+
+        return F.chr(self)
+
+    def ln(self) -> Expr:
+        """Returns the natural logarithm (base e) of the argument."""
+        from . import functions as F
+
+        return F.ln(self)
+
+    def tan(self) -> Expr:
+        """Returns the tangent of the argument."""
+        from . import functions as F
+
+        return F.tan(self)
+
+    def array_pop_front(self) -> Expr:
+        """Returns the array without the first element."""
+        from . import functions as F
+
+        return F.array_pop_front(self)
+
+    def cbrt(self) -> Expr:
+        """Returns the cube root of a number."""
+        from . import functions as F
+
+        return F.cbrt(self)
+
+    def sha512(self) -> Expr:
+        """Computes the SHA-512 hash of a binary string."""
+        from . import functions as F
+
+        return F.sha512(self)
+
+    def char_length(self) -> Expr:
+        """The number of characters in the ``string``."""
+        from . import functions as F
+
+        return F.char_length(self)
+
+    def list_ndims(self) -> Expr:
+        """Returns the number of dimensions of the array.
+
+        This is an alias for :py:func:`array_ndims`.
+        """
+        from . import functions as F
+
+        return F.list_ndims(self)
+
+    def trim(self) -> Expr:
+        """Removes all characters, spaces by default, from both sides of a string."""
+        from . import functions as F
+
+        return F.trim(self)
+
+    def cos(self) -> Expr:
+        """Returns the cosine of the argument."""
+        from . import functions as F
+
+        return F.cos(self)
+
+    def sinh(self) -> Expr:
+        """Returns the hyperbolic sine of the argument."""
+        from . import functions as F
+
+        return F.sinh(self)
+
+    def empty(self) -> Expr:
+        """This is an alias for :py:func:`array_empty`."""
+        from . import functions as F
+
+        return F.empty(self)
+
+    def ltrim(self) -> Expr:
+        """Removes all characters, spaces by default, from the beginning of a string."""
+        from . import functions as F
+
+        return F.ltrim(self)
+
+    def signum(self) -> Expr:
+        """Returns the sign of the argument (-1, 0, +1)."""
+        from . import functions as F
+
+        return F.signum(self)
+
+    def log2(self) -> Expr:
+        """Base 2 logarithm of the argument."""
+        from . import functions as F
+
+        return F.log2(self)
+
+    def cot(self) -> Expr:
+        """Returns the cotangent of the argument."""
+        from . import functions as F
+
+        return F.cot(self)
+
+
+class ExprFuncBuilder:
+    def __init__(self, builder: expr_internal.ExprFuncBuilder) -> None:
+        self.builder = builder
+
+    def order_by(self, *exprs: Expr) -> ExprFuncBuilder:
+        """Set the ordering for a window or aggregate function.
+
+        Values given in ``exprs`` must be sort expressions. You can convert any other
+        expression to a sort expression using `.sort()`.
+        """
+        return ExprFuncBuilder(
+            self.builder.order_by([sort_or_default(e) for e in exprs])
+        )
+
+    def filter(self, filter: Expr) -> ExprFuncBuilder:
+        """Filter values during aggregation."""
+        return ExprFuncBuilder(self.builder.filter(filter.expr))
+
+    def distinct(self) -> ExprFuncBuilder:
+        """Only evaluate distinct values during aggregation."""
+        return ExprFuncBuilder(self.builder.distinct())
+
+    def null_treatment(self, null_treatment: NullTreatment) -> ExprFuncBuilder:
+        """Set how nulls are treated for either window or aggregate functions."""
+        return ExprFuncBuilder(self.builder.null_treatment(null_treatment.value))
+
+    def partition_by(self, *partition_by: Expr) -> ExprFuncBuilder:
+        """Set partitioning for window functions."""
+        return ExprFuncBuilder(
+            self.builder.partition_by([e.expr for e in partition_by])
+        )
+
+    def window_frame(self, window_frame: WindowFrame) -> ExprFuncBuilder:
+        """Set window frame for window functions."""
+        return ExprFuncBuilder(self.builder.window_frame(window_frame.window_frame))
+
+    def build(self) -> Expr:
+        """Create an expression from a Function Builder."""
+        return Expr(self.builder.build())
+
+
+class Window:
+    """Define reusable window parameters."""
+
+    def __init__(
+        self,
+        partition_by: list[Expr] | Expr | None = None,
+        window_frame: WindowFrame | None = None,
+        order_by: list[SortExpr | Expr | str] | Expr | SortExpr | str | None = None,
+        null_treatment: NullTreatment | None = None,
+    ) -> None:
+        """Construct a window definition.
+
+        Args:
+            partition_by: Partitions for window operation
+            window_frame: Define the start and end bounds of the window frame
+            order_by: Set ordering
+            null_treatment: Indicate how nulls are to be treated
+        """
+        self._partition_by = partition_by
+        self._window_frame = window_frame
+        self._order_by = sort_list_to_raw_sort_list(order_by)
+        self._null_treatment = null_treatment
+
+
+class WindowFrame:
+    """Defines a window frame for performing window operations."""
+
+    def __init__(
+        self, units: str, start_bound: Any | None, end_bound: Any | None
+    ) -> None:
+        """Construct a window frame using the given parameters.
+
+        Args:
+            units: Should be one of ``rows``, ``range``, or ``groups``.
+            start_bound: Sets the preceding bound. Must be >= 0. If none, this
+                will be set to unbounded. If unit type is ``groups``, this
+                parameter must be set.
+            end_bound: Sets the following bound. Must be >= 0. If none, this
+                will be set to unbounded. If unit type is ``groups``, this
+                parameter must be set.
+        """
+        if not isinstance(start_bound, pa.Scalar) and start_bound is not None:
+            start_bound = pa.scalar(start_bound)
+            if units in ("rows", "groups"):
+                start_bound = start_bound.cast(pa.uint64())
+        if not isinstance(end_bound, pa.Scalar) and end_bound is not None:
+            end_bound = pa.scalar(end_bound)
+            if units in ("rows", "groups"):
+                end_bound = end_bound.cast(pa.uint64())
+        self.window_frame = expr_internal.WindowFrame(units, start_bound, end_bound)
+
+    def __repr__(self) -> str:
+        """Print a string representation of the window frame."""
+        return self.window_frame.__repr__()
+
+    def get_frame_units(self) -> str:
+        """Returns the window frame units for the bounds."""
+        return self.window_frame.get_frame_units()
+
+    def get_lower_bound(self) -> WindowFrameBound:
+        """Returns starting bound."""
+        return WindowFrameBound(self.window_frame.get_lower_bound())
+
+    def get_upper_bound(self) -> WindowFrameBound:
+        """Returns end bound."""
+        return WindowFrameBound(self.window_frame.get_upper_bound())
+
+
+class WindowFrameBound:
+    """Defines a single window frame bound.
+
+    :py:class:`WindowFrame` typically requires a start and end bound.
+    """
+
+    def __init__(self, frame_bound: expr_internal.WindowFrameBound) -> None:
+        """Constructs a window frame bound."""
+        self.frame_bound = frame_bound
+
+    def get_offset(self) -> int | None:
+        """Returns the offset of the window frame."""
+        return self.frame_bound.get_offset()
+
+    def is_current_row(self) -> bool:
+        """Returns if the frame bound is current row."""
+        return self.frame_bound.is_current_row()
+
+    def is_following(self) -> bool:
+        """Returns if the frame bound is following."""
+        return self.frame_bound.is_following()
+
+    def is_preceding(self) -> bool:
+        """Returns if the frame bound is preceding."""
+        return self.frame_bound.is_preceding()
+
+    def is_unbounded(self) -> bool:
+        """Returns if the frame bound is unbounded."""
+        return self.frame_bound.is_unbounded()
+
+
+class CaseBuilder:
+    """Builder class for constructing case statements.
+
+    An example usage would be as follows::
+
+        import datafusion.functions as f
+        from datafusion import lit, col
+        df.select(
+            f.case(col("column_a"))
+            .when(lit(1), lit("One"))
+            .when(lit(2), lit("Two"))
+            .otherwise(lit("Unknown"))
+        )
+    """
+
+    def __init__(self, case_builder: expr_internal.CaseBuilder) -> None:
+        """Constructs a case builder.
+
+        This is not typically called by the end user directly. See
+        :py:func:`datafusion.functions.case` instead.
+        """
+        self.case_builder = case_builder
+
+    def when(self, when_expr: Expr, then_expr: Expr) -> CaseBuilder:
+        """Add a case to match against."""
+        return CaseBuilder(self.case_builder.when(when_expr.expr, then_expr.expr))
+
+    def otherwise(self, else_expr: Expr) -> Expr:
+        """Set a default value for the case statement."""
+        return Expr(self.case_builder.otherwise(else_expr.expr))
+
+    def end(self) -> Expr:
+        """Finish building a case statement.
+
+        Any non-matching cases will end in a `null` value.
+        """
+        return Expr(self.case_builder.end())
+
+
+class SortExpr:
+    """Used to specify sorting on either a DataFrame or function."""
+
+    def __init__(self, expr: Expr, ascending: bool, nulls_first: bool) -> None:
+        """This constructor should not be called by the end user."""
+        self.raw_sort = expr_internal.SortExpr(expr.expr, ascending, nulls_first)
+
+    def expr(self) -> Expr:
+        """Return the raw expr backing the SortExpr."""
+        return Expr(self.raw_sort.expr())
+
+    def ascending(self) -> bool:
+        """Return ascending property."""
+        return self.raw_sort.ascending()
+
+    def nulls_first(self) -> bool:
+        """Return nulls_first property."""
+        return self.raw_sort.nulls_first()
+
+    def __repr__(self) -> str:
+        """Generate a string representation of this expression."""
+        return self.raw_sort.__repr__()
+
+
+SortKey = Expr | SortExpr | str
diff --git a/python/datafusion/functions.py b/python/datafusion/functions.py
new file mode 100644
index 000000000..fd116254b
--- /dev/null
+++ b/python/datafusion/functions.py
@@ -0,0 +1,3091 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+"""User functions for operating on :py:class:`~datafusion.expr.Expr`."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import pyarrow as pa
+
+from datafusion._internal import functions as f
+from datafusion.common import NullTreatment
+from datafusion.expr import (
+    CaseBuilder,
+    Expr,
+    SortExpr,
+    SortKey,
+    WindowFrame,
+    expr_list_to_raw_expr_list,
+    sort_list_to_raw_sort_list,
+    sort_or_default,
+)
+
+try:
+    from warnings import deprecated  # Python 3.13+
+except ImportError:
+    from typing_extensions import deprecated  # Python 3.12
+
+if TYPE_CHECKING:
+    from datafusion.context import SessionContext
+__all__ = [
+    "abs",
+    "acos",
+    "acosh",
+    "alias",
+    "approx_distinct",
+    "approx_median",
+    "approx_percentile_cont",
+    "approx_percentile_cont_with_weight",
+    "array",
+    "array_agg",
+    "array_append",
+    "array_cat",
+    "array_concat",
+    "array_dims",
+    "array_distinct",
+    "array_element",
+    "array_empty",
+    "array_except",
+    "array_extract",
+    "array_has",
+    "array_has_all",
+    "array_has_any",
+    "array_indexof",
+    "array_intersect",
+    "array_join",
+    "array_length",
+    "array_ndims",
+    "array_pop_back",
+    "array_pop_front",
+    "array_position",
+    "array_positions",
+    "array_prepend",
+    "array_push_back",
+    "array_push_front",
+    "array_remove",
+    "array_remove_all",
+    "array_remove_n",
+    "array_repeat",
+    "array_replace",
+    "array_replace_all",
+    "array_replace_n",
+    "array_resize",
+    "array_slice",
+    "array_sort",
+    "array_to_string",
+    "array_union",
+    "arrow_cast",
+    "arrow_typeof",
+    "ascii",
+    "asin",
+    "asinh",
+    "atan",
+    "atan2",
+    "atanh",
+    "avg",
+    "bit_and",
+    "bit_length",
+    "bit_or",
+    "bit_xor",
+    "bool_and",
+    "bool_or",
+    "btrim",
+    "cardinality",
+    "case",
+    "cbrt",
+    "ceil",
+    "char_length",
+    "character_length",
+    "chr",
+    "coalesce",
+    "col",
+    "concat",
+    "concat_ws",
+    "corr",
+    "cos",
+    "cosh",
+    "cot",
+    "count",
+    "count_star",
+    "covar",
+    "covar_pop",
+    "covar_samp",
+    "cume_dist",
+    "current_date",
+    "current_time",
+    "date_bin",
+    "date_part",
+    "date_trunc",
+    "datepart",
+    "datetrunc",
+    "decode",
+    "degrees",
+    "dense_rank",
+    "digest",
+    "empty",
+    "encode",
+    "ends_with",
+    "exp",
+    "extract",
+    "factorial",
+    "find_in_set",
+    "first_value",
+    "flatten",
+    "floor",
+    "from_unixtime",
+    "gcd",
+    "in_list",
+    "initcap",
+    "isnan",
+    "iszero",
+    "lag",
+    "last_value",
+    "lcm",
+    "lead",
+    "left",
+    "length",
+    "levenshtein",
+    "list_append",
+    "list_cat",
+    "list_concat",
+    "list_dims",
+    "list_distinct",
+    "list_element",
+    "list_except",
+    "list_extract",
+    "list_indexof",
+    "list_intersect",
+    "list_join",
+    "list_length",
+    "list_ndims",
+    "list_position",
+    "list_positions",
+    "list_prepend",
+    "list_push_back",
+    "list_push_front",
+    "list_remove",
+    "list_remove_all",
+    "list_remove_n",
+    "list_repeat",
+    "list_replace",
+    "list_replace_all",
+    "list_replace_n",
+    "list_resize",
+    "list_slice",
+    "list_sort",
+    "list_to_string",
+    "list_union",
+    "ln",
+    "log",
+    "log2",
+    "log10",
+    "lower",
+    "lpad",
+    "ltrim",
+    "make_array",
+    "make_date",
+    "make_list",
+    "max",
+    "md5",
+    "mean",
+    "median",
+    "min",
+    "named_struct",
+    "nanvl",
+    "now",
+    "nth_value",
+    "ntile",
+    "nullif",
+    "nvl",
+    "octet_length",
+    "order_by",
+    "overlay",
+    "percent_rank",
+    "pi",
+    "pow",
+    "power",
+    "radians",
+    "random",
+    "range",
+    "rank",
+    "regexp_count",
+    "regexp_instr",
+    "regexp_like",
+    "regexp_match",
+    "regexp_replace",
+    "regr_avgx",
+    "regr_avgy",
+    "regr_count",
+    "regr_intercept",
+    "regr_r2",
+    "regr_slope",
+    "regr_sxx",
+    "regr_sxy",
+    "regr_syy",
+    "repeat",
+    "replace",
+    "reverse",
+    "right",
+    "round",
+    "row_number",
+    "rpad",
+    "rtrim",
+    "sha224",
+    "sha256",
+    "sha384",
+    "sha512",
+    "signum",
+    "sin",
+    "sinh",
+    "split_part",
+    "sqrt",
+    "starts_with",
+    "stddev",
+    "stddev_pop",
+    "stddev_samp",
+    "string_agg",
+    "strpos",
+    "struct",
+    "substr",
+    "substr_index",
+    "substring",
+    "sum",
+    "tan",
+    "tanh",
+    "to_char",
+    "to_date",
+    "to_hex",
+    "to_local_time",
+    "to_time",
+    "to_timestamp",
+    "to_timestamp_micros",
+    "to_timestamp_millis",
+    "to_timestamp_nanos",
+    "to_timestamp_seconds",
+    "to_unixtime",
+    "today",
+    "translate",
+    "trim",
+    "trunc",
+    "upper",
+    "uuid",
+    "var",
+    "var_pop",
+    "var_samp",
+    "var_sample",
+    "when",
+    # Window Functions
+    "window",
+]
+
+
+def isnan(expr: Expr) -> Expr:
+    """Returns true if a given number is +NaN or -NaN otherwise returns false."""
+    return Expr(f.isnan(expr.expr))
+
+
+def nullif(expr1: Expr, expr2: Expr) -> Expr:
+    """Returns NULL if expr1 equals expr2; otherwise it returns expr1.
+
+    This can be used to perform the inverse operation of the COALESCE expression.
+    """
+    return Expr(f.nullif(expr1.expr, expr2.expr))
+
+
+def encode(expr: Expr, encoding: Expr) -> Expr:
+    """Encode the ``input``, using the ``encoding``. encoding can be base64 or hex."""
+    return Expr(f.encode(expr.expr, encoding.expr))
+
+
+def decode(expr: Expr, encoding: Expr) -> Expr:
+    """Decode the ``input``, using the ``encoding``. encoding can be base64 or hex."""
+    return Expr(f.decode(expr.expr, encoding.expr))
+
+
+def array_to_string(expr: Expr, delimiter: Expr) -> Expr:
+    """Converts each element to its text representation."""
+    return Expr(f.array_to_string(expr.expr, delimiter.expr.cast(pa.string())))
+
+
+def array_join(expr: Expr, delimiter: Expr) -> Expr:
+    """Converts each element to its text representation.
+
+    This is an alias for :py:func:`array_to_string`.
+    """
+    return array_to_string(expr, delimiter)
+
+
+def list_to_string(expr: Expr, delimiter: Expr) -> Expr:
+    """Converts each element to its text representation.
+
+    This is an alias for :py:func:`array_to_string`.
+    """
+    return array_to_string(expr, delimiter)
+
+
+def list_join(expr: Expr, delimiter: Expr) -> Expr:
+    """Converts each element to its text representation.
+
+    This is an alias for :py:func:`array_to_string`.
+    """
+    return array_to_string(expr, delimiter)
+
+
+def in_list(arg: Expr, values: list[Expr], negated: bool = False) -> Expr:
+    """Returns whether the argument is contained within the list ``values``."""
+    values = [v.expr for v in values]
+    return Expr(f.in_list(arg.expr, values, negated))
+
+
+def digest(value: Expr, method: Expr) -> Expr:
+    """Computes the binary hash of an expression using the specified algorithm.
+
+    Standard algorithms are md5, sha224, sha256, sha384, sha512, blake2s,
+    blake2b, and blake3.
+    """
+    return Expr(f.digest(value.expr, method.expr))
+
+
+def concat(*args: Expr) -> Expr:
+    """Concatenates the text representations of all the arguments.
+
+    NULL arguments are ignored.
+    """
+    args = [arg.expr for arg in args]
+    return Expr(f.concat(args))
+
+
+def concat_ws(separator: str, *args: Expr) -> Expr:
+    """Concatenates the list ``args`` with the separator.
+
+    ``NULL`` arguments are ignored. ``separator`` should not be ``NULL``.
+    """
+    args = [arg.expr for arg in args]
+    return Expr(f.concat_ws(separator, args))
+
+
+def order_by(expr: Expr, ascending: bool = True, nulls_first: bool = True) -> SortExpr:
+    """Creates a new sort expression."""
+    return SortExpr(expr, ascending=ascending, nulls_first=nulls_first)
+
+
+def alias(expr: Expr, name: str, metadata: dict[str, str] | None = None) -> Expr:
+    """Creates an alias expression with an optional metadata dictionary.
+
+    Args:
+        expr: The expression to alias
+        name: The alias name
+        metadata: Optional metadata to attach to the column
+
+    Returns:
+        An expression with the given alias
+    """
+    return Expr(f.alias(expr.expr, name, metadata))
+
+
+def col(name: str) -> Expr:
+    """Creates a column reference expression."""
+    return Expr(f.col(name))
+
+
+def count_star(filter: Expr | None = None) -> Expr:
+    """Create a COUNT(1) aggregate expression.
+
+    This aggregate function will count all of the rows in the partition.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``distinct``, and ``null_treatment``.
+
+    Args:
+        filter: If provided, only count rows for which the filter is True
+    """
+    return count(Expr.literal(1), filter=filter)
+
+
+def case(expr: Expr) -> CaseBuilder:
+    """Create a case expression.
+
+    Create a :py:class:`~datafusion.expr.CaseBuilder` to match cases for the
+    expression ``expr``. See :py:class:`~datafusion.expr.CaseBuilder` for
+    detailed usage.
+    """
+    return CaseBuilder(f.case(expr.expr))
+
+
+def when(when: Expr, then: Expr) -> CaseBuilder:
+    """Create a case expression that has no base expression.
+
+    Create a :py:class:`~datafusion.expr.CaseBuilder` to match cases for the
+    expression ``expr``. See :py:class:`~datafusion.expr.CaseBuilder` for
+    detailed usage.
+    """
+    return CaseBuilder(f.when(when.expr, then.expr))
+
+
+@deprecated("Prefer to call Expr.over() instead")
+def window(
+    name: str,
+    args: list[Expr],
+    partition_by: list[Expr] | Expr | None = None,
+    order_by: list[SortKey] | SortKey | None = None,
+    window_frame: WindowFrame | None = None,
+    filter: Expr | None = None,
+    distinct: bool = False,
+    ctx: SessionContext | None = None,
+) -> Expr:
+    """Creates a new Window function expression.
+
+    This interface will soon be deprecated. Instead of using this interface,
+    users should call the window functions directly. For example, to perform a
+    lag use::
+
+        df.select(functions.lag(col("a")).partition_by(col("b")).build())
+
+    The ``order_by`` parameter accepts column names or expressions, e.g.::
+
+        window("lag", [col("a")], order_by="ts")
+    """
+    args = [a.expr for a in args]
+    partition_by_raw = expr_list_to_raw_expr_list(partition_by)
+    order_by_raw = sort_list_to_raw_sort_list(order_by)
+    window_frame = window_frame.window_frame if window_frame is not None else None
+    ctx = ctx.ctx if ctx is not None else None
+    filter_raw = filter.expr if filter is not None else None
+    return Expr(
+        f.window(
+            name,
+            args,
+            partition_by=partition_by_raw,
+            order_by=order_by_raw,
+            window_frame=window_frame,
+            ctx=ctx,
+            filter=filter_raw,
+            distinct=distinct,
+        )
+    )
+
+
+# scalar functions
+def abs(arg: Expr) -> Expr:
+    """Return the absolute value of a given number.
+
+    Returns:
+    --------
+    Expr
+        A new expression representing the absolute value of the input expression.
+    """
+    return Expr(f.abs(arg.expr))
+
+
+def acos(arg: Expr) -> Expr:
+    """Returns the arc cosine or inverse cosine of a number.
+
+    Examples:
+    ---------
+    >>> ctx = dfn.SessionContext()
+    >>> df = ctx.from_pydict({"a": [1.0]})
+    >>> result = df.select(dfn.functions.acos(dfn.col("a")).alias("acos"))
+    >>> result.collect_column("acos")[0].as_py()
+    0.0
+    """
+    return Expr(f.acos(arg.expr))
+
+
+def acosh(arg: Expr) -> Expr:
+    """Returns inverse hyperbolic cosine.
+
+    Examples:
+    ---------
+    >>> ctx = dfn.SessionContext()
+    >>> df = ctx.from_pydict({"a": [1.0]})
+    >>> result = df.select(dfn.functions.acosh(dfn.col("a")).alias("acosh"))
+    >>> result.collect_column("acosh")[0].as_py()
+    0.0
+    """
+    return Expr(f.acosh(arg.expr))
+
+
+def ascii(arg: Expr) -> Expr:
+    """Returns the numeric code of the first character of the argument."""
+    return Expr(f.ascii(arg.expr))
+
+
+def asin(arg: Expr) -> Expr:
+    """Returns the arc sine or inverse sine of a number.
+
+    Examples:
+    ---------
+    >>> ctx = dfn.SessionContext()
+    >>> df = ctx.from_pydict({"a": [0.0]})
+    >>> result = df.select(dfn.functions.asin(dfn.col("a")).alias("asin"))
+    >>> result.collect_column("asin")[0].as_py()
+    0.0
+    """
+    return Expr(f.asin(arg.expr))
+
+
+def asinh(arg: Expr) -> Expr:
+    """Returns inverse hyperbolic sine.
+
+    Examples:
+    ---------
+    >>> ctx = dfn.SessionContext()
+    >>> df = ctx.from_pydict({"a": [0.0]})
+    >>> result = df.select(dfn.functions.asinh(dfn.col("a")).alias("asinh"))
+    >>> result.collect_column("asinh")[0].as_py()
+    0.0
+    """
+    return Expr(f.asinh(arg.expr))
+
+
+def atan(arg: Expr) -> Expr:
+    """Returns inverse tangent of a number.
+
+    Examples:
+    ---------
+    >>> ctx = dfn.SessionContext()
+    >>> df = ctx.from_pydict({"a": [0.0]})
+    >>> result = df.select(dfn.functions.atan(dfn.col("a")).alias("atan"))
+    >>> result.collect_column("atan")[0].as_py()
+    0.0
+    """
+    return Expr(f.atan(arg.expr))
+
+
+def atanh(arg: Expr) -> Expr:
+    """Returns inverse hyperbolic tangent.
+
+    Examples:
+    ---------
+    >>> ctx = dfn.SessionContext()
+    >>> df = ctx.from_pydict({"a": [0.0]})
+    >>> result = df.select(dfn.functions.atanh(dfn.col("a")).alias("atanh"))
+    >>> result.collect_column("atanh")[0].as_py()
+    0.0
+    """
+    return Expr(f.atanh(arg.expr))
+
+
+def atan2(y: Expr, x: Expr) -> Expr:
+    """Returns inverse tangent of a division given in the argument.
+
+    Examples:
+    ---------
+    >>> ctx = dfn.SessionContext()
+    >>> df = ctx.from_pydict({"y": [0.0], "x": [1.0]})
+    >>> result = df.select(
+    ...     dfn.functions.atan2(dfn.col("y"), dfn.col("x")).alias("atan2"))
+    >>> result.collect_column("atan2")[0].as_py()
+    0.0
+    """
+    return Expr(f.atan2(y.expr, x.expr))
+
+
+def bit_length(arg: Expr) -> Expr:
+    """Returns the number of bits in the string argument."""
+    return Expr(f.bit_length(arg.expr))
+
+
+def btrim(arg: Expr) -> Expr:
+    """Removes all characters, spaces by default, from both sides of a string."""
+    return Expr(f.btrim(arg.expr))
+
+
+def cbrt(arg: Expr) -> Expr:
+    """Returns the cube root of a number."""
+    return Expr(f.cbrt(arg.expr))
+
+
+def ceil(arg: Expr) -> Expr:
+    """Returns the nearest integer greater than or equal to argument."""
+    return Expr(f.ceil(arg.expr))
+
+
+def character_length(arg: Expr) -> Expr:
+    """Returns the number of characters in the argument."""
+    return Expr(f.character_length(arg.expr))
+
+
+def length(string: Expr) -> Expr:
+    """The number of characters in the ``string``."""
+    return Expr(f.length(string.expr))
+
+
+def char_length(string: Expr) -> Expr:
+    """The number of characters in the ``string``."""
+    return Expr(f.char_length(string.expr))
+
+
+def chr(arg: Expr) -> Expr:
+    """Converts the Unicode code point to a UTF8 character."""
+    return Expr(f.chr(arg.expr))
+
+
+def coalesce(*args: Expr) -> Expr:
+    """Returns the value of the first expr in ``args`` which is not NULL."""
+    args = [arg.expr for arg in args]
+    return Expr(f.coalesce(*args))
+
+
+def cos(arg: Expr) -> Expr:
+    """Returns the cosine of the argument.
+
+    Examples:
+    ---------
+    >>> ctx = dfn.SessionContext()
+    >>> df = ctx.from_pydict({"a": [0,-1,1]})
+    >>> cos_df = df.select(dfn.functions.cos(dfn.col("a")).alias("cos"))
+    >>> cos_df.collect_column("cos")[0].as_py()
+    1.0
+    """
+    return Expr(f.cos(arg.expr))
+
+
+def cosh(arg: Expr) -> Expr:
+    """Returns the hyperbolic cosine of the argument.
+
+    Examples:
+    ---------
+    >>> ctx = dfn.SessionContext()
+    >>> df = ctx.from_pydict({"a": [0,-1,1]})
+    >>> cosh_df = df.select(dfn.functions.cosh(dfn.col("a")).alias("cosh"))
+    >>> cosh_df.collect_column("cosh")[0].as_py()
+    1.0
+    """
+    return Expr(f.cosh(arg.expr))
+
+
+def cot(arg: Expr) -> Expr:
+    """Returns the cotangent of the argument.
+
+    Examples:
+    ---------
+    >>> from math import pi
+    >>> ctx = dfn.SessionContext()
+    >>> df = ctx.from_pydict({"a": [pi / 4]})
+    >>> import builtins
+    >>> result = df.select(
+    ...     dfn.functions.cot(dfn.col("a")).alias("cot")
+    ... )
+    >>> builtins.round(
+    ...     result.collect_column("cot")[0].as_py(), 1
+    ... )
+    1.0
+    """
+    return Expr(f.cot(arg.expr))
+
+
+def degrees(arg: Expr) -> Expr:
+    """Converts the argument from radians to degrees.
+
+    Examples:
+    ---------
+    >>> from math import pi
+    >>> ctx = dfn.SessionContext()
+    >>> df = ctx.from_pydict({"a": [0,pi,2*pi]})
+    >>> deg_df = df.select(dfn.functions.degrees(dfn.col("a")).alias("deg"))
+    >>> deg_df.collect_column("deg")[2].as_py()
+    360.0
+    """
+    return Expr(f.degrees(arg.expr))
+
+
+def ends_with(arg: Expr, suffix: Expr) -> Expr:
+    """Returns true if the ``string`` ends with the ``suffix``, false otherwise."""
+    return Expr(f.ends_with(arg.expr, suffix.expr))
+
+
+def exp(arg: Expr) -> Expr:
+    """Returns the exponential of the argument."""
+    return Expr(f.exp(arg.expr))
+
+
+def factorial(arg: Expr) -> Expr:
+    """Returns the factorial of the argument."""
+    return Expr(f.factorial(arg.expr))
+
+
+def find_in_set(string: Expr, string_list: Expr) -> Expr:
+    """Find a string in a list of strings.
+
+    Returns a value in the range of 1 to N if the string is in the string list
+    ``string_list`` consisting of N substrings.
+
+    The string list is a string composed of substrings separated by ``,`` characters.
+    """
+    return Expr(f.find_in_set(string.expr, string_list.expr))
+
+
+def floor(arg: Expr) -> Expr:
+    """Returns the nearest integer less than or equal to the argument."""
+    return Expr(f.floor(arg.expr))
+
+
+def gcd(x: Expr, y: Expr) -> Expr:
+    """Returns the greatest common divisor."""
+    return Expr(f.gcd(x.expr, y.expr))
+
+
+def initcap(string: Expr) -> Expr:
+    """Set the initial letter of each word to capital.
+
+    Converts the first letter of each word in ``string`` to uppercase and the remaining
+    characters to lowercase.
+    """
+    return Expr(f.initcap(string.expr))
+
+
+def instr(string: Expr, substring: Expr) -> Expr:
+    """Finds the position from where the ``substring`` matches the ``string``.
+
+    This is an alias for :py:func:`strpos`.
+    """
+    return strpos(string, substring)
+
+
+def iszero(arg: Expr) -> Expr:
+    """Returns true if a given number is +0.0 or -0.0 otherwise returns false."""
+    return Expr(f.iszero(arg.expr))
+
+
+def lcm(x: Expr, y: Expr) -> Expr:
+    """Returns the least common multiple."""
+    return Expr(f.lcm(x.expr, y.expr))
+
+
+def left(string: Expr, n: Expr) -> Expr:
+    """Returns the first ``n`` characters in the ``string``."""
+    return Expr(f.left(string.expr, n.expr))
+
+
+def levenshtein(string1: Expr, string2: Expr) -> Expr:
+    """Returns the Levenshtein distance between the two given strings."""
+    return Expr(f.levenshtein(string1.expr, string2.expr))
+
+
+def ln(arg: Expr) -> Expr:
+    """Returns the natural logarithm (base e) of the argument."""
+    return Expr(f.ln(arg.expr))
+
+
+def log(base: Expr, num: Expr) -> Expr:
+    """Returns the logarithm of a number for a particular ``base``."""
+    return Expr(f.log(base.expr, num.expr))
+
+
+def log10(arg: Expr) -> Expr:
+    """Base 10 logarithm of the argument."""
+    return Expr(f.log10(arg.expr))
+
+
+def log2(arg: Expr) -> Expr:
+    """Base 2 logarithm of the argument."""
+    return Expr(f.log2(arg.expr))
+
+
+def lower(arg: Expr) -> Expr:
+    """Converts a string to lowercase."""
+    return Expr(f.lower(arg.expr))
+
+
+def lpad(string: Expr, count: Expr, characters: Expr | None = None) -> Expr:
+    """Add left padding to a string.
+
+    Extends the string to length length by prepending the characters fill (a
+    space by default). If the string is already longer than length then it is
+    truncated (on the right).
+    """
+    characters = characters if characters is not None else Expr.literal(" ")
+    return Expr(f.lpad(string.expr, count.expr, characters.expr))
+
+
+def ltrim(arg: Expr) -> Expr:
+    """Removes all characters, spaces by default, from the beginning of a string."""
+    return Expr(f.ltrim(arg.expr))
+
+
+def md5(arg: Expr) -> Expr:
+    """Computes an MD5 128-bit checksum for a string expression."""
+    return Expr(f.md5(arg.expr))
+
+
+def nanvl(x: Expr, y: Expr) -> Expr:
+    """Returns ``x`` if ``x`` is not ``NaN``. Otherwise returns ``y``."""
+    return Expr(f.nanvl(x.expr, y.expr))
+
+
+def nvl(x: Expr, y: Expr) -> Expr:
+    """Returns ``x`` if ``x`` is not ``NULL``. Otherwise returns ``y``."""
+    return Expr(f.nvl(x.expr, y.expr))
+
+
+def octet_length(arg: Expr) -> Expr:
+    """Returns the number of bytes of a string."""
+    return Expr(f.octet_length(arg.expr))
+
+
+def overlay(
+    string: Expr, substring: Expr, start: Expr, length: Expr | None = None
+) -> Expr:
+    """Replace a substring with a new substring.
+
+    Replace the substring of string that starts at the ``start``'th character and
+    extends for ``length`` characters with new substring.
+    """
+    if length is None:
+        return Expr(f.overlay(string.expr, substring.expr, start.expr))
+    return Expr(f.overlay(string.expr, substring.expr, start.expr, length.expr))
+
+
+def pi() -> Expr:
+    """Returns an approximate value of π."""
+    return Expr(f.pi())
+
+
+def position(string: Expr, substring: Expr) -> Expr:
+    """Finds the position from where the ``substring`` matches the ``string``.
+
+    This is an alias for :py:func:`strpos`.
+    """
+    return strpos(string, substring)
+
+
+def power(base: Expr, exponent: Expr) -> Expr:
+    """Returns ``base`` raised to the power of ``exponent``."""
+    return Expr(f.power(base.expr, exponent.expr))
+
+
+def pow(base: Expr, exponent: Expr) -> Expr:
+    """Returns ``base`` raised to the power of ``exponent``.
+
+    This is an alias of :py:func:`power`.
+    """
+    return power(base, exponent)
+
+
+def radians(arg: Expr) -> Expr:
+    """Converts the argument from degrees to radians.
+
+    Examples:
+    ---------
+    >>> from math import pi
+    >>> ctx = dfn.SessionContext()
+    >>> df = ctx.from_pydict({"a": [180.0]})
+    >>> import builtins
+    >>> result = df.select(
+    ...     dfn.functions.radians(dfn.col("a")).alias("rad")
+    ... )
+    >>> builtins.round(
+    ...     result.collect_column("rad")[0].as_py(), 6
+    ... )
+    3.141593
+    """
+    return Expr(f.radians(arg.expr))
+
+
+def regexp_like(string: Expr, regex: Expr, flags: Expr | None = None) -> Expr:
+    """Find if any regular expression (regex) matches exist.
+
+    Tests a string using a regular expression returning true if at least one match,
+    false otherwise.
+    """
+    if flags is not None:
+        flags = flags.expr
+    return Expr(f.regexp_like(string.expr, regex.expr, flags))
+
+
+def regexp_match(string: Expr, regex: Expr, flags: Expr | None = None) -> Expr:
+    """Perform regular expression (regex) matching.
+
+    Returns an array with each element containing the leftmost-first match of the
+    corresponding index in ``regex`` to string in ``string``.
+    """
+    if flags is not None:
+        flags = flags.expr
+    return Expr(f.regexp_match(string.expr, regex.expr, flags))
+
+
+def regexp_replace(
+    string: Expr, pattern: Expr, replacement: Expr, flags: Expr | None = None
+) -> Expr:
+    """Replaces substring(s) matching a PCRE-like regular expression.
+
+    The full list of supported features and syntax can be found at
+    <https://docs.rs/regex/latest/regex/#syntax>
+
+    Supported flags with the addition of 'g' can be found at
+    <https://docs.rs/regex/latest/regex/#grouping-and-flags>
+    """
+    if flags is not None:
+        flags = flags.expr
+    return Expr(f.regexp_replace(string.expr, pattern.expr, replacement.expr, flags))
+
+
+def regexp_count(
+    string: Expr, pattern: Expr, start: Expr | None = None, flags: Expr | None = None
+) -> Expr:
+    """Returns the number of matches in a string.
+
+    Optional start position (the first position is 1) to search for the regular
+    expression.
+    """
+    if flags is not None:
+        flags = flags.expr
+    start = start.expr if start is not None else start
+    return Expr(f.regexp_count(string.expr, pattern.expr, start, flags))
+
+
+def regexp_instr(
+    values: Expr,
+    regex: Expr,
+    start: Expr | None = None,
+    n: Expr | None = None,
+    flags: Expr | None = None,
+    sub_expr: Expr | None = None,
+) -> Expr:
+    """Returns the position of a regular expression match in a string.
+
+    Searches ``values`` for the ``n``-th occurrence of ``regex``, starting at position
+    ``start`` (the first position is 1). Returns the starting or ending position based
+    on ``end_position``. Use ``flags`` to control regex behavior and ``sub_expr`` to
+    return the position of a specific capture group instead of the entire match.
+    """
+    start = start.expr if start is not None else None
+    n = n.expr if n is not None else None
+    flags = flags.expr if flags is not None else None
+    sub_expr = sub_expr.expr if sub_expr is not None else None
+
+    return Expr(
+        f.regexp_instr(
+            values.expr,
+            regex.expr,
+            start,
+            n,
+            flags,
+            sub_expr,
+        )
+    )
+
+
+def repeat(string: Expr, n: Expr) -> Expr:
+    """Repeats the ``string`` to ``n`` times."""
+    return Expr(f.repeat(string.expr, n.expr))
+
+
+def replace(string: Expr, from_val: Expr, to_val: Expr) -> Expr:
+    """Replaces all occurrences of ``from_val`` with ``to_val`` in the ``string``."""
+    return Expr(f.replace(string.expr, from_val.expr, to_val.expr))
+
+
+def reverse(arg: Expr) -> Expr:
+    """Reverse the string argument."""
+    return Expr(f.reverse(arg.expr))
+
+
+def right(string: Expr, n: Expr) -> Expr:
+    """Returns the last ``n`` characters in the ``string``."""
+    return Expr(f.right(string.expr, n.expr))
+
+
+def round(value: Expr, decimal_places: Expr | None = None) -> Expr:
+    """Round the argument to the nearest integer.
+
+    If the optional ``decimal_places`` is specified, round to the nearest number of
+    decimal places. You can specify a negative number of decimal places. For example
+    ``round(lit(125.2345), lit(-2))`` would yield a value of ``100.0``.
+    """
+    if decimal_places is None:
+        decimal_places = Expr.literal(0)
+    return Expr(f.round(value.expr, decimal_places.expr))
+
+
+def rpad(string: Expr, count: Expr, characters: Expr | None = None) -> Expr:
+    """Add right padding to a string.
+
+    Extends the string to length length by appending the characters fill (a space
+    by default). If the string is already longer than length then it is truncated.
+    """
+    characters = characters if characters is not None else Expr.literal(" ")
+    return Expr(f.rpad(string.expr, count.expr, characters.expr))
+
+
+def rtrim(arg: Expr) -> Expr:
+    """Removes all characters, spaces by default, from the end of a string."""
+    return Expr(f.rtrim(arg.expr))
+
+
+def sha224(arg: Expr) -> Expr:
+    """Computes the SHA-224 hash of a binary string."""
+    return Expr(f.sha224(arg.expr))
+
+
+def sha256(arg: Expr) -> Expr:
+    """Computes the SHA-256 hash of a binary string."""
+    return Expr(f.sha256(arg.expr))
+
+
+def sha384(arg: Expr) -> Expr:
+    """Computes the SHA-384 hash of a binary string."""
+    return Expr(f.sha384(arg.expr))
+
+
+def sha512(arg: Expr) -> Expr:
+    """Computes the SHA-512 hash of a binary string."""
+    return Expr(f.sha512(arg.expr))
+
+
+def signum(arg: Expr) -> Expr:
+    """Returns the sign of the argument (-1, 0, +1)."""
+    return Expr(f.signum(arg.expr))
+
+
+def sin(arg: Expr) -> Expr:
+    """Returns the sine of the argument.
+
+    Examples:
+    ---------
+    >>> ctx = dfn.SessionContext()
+    >>> df = ctx.from_pydict({"a": [0.0]})
+    >>> result = df.select(dfn.functions.sin(dfn.col("a")).alias("sin"))
+    >>> result.collect_column("sin")[0].as_py()
+    0.0
+    """
+    return Expr(f.sin(arg.expr))
+
+
+def sinh(arg: Expr) -> Expr:
+    """Returns the hyperbolic sine of the argument.
+
+    Examples:
+    ---------
+    >>> ctx = dfn.SessionContext()
+    >>> df = ctx.from_pydict({"a": [0.0]})
+    >>> result = df.select(dfn.functions.sinh(dfn.col("a")).alias("sinh"))
+    >>> result.collect_column("sinh")[0].as_py()
+    0.0
+    """
+    return Expr(f.sinh(arg.expr))
+
+
+def split_part(string: Expr, delimiter: Expr, index: Expr) -> Expr:
+    """Split a string and return one part.
+
+    Splits a string based on a delimiter and picks out the desired field based
+    on the index.
+    """
+    return Expr(f.split_part(string.expr, delimiter.expr, index.expr))
+
+
+def sqrt(arg: Expr) -> Expr:
+    """Returns the square root of the argument."""
+    return Expr(f.sqrt(arg.expr))
+
+
+def starts_with(string: Expr, prefix: Expr) -> Expr:
+    """Returns true if string starts with prefix."""
+    return Expr(f.starts_with(string.expr, prefix.expr))
+
+
+def strpos(string: Expr, substring: Expr) -> Expr:
+    """Finds the position from where the ``substring`` matches the ``string``."""
+    return Expr(f.strpos(string.expr, substring.expr))
+
+
+def substr(string: Expr, position: Expr) -> Expr:
+    """Substring from the ``position`` to the end."""
+    return Expr(f.substr(string.expr, position.expr))
+
+
+def substr_index(string: Expr, delimiter: Expr, count: Expr) -> Expr:
+    """Returns an indexed substring.
+
+    The return will be the ``string`` from before ``count`` occurrences of
+    ``delimiter``.
+    """
+    return Expr(f.substr_index(string.expr, delimiter.expr, count.expr))
+
+
+def substring(string: Expr, position: Expr, length: Expr) -> Expr:
+    """Substring from the ``position`` with ``length`` characters."""
+    return Expr(f.substring(string.expr, position.expr, length.expr))
+
+
+def tan(arg: Expr) -> Expr:
+    """Returns the tangent of the argument.
+
+    Examples:
+    ---------
+    >>> ctx = dfn.SessionContext()
+    >>> df = ctx.from_pydict({"a": [0.0]})
+    >>> result = df.select(dfn.functions.tan(dfn.col("a")).alias("tan"))
+    >>> result.collect_column("tan")[0].as_py()
+    0.0
+    """
+    return Expr(f.tan(arg.expr))
+
+
+def tanh(arg: Expr) -> Expr:
+    """Returns the hyperbolic tangent of the argument.
+
+    Examples:
+    ---------
+    >>> ctx = dfn.SessionContext()
+    >>> df = ctx.from_pydict({"a": [0.0]})
+    >>> result = df.select(dfn.functions.tanh(dfn.col("a")).alias("tanh"))
+    >>> result.collect_column("tanh")[0].as_py()
+    0.0
+    """
+    return Expr(f.tanh(arg.expr))
+
+
+def to_hex(arg: Expr) -> Expr:
+    """Converts an integer to a hexadecimal string."""
+    return Expr(f.to_hex(arg.expr))
+
+
+def now() -> Expr:
+    """Returns the current timestamp in nanoseconds.
+
+    This will use the same value for all instances of now() in same statement.
+    """
+    return Expr(f.now())
+
+
+def to_char(arg: Expr, formatter: Expr) -> Expr:
+    """Returns a string representation of a date, time, timestamp or duration.
+
+    For usage of ``formatter`` see the rust chrono package ``strftime`` package.
+
+    [Documentation here.](https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
+    """
+    return Expr(f.to_char(arg.expr, formatter.expr))
+
+
+def _unwrap_exprs(args: tuple[Expr, ...]) -> list:
+    return [arg.expr for arg in args]
+
+
+def to_date(arg: Expr, *formatters: Expr) -> Expr:
+    """Converts a value to a date (YYYY-MM-DD).
+
+    Supports strings, numeric and timestamp types as input.
+    Integers and doubles are interpreted as days since the unix epoch.
+    Strings are parsed as YYYY-MM-DD (e.g. '2023-07-20')
+    if ``formatters`` are not provided.
+
+    For usage of ``formatters`` see the rust chrono package ``strftime`` package.
+
+    [Documentation here.](https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
+    """
+    return Expr(f.to_date(arg.expr, *_unwrap_exprs(formatters)))
+
+
+def to_local_time(*args: Expr) -> Expr:
+    """Converts a timestamp with a timezone to a timestamp without a timezone.
+
+    This function handles daylight saving time changes.
+    """
+    return Expr(f.to_local_time(*_unwrap_exprs(args)))
+
+
+def to_time(arg: Expr, *formatters: Expr) -> Expr:
+    """Converts a value to a time. Supports strings and timestamps as input.
+
+    If ``formatters`` is not provided strings are parsed as HH:MM:SS, HH:MM or
+    HH:MM:SS.nnnnnnnnn;
+
+    For usage of ``formatters`` see the rust chrono package ``strftime`` package.
+
+    [Documentation here.](https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
+    """
+    return Expr(f.to_time(arg.expr, *_unwrap_exprs(formatters)))
+
+
+def to_timestamp(arg: Expr, *formatters: Expr) -> Expr:
+    """Converts a string and optional formats to a ``Timestamp`` in nanoseconds.
+
+    For usage of ``formatters`` see the rust chrono package ``strftime`` package.
+
+    [Documentation here.](https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
+    """
+    return Expr(f.to_timestamp(arg.expr, *_unwrap_exprs(formatters)))
+
+
+def to_timestamp_millis(arg: Expr, *formatters: Expr) -> Expr:
+    """Converts a string and optional formats to a ``Timestamp`` in milliseconds.
+
+    See :py:func:`to_timestamp` for a description on how to use formatters.
+    """
+    return Expr(f.to_timestamp_millis(arg.expr, *_unwrap_exprs(formatters)))
+
+
+def to_timestamp_micros(arg: Expr, *formatters: Expr) -> Expr:
+    """Converts a string and optional formats to a ``Timestamp`` in microseconds.
+
+    See :py:func:`to_timestamp` for a description on how to use formatters.
+    """
+    return Expr(f.to_timestamp_micros(arg.expr, *_unwrap_exprs(formatters)))
+
+
+def to_timestamp_nanos(arg: Expr, *formatters: Expr) -> Expr:
+    """Converts a string and optional formats to a ``Timestamp`` in nanoseconds.
+
+    See :py:func:`to_timestamp` for a description on how to use formatters.
+    """
+    return Expr(f.to_timestamp_nanos(arg.expr, *_unwrap_exprs(formatters)))
+
+
+def to_timestamp_seconds(arg: Expr, *formatters: Expr) -> Expr:
+    """Converts a string and optional formats to a ``Timestamp`` in seconds.
+
+    See :py:func:`to_timestamp` for a description on how to use formatters.
+    """
+    return Expr(f.to_timestamp_seconds(arg.expr, *_unwrap_exprs(formatters)))
+
+
+def to_unixtime(string: Expr, *format_arguments: Expr) -> Expr:
+    """Converts a string and optional formats to a Unixtime."""
+    return Expr(f.to_unixtime(string.expr, *_unwrap_exprs(format_arguments)))
+
+
+def current_date() -> Expr:
+    """Returns current UTC date as a Date32 value."""
+    return Expr(f.current_date())
+
+
+today = current_date
+
+
+def current_time() -> Expr:
+    """Returns current UTC time as a Time64 value."""
+    return Expr(f.current_time())
+
+
+def datepart(part: Expr, date: Expr) -> Expr:
+    """Return a specified part of a date.
+
+    This is an alias for :py:func:`date_part`.
+    """
+    return date_part(part, date)
+
+
+def date_part(part: Expr, date: Expr) -> Expr:
+    """Extracts a subfield from the date."""
+    return Expr(f.date_part(part.expr, date.expr))
+
+
+def extract(part: Expr, date: Expr) -> Expr:
+    """Extracts a subfield from the date.
+
+    This is an alias for :py:func:`date_part`.
+    """
+    return date_part(part, date)
+
+
+def date_trunc(part: Expr, date: Expr) -> Expr:
+    """Truncates the date to a specified level of precision."""
+    return Expr(f.date_trunc(part.expr, date.expr))
+
+
+def datetrunc(part: Expr, date: Expr) -> Expr:
+    """Truncates the date to a specified level of precision.
+
+    This is an alias for :py:func:`date_trunc`.
+    """
+    return date_trunc(part, date)
+
+
+def date_bin(stride: Expr, source: Expr, origin: Expr) -> Expr:
+    """Coerces an arbitrary timestamp to the start of the nearest specified interval."""
+    return Expr(f.date_bin(stride.expr, source.expr, origin.expr))
+
+
+def make_date(year: Expr, month: Expr, day: Expr) -> Expr:
+    """Make a date from year, month and day component parts."""
+    return Expr(f.make_date(year.expr, month.expr, day.expr))
+
+
+def translate(string: Expr, from_val: Expr, to_val: Expr) -> Expr:
+    """Replaces the characters in ``from_val`` with the counterpart in ``to_val``."""
+    return Expr(f.translate(string.expr, from_val.expr, to_val.expr))
+
+
+def trim(arg: Expr) -> Expr:
+    """Removes all characters, spaces by default, from both sides of a string."""
+    return Expr(f.trim(arg.expr))
+
+
+def trunc(num: Expr, precision: Expr | None = None) -> Expr:
+    """Truncate the number toward zero with optional precision."""
+    if precision is not None:
+        return Expr(f.trunc(num.expr, precision.expr))
+    return Expr(f.trunc(num.expr))
+
+
+def upper(arg: Expr) -> Expr:
+    """Converts a string to uppercase."""
+    return Expr(f.upper(arg.expr))
+
+
+def make_array(*args: Expr) -> Expr:
+    """Returns an array using the specified input expressions."""
+    args = [arg.expr for arg in args]
+    return Expr(f.make_array(args))
+
+
+def make_list(*args: Expr) -> Expr:
+    """Returns an array using the specified input expressions.
+
+    This is an alias for :py:func:`make_array`.
+    """
+    return make_array(*args)
+
+
+def array(*args: Expr) -> Expr:
+    """Returns an array using the specified input expressions.
+
+    This is an alias for :py:func:`make_array`.
+    """
+    return make_array(*args)
+
+
+def range(start: Expr, stop: Expr, step: Expr) -> Expr:
+    """Create a list of values in the range between start and stop."""
+    return Expr(f.range(start.expr, stop.expr, step.expr))
+
+
+def uuid() -> Expr:
+    """Returns uuid v4 as a string value."""
+    return Expr(f.uuid())
+
+
+def struct(*args: Expr) -> Expr:
+    """Returns a struct with the given arguments."""
+    args = [arg.expr for arg in args]
+    return Expr(f.struct(*args))
+
+
+def named_struct(name_pairs: list[tuple[str, Expr]]) -> Expr:
+    """Returns a struct with the given names and arguments pairs."""
+    name_pair_exprs = [
+        [Expr.literal(pa.scalar(pair[0], type=pa.string())), pair[1]]
+        for pair in name_pairs
+    ]
+
+    # flatten
+    name_pairs = [x.expr for xs in name_pair_exprs for x in xs]
+    return Expr(f.named_struct(*name_pairs))
+
+
+def from_unixtime(arg: Expr) -> Expr:
+    """Converts an integer to RFC3339 timestamp format string."""
+    return Expr(f.from_unixtime(arg.expr))
+
+
+def arrow_typeof(arg: Expr) -> Expr:
+    """Returns the Arrow type of the expression."""
+    return Expr(f.arrow_typeof(arg.expr))
+
+
+def arrow_cast(expr: Expr, data_type: Expr) -> Expr:
+    """Casts an expression to a specified data type."""
+    return Expr(f.arrow_cast(expr.expr, data_type.expr))
+
+
+def random() -> Expr:
+    """Returns a random value in the range ``0.0 <= x < 1.0``."""
+    return Expr(f.random())
+
+
+def array_append(array: Expr, element: Expr) -> Expr:
+    """Appends an element to the end of an array."""
+    return Expr(f.array_append(array.expr, element.expr))
+
+
+def array_push_back(array: Expr, element: Expr) -> Expr:
+    """Appends an element to the end of an array.
+
+    This is an alias for :py:func:`array_append`.
+    """
+    return array_append(array, element)
+
+
+def list_append(array: Expr, element: Expr) -> Expr:
+    """Appends an element to the end of an array.
+
+    This is an alias for :py:func:`array_append`.
+    """
+    return array_append(array, element)
+
+
+def list_push_back(array: Expr, element: Expr) -> Expr:
+    """Appends an element to the end of an array.
+
+    This is an alias for :py:func:`array_append`.
+    """
+    return array_append(array, element)
+
+
+def array_concat(*args: Expr) -> Expr:
+    """Concatenates the input arrays."""
+    args = [arg.expr for arg in args]
+    return Expr(f.array_concat(args))
+
+
+def array_cat(*args: Expr) -> Expr:
+    """Concatenates the input arrays.
+
+    This is an alias for :py:func:`array_concat`.
+    """
+    return array_concat(*args)
+
+
+def array_dims(array: Expr) -> Expr:
+    """Returns an array of the array's dimensions."""
+    return Expr(f.array_dims(array.expr))
+
+
+def array_distinct(array: Expr) -> Expr:
+    """Returns distinct values from the array after removing duplicates."""
+    return Expr(f.array_distinct(array.expr))
+
+
+def list_cat(*args: Expr) -> Expr:
+    """Concatenates the input arrays.
+
+    This is an alias for :py:func:`array_concat`, :py:func:`array_cat`.
+    """
+    return array_concat(*args)
+
+
+def list_concat(*args: Expr) -> Expr:
+    """Concatenates the input arrays.
+
+    This is an alias for :py:func:`array_concat`, :py:func:`array_cat`.
+    """
+    return array_concat(*args)
+
+
+def list_distinct(array: Expr) -> Expr:
+    """Returns distinct values from the array after removing duplicates.
+
+    This is an alias for :py:func:`array_distinct`.
+    """
+    return array_distinct(array)
+
+
+def list_dims(array: Expr) -> Expr:
+    """Returns an array of the array's dimensions.
+
+    This is an alias for :py:func:`array_dims`.
+    """
+    return array_dims(array)
+
+
+def array_element(array: Expr, n: Expr) -> Expr:
+    """Extracts the element with the index n from the array."""
+    return Expr(f.array_element(array.expr, n.expr))
+
+
+def array_empty(array: Expr) -> Expr:
+    """Returns a boolean indicating whether the array is empty."""
+    return Expr(f.array_empty(array.expr))
+
+
+def array_extract(array: Expr, n: Expr) -> Expr:
+    """Extracts the element with the index n from the array.
+
+    This is an alias for :py:func:`array_element`.
+    """
+    return array_element(array, n)
+
+
+def list_element(array: Expr, n: Expr) -> Expr:
+    """Extracts the element with the index n from the array.
+
+    This is an alias for :py:func:`array_element`.
+    """
+    return array_element(array, n)
+
+
+def list_extract(array: Expr, n: Expr) -> Expr:
+    """Extracts the element with the index n from the array.
+
+    This is an alias for :py:func:`array_element`.
+    """
+    return array_element(array, n)
+
+
+def array_length(array: Expr) -> Expr:
+    """Returns the length of the array."""
+    return Expr(f.array_length(array.expr))
+
+
+def list_length(array: Expr) -> Expr:
+    """Returns the length of the array.
+
+    This is an alias for :py:func:`array_length`.
+    """
+    return array_length(array)
+
+
+def array_has(first_array: Expr, second_array: Expr) -> Expr:
+    """Returns true if the element appears in the first array, otherwise false."""
+    return Expr(f.array_has(first_array.expr, second_array.expr))
+
+
+def array_has_all(first_array: Expr, second_array: Expr) -> Expr:
+    """Determines if there is complete overlap ``second_array`` in ``first_array``.
+
+    Returns true if each element of the second array appears in the first array.
+    Otherwise, it returns false.
+    """
+    return Expr(f.array_has_all(first_array.expr, second_array.expr))
+
+
+def array_has_any(first_array: Expr, second_array: Expr) -> Expr:
+    """Determine if there is an overlap between ``first_array`` and ``second_array``.
+
+    Returns true if at least one element of the second array appears in the first
+    array. Otherwise, it returns false.
+    """
+    return Expr(f.array_has_any(first_array.expr, second_array.expr))
+
+
+def array_position(array: Expr, element: Expr, index: int | None = 1) -> Expr:
+    """Return the position of the first occurrence of ``element`` in ``array``."""
+    return Expr(f.array_position(array.expr, element.expr, index))
+
+
+def array_indexof(array: Expr, element: Expr, index: int | None = 1) -> Expr:
+    """Return the position of the first occurrence of ``element`` in ``array``.
+
+    This is an alias for :py:func:`array_position`.
+    """
+    return array_position(array, element, index)
+
+
+def list_position(array: Expr, element: Expr, index: int | None = 1) -> Expr:
+    """Return the position of the first occurrence of ``element`` in ``array``.
+
+    This is an alias for :py:func:`array_position`.
+    """
+    return array_position(array, element, index)
+
+
+def list_indexof(array: Expr, element: Expr, index: int | None = 1) -> Expr:
+    """Return the position of the first occurrence of ``element`` in ``array``.
+
+    This is an alias for :py:func:`array_position`.
+    """
+    return array_position(array, element, index)
+
+
+def array_positions(array: Expr, element: Expr) -> Expr:
+    """Searches for an element in the array and returns all occurrences."""
+    return Expr(f.array_positions(array.expr, element.expr))
+
+
+def list_positions(array: Expr, element: Expr) -> Expr:
+    """Searches for an element in the array and returns all occurrences.
+
+    This is an alias for :py:func:`array_positions`.
+    """
+    return array_positions(array, element)
+
+
+def array_ndims(array: Expr) -> Expr:
+    """Returns the number of dimensions of the array."""
+    return Expr(f.array_ndims(array.expr))
+
+
+def list_ndims(array: Expr) -> Expr:
+    """Returns the number of dimensions of the array.
+
+    This is an alias for :py:func:`array_ndims`.
+    """
+    return array_ndims(array)
+
+
+def array_prepend(element: Expr, array: Expr) -> Expr:
+    """Prepends an element to the beginning of an array."""
+    return Expr(f.array_prepend(element.expr, array.expr))
+
+
+def array_push_front(element: Expr, array: Expr) -> Expr:
+    """Prepends an element to the beginning of an array.
+
+    This is an alias for :py:func:`array_prepend`.
+    """
+    return array_prepend(element, array)
+
+
+def list_prepend(element: Expr, array: Expr) -> Expr:
+    """Prepends an element to the beginning of an array.
+
+    This is an alias for :py:func:`array_prepend`.
+    """
+    return array_prepend(element, array)
+
+
+def list_push_front(element: Expr, array: Expr) -> Expr:
+    """Prepends an element to the beginning of an array.
+
+    This is an alias for :py:func:`array_prepend`.
+    """
+    return array_prepend(element, array)
+
+
+def array_pop_back(array: Expr) -> Expr:
+    """Returns the array without the last element."""
+    return Expr(f.array_pop_back(array.expr))
+
+
+def array_pop_front(array: Expr) -> Expr:
+    """Returns the array without the first element."""
+    return Expr(f.array_pop_front(array.expr))
+
+
+def array_remove(array: Expr, element: Expr) -> Expr:
+    """Removes the first element from the array equal to the given value."""
+    return Expr(f.array_remove(array.expr, element.expr))
+
+
+def list_remove(array: Expr, element: Expr) -> Expr:
+    """Removes the first element from the array equal to the given value.
+
+    This is an alias for :py:func:`array_remove`.
+    """
+    return array_remove(array, element)
+
+
+def array_remove_n(array: Expr, element: Expr, max: Expr) -> Expr:
+    """Removes the first ``max`` elements from the array equal to the given value."""
+    return Expr(f.array_remove_n(array.expr, element.expr, max.expr))
+
+
+def list_remove_n(array: Expr, element: Expr, max: Expr) -> Expr:
+    """Removes the first ``max`` elements from the array equal to the given value.
+
+    This is an alias for :py:func:`array_remove_n`.
+    """
+    return array_remove_n(array, element, max)
+
+
+def array_remove_all(array: Expr, element: Expr) -> Expr:
+    """Removes all elements from the array equal to the given value."""
+    return Expr(f.array_remove_all(array.expr, element.expr))
+
+
+def list_remove_all(array: Expr, element: Expr) -> Expr:
+    """Removes all elements from the array equal to the given value.
+
+    This is an alias for :py:func:`array_remove_all`.
+    """
+    return array_remove_all(array, element)
+
+
+def array_repeat(element: Expr, count: Expr) -> Expr:
+    """Returns an array containing ``element`` ``count`` times."""
+    return Expr(f.array_repeat(element.expr, count.expr))
+
+
+def list_repeat(element: Expr, count: Expr) -> Expr:
+    """Returns an array containing ``element`` ``count`` times.
+
+    This is an alias for :py:func:`array_repeat`.
+    """
+    return array_repeat(element, count)
+
+
+def array_replace(array: Expr, from_val: Expr, to_val: Expr) -> Expr:
+    """Replaces the first occurrence of ``from_val`` with ``to_val``."""
+    return Expr(f.array_replace(array.expr, from_val.expr, to_val.expr))
+
+
+def list_replace(array: Expr, from_val: Expr, to_val: Expr) -> Expr:
+    """Replaces the first occurrence of ``from_val`` with ``to_val``.
+
+    This is an alias for :py:func:`array_replace`.
+    """
+    return array_replace(array, from_val, to_val)
+
+
+def array_replace_n(array: Expr, from_val: Expr, to_val: Expr, max: Expr) -> Expr:
+    """Replace ``n`` occurrences of ``from_val`` with ``to_val``.
+
+    Replaces the first ``max`` occurrences of the specified element with another
+    specified element.
+    """
+    return Expr(f.array_replace_n(array.expr, from_val.expr, to_val.expr, max.expr))
+
+
+def list_replace_n(array: Expr, from_val: Expr, to_val: Expr, max: Expr) -> Expr:
+    """Replace ``n`` occurrences of ``from_val`` with ``to_val``.
+
+    Replaces the first ``max`` occurrences of the specified element with another
+    specified element.
+
+    This is an alias for :py:func:`array_replace_n`.
+    """
+    return array_replace_n(array, from_val, to_val, max)
+
+
+def array_replace_all(array: Expr, from_val: Expr, to_val: Expr) -> Expr:
+    """Replaces all occurrences of ``from_val`` with ``to_val``."""
+    return Expr(f.array_replace_all(array.expr, from_val.expr, to_val.expr))
+
+
+def list_replace_all(array: Expr, from_val: Expr, to_val: Expr) -> Expr:
+    """Replaces all occurrences of ``from_val`` with ``to_val``.
+
+    This is an alias for :py:func:`array_replace_all`.
+    """
+    return array_replace_all(array, from_val, to_val)
+
+
+def array_sort(array: Expr, descending: bool = False, null_first: bool = False) -> Expr:
+    """Sort an array.
+
+    Args:
+        array: The input array to sort.
+        descending: If True, sorts in descending order.
+        null_first: If True, nulls will be returned at the beginning of the array.
+    """
+    desc = "DESC" if descending else "ASC"
+    nulls_first = "NULLS FIRST" if null_first else "NULLS LAST"
+    return Expr(
+        f.array_sort(
+            array.expr,
+            Expr.literal(pa.scalar(desc, type=pa.string())).expr,
+            Expr.literal(pa.scalar(nulls_first, type=pa.string())).expr,
+        )
+    )
+
+
+def list_sort(array: Expr, descending: bool = False, null_first: bool = False) -> Expr:
+    """This is an alias for :py:func:`array_sort`."""
+    return array_sort(array, descending=descending, null_first=null_first)
+
+
+def array_slice(
+    array: Expr, begin: Expr, end: Expr, stride: Expr | None = None
+) -> Expr:
+    """Returns a slice of the array."""
+    if stride is not None:
+        stride = stride.expr
+    return Expr(f.array_slice(array.expr, begin.expr, end.expr, stride))
+
+
+def list_slice(array: Expr, begin: Expr, end: Expr, stride: Expr | None = None) -> Expr:
+    """Returns a slice of the array.
+
+    This is an alias for :py:func:`array_slice`.
+    """
+    return array_slice(array, begin, end, stride)
+
+
+def array_intersect(array1: Expr, array2: Expr) -> Expr:
+    """Returns the intersection of ``array1`` and ``array2``."""
+    return Expr(f.array_intersect(array1.expr, array2.expr))
+
+
+def list_intersect(array1: Expr, array2: Expr) -> Expr:
+    """Returns an the intersection of ``array1`` and ``array2``.
+
+    This is an alias for :py:func:`array_intersect`.
+    """
+    return array_intersect(array1, array2)
+
+
+def array_union(array1: Expr, array2: Expr) -> Expr:
+    """Returns an array of the elements in the union of array1 and array2.
+
+    Duplicate rows will not be returned.
+    """
+    return Expr(f.array_union(array1.expr, array2.expr))
+
+
+def list_union(array1: Expr, array2: Expr) -> Expr:
+    """Returns an array of the elements in the union of array1 and array2.
+
+    Duplicate rows will not be returned.
+
+    This is an alias for :py:func:`array_union`.
+    """
+    return array_union(array1, array2)
+
+
+def array_except(array1: Expr, array2: Expr) -> Expr:
+    """Returns the elements that appear in ``array1`` but not in ``array2``."""
+    return Expr(f.array_except(array1.expr, array2.expr))
+
+
+def list_except(array1: Expr, array2: Expr) -> Expr:
+    """Returns the elements that appear in ``array1`` but not in the ``array2``.
+
+    This is an alias for :py:func:`array_except`.
+    """
+    return array_except(array1, array2)
+
+
+def array_resize(array: Expr, size: Expr, value: Expr) -> Expr:
+    """Returns an array with the specified size filled.
+
+    If ``size`` is greater than the ``array`` length, the additional entries will
+    be filled with the given ``value``.
+    """
+    return Expr(f.array_resize(array.expr, size.expr, value.expr))
+
+
+def list_resize(array: Expr, size: Expr, value: Expr) -> Expr:
+    """Returns an array with the specified size filled.
+
+    If ``size`` is greater than the ``array`` length, the additional entries will be
+    filled with the given ``value``. This is an alias for :py:func:`array_resize`.
+    """
+    return array_resize(array, size, value)
+
+
+def flatten(array: Expr) -> Expr:
+    """Flattens an array of arrays into a single array."""
+    return Expr(f.flatten(array.expr))
+
+
+def cardinality(array: Expr) -> Expr:
+    """Returns the total number of elements in the array."""
+    return Expr(f.cardinality(array.expr))
+
+
+def empty(array: Expr) -> Expr:
+    """This is an alias for :py:func:`array_empty`."""
+    return array_empty(array)
+
+
+# aggregate functions
+def approx_distinct(
+    expression: Expr,
+    filter: Expr | None = None,
+) -> Expr:
+    """Returns the approximate number of distinct values.
+
+    This aggregate function is similar to :py:func:`count` with distinct set, but it
+    will approximate the number of distinct entries. It may return significantly faster
+    than :py:func:`count` for some DataFrames.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        expression: Values to check for distinct entries
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+
+    return Expr(f.approx_distinct(expression.expr, filter=filter_raw))
+
+
+def approx_median(expression: Expr, filter: Expr | None = None) -> Expr:
+    """Returns the approximate median value.
+
+    This aggregate function is similar to :py:func:`median`, but it will only
+    approximate the median. It may return significantly faster for some DataFrames.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by`` and ``null_treatment``, and ``distinct``.
+
+    Args:
+        expression: Values to find the median for
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+    return Expr(f.approx_median(expression.expr, filter=filter_raw))
+
+
+def approx_percentile_cont(
+    sort_expression: Expr | SortExpr,
+    percentile: float,
+    num_centroids: int | None = None,
+    filter: Expr | None = None,
+) -> Expr:
+    """Returns the value that is approximately at a given percentile of ``expr``.
+
+    This aggregate function assumes the input values form a continuous distribution.
+    Suppose you have a DataFrame which consists of 100 different test scores. If you
+    called this function with a percentile of 0.9, it would return the value of the
+    test score that is above 90% of the other test scores. The returned value may be
+    between two of the values.
+
+    This function uses the [t-digest](https://arxiv.org/abs/1902.04023) algorithm to
+    compute the percentile. You can limit the number of bins used in this algorithm by
+    setting the ``num_centroids`` parameter.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        sort_expression: Values for which to find the approximate percentile
+        percentile: This must be between 0.0 and 1.0, inclusive
+        num_centroids: Max bin size for the t-digest algorithm
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    sort_expr_raw = sort_or_default(sort_expression)
+    filter_raw = filter.expr if filter is not None else None
+    return Expr(
+        f.approx_percentile_cont(
+            sort_expr_raw, percentile, num_centroids=num_centroids, filter=filter_raw
+        )
+    )
+
+
+def approx_percentile_cont_with_weight(
+    sort_expression: Expr | SortExpr,
+    weight: Expr,
+    percentile: float,
+    num_centroids: int | None = None,
+    filter: Expr | None = None,
+) -> Expr:
+    """Returns the value of the weighted approximate percentile.
+
+    This aggregate function is similar to :py:func:`approx_percentile_cont` except that
+    it uses the associated associated weights.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        sort_expression: Values for which to find the approximate percentile
+        weight: Relative weight for each of the values in ``expression``
+        percentile: This must be between 0.0 and 1.0, inclusive
+        num_centroids: Max bin size for the t-digest algorithm
+        filter: If provided, only compute against rows for which the filter is True
+
+    """
+    sort_expr_raw = sort_or_default(sort_expression)
+    filter_raw = filter.expr if filter is not None else None
+    return Expr(
+        f.approx_percentile_cont_with_weight(
+            sort_expr_raw,
+            weight.expr,
+            percentile,
+            num_centroids=num_centroids,
+            filter=filter_raw,
+        )
+    )
+
+
+def array_agg(
+    expression: Expr,
+    distinct: bool = False,
+    filter: Expr | None = None,
+    order_by: list[SortKey] | SortKey | None = None,
+) -> Expr:
+    """Aggregate values into an array.
+
+    Currently ``distinct`` and ``order_by`` cannot be used together. As a work around,
+    consider :py:func:`array_sort` after aggregation.
+    [Issue Tracker](https://github.com/apache/datafusion/issues/12371)
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the option ``null_treatment``.
+
+    Args:
+        expression: Values to combine into an array
+        distinct: If True, a single entry for each distinct value will be in the result
+        filter: If provided, only compute against rows for which the filter is True
+        order_by: Order the resultant array values. Accepts column names or expressions.
+
+    For example::
+
+        df.aggregate([], array_agg(col("a"), order_by="b"))
+    """
+    order_by_raw = sort_list_to_raw_sort_list(order_by)
+    filter_raw = filter.expr if filter is not None else None
+
+    return Expr(
+        f.array_agg(
+            expression.expr, distinct=distinct, filter=filter_raw, order_by=order_by_raw
+        )
+    )
+
+
+def avg(
+    expression: Expr,
+    filter: Expr | None = None,
+) -> Expr:
+    """Returns the average value.
+
+    This aggregate function expects a numeric expression and will return a float.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        expression: Values to combine into an array
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+    return Expr(f.avg(expression.expr, filter=filter_raw))
+
+
+def corr(value_y: Expr, value_x: Expr, filter: Expr | None = None) -> Expr:
+    """Returns the correlation coefficient between ``value1`` and ``value2``.
+
+    This aggregate function expects both values to be numeric and will return a float.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        value_y: The dependent variable for correlation
+        value_x: The independent variable for correlation
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+    return Expr(f.corr(value_y.expr, value_x.expr, filter=filter_raw))
+
+
+def count(
+    expressions: Expr | list[Expr] | None = None,
+    distinct: bool = False,
+    filter: Expr | None = None,
+) -> Expr:
+    """Returns the number of rows that match the given arguments.
+
+    This aggregate function will count the non-null rows provided in the expression.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by`` and ``null_treatment``.
+
+    Args:
+        expressions: Argument to perform bitwise calculation on
+        distinct: If True, a single entry for each distinct value will be in the result
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+
+    if expressions is None:
+        args = [Expr.literal(1).expr]
+    elif isinstance(expressions, list):
+        args = [arg.expr for arg in expressions]
+    else:
+        args = [expressions.expr]
+
+    return Expr(f.count(*args, distinct=distinct, filter=filter_raw))
+
+
+def covar_pop(value_y: Expr, value_x: Expr, filter: Expr | None = None) -> Expr:
+    """Computes the population covariance.
+
+    This aggregate function expects both values to be numeric and will return a float.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        value_y: The dependent variable for covariance
+        value_x: The independent variable for covariance
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+    return Expr(f.covar_pop(value_y.expr, value_x.expr, filter=filter_raw))
+
+
+def covar_samp(value_y: Expr, value_x: Expr, filter: Expr | None = None) -> Expr:
+    """Computes the sample covariance.
+
+    This aggregate function expects both values to be numeric and will return a float.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        value_y: The dependent variable for covariance
+        value_x: The independent variable for covariance
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+    return Expr(f.covar_samp(value_y.expr, value_x.expr, filter=filter_raw))
+
+
+def covar(value_y: Expr, value_x: Expr, filter: Expr | None = None) -> Expr:
+    """Computes the sample covariance.
+
+    This is an alias for :py:func:`covar_samp`.
+    """
+    return covar_samp(value_y, value_x, filter)
+
+
+def max(expression: Expr, filter: Expr | None = None) -> Expr:
+    """Aggregate function that returns the maximum value of the argument.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        expression: The value to find the maximum of
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+    return Expr(f.max(expression.expr, filter=filter_raw))
+
+
+def mean(expression: Expr, filter: Expr | None = None) -> Expr:
+    """Returns the average (mean) value of the argument.
+
+    This is an alias for :py:func:`avg`.
+    """
+    return avg(expression, filter)
+
+
+def median(
+    expression: Expr, distinct: bool = False, filter: Expr | None = None
+) -> Expr:
+    """Computes the median of a set of numbers.
+
+    This aggregate function returns the median value of the expression for the given
+    aggregate function.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by`` and ``null_treatment``.
+
+    Args:
+        expression: The value to compute the median of
+        distinct: If True, a single entry for each distinct value will be in the result
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+    return Expr(f.median(expression.expr, distinct=distinct, filter=filter_raw))
+
+
+def min(expression: Expr, filter: Expr | None = None) -> Expr:
+    """Aggregate function that returns the minimum value of the argument.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        expression: The value to find the minimum of
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+    return Expr(f.min(expression.expr, filter=filter_raw))
+
+
+def sum(
+    expression: Expr,
+    filter: Expr | None = None,
+) -> Expr:
+    """Computes the sum of a set of numbers.
+
+    This aggregate function expects a numeric expression.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        expression: Values to combine into an array
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+    return Expr(f.sum(expression.expr, filter=filter_raw))
+
+
+def stddev(expression: Expr, filter: Expr | None = None) -> Expr:
+    """Computes the standard deviation of the argument.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        expression: The value to find the minimum of
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+    return Expr(f.stddev(expression.expr, filter=filter_raw))
+
+
+def stddev_pop(expression: Expr, filter: Expr | None = None) -> Expr:
+    """Computes the population standard deviation of the argument.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        expression: The value to find the minimum of
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+    return Expr(f.stddev_pop(expression.expr, filter=filter_raw))
+
+
+def stddev_samp(arg: Expr, filter: Expr | None = None) -> Expr:
+    """Computes the sample standard deviation of the argument.
+
+    This is an alias for :py:func:`stddev`.
+    """
+    return stddev(arg, filter=filter)
+
+
+def var(expression: Expr, filter: Expr | None = None) -> Expr:
+    """Computes the sample variance of the argument.
+
+    This is an alias for :py:func:`var_samp`.
+    """
+    return var_samp(expression, filter)
+
+
+def var_pop(expression: Expr, filter: Expr | None = None) -> Expr:
+    """Computes the population variance of the argument.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        expression: The variable to compute the variance for
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+    return Expr(f.var_pop(expression.expr, filter=filter_raw))
+
+
+def var_samp(expression: Expr, filter: Expr | None = None) -> Expr:
+    """Computes the sample variance of the argument.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        expression: The variable to compute the variance for
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+    return Expr(f.var_sample(expression.expr, filter=filter_raw))
+
+
+def var_sample(expression: Expr, filter: Expr | None = None) -> Expr:
+    """Computes the sample variance of the argument.
+
+    This is an alias for :py:func:`var_samp`.
+    """
+    return var_samp(expression, filter)
+
+
+def regr_avgx(
+    y: Expr,
+    x: Expr,
+    filter: Expr | None = None,
+) -> Expr:
+    """Computes the average of the independent variable ``x``.
+
+    This is a linear regression aggregate function. Only non-null pairs of the inputs
+    are evaluated.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        y: The linear regression dependent variable
+        x: The linear regression independent variable
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+
+    return Expr(f.regr_avgx(y.expr, x.expr, filter=filter_raw))
+
+
+def regr_avgy(
+    y: Expr,
+    x: Expr,
+    filter: Expr | None = None,
+) -> Expr:
+    """Computes the average of the dependent variable ``y``.
+
+    This is a linear regression aggregate function. Only non-null pairs of the inputs
+    are evaluated.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        y: The linear regression dependent variable
+        x: The linear regression independent variable
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+
+    return Expr(f.regr_avgy(y.expr, x.expr, filter=filter_raw))
+
+
+def regr_count(
+    y: Expr,
+    x: Expr,
+    filter: Expr | None = None,
+) -> Expr:
+    """Counts the number of rows in which both expressions are not null.
+
+    This is a linear regression aggregate function. Only non-null pairs of the inputs
+    are evaluated.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        y: The linear regression dependent variable
+        x: The linear regression independent variable
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+
+    return Expr(f.regr_count(y.expr, x.expr, filter=filter_raw))
+
+
+def regr_intercept(
+    y: Expr,
+    x: Expr,
+    filter: Expr | None = None,
+) -> Expr:
+    """Computes the intercept from the linear regression.
+
+    This is a linear regression aggregate function. Only non-null pairs of the inputs
+    are evaluated.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        y: The linear regression dependent variable
+        x: The linear regression independent variable
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+
+    return Expr(f.regr_intercept(y.expr, x.expr, filter=filter_raw))
+
+
+def regr_r2(
+    y: Expr,
+    x: Expr,
+    filter: Expr | None = None,
+) -> Expr:
+    """Computes the R-squared value from linear regression.
+
+    This is a linear regression aggregate function. Only non-null pairs of the inputs
+    are evaluated.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        y: The linear regression dependent variable
+        x: The linear regression independent variable
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+
+    return Expr(f.regr_r2(y.expr, x.expr, filter=filter_raw))
+
+
+def regr_slope(
+    y: Expr,
+    x: Expr,
+    filter: Expr | None = None,
+) -> Expr:
+    """Computes the slope from linear regression.
+
+    This is a linear regression aggregate function. Only non-null pairs of the inputs
+    are evaluated.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        y: The linear regression dependent variable
+        x: The linear regression independent variable
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+
+    return Expr(f.regr_slope(y.expr, x.expr, filter=filter_raw))
+
+
+def regr_sxx(
+    y: Expr,
+    x: Expr,
+    filter: Expr | None = None,
+) -> Expr:
+    """Computes the sum of squares of the independent variable ``x``.
+
+    This is a linear regression aggregate function. Only non-null pairs of the inputs
+    are evaluated.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        y: The linear regression dependent variable
+        x: The linear regression independent variable
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+
+    return Expr(f.regr_sxx(y.expr, x.expr, filter=filter_raw))
+
+
+def regr_sxy(
+    y: Expr,
+    x: Expr,
+    filter: Expr | None = None,
+) -> Expr:
+    """Computes the sum of products of pairs of numbers.
+
+    This is a linear regression aggregate function. Only non-null pairs of the inputs
+    are evaluated.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        y: The linear regression dependent variable
+        x: The linear regression independent variable
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+
+    return Expr(f.regr_sxy(y.expr, x.expr, filter=filter_raw))
+
+
+def regr_syy(
+    y: Expr,
+    x: Expr,
+    filter: Expr | None = None,
+) -> Expr:
+    """Computes the sum of squares of the dependent variable ``y``.
+
+    This is a linear regression aggregate function. Only non-null pairs of the inputs
+    are evaluated.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        y: The linear regression dependent variable
+        x: The linear regression independent variable
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+
+    return Expr(f.regr_syy(y.expr, x.expr, filter=filter_raw))
+
+
+def first_value(
+    expression: Expr,
+    filter: Expr | None = None,
+    order_by: list[SortKey] | SortKey | None = None,
+    null_treatment: NullTreatment = NullTreatment.RESPECT_NULLS,
+) -> Expr:
+    """Returns the first value in a group of values.
+
+    This aggregate function will return the first value in the partition.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the option ``distinct``.
+
+    Args:
+        expression: Argument to perform bitwise calculation on
+        filter: If provided, only compute against rows for which the filter is True
+        order_by: Set the ordering of the expression to evaluate. Accepts
+            column names or expressions.
+        null_treatment: Assign whether to respect or ignore null values.
+
+    For example::
+
+        df.aggregate([], first_value(col("a"), order_by="ts"))
+    """
+    order_by_raw = sort_list_to_raw_sort_list(order_by)
+    filter_raw = filter.expr if filter is not None else None
+
+    return Expr(
+        f.first_value(
+            expression.expr,
+            filter=filter_raw,
+            order_by=order_by_raw,
+            null_treatment=null_treatment.value,
+        )
+    )
+
+
+def last_value(
+    expression: Expr,
+    filter: Expr | None = None,
+    order_by: list[SortKey] | SortKey | None = None,
+    null_treatment: NullTreatment = NullTreatment.RESPECT_NULLS,
+) -> Expr:
+    """Returns the last value in a group of values.
+
+    This aggregate function will return the last value in the partition.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the option ``distinct``.
+
+    Args:
+        expression: Argument to perform bitwise calculation on
+        filter: If provided, only compute against rows for which the filter is True
+        order_by: Set the ordering of the expression to evaluate. Accepts
+            column names or expressions.
+        null_treatment: Assign whether to respect or ignore null values.
+
+    For example::
+
+        df.aggregate([], last_value(col("a"), order_by="ts"))
+    """
+    order_by_raw = sort_list_to_raw_sort_list(order_by)
+    filter_raw = filter.expr if filter is not None else None
+
+    return Expr(
+        f.last_value(
+            expression.expr,
+            filter=filter_raw,
+            order_by=order_by_raw,
+            null_treatment=null_treatment.value,
+        )
+    )
+
+
+def nth_value(
+    expression: Expr,
+    n: int,
+    filter: Expr | None = None,
+    order_by: list[SortKey] | SortKey | None = None,
+    null_treatment: NullTreatment = NullTreatment.RESPECT_NULLS,
+) -> Expr:
+    """Returns the n-th value in a group of values.
+
+    This aggregate function will return the n-th value in the partition.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the option ``distinct``.
+
+    Args:
+        expression: Argument to perform bitwise calculation on
+        n: Index of value to return. Starts at 1.
+        filter: If provided, only compute against rows for which the filter is True
+        order_by: Set the ordering of the expression to evaluate. Accepts
+            column names or expressions.
+        null_treatment: Assign whether to respect or ignore null values.
+
+    For example::
+
+        df.aggregate([], nth_value(col("a"), 2, order_by="ts"))
+    """
+    order_by_raw = sort_list_to_raw_sort_list(order_by)
+    filter_raw = filter.expr if filter is not None else None
+
+    return Expr(
+        f.nth_value(
+            expression.expr,
+            n,
+            filter=filter_raw,
+            order_by=order_by_raw,
+            null_treatment=null_treatment.value,
+        )
+    )
+
+
+def bit_and(expression: Expr, filter: Expr | None = None) -> Expr:
+    """Computes the bitwise AND of the argument.
+
+    This aggregate function will bitwise compare every value in the input partition.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        expression: Argument to perform bitwise calculation on
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+    return Expr(f.bit_and(expression.expr, filter=filter_raw))
+
+
+def bit_or(expression: Expr, filter: Expr | None = None) -> Expr:
+    """Computes the bitwise OR of the argument.
+
+    This aggregate function will bitwise compare every value in the input partition.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        expression: Argument to perform bitwise calculation on
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+    return Expr(f.bit_or(expression.expr, filter=filter_raw))
+
+
+def bit_xor(
+    expression: Expr, distinct: bool = False, filter: Expr | None = None
+) -> Expr:
+    """Computes the bitwise XOR of the argument.
+
+    This aggregate function will bitwise compare every value in the input partition.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by`` and ``null_treatment``.
+
+    Args:
+        expression: Argument to perform bitwise calculation on
+        distinct: If True, evaluate each unique value of expression only once
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+    return Expr(f.bit_xor(expression.expr, distinct=distinct, filter=filter_raw))
+
+
+def bool_and(expression: Expr, filter: Expr | None = None) -> Expr:
+    """Computes the boolean AND of the argument.
+
+    This aggregate function will compare every value in the input partition. These are
+    expected to be boolean values.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        expression: Argument to perform calculation on
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+    return Expr(f.bool_and(expression.expr, filter=filter_raw))
+
+
+def bool_or(expression: Expr, filter: Expr | None = None) -> Expr:
+    """Computes the boolean OR of the argument.
+
+    This aggregate function will compare every value in the input partition. These are
+    expected to be boolean values.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``order_by``, ``null_treatment``, and ``distinct``.
+
+    Args:
+        expression: Argument to perform calculation on
+        filter: If provided, only compute against rows for which the filter is True
+    """
+    filter_raw = filter.expr if filter is not None else None
+    return Expr(f.bool_or(expression.expr, filter=filter_raw))
+
+
+def lead(
+    arg: Expr,
+    shift_offset: int = 1,
+    default_value: Any | None = None,
+    partition_by: list[Expr] | Expr | None = None,
+    order_by: list[SortKey] | SortKey | None = None,
+) -> Expr:
+    """Create a lead window function.
+
+    Lead operation will return the argument that is in the next shift_offset-th row in
+    the partition. For example ``lead(col("b"), shift_offset=3, default_value=5)`` will
+    return the 3rd following value in column ``b``. At the end of the partition, where
+    no further values can be returned it will return the default value of 5.
+
+    Here is an example of both the ``lead`` and :py:func:`datafusion.functions.lag`
+    functions on a simple DataFrame::
+
+        +--------+------+-----+
+        | points | lead | lag |
+        +--------+------+-----+
+        | 100    | 100  |     |
+        | 100    | 50   | 100 |
+        | 50     | 25   | 100 |
+        | 25     |      | 50  |
+        +--------+------+-----+
+
+    To set window function parameters use the window builder approach described in the
+    ref:`_window_functions` online documentation.
+
+    Args:
+        arg: Value to return
+        shift_offset: Number of rows following the current row.
+        default_value: Value to return if shift_offet row does not exist.
+        partition_by: Expressions to partition the window frame on.
+        order_by: Set ordering within the window frame. Accepts
+            column names or expressions.
+
+    For example::
+
+        lead(col("b"), order_by="ts")
+    """
+    if not isinstance(default_value, pa.Scalar) and default_value is not None:
+        default_value = pa.scalar(default_value)
+
+    partition_by_raw = expr_list_to_raw_expr_list(partition_by)
+    order_by_raw = sort_list_to_raw_sort_list(order_by)
+
+    return Expr(
+        f.lead(
+            arg.expr,
+            shift_offset,
+            default_value,
+            partition_by=partition_by_raw,
+            order_by=order_by_raw,
+        )
+    )
+
+
+def lag(
+    arg: Expr,
+    shift_offset: int = 1,
+    default_value: Any | None = None,
+    partition_by: list[Expr] | Expr | None = None,
+    order_by: list[SortKey] | SortKey | None = None,
+) -> Expr:
+    """Create a lag window function.
+
+    Lag operation will return the argument that is in the previous shift_offset-th row
+    in the partition. For example ``lag(col("b"), shift_offset=3, default_value=5)``
+    will return the 3rd previous value in column ``b``. At the beginning of the
+    partition, where no values can be returned it will return the default value of 5.
+
+    Here is an example of both the ``lag`` and :py:func:`datafusion.functions.lead`
+    functions on a simple DataFrame::
+
+        +--------+------+-----+
+        | points | lead | lag |
+        +--------+------+-----+
+        | 100    | 100  |     |
+        | 100    | 50   | 100 |
+        | 50     | 25   | 100 |
+        | 25     |      | 50  |
+        +--------+------+-----+
+
+    Args:
+        arg: Value to return
+        shift_offset: Number of rows before the current row.
+        default_value: Value to return if shift_offet row does not exist.
+        partition_by: Expressions to partition the window frame on.
+        order_by: Set ordering within the window frame. Accepts
+            column names or expressions.
+
+    For example::
+
+        lag(col("b"), order_by="ts")
+    """
+    if not isinstance(default_value, pa.Scalar):
+        default_value = pa.scalar(default_value)
+
+    partition_by_raw = expr_list_to_raw_expr_list(partition_by)
+    order_by_raw = sort_list_to_raw_sort_list(order_by)
+
+    return Expr(
+        f.lag(
+            arg.expr,
+            shift_offset,
+            default_value,
+            partition_by=partition_by_raw,
+            order_by=order_by_raw,
+        )
+    )
+
+
+def row_number(
+    partition_by: list[Expr] | Expr | None = None,
+    order_by: list[SortKey] | SortKey | None = None,
+) -> Expr:
+    """Create a row number window function.
+
+    Returns the row number of the window function.
+
+    Here is an example of the ``row_number`` on a simple DataFrame::
+
+        +--------+------------+
+        | points | row number |
+        +--------+------------+
+        | 100    | 1          |
+        | 100    | 2          |
+        | 50     | 3          |
+        | 25     | 4          |
+        +--------+------------+
+
+    Args:
+        partition_by: Expressions to partition the window frame on.
+        order_by: Set ordering within the window frame. Accepts
+            column names or expressions.
+
+    For example::
+
+        row_number(order_by="points")
+    """
+    partition_by_raw = expr_list_to_raw_expr_list(partition_by)
+    order_by_raw = sort_list_to_raw_sort_list(order_by)
+
+    return Expr(
+        f.row_number(
+            partition_by=partition_by_raw,
+            order_by=order_by_raw,
+        )
+    )
+
+
+def rank(
+    partition_by: list[Expr] | Expr | None = None,
+    order_by: list[SortKey] | SortKey | None = None,
+) -> Expr:
+    """Create a rank window function.
+
+    Returns the rank based upon the window order. Consecutive equal values will receive
+    the same rank, but the next different value will not be consecutive but rather the
+    number of rows that precede it plus one. This is similar to Olympic medals. If two
+    people tie for gold, the next place is bronze. There would be no silver medal. Here
+    is an example of a dataframe with a window ordered by descending ``points`` and the
+    associated rank.
+
+    You should set ``order_by`` to produce meaningful results::
+
+        +--------+------+
+        | points | rank |
+        +--------+------+
+        | 100    | 1    |
+        | 100    | 1    |
+        | 50     | 3    |
+        | 25     | 4    |
+        +--------+------+
+
+    Args:
+        partition_by: Expressions to partition the window frame on.
+        order_by: Set ordering within the window frame. Accepts
+            column names or expressions.
+
+    For example::
+
+        rank(order_by="points")
+    """
+    partition_by_raw = expr_list_to_raw_expr_list(partition_by)
+    order_by_raw = sort_list_to_raw_sort_list(order_by)
+
+    return Expr(
+        f.rank(
+            partition_by=partition_by_raw,
+            order_by=order_by_raw,
+        )
+    )
+
+
+def dense_rank(
+    partition_by: list[Expr] | Expr | None = None,
+    order_by: list[SortKey] | SortKey | None = None,
+) -> Expr:
+    """Create a dense_rank window function.
+
+    This window function is similar to :py:func:`rank` except that the returned values
+    will be consecutive. Here is an example of a dataframe with a window ordered by
+    descending ``points`` and the associated dense rank::
+
+        +--------+------------+
+        | points | dense_rank |
+        +--------+------------+
+        | 100    | 1          |
+        | 100    | 1          |
+        | 50     | 2          |
+        | 25     | 3          |
+        +--------+------------+
+
+    Args:
+        partition_by: Expressions to partition the window frame on.
+        order_by: Set ordering within the window frame. Accepts
+            column names or expressions.
+
+    For example::
+
+        dense_rank(order_by="points")
+    """
+    partition_by_raw = expr_list_to_raw_expr_list(partition_by)
+    order_by_raw = sort_list_to_raw_sort_list(order_by)
+
+    return Expr(
+        f.dense_rank(
+            partition_by=partition_by_raw,
+            order_by=order_by_raw,
+        )
+    )
+
+
+def percent_rank(
+    partition_by: list[Expr] | Expr | None = None,
+    order_by: list[SortKey] | SortKey | None = None,
+) -> Expr:
+    """Create a percent_rank window function.
+
+    This window function is similar to :py:func:`rank` except that the returned values
+    are the percentage from 0.0 to 1.0 from first to last. Here is an example of a
+    dataframe with a window ordered by descending ``points`` and the associated percent
+    rank::
+
+        +--------+--------------+
+        | points | percent_rank |
+        +--------+--------------+
+        | 100    | 0.0          |
+        | 100    | 0.0          |
+        | 50     | 0.666667     |
+        | 25     | 1.0          |
+        +--------+--------------+
+
+    Args:
+        partition_by: Expressions to partition the window frame on.
+        order_by: Set ordering within the window frame. Accepts
+            column names or expressions.
+
+    For example::
+
+        percent_rank(order_by="points")
+    """
+    partition_by_raw = expr_list_to_raw_expr_list(partition_by)
+    order_by_raw = sort_list_to_raw_sort_list(order_by)
+
+    return Expr(
+        f.percent_rank(
+            partition_by=partition_by_raw,
+            order_by=order_by_raw,
+        )
+    )
+
+
+def cume_dist(
+    partition_by: list[Expr] | Expr | None = None,
+    order_by: list[SortKey] | SortKey | None = None,
+) -> Expr:
+    """Create a cumulative distribution window function.
+
+    This window function is similar to :py:func:`rank` except that the returned values
+    are the ratio of the row number to the total number of rows. Here is an example of a
+    dataframe with a window ordered by descending ``points`` and the associated
+    cumulative distribution::
+
+        +--------+-----------+
+        | points | cume_dist |
+        +--------+-----------+
+        | 100    | 0.5       |
+        | 100    | 0.5       |
+        | 50     | 0.75      |
+        | 25     | 1.0       |
+        +--------+-----------+
+
+    Args:
+        partition_by: Expressions to partition the window frame on.
+        order_by: Set ordering within the window frame. Accepts
+            column names or expressions.
+
+    For example::
+
+        cume_dist(order_by="points")
+    """
+    partition_by_raw = expr_list_to_raw_expr_list(partition_by)
+    order_by_raw = sort_list_to_raw_sort_list(order_by)
+
+    return Expr(
+        f.cume_dist(
+            partition_by=partition_by_raw,
+            order_by=order_by_raw,
+        )
+    )
+
+
+def ntile(
+    groups: int,
+    partition_by: list[Expr] | Expr | None = None,
+    order_by: list[SortKey] | SortKey | None = None,
+) -> Expr:
+    """Create a n-tile window function.
+
+    This window function orders the window frame into a give number of groups based on
+    the ordering criteria. It then returns which group the current row is assigned to.
+    Here is an example of a dataframe with a window ordered by descending ``points``
+    and the associated n-tile function::
+
+        +--------+-------+
+        | points | ntile |
+        +--------+-------+
+        | 120    | 1     |
+        | 100    | 1     |
+        | 80     | 2     |
+        | 60     | 2     |
+        | 40     | 3     |
+        | 20     | 3     |
+        +--------+-------+
+
+    Args:
+        groups: Number of groups for the n-tile to be divided into.
+        partition_by: Expressions to partition the window frame on.
+        order_by: Set ordering within the window frame. Accepts
+            column names or expressions.
+
+    For example::
+
+        ntile(3, order_by="points")
+    """
+    partition_by_raw = expr_list_to_raw_expr_list(partition_by)
+    order_by_raw = sort_list_to_raw_sort_list(order_by)
+
+    return Expr(
+        f.ntile(
+            Expr.literal(groups).expr,
+            partition_by=partition_by_raw,
+            order_by=order_by_raw,
+        )
+    )
+
+
+def string_agg(
+    expression: Expr,
+    delimiter: str,
+    filter: Expr | None = None,
+    order_by: list[SortKey] | SortKey | None = None,
+) -> Expr:
+    """Concatenates the input strings.
+
+    This aggregate function will concatenate input strings, ignoring null values, and
+    separating them with the specified delimiter. Non-string values will be converted to
+    their string equivalents.
+
+    If using the builder functions described in ref:`_aggregation` this function ignores
+    the options ``distinct`` and ``null_treatment``.
+
+    Args:
+        expression: Argument to perform bitwise calculation on
+        delimiter: Text to place between each value of expression
+        filter: If provided, only compute against rows for which the filter is True
+        order_by: Set the ordering of the expression to evaluate. Accepts
+            column names or expressions.
+
+    For example::
+
+        df.aggregate([], string_agg(col("a"), ",", order_by="b"))
+    """
+    order_by_raw = sort_list_to_raw_sort_list(order_by)
+    filter_raw = filter.expr if filter is not None else None
+
+    return Expr(
+        f.string_agg(
+            expression.expr,
+            delimiter,
+            filter=filter_raw,
+            order_by=order_by_raw,
+        )
+    )
diff --git a/python/datafusion/html_formatter.py b/python/datafusion/html_formatter.py
new file mode 100644
index 000000000..65eb1f042
--- /dev/null
+++ b/python/datafusion/html_formatter.py
@@ -0,0 +1,29 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""Deprecated module for dataframe formatting."""
+
+import warnings
+
+from datafusion.dataframe_formatter import *  # noqa: F403
+
+warnings.warn(
+    "The module 'html_formatter' is deprecated and will be removed in the next release."
+    "Please use 'dataframe_formatter' instead.",
+    DeprecationWarning,
+    stacklevel=3,
+)
diff --git a/datafusion/functions.py b/python/datafusion/input/__init__.py
similarity index 79%
rename from datafusion/functions.py
rename to python/datafusion/input/__init__.py
index 782ecba22..f0c1f42b4 100644
--- a/datafusion/functions.py
+++ b/python/datafusion/input/__init__.py
@@ -15,9 +15,13 @@
 # specific language governing permissions and limitations
 # under the License.
 
+"""This package provides for input sources.
 
-from ._internal import functions
+The primary class used within DataFusion is ``LocationInputPlugin``.
+"""
 
+from .location import LocationInputPlugin
 
-def __getattr__(name):
-    return getattr(functions, name)
+__all__ = [
+    "LocationInputPlugin",
+]
diff --git a/python/datafusion/input/base.py b/python/datafusion/input/base.py
new file mode 100644
index 000000000..f67dde2a1
--- /dev/null
+++ b/python/datafusion/input/base.py
@@ -0,0 +1,46 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""This module provides ``BaseInputSource``.
+
+A user can extend this to provide a custom input source.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from datafusion.common import SqlTable
+
+
+class BaseInputSource(ABC):
+    """Base Input Source class.
+
+    If a consuming library would like to provider their own InputSource this is
+    the class they should extend to write their own.
+
+    Once completed the Plugin InputSource can be registered with the
+    SessionContext to ensure that it will be used in order
+    to obtain the SqlTable information from the custom datasource.
+    """
+
+    @abstractmethod
+    def is_correct_input(self, input_item: Any, table_name: str, **kwargs: Any) -> bool:
+        """Returns `True` if the input is valid."""
+
+    @abstractmethod
+    def build_table(self, input_item: Any, table_name: str, **kwarg: Any) -> SqlTable:  # type: ignore[invalid-type-form]
+        """Create a table from the input source."""
diff --git a/python/datafusion/input/location.py b/python/datafusion/input/location.py
new file mode 100644
index 000000000..b804ac18b
--- /dev/null
+++ b/python/datafusion/input/location.py
@@ -0,0 +1,89 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""The default input source for DataFusion."""
+
+from pathlib import Path
+from typing import Any
+
+from datafusion.common import DataTypeMap, SqlTable
+from datafusion.input.base import BaseInputSource
+
+
+class LocationInputPlugin(BaseInputSource):
+    """Input Plugin for everything.
+
+    This can be read in from a file (on disk, remote etc.).
+    """
+
+    def is_correct_input(self, input_item: Any, table_name: str, **kwargs: Any) -> bool:  # noqa: ARG002
+        """Returns `True` if the input is valid."""
+        return isinstance(input_item, str)
+
+    def build_table(
+        self,
+        input_item: str,
+        table_name: str,
+        **kwargs: Any,  # noqa: ARG002
+    ) -> SqlTable:  # type: ignore[invalid-type-form]
+        """Create a table from the input source."""
+        extension = Path(input_item).suffix
+        file_format = extension.lstrip(".").lower()
+        num_rows = 0  # Total number of rows in the file. Used for statistics
+        columns = []
+        if file_format == "parquet":
+            import pyarrow.parquet as pq
+
+            # Read the Parquet metadata
+            metadata = pq.read_metadata(input_item)
+            num_rows = metadata.num_rows
+            # Iterate through the schema and build the SqlTable
+            columns = [
+                (
+                    col.name,
+                    DataTypeMap.from_parquet_type_str(col.physical_type),
+                )
+                for col in metadata.schema
+            ]
+
+        elif format == "csv":
+            import csv
+
+            # Consume header row and count number of rows for statistics.
+            # TODO: Possibly makes sense to have the eager number of rows
+            # calculated as a configuration since you must read the entire file
+            # to get that information. However, this should only be occurring
+            # at table creation time and therefore shouldn't
+            # slow down query performance.
+            with Path(input_item).open() as file:
+                reader = csv.reader(file)
+                _header_row = next(reader)
+                for _ in reader:
+                    num_rows += 1
+            # TODO: Need to actually consume this row into reasonable columns
+            msg = "TODO: Currently unable to support CSV input files."
+            raise RuntimeError(msg)
+        else:
+            msg = f"Input of format: `{format}` is currently not supported.\
+                Only Parquet and CSV."
+            raise RuntimeError(msg)
+
+        # Input could possibly be multiple files. Create a list if so
+        input_path = Path(input_item)
+        input_files = [str(p) for p in input_path.parent.glob(input_path.name)]
+
+        return SqlTable(table_name, columns, num_rows, input_files)
diff --git a/python/datafusion/io.py b/python/datafusion/io.py
new file mode 100644
index 000000000..4f9c3c516
--- /dev/null
+++ b/python/datafusion/io.py
@@ -0,0 +1,197 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""IO read functions using global context."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from datafusion.context import SessionContext
+
+if TYPE_CHECKING:
+    import pathlib
+
+    import pyarrow as pa
+
+    from datafusion.dataframe import DataFrame
+    from datafusion.expr import Expr
+
+    from .options import CsvReadOptions
+
+
+def read_parquet(
+    path: str | pathlib.Path,
+    table_partition_cols: list[tuple[str, str | pa.DataType]] | None = None,
+    parquet_pruning: bool = True,
+    file_extension: str = ".parquet",
+    skip_metadata: bool = True,
+    schema: pa.Schema | None = None,
+    file_sort_order: list[list[Expr]] | None = None,
+) -> DataFrame:
+    """Read a Parquet source into a :py:class:`~datafusion.dataframe.Dataframe`.
+
+    This function will use the global context. Any functions or tables registered
+    with another context may not be accessible when used with a DataFrame created
+    using this function.
+
+    Args:
+        path: Path to the Parquet file.
+        table_partition_cols: Partition columns.
+        parquet_pruning: Whether the parquet reader should use the predicate
+            to prune row groups.
+        file_extension: File extension; only files with this extension are
+            selected for data input.
+        skip_metadata: Whether the parquet reader should skip any metadata
+            that may be in the file schema. This can help avoid schema
+            conflicts due to metadata.
+        schema: An optional schema representing the parquet files. If None,
+            the parquet reader will try to infer it based on data in the
+            file.
+        file_sort_order: Sort order for the file.
+
+    Returns:
+        DataFrame representation of the read Parquet files
+    """
+    if table_partition_cols is None:
+        table_partition_cols = []
+    return SessionContext.global_ctx().read_parquet(
+        str(path),
+        table_partition_cols,
+        parquet_pruning,
+        file_extension,
+        skip_metadata,
+        schema,
+        file_sort_order,
+    )
+
+
+def read_json(
+    path: str | pathlib.Path,
+    schema: pa.Schema | None = None,
+    schema_infer_max_records: int = 1000,
+    file_extension: str = ".json",
+    table_partition_cols: list[tuple[str, str | pa.DataType]] | None = None,
+    file_compression_type: str | None = None,
+) -> DataFrame:
+    """Read a line-delimited JSON data source.
+
+    This function will use the global context. Any functions or tables registered
+    with another context may not be accessible when used with a DataFrame created
+    using this function.
+
+    Args:
+        path: Path to the JSON file.
+        schema: The data source schema.
+        schema_infer_max_records: Maximum number of rows to read from JSON
+            files for schema inference if needed.
+        file_extension: File extension; only files with this extension are
+            selected for data input.
+        table_partition_cols: Partition columns.
+        file_compression_type: File compression type.
+
+    Returns:
+        DataFrame representation of the read JSON files.
+    """
+    if table_partition_cols is None:
+        table_partition_cols = []
+    return SessionContext.global_ctx().read_json(
+        str(path),
+        schema,
+        schema_infer_max_records,
+        file_extension,
+        table_partition_cols,
+        file_compression_type,
+    )
+
+
+def read_csv(
+    path: str | pathlib.Path | list[str] | list[pathlib.Path],
+    schema: pa.Schema | None = None,
+    has_header: bool = True,
+    delimiter: str = ",",
+    schema_infer_max_records: int = 1000,
+    file_extension: str = ".csv",
+    table_partition_cols: list[tuple[str, str | pa.DataType]] | None = None,
+    file_compression_type: str | None = None,
+    options: CsvReadOptions | None = None,
+) -> DataFrame:
+    """Read a CSV data source.
+
+    This function will use the global context. Any functions or tables registered
+    with another context may not be accessible when used with a DataFrame created
+    using this function.
+
+    Args:
+        path: Path to the CSV file
+        schema: An optional schema representing the CSV files. If None, the
+            CSV reader will try to infer it based on data in file.
+        has_header: Whether the CSV file have a header. If schema inference
+            is run on a file with no headers, default column names are
+            created.
+        delimiter: An optional column delimiter.
+        schema_infer_max_records: Maximum number of rows to read from CSV
+            files for schema inference if needed.
+        file_extension:  File extension; only files with this extension are
+            selected for data input.
+        table_partition_cols:  Partition columns.
+        file_compression_type:  File compression type.
+        options: Set advanced options for CSV reading. This cannot be
+            combined with any of the other options in this method.
+
+    Returns:
+        DataFrame representation of the read CSV files
+    """
+    return SessionContext.global_ctx().read_csv(
+        path,
+        schema,
+        has_header,
+        delimiter,
+        schema_infer_max_records,
+        file_extension,
+        table_partition_cols,
+        file_compression_type,
+        options,
+    )
+
+
+def read_avro(
+    path: str | pathlib.Path,
+    schema: pa.Schema | None = None,
+    file_partition_cols: list[tuple[str, str | pa.DataType]] | None = None,
+    file_extension: str = ".avro",
+) -> DataFrame:
+    """Create a :py:class:`DataFrame` for reading Avro data source.
+
+    This function will use the global context. Any functions or tables registered
+    with another context may not be accessible when used with a DataFrame created
+    using this function.
+
+    Args:
+        path: Path to the Avro file.
+        schema: The data source schema.
+        file_partition_cols: Partition columns.
+        file_extension: File extension to select.
+
+    Returns:
+        DataFrame representation of the read Avro file
+    """
+    if file_partition_cols is None:
+        file_partition_cols = []
+    return SessionContext.global_ctx().read_avro(
+        str(path), schema, file_partition_cols, file_extension
+    )
diff --git a/datafusion/object_store.py b/python/datafusion/object_store.py
similarity index 72%
rename from datafusion/object_store.py
rename to python/datafusion/object_store.py
index 70ecbd2bb..6298526f5 100644
--- a/datafusion/object_store.py
+++ b/python/datafusion/object_store.py
@@ -14,10 +14,14 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-
+"""Object store functionality."""
 
 from ._internal import object_store
 
+AmazonS3 = object_store.AmazonS3
+GoogleCloud = object_store.GoogleCloud
+LocalFileSystem = object_store.LocalFileSystem
+MicrosoftAzure = object_store.MicrosoftAzure
+Http = object_store.Http
 
-def __getattr__(name):
-    return getattr(object_store, name)
+__all__ = ["AmazonS3", "GoogleCloud", "Http", "LocalFileSystem", "MicrosoftAzure"]
diff --git a/python/datafusion/options.py b/python/datafusion/options.py
new file mode 100644
index 000000000..ec19f37d0
--- /dev/null
+++ b/python/datafusion/options.py
@@ -0,0 +1,284 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""Options for reading various file formats."""
+
+from __future__ import annotations
+
+import warnings
+from typing import TYPE_CHECKING
+
+import pyarrow as pa
+
+from datafusion.expr import sort_list_to_raw_sort_list
+
+if TYPE_CHECKING:
+    from datafusion.expr import SortExpr
+
+from ._internal import options
+
+__all__ = ["CsvReadOptions"]
+
+DEFAULT_MAX_INFER_SCHEMA = 1000
+
+
+class CsvReadOptions:
+    """Options for reading CSV files.
+
+    This class provides a builder pattern for configuring CSV reading options.
+    All methods starting with ``with_`` return ``self`` to allow method chaining.
+    """
+
+    def __init__(
+        self,
+        *,
+        has_header: bool = True,
+        delimiter: str = ",",
+        quote: str = '"',
+        terminator: str | None = None,
+        escape: str | None = None,
+        comment: str | None = None,
+        newlines_in_values: bool = False,
+        schema: pa.Schema | None = None,
+        schema_infer_max_records: int = DEFAULT_MAX_INFER_SCHEMA,
+        file_extension: str = ".csv",
+        table_partition_cols: list[tuple[str, pa.DataType]] | None = None,
+        file_compression_type: str = "",
+        file_sort_order: list[list[SortExpr]] | None = None,
+        null_regex: str | None = None,
+        truncated_rows: bool = False,
+    ) -> None:
+        """Initialize CsvReadOptions.
+
+        Args:
+            has_header: Does the CSV file have a header row? If schema inference
+                is run on a file with no headers, default column names are created.
+            delimiter: Column delimiter character. Must be a single ASCII character.
+            quote: Quote character for fields containing delimiters or newlines.
+                Must be a single ASCII character.
+            terminator: Optional line terminator character. If ``None``, uses CRLF.
+                Must be a single ASCII character.
+            escape: Optional escape character for quotes. Must be a single ASCII
+                character.
+            comment: If specified, lines beginning with this character are ignored.
+                Must be a single ASCII character.
+            newlines_in_values: Whether newlines in quoted values are supported.
+                Parsing newlines in quoted values may be affected by execution
+                behavior such as parallel file scanning. Setting this to ``True``
+                ensures that newlines in values are parsed successfully, which may
+                reduce performance.
+            schema: Optional PyArrow schema representing the CSV files. If ``None``,
+                the CSV reader will try to infer it based on data in the file.
+            schema_infer_max_records: Maximum number of rows to read from CSV files
+                for schema inference if needed.
+            file_extension: File extension; only files with this extension are
+                selected for data input.
+            table_partition_cols: Partition columns as a list of tuples of
+                (column_name, data_type).
+            file_compression_type: File compression type. Supported values are
+                ``"gzip"``, ``"bz2"``, ``"xz"``, ``"zstd"``, or empty string for
+                uncompressed.
+            file_sort_order: Optional sort order of the files as a list of sort
+                expressions per file.
+            null_regex: Optional regex pattern to match null values in the CSV.
+            truncated_rows: Whether to allow truncated rows when parsing. By default
+                this is ``False`` and will error if the CSV rows have different
+                lengths. When set to ``True``, it will allow records with less than
+                the expected number of columns and fill the missing columns with
+                nulls. If the record's schema is not nullable, it will still return
+                an error.
+        """
+        validate_single_character("delimiter", delimiter)
+        validate_single_character("quote", quote)
+        validate_single_character("terminator", terminator)
+        validate_single_character("escape", escape)
+        validate_single_character("comment", comment)
+
+        self.has_header = has_header
+        self.delimiter = delimiter
+        self.quote = quote
+        self.terminator = terminator
+        self.escape = escape
+        self.comment = comment
+        self.newlines_in_values = newlines_in_values
+        self.schema = schema
+        self.schema_infer_max_records = schema_infer_max_records
+        self.file_extension = file_extension
+        self.table_partition_cols = table_partition_cols or []
+        self.file_compression_type = file_compression_type
+        self.file_sort_order = file_sort_order or []
+        self.null_regex = null_regex
+        self.truncated_rows = truncated_rows
+
+    def with_has_header(self, has_header: bool) -> CsvReadOptions:
+        """Configure whether the CSV has a header row."""
+        self.has_header = has_header
+        return self
+
+    def with_delimiter(self, delimiter: str) -> CsvReadOptions:
+        """Configure the column delimiter."""
+        self.delimiter = delimiter
+        return self
+
+    def with_quote(self, quote: str) -> CsvReadOptions:
+        """Configure the quote character."""
+        self.quote = quote
+        return self
+
+    def with_terminator(self, terminator: str | None) -> CsvReadOptions:
+        """Configure the line terminator character."""
+        self.terminator = terminator
+        return self
+
+    def with_escape(self, escape: str | None) -> CsvReadOptions:
+        """Configure the escape character."""
+        self.escape = escape
+        return self
+
+    def with_comment(self, comment: str | None) -> CsvReadOptions:
+        """Configure the comment character."""
+        self.comment = comment
+        return self
+
+    def with_newlines_in_values(self, newlines_in_values: bool) -> CsvReadOptions:
+        """Configure whether newlines in values are supported."""
+        self.newlines_in_values = newlines_in_values
+        return self
+
+    def with_schema(self, schema: pa.Schema | None) -> CsvReadOptions:
+        """Configure the schema."""
+        self.schema = schema
+        return self
+
+    def with_schema_infer_max_records(
+        self, schema_infer_max_records: int
+    ) -> CsvReadOptions:
+        """Configure maximum records for schema inference."""
+        self.schema_infer_max_records = schema_infer_max_records
+        return self
+
+    def with_file_extension(self, file_extension: str) -> CsvReadOptions:
+        """Configure the file extension filter."""
+        self.file_extension = file_extension
+        return self
+
+    def with_table_partition_cols(
+        self, table_partition_cols: list[tuple[str, pa.DataType]]
+    ) -> CsvReadOptions:
+        """Configure table partition columns."""
+        self.table_partition_cols = table_partition_cols
+        return self
+
+    def with_file_compression_type(self, file_compression_type: str) -> CsvReadOptions:
+        """Configure file compression type."""
+        self.file_compression_type = file_compression_type
+        return self
+
+    def with_file_sort_order(
+        self, file_sort_order: list[list[SortExpr]]
+    ) -> CsvReadOptions:
+        """Configure file sort order."""
+        self.file_sort_order = file_sort_order
+        return self
+
+    def with_null_regex(self, null_regex: str | None) -> CsvReadOptions:
+        """Configure null value regex pattern."""
+        self.null_regex = null_regex
+        return self
+
+    def with_truncated_rows(self, truncated_rows: bool) -> CsvReadOptions:
+        """Configure whether to allow truncated rows."""
+        self.truncated_rows = truncated_rows
+        return self
+
+    def to_inner(self) -> options.CsvReadOptions:
+        """Convert this object into the underlying Rust structure.
+
+        This is intended for internal use only.
+        """
+        file_sort_order = (
+            []
+            if self.file_sort_order is None
+            else [
+                sort_list_to_raw_sort_list(sort_list)
+                for sort_list in self.file_sort_order
+            ]
+        )
+
+        return options.CsvReadOptions(
+            has_header=self.has_header,
+            delimiter=ord(self.delimiter[0]) if self.delimiter else ord(","),
+            quote=ord(self.quote[0]) if self.quote else ord('"'),
+            terminator=ord(self.terminator[0]) if self.terminator else None,
+            escape=ord(self.escape[0]) if self.escape else None,
+            comment=ord(self.comment[0]) if self.comment else None,
+            newlines_in_values=self.newlines_in_values,
+            schema=self.schema,
+            schema_infer_max_records=self.schema_infer_max_records,
+            file_extension=self.file_extension,
+            table_partition_cols=_convert_table_partition_cols(
+                self.table_partition_cols
+            ),
+            file_compression_type=self.file_compression_type or "",
+            file_sort_order=file_sort_order,
+            null_regex=self.null_regex,
+            truncated_rows=self.truncated_rows,
+        )
+
+
+def validate_single_character(name: str, value: str | None) -> None:
+    if value is not None and len(value) != 1:
+        message = f"{name} must be a single character"
+        raise ValueError(message)
+
+
+def _convert_table_partition_cols(
+    table_partition_cols: list[tuple[str, str | pa.DataType]],
+) -> list[tuple[str, pa.DataType]]:
+    warn = False
+    converted_table_partition_cols = []
+
+    for col, data_type in table_partition_cols:
+        if isinstance(data_type, str):
+            warn = True
+            if data_type == "string":
+                converted_data_type = pa.string()
+            elif data_type == "int":
+                converted_data_type = pa.int32()
+            else:
+                message = (
+                    f"Unsupported literal data type '{data_type}' for partition "
+                    "column. Supported types are 'string' and 'int'"
+                )
+                raise ValueError(message)
+        else:
+            converted_data_type = data_type
+
+        converted_table_partition_cols.append((col, converted_data_type))
+
+    if warn:
+        message = (
+            "using literals for table_partition_cols data types is deprecated,"
+            "use pyarrow types instead"
+        )
+        warnings.warn(
+            message,
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+
+    return converted_table_partition_cols
diff --git a/python/datafusion/plan.py b/python/datafusion/plan.py
new file mode 100644
index 000000000..fb54fd624
--- /dev/null
+++ b/python/datafusion/plan.py
@@ -0,0 +1,153 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""This module supports physical and logical plans in DataFusion."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import datafusion._internal as df_internal
+
+if TYPE_CHECKING:
+    from datafusion.context import SessionContext
+
+__all__ = [
+    "ExecutionPlan",
+    "LogicalPlan",
+]
+
+
+class LogicalPlan:
+    """Logical Plan.
+
+    A `LogicalPlan` is a node in a tree of relational operators (such as
+    Projection or Filter).
+
+    Represents transforming an input relation (table) to an output relation
+    (table) with a potentially different schema. Plans form a dataflow tree
+    where data flows from leaves up to the root to produce the query result.
+
+    A `LogicalPlan` can be created by the SQL query planner, the DataFrame API,
+    or programmatically (for example custom query languages).
+    """
+
+    def __init__(self, plan: df_internal.LogicalPlan) -> None:
+        """This constructor should not be called by the end user."""
+        self._raw_plan = plan
+
+    def to_variant(self) -> Any:
+        """Convert the logical plan into its specific variant."""
+        return self._raw_plan.to_variant()
+
+    def inputs(self) -> list[LogicalPlan]:
+        """Returns the list of inputs to the logical plan."""
+        return [LogicalPlan(p) for p in self._raw_plan.inputs()]
+
+    def __repr__(self) -> str:
+        """Generate a printable representation of the plan."""
+        return self._raw_plan.__repr__()
+
+    def display(self) -> str:
+        """Print the logical plan."""
+        return self._raw_plan.display()
+
+    def display_indent(self) -> str:
+        """Print an indented form of the logical plan."""
+        return self._raw_plan.display_indent()
+
+    def display_indent_schema(self) -> str:
+        """Print an indented form of the schema for the logical plan."""
+        return self._raw_plan.display_indent_schema()
+
+    def display_graphviz(self) -> str:
+        """Print the graph visualization of the logical plan.
+
+        Returns a `format`able structure that produces lines meant for graphical display
+        using the `DOT` language. This format can be visualized using software from
+        [`graphviz`](https://graphviz.org/)
+        """
+        return self._raw_plan.display_graphviz()
+
+    @staticmethod
+    def from_proto(ctx: SessionContext, data: bytes) -> LogicalPlan:
+        """Create a LogicalPlan from protobuf bytes.
+
+        Tables created in memory from record batches are currently not supported.
+        """
+        return LogicalPlan(df_internal.LogicalPlan.from_proto(ctx.ctx, data))
+
+    def to_proto(self) -> bytes:
+        """Convert a LogicalPlan to protobuf bytes.
+
+        Tables created in memory from record batches are currently not supported.
+        """
+        return self._raw_plan.to_proto()
+
+    def __eq__(self, other: LogicalPlan) -> bool:
+        """Test equality."""
+        if not isinstance(other, LogicalPlan):
+            return False
+        return self._raw_plan.__eq__(other._raw_plan)
+
+
+class ExecutionPlan:
+    """Represent nodes in the DataFusion Physical Plan."""
+
+    def __init__(self, plan: df_internal.ExecutionPlan) -> None:
+        """This constructor should not be called by the end user."""
+        self._raw_plan = plan
+
+    def children(self) -> list[ExecutionPlan]:
+        """Get a list of children `ExecutionPlan` that act as inputs to this plan.
+
+        The returned list will be empty for leaf nodes such as scans, will contain a
+        single value for unary nodes, or two values for binary nodes (such as joins).
+        """
+        return [ExecutionPlan(e) for e in self._raw_plan.children()]
+
+    def display(self) -> str:
+        """Print the physical plan."""
+        return self._raw_plan.display()
+
+    def display_indent(self) -> str:
+        """Print an indented form of the physical plan."""
+        return self._raw_plan.display_indent()
+
+    def __repr__(self) -> str:
+        """Print a string representation of the physical plan."""
+        return self._raw_plan.__repr__()
+
+    @property
+    def partition_count(self) -> int:
+        """Returns the number of partitions in the physical plan."""
+        return self._raw_plan.partition_count
+
+    @staticmethod
+    def from_proto(ctx: SessionContext, data: bytes) -> ExecutionPlan:
+        """Create an ExecutionPlan from protobuf bytes.
+
+        Tables created in memory from record batches are currently not supported.
+        """
+        return ExecutionPlan(df_internal.ExecutionPlan.from_proto(ctx.ctx, data))
+
+    def to_proto(self) -> bytes:
+        """Convert an ExecutionPlan into protobuf bytes.
+
+        Tables created in memory from record batches are currently not supported.
+        """
+        return self._raw_plan.to_proto()
diff --git a/conda/recipes/build.sh b/python/datafusion/py.typed
similarity index 93%
rename from conda/recipes/build.sh
rename to python/datafusion/py.typed
index f10be3581..d216be4dd 100644
--- a/conda/recipes/build.sh
+++ b/python/datafusion/py.typed
@@ -1,5 +1,3 @@
-#!/bin/bash
-
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information
@@ -15,6 +13,4 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
-# under the License.
-
-maturin build -r
+# under the License.
\ No newline at end of file
diff --git a/python/datafusion/record_batch.py b/python/datafusion/record_batch.py
new file mode 100644
index 000000000..c24cde0ac
--- /dev/null
+++ b/python/datafusion/record_batch.py
@@ -0,0 +1,101 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""This module provides the classes for handling record batches.
+
+These are typically the result of dataframe
+:py:func:`datafusion.dataframe.execute_stream` operations.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import pyarrow as pa
+    import typing_extensions
+
+    import datafusion._internal as df_internal
+
+
+class RecordBatch:
+    """This class is essentially a wrapper for :py:class:`pa.RecordBatch`."""
+
+    def __init__(self, record_batch: df_internal.RecordBatch) -> None:
+        """This constructor is generally not called by the end user.
+
+        See the :py:class:`RecordBatchStream` iterator for generating this class.
+        """
+        self.record_batch = record_batch
+
+    def to_pyarrow(self) -> pa.RecordBatch:
+        """Convert to :py:class:`pa.RecordBatch`."""
+        return self.record_batch.to_pyarrow()
+
+    def __arrow_c_array__(
+        self, requested_schema: object | None = None
+    ) -> tuple[object, object]:
+        """Export the record batch via the Arrow C Data Interface.
+
+        This allows zero-copy interchange with libraries that support the
+        `Arrow PyCapsule interface <https://arrow.apache.org/docs/format/
+        CDataInterface/PyCapsuleInterface.html>`_.
+
+        Args:
+            requested_schema: Attempt to provide the record batch using this
+                schema. Only straightforward projections such as column
+                selection or reordering are applied.
+
+        Returns:
+            Two Arrow PyCapsule objects representing the ``ArrowArray`` and
+            ``ArrowSchema``.
+        """
+        return self.record_batch.__arrow_c_array__(requested_schema)
+
+
+class RecordBatchStream:
+    """This class represents a stream of record batches.
+
+    These are typically the result of a
+    :py:func:`~datafusion.dataframe.DataFrame.execute_stream` operation.
+    """
+
+    def __init__(self, record_batch_stream: df_internal.RecordBatchStream) -> None:
+        """This constructor is typically not called by the end user."""
+        self.rbs = record_batch_stream
+
+    def next(self) -> RecordBatch:
+        """See :py:func:`__next__` for the iterator function."""
+        return next(self)
+
+    async def __anext__(self) -> RecordBatch:
+        """Return the next :py:class:`RecordBatch` in the stream asynchronously."""
+        next_batch = await self.rbs.__anext__()
+        return RecordBatch(next_batch)
+
+    def __next__(self) -> RecordBatch:
+        """Return the next :py:class:`RecordBatch` in the stream."""
+        next_batch = next(self.rbs)
+        return RecordBatch(next_batch)
+
+    def __aiter__(self) -> typing_extensions.Self:
+        """Return an asynchronous iterator over record batches."""
+        return self
+
+    def __iter__(self) -> typing_extensions.Self:
+        """Return an iterator over record batches."""
+        return self
diff --git a/python/datafusion/substrait.py b/python/datafusion/substrait.py
new file mode 100644
index 000000000..3115238fa
--- /dev/null
+++ b/python/datafusion/substrait.py
@@ -0,0 +1,213 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""This module provides support for using substrait with datafusion.
+
+For additional information about substrait, see https://substrait.io/ for more
+information about substrait.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+try:
+    from warnings import deprecated  # Python 3.13+
+except ImportError:
+    from typing_extensions import deprecated  # Python 3.12
+
+from datafusion.plan import LogicalPlan
+
+from ._internal import substrait as substrait_internal
+
+if TYPE_CHECKING:
+    import pathlib
+
+    from datafusion.context import SessionContext
+
+__all__ = [
+    "Consumer",
+    "Plan",
+    "Producer",
+    "Serde",
+]
+
+
+class Plan:
+    """A class representing an encodable substrait plan."""
+
+    def __init__(self, plan: substrait_internal.Plan) -> None:
+        """Create a substrait plan.
+
+        The user should not have to call this constructor directly. Rather, it
+        should be created via :py:class:`Serde` or py:class:`Producer` classes
+        in this module.
+        """
+        self.plan_internal = plan
+
+    def encode(self) -> bytes:
+        """Encode the plan to bytes.
+
+        Returns:
+            Encoded plan.
+        """
+        return self.plan_internal.encode()
+
+    def to_json(self) -> str:
+        """Get the JSON representation of the Substrait plan.
+
+        Returns:
+            A JSON representation of the Substrait plan.
+        """
+        return self.plan_internal.to_json()
+
+    @staticmethod
+    def from_json(json: str) -> Plan:
+        """Parse a plan from a JSON string representation.
+
+        Args:
+            json: JSON representation of a Substrait plan.
+
+        Returns:
+            Plan object representing the Substrait plan.
+        """
+        return Plan(substrait_internal.Plan.from_json(json))
+
+
+@deprecated("Use `Plan` instead.")
+class plan(Plan):  # noqa: N801
+    """See `Plan`."""
+
+
+class Serde:
+    """Provides the ``Substrait`` serialization and deserialization."""
+
+    @staticmethod
+    def serialize(sql: str, ctx: SessionContext, path: str | pathlib.Path) -> None:
+        """Serialize a SQL query to a Substrait plan and write it to a file.
+
+        Args:
+            sql:SQL query to serialize.
+            ctx: SessionContext to use.
+            path: Path to write the Substrait plan to.
+        """
+        return substrait_internal.Serde.serialize(sql, ctx.ctx, str(path))
+
+    @staticmethod
+    def serialize_to_plan(sql: str, ctx: SessionContext) -> Plan:
+        """Serialize a SQL query to a Substrait plan.
+
+        Args:
+        sql: SQL query to serialize.
+        ctx: SessionContext to use.
+
+        Returns:
+            Substrait plan.
+        """
+        return Plan(substrait_internal.Serde.serialize_to_plan(sql, ctx.ctx))
+
+    @staticmethod
+    def serialize_bytes(sql: str, ctx: SessionContext) -> bytes:
+        """Serialize a SQL query to a Substrait plan as bytes.
+
+        Args:
+            sql: SQL query to serialize.
+            ctx: SessionContext to use.
+
+        Returns:
+            Substrait plan as bytes.
+        """
+        return substrait_internal.Serde.serialize_bytes(sql, ctx.ctx)
+
+    @staticmethod
+    def deserialize(path: str | pathlib.Path) -> Plan:
+        """Deserialize a Substrait plan from a file.
+
+        Args:
+            path: Path to read the Substrait plan from.
+
+        Returns:
+            Substrait plan.
+        """
+        return Plan(substrait_internal.Serde.deserialize(str(path)))
+
+    @staticmethod
+    def deserialize_bytes(proto_bytes: bytes) -> Plan:
+        """Deserialize a Substrait plan from bytes.
+
+        Args:
+            proto_bytes: Bytes to read the Substrait plan from.
+
+        Returns:
+            Substrait plan.
+        """
+        return Plan(substrait_internal.Serde.deserialize_bytes(proto_bytes))
+
+
+@deprecated("Use `Serde` instead.")
+class serde(Serde):  # noqa: N801
+    """See `Serde` instead."""
+
+
+class Producer:
+    """Generates substrait plans from a logical plan."""
+
+    @staticmethod
+    def to_substrait_plan(logical_plan: LogicalPlan, ctx: SessionContext) -> Plan:
+        """Convert a DataFusion LogicalPlan to a Substrait plan.
+
+        Args:
+            logical_plan: LogicalPlan to convert.
+            ctx: SessionContext to use.
+
+        Returns:
+            Substrait plan.
+        """
+        return Plan(
+            substrait_internal.Producer.to_substrait_plan(
+                logical_plan._raw_plan, ctx.ctx
+            )
+        )
+
+
+@deprecated("Use `Producer` instead.")
+class producer(Producer):  # noqa: N801
+    """Use `Producer` instead."""
+
+
+class Consumer:
+    """Generates a logical plan from a substrait plan."""
+
+    @staticmethod
+    def from_substrait_plan(ctx: SessionContext, plan: Plan) -> LogicalPlan:
+        """Convert a Substrait plan to a DataFusion LogicalPlan.
+
+        Args:
+            ctx: SessionContext to use.
+            plan: Substrait plan to convert.
+
+        Returns:
+            LogicalPlan.
+        """
+        return LogicalPlan(
+            substrait_internal.Consumer.from_substrait_plan(ctx.ctx, plan.plan_internal)
+        )
+
+
+@deprecated("Use `Consumer` instead.")
+class consumer(Consumer):  # noqa: N801
+    """Use `Consumer` instead."""
diff --git a/python/datafusion/udf.py b/python/datafusion/udf.py
new file mode 100644
index 000000000..c7265fa09
--- /dev/null
+++ b/python/datafusion/udf.py
@@ -0,0 +1,29 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""Deprecated module for user defined functions."""
+
+import warnings
+
+from datafusion.user_defined import *  # noqa: F403
+
+warnings.warn(
+    "The module 'udf' is deprecated and will be removed in the next release. "
+    "Please use 'user_defined' instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)
diff --git a/python/datafusion/unparser.py b/python/datafusion/unparser.py
new file mode 100644
index 000000000..7ca5b9190
--- /dev/null
+++ b/python/datafusion/unparser.py
@@ -0,0 +1,80 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""This module provides support for unparsing datafusion plans to SQL.
+
+For additional information about unparsing, see https://docs.rs/datafusion-sql/latest/datafusion_sql/unparser/index.html
+"""
+
+from ._internal import unparser as unparser_internal
+from .plan import LogicalPlan
+
+
+class Dialect:
+    """DataFusion data catalog."""
+
+    def __init__(self, dialect: unparser_internal.Dialect) -> None:
+        """This constructor is not typically called by the end user."""
+        self.dialect = dialect
+
+    @staticmethod
+    def default() -> "Dialect":
+        """Create a new default dialect."""
+        return Dialect(unparser_internal.Dialect.default())
+
+    @staticmethod
+    def mysql() -> "Dialect":
+        """Create a new MySQL dialect."""
+        return Dialect(unparser_internal.Dialect.mysql())
+
+    @staticmethod
+    def postgres() -> "Dialect":
+        """Create a new PostgreSQL dialect."""
+        return Dialect(unparser_internal.Dialect.postgres())
+
+    @staticmethod
+    def sqlite() -> "Dialect":
+        """Create a new SQLite dialect."""
+        return Dialect(unparser_internal.Dialect.sqlite())
+
+    @staticmethod
+    def duckdb() -> "Dialect":
+        """Create a new DuckDB dialect."""
+        return Dialect(unparser_internal.Dialect.duckdb())
+
+
+class Unparser:
+    """DataFusion unparser."""
+
+    def __init__(self, dialect: Dialect) -> None:
+        """This constructor is not typically called by the end user."""
+        self.unparser = unparser_internal.Unparser(dialect.dialect)
+
+    def plan_to_sql(self, plan: LogicalPlan) -> str:
+        """Convert a logical plan to a SQL string."""
+        return self.unparser.plan_to_sql(plan._raw_plan)
+
+    def with_pretty(self, pretty: bool) -> "Unparser":
+        """Set the pretty flag."""
+        self.unparser = self.unparser.with_pretty(pretty)
+        return self
+
+
+__all__ = [
+    "Dialect",
+    "Unparser",
+]
diff --git a/python/datafusion/user_defined.py b/python/datafusion/user_defined.py
new file mode 100644
index 000000000..eef23e741
--- /dev/null
+++ b/python/datafusion/user_defined.py
@@ -0,0 +1,1044 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""Provides the user-defined functions for evaluation of dataframes."""
+
+from __future__ import annotations
+
+import functools
+from abc import ABCMeta, abstractmethod
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Protocol, TypeGuard, TypeVar, cast, overload
+
+import pyarrow as pa
+
+import datafusion._internal as df_internal
+from datafusion import SessionContext
+from datafusion.expr import Expr
+
+if TYPE_CHECKING:
+    from _typeshed import CapsuleType as _PyCapsule
+
+    _R = TypeVar("_R", bound=pa.DataType)
+    from collections.abc import Callable, Sequence
+
+
+class Volatility(Enum):
+    """Defines how stable or volatile a function is.
+
+    When setting the volatility of a function, you can either pass this
+    enumeration or a ``str``. The ``str`` equivalent is the lower case value of the
+    name (`"immutable"`, `"stable"`, or `"volatile"`).
+    """
+
+    Immutable = 1
+    """An immutable function will always return the same output when given the
+    same input.
+
+    DataFusion will attempt to inline immutable functions during planning.
+    """
+
+    Stable = 2
+    """
+    Returns the same value for a given input within a single queries.
+
+    A stable function may return different values given the same input across
+    different queries but must return the same value for a given input within a
+    query. An example of this is the ``Now`` function. DataFusion will attempt to
+    inline ``Stable`` functions during planning, when possible. For query
+    ``select col1, now() from t1``, it might take a while to execute but ``now()``
+    column will be the same for each output row, which is evaluated during
+    planning.
+    """
+
+    Volatile = 3
+    """A volatile function may change the return value from evaluation to
+    evaluation.
+
+    Multiple invocations of a volatile function may return different results
+    when used in the same query. An example of this is the random() function.
+    DataFusion can not evaluate such functions during planning. In the query
+    ``select col1, random() from t1``, ``random()`` function will be evaluated
+    for each output row, resulting in a unique random value for each row.
+    """
+
+    def __str__(self) -> str:
+        """Returns the string equivalent."""
+        return self.name.lower()
+
+
+def data_type_or_field_to_field(value: pa.DataType | pa.Field, name: str) -> pa.Field:
+    """Helper function to return a Field from either a Field or DataType."""
+    if isinstance(value, pa.Field):
+        return value
+    return pa.field(name, type=value)
+
+
+def data_types_or_fields_to_field_list(
+    inputs: Sequence[pa.Field | pa.DataType] | pa.Field | pa.DataType,
+) -> list[pa.Field]:
+    """Helper function to return a list of Fields."""
+    if isinstance(inputs, pa.DataType):
+        return [pa.field("value", type=inputs)]
+    if isinstance(inputs, pa.Field):
+        return [inputs]
+
+    return [
+        data_type_or_field_to_field(v, f"value_{idx}") for (idx, v) in enumerate(inputs)
+    ]
+
+
+class ScalarUDFExportable(Protocol):
+    """Type hint for object that has __datafusion_scalar_udf__ PyCapsule."""
+
+    def __datafusion_scalar_udf__(self) -> object: ...  # noqa: D105
+
+
+def _is_pycapsule(value: object) -> TypeGuard[_PyCapsule]:
+    """Return ``True`` when ``value`` is a CPython ``PyCapsule``."""
+    return value.__class__.__name__ == "PyCapsule"
+
+
+class ScalarUDF:
+    """Class for performing scalar user-defined functions (UDF).
+
+    Scalar UDFs operate on a row by row basis. See also :py:class:`AggregateUDF` for
+    operating on a group of rows.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        func: Callable[..., _R],
+        input_fields: list[pa.Field],
+        return_field: _R,
+        volatility: Volatility | str,
+    ) -> None:
+        """Instantiate a scalar user-defined function (UDF).
+
+        See helper method :py:func:`udf` for argument details.
+        """
+        if hasattr(func, "__datafusion_scalar_udf__"):
+            self._udf = df_internal.ScalarUDF.from_pycapsule(func)
+            return
+        if isinstance(input_fields, pa.DataType):
+            input_fields = [input_fields]
+        self._udf = df_internal.ScalarUDF(
+            name, func, input_fields, return_field, str(volatility)
+        )
+
+    def __repr__(self) -> str:
+        """Print a string representation of the Scalar UDF."""
+        return self._udf.__repr__()
+
+    def __call__(self, *args: Expr) -> Expr:
+        """Execute the UDF.
+
+        This function is not typically called by an end user. These calls will
+        occur during the evaluation of the dataframe.
+        """
+        args_raw = [arg.expr for arg in args]
+        return Expr(self._udf.__call__(*args_raw))
+
+    @overload
+    @staticmethod
+    def udf(
+        input_fields: Sequence[pa.DataType | pa.Field] | pa.DataType | pa.Field,
+        return_field: pa.DataType | pa.Field,
+        volatility: Volatility | str,
+        name: str | None = None,
+    ) -> Callable[..., ScalarUDF]: ...
+
+    @overload
+    @staticmethod
+    def udf(
+        func: Callable[..., _R],
+        input_fields: Sequence[pa.DataType | pa.Field] | pa.DataType | pa.Field,
+        return_field: pa.DataType | pa.Field,
+        volatility: Volatility | str,
+        name: str | None = None,
+    ) -> ScalarUDF: ...
+
+    @overload
+    @staticmethod
+    def udf(func: ScalarUDFExportable) -> ScalarUDF: ...
+
+    @staticmethod
+    def udf(*args: Any, **kwargs: Any):  # noqa: D417
+        """Create a new User-Defined Function (UDF).
+
+        This class can be used both as either a function or a decorator.
+
+        Usage:
+            - As a function: ``udf(func, input_fields, return_field, volatility, name)``.
+            - As a decorator: ``@udf(input_fields, return_field, volatility, name)``.
+              When used a decorator, do **not** pass ``func`` explicitly.
+
+        In lieu of passing a PyArrow Field, you can pass a DataType for simplicity.
+        When you do so, it will be assumed that the nullability of the inputs and
+        output are True and that they have no metadata.
+
+        Args:
+            func (Callable, optional): Only needed when calling as a function.
+                Skip this argument when using `udf` as a decorator. If you have a Rust
+                backed ScalarUDF within a PyCapsule, you can pass this parameter
+                and ignore the rest. They will be determined directly from the
+                underlying function. See the online documentation for more information.
+            input_fields (list[pa.Field | pa.DataType]): The data types or Fields
+                of the arguments to ``func``. This list must be of the same length
+                as the number of arguments.
+            return_field (_R): The field of the return value from the function.
+            volatility (Volatility | str): See `Volatility` for allowed values.
+            name (Optional[str]): A descriptive name for the function.
+
+        Returns:
+            A user-defined function that can be used in SQL expressions,
+            data aggregation, or window function calls.
+
+        Example: Using ``udf`` as a function::
+
+            def double_func(x):
+                return x * 2
+            double_udf = udf(double_func, [pa.int32()], pa.int32(),
+            "volatile", "double_it")
+
+        Example: Using ``udf`` as a decorator::
+
+            @udf([pa.int32()], pa.int32(), "volatile", "double_it")
+            def double_udf(x):
+                return x * 2
+        """  # noqa: W505 E501
+
+        def _function(
+            func: Callable[..., _R],
+            input_fields: Sequence[pa.DataType | pa.Field] | pa.DataType | pa.Field,
+            return_field: pa.DataType | pa.Field,
+            volatility: Volatility | str,
+            name: str | None = None,
+        ) -> ScalarUDF:
+            if not callable(func):
+                msg = "`func` argument must be callable"
+                raise TypeError(msg)
+            if name is None:
+                if hasattr(func, "__qualname__"):
+                    name = func.__qualname__.lower()
+                else:
+                    name = func.__class__.__name__.lower()
+            input_fields = data_types_or_fields_to_field_list(input_fields)
+            return_field = data_type_or_field_to_field(return_field, "value")
+            return ScalarUDF(
+                name=name,
+                func=func,
+                input_fields=input_fields,
+                return_field=return_field,
+                volatility=volatility,
+            )
+
+        def _decorator(
+            input_fields: Sequence[pa.DataType | pa.Field] | pa.DataType | pa.Field,
+            return_field: _R,
+            volatility: Volatility | str,
+            name: str | None = None,
+        ) -> Callable:
+            def decorator(func: Callable) -> Callable:
+                udf_caller = ScalarUDF.udf(
+                    func, input_fields, return_field, volatility, name
+                )
+
+                @functools.wraps(func)
+                def wrapper(*args: Any, **kwargs: Any) -> Callable:
+                    return udf_caller(*args, **kwargs)
+
+                return wrapper
+
+            return decorator
+
+        if hasattr(args[0], "__datafusion_scalar_udf__"):
+            return ScalarUDF.from_pycapsule(args[0])
+
+        if args and callable(args[0]):
+            # Case 1: Used as a function, require the first parameter to be callable
+            return _function(*args, **kwargs)
+        # Case 2: Used as a decorator with parameters
+        return _decorator(*args, **kwargs)
+
+    @staticmethod
+    def from_pycapsule(func: ScalarUDFExportable) -> ScalarUDF:
+        """Create a Scalar UDF from ScalarUDF PyCapsule object.
+
+        This function will instantiate a Scalar UDF that uses a DataFusion
+        ScalarUDF that is exported via the FFI bindings.
+        """
+        name = str(func.__class__)
+        return ScalarUDF(
+            name=name,
+            func=func,
+            input_fields=None,
+            return_field=None,
+            volatility=None,
+        )
+
+
+class Accumulator(metaclass=ABCMeta):
+    """Defines how an :py:class:`AggregateUDF` accumulates values."""
+
+    @abstractmethod
+    def state(self) -> list[pa.Scalar]:
+        """Return the current state.
+
+        While this function template expects PyArrow Scalar values return type,
+        you can return any value that can be converted into a Scalar. This
+        includes basic Python data types such as integers and strings. In
+        addition to primitive types, we currently support PyArrow, nanoarrow,
+        and arro3 objects in addition to primitive data types. Other objects
+        that support the Arrow FFI standard will be given a "best attempt" at
+        conversion to scalar objects.
+        """
+
+    @abstractmethod
+    def update(self, *values: pa.Array) -> None:
+        """Evaluate an array of values and update state."""
+
+    @abstractmethod
+    def merge(self, states: list[pa.Array]) -> None:
+        """Merge a set of states."""
+
+    @abstractmethod
+    def evaluate(self) -> pa.Scalar:
+        """Return the resultant value.
+
+        While this function template expects a PyArrow Scalar value return type,
+        you can return any value that can be converted into a Scalar. This
+        includes basic Python data types such as integers and strings. In
+        addition to primitive types, we currently support PyArrow, nanoarrow,
+        and arro3 objects in addition to primitive data types. Other objects
+        that support the Arrow FFI standard will be given a "best attempt" at
+        conversion to scalar objects.
+        """
+
+
+class AggregateUDFExportable(Protocol):
+    """Type hint for object that has __datafusion_aggregate_udf__ PyCapsule."""
+
+    def __datafusion_aggregate_udf__(self) -> object: ...  # noqa: D105
+
+
+class AggregateUDF:
+    """Class for performing scalar user-defined functions (UDF).
+
+    Aggregate UDFs operate on a group of rows and return a single value. See
+    also :py:class:`ScalarUDF` for operating on a row by row basis.
+    """
+
+    @overload
+    def __init__(
+        self,
+        name: str,
+        accumulator: Callable[[], Accumulator],
+        input_types: list[pa.DataType],
+        return_type: pa.DataType,
+        state_type: list[pa.DataType],
+        volatility: Volatility | str,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        name: str,
+        accumulator: AggregateUDFExportable,
+        input_types: None = ...,
+        return_type: None = ...,
+        state_type: None = ...,
+        volatility: None = ...,
+    ) -> None: ...
+
+    def __init__(
+        self,
+        name: str,
+        accumulator: Callable[[], Accumulator] | AggregateUDFExportable,
+        input_types: list[pa.DataType] | None,
+        return_type: pa.DataType | None,
+        state_type: list[pa.DataType] | None,
+        volatility: Volatility | str | None,
+    ) -> None:
+        """Instantiate a user-defined aggregate function (UDAF).
+
+        See :py:func:`udaf` for a convenience function and argument
+        descriptions.
+        """
+        if hasattr(accumulator, "__datafusion_aggregate_udf__"):
+            self._udaf = df_internal.AggregateUDF.from_pycapsule(accumulator)
+            return
+        if (
+            input_types is None
+            or return_type is None
+            or state_type is None
+            or volatility is None
+        ):
+            msg = (
+                "`input_types`, `return_type`, `state_type`, and `volatility` "
+                "must be provided when `accumulator` is callable."
+            )
+            raise TypeError(msg)
+
+        self._udaf = df_internal.AggregateUDF(
+            name,
+            accumulator,
+            input_types,
+            return_type,
+            state_type,
+            str(volatility),
+        )
+
+    def __repr__(self) -> str:
+        """Print a string representation of the Aggregate UDF."""
+        return self._udaf.__repr__()
+
+    def __call__(self, *args: Expr) -> Expr:
+        """Execute the UDAF.
+
+        This function is not typically called by an end user. These calls will
+        occur during the evaluation of the dataframe.
+        """
+        args_raw = [arg.expr for arg in args]
+        return Expr(self._udaf.__call__(*args_raw))
+
+    @overload
+    @staticmethod
+    def udaf(
+        input_types: pa.DataType | list[pa.DataType],
+        return_type: pa.DataType,
+        state_type: list[pa.DataType],
+        volatility: Volatility | str,
+        name: str | None = None,
+    ) -> Callable[..., AggregateUDF]: ...
+
+    @overload
+    @staticmethod
+    def udaf(
+        accum: Callable[[], Accumulator],
+        input_types: pa.DataType | list[pa.DataType],
+        return_type: pa.DataType,
+        state_type: list[pa.DataType],
+        volatility: Volatility | str,
+        name: str | None = None,
+    ) -> AggregateUDF: ...
+
+    @overload
+    @staticmethod
+    def udaf(accum: AggregateUDFExportable) -> AggregateUDF: ...
+
+    @overload
+    @staticmethod
+    def udaf(accum: _PyCapsule) -> AggregateUDF: ...
+
+    @staticmethod
+    def udaf(*args: Any, **kwargs: Any):  # noqa: D417, C901
+        """Create a new User-Defined Aggregate Function (UDAF).
+
+        This class allows you to define an aggregate function that can be used in
+        data aggregation or window function calls.
+
+        Usage:
+            - As a function: ``udaf(accum, input_types, return_type, state_type, volatility, name)``.
+            - As a decorator: ``@udaf(input_types, return_type, state_type, volatility, name)``.
+              When using ``udaf`` as a decorator, do not pass ``accum`` explicitly.
+
+        Function example:
+
+        If your :py:class:`Accumulator` can be instantiated with no arguments, you
+        can simply pass it's type as `accum`. If you need to pass additional
+        arguments to it's constructor, you can define a lambda or a factory method.
+        During runtime the :py:class:`Accumulator` will be constructed for every
+        instance in which this UDAF is used. The following examples are all valid::
+
+            import pyarrow as pa
+            import pyarrow.compute as pc
+
+            class Summarize(Accumulator):
+                def __init__(self, bias: float = 0.0):
+                    self._sum = pa.scalar(bias)
+
+                def state(self) -> list[pa.Scalar]:
+                    return [self._sum]
+
+                def update(self, values: pa.Array) -> None:
+                    self._sum = pa.scalar(self._sum.as_py() + pc.sum(values).as_py())
+
+                def merge(self, states: list[pa.Array]) -> None:
+                    self._sum = pa.scalar(self._sum.as_py() + pc.sum(states[0]).as_py())
+
+                def evaluate(self) -> pa.Scalar:
+                    return self._sum
+
+            def sum_bias_10() -> Summarize:
+                return Summarize(10.0)
+
+            udaf1 = udaf(Summarize, pa.float64(), pa.float64(), [pa.float64()],
+                "immutable")
+            udaf2 = udaf(sum_bias_10, pa.float64(), pa.float64(), [pa.float64()],
+                "immutable")
+            udaf3 = udaf(lambda: Summarize(20.0), pa.float64(), pa.float64(),
+                [pa.float64()], "immutable")
+
+        Decorator example:::
+
+            @udaf(pa.float64(), pa.float64(), [pa.float64()], "immutable")
+            def udf4() -> Summarize:
+                return Summarize(10.0)
+
+        Args:
+            accum: The accumulator python function. Only needed when calling as a
+                function. Skip this argument when using ``udaf`` as a decorator.
+                If you have a Rust backed AggregateUDF within a PyCapsule, you can
+                pass this parameter and ignore the rest. They will be determined
+                directly from the underlying function. See the online documentation
+                for more information.
+            input_types: The data types of the arguments to ``accum``.
+            return_type: The data type of the return value.
+            state_type: The data types of the intermediate accumulation.
+            volatility: See :py:class:`Volatility` for allowed values.
+            name: A descriptive name for the function.
+
+        Returns:
+            A user-defined aggregate function, which can be used in either data
+            aggregation or window function calls.
+        """  # noqa: E501 W505
+
+        def _function(
+            accum: Callable[[], Accumulator],
+            input_types: pa.DataType | list[pa.DataType],
+            return_type: pa.DataType,
+            state_type: list[pa.DataType],
+            volatility: Volatility | str,
+            name: str | None = None,
+        ) -> AggregateUDF:
+            if not callable(accum):
+                msg = "`func` must be callable."
+                raise TypeError(msg)
+            if not isinstance(accum(), Accumulator):
+                msg = "Accumulator must implement the abstract base class Accumulator"
+                raise TypeError(msg)
+            if name is None:
+                name = accum().__class__.__qualname__.lower()
+            if isinstance(input_types, pa.DataType):
+                input_types = [input_types]
+            return AggregateUDF(
+                name=name,
+                accumulator=accum,
+                input_types=input_types,
+                return_type=return_type,
+                state_type=state_type,
+                volatility=volatility,
+            )
+
+        def _decorator(
+            input_types: pa.DataType | list[pa.DataType],
+            return_type: pa.DataType,
+            state_type: list[pa.DataType],
+            volatility: Volatility | str,
+            name: str | None = None,
+        ) -> Callable[..., Callable[..., Expr]]:
+            def decorator(accum: Callable[[], Accumulator]) -> Callable[..., Expr]:
+                udaf_caller = AggregateUDF.udaf(
+                    accum, input_types, return_type, state_type, volatility, name
+                )
+
+                @functools.wraps(accum)
+                def wrapper(*args: Any, **kwargs: Any) -> Expr:
+                    return udaf_caller(*args, **kwargs)
+
+                return wrapper
+
+            return decorator
+
+        if hasattr(args[0], "__datafusion_aggregate_udf__") or _is_pycapsule(args[0]):
+            return AggregateUDF.from_pycapsule(args[0])
+
+        if args and callable(args[0]):
+            # Case 1: Used as a function, require the first parameter to be callable
+            return _function(*args, **kwargs)
+        # Case 2: Used as a decorator with parameters
+        return _decorator(*args, **kwargs)
+
+    @staticmethod
+    def from_pycapsule(func: AggregateUDFExportable | _PyCapsule) -> AggregateUDF:
+        """Create an Aggregate UDF from AggregateUDF PyCapsule object.
+
+        This function will instantiate a Aggregate UDF that uses a DataFusion
+        AggregateUDF that is exported via the FFI bindings.
+        """
+        if _is_pycapsule(func):
+            aggregate = cast("AggregateUDF", object.__new__(AggregateUDF))
+            aggregate._udaf = df_internal.AggregateUDF.from_pycapsule(func)
+            return aggregate
+
+        capsule = cast("AggregateUDFExportable", func)
+        name = str(capsule.__class__)
+        return AggregateUDF(
+            name=name,
+            accumulator=capsule,
+            input_types=None,
+            return_type=None,
+            state_type=None,
+            volatility=None,
+        )
+
+
+class WindowEvaluator:
+    """Evaluator class for user-defined window functions (UDWF).
+
+    It is up to the user to decide which evaluate function is appropriate.
+
+    +------------------------+--------------------------------+------------------+---------------------------+
+    | ``uses_window_frame``  | ``supports_bounded_execution`` | ``include_rank`` | function_to_implement     |
+    +========================+================================+==================+===========================+
+    | False (default)        | False (default)                | False (default)  | ``evaluate_all``          |
+    +------------------------+--------------------------------+------------------+---------------------------+
+    | False                  | True                           | False            | ``evaluate``              |
+    +------------------------+--------------------------------+------------------+---------------------------+
+    | False                  | True/False                     | True             | ``evaluate_all_with_rank``|
+    +------------------------+--------------------------------+------------------+---------------------------+
+    | True                   | True/False                     | True/False       | ``evaluate``              |
+    +------------------------+--------------------------------+------------------+---------------------------+
+    """  # noqa: W505, E501
+
+    def memoize(self) -> None:
+        """Perform a memoize operation to improve performance.
+
+        When the window frame has a fixed beginning (e.g UNBOUNDED
+        PRECEDING), some functions such as FIRST_VALUE and
+        NTH_VALUE do not need the (unbounded) input once they have
+        seen a certain amount of input.
+
+        `memoize` is called after each input batch is processed, and
+        such functions can save whatever they need
+        """
+
+    def get_range(self, idx: int, num_rows: int) -> tuple[int, int]:  # noqa: ARG002
+        """Return the range for the window function.
+
+        If `uses_window_frame` flag is `false`. This method is used to
+        calculate required range for the window function during
+        stateful execution.
+
+        Generally there is no required range, hence by default this
+        returns smallest range(current row). e.g seeing current row is
+        enough to calculate window result (such as row_number, rank,
+        etc)
+
+        Args:
+            idx:: Current index
+            num_rows: Number of rows.
+        """
+        return (idx, idx + 1)
+
+    def is_causal(self) -> bool:
+        """Get whether evaluator needs future data for its result."""
+        return False
+
+    def evaluate_all(self, values: list[pa.Array], num_rows: int) -> pa.Array:
+        """Evaluate a window function on an entire input partition.
+
+        This function is called once per input *partition* for window functions that
+        *do not use* values from the window frame, such as
+        :py:func:`~datafusion.functions.row_number`,
+        :py:func:`~datafusion.functions.rank`,
+        :py:func:`~datafusion.functions.dense_rank`,
+        :py:func:`~datafusion.functions.percent_rank`,
+        :py:func:`~datafusion.functions.cume_dist`,
+        :py:func:`~datafusion.functions.lead`,
+        and :py:func:`~datafusion.functions.lag`.
+
+        It produces the result of all rows in a single pass. It
+        expects to receive the entire partition as the ``value`` and
+        must produce an output column with one output row for every
+        input row.
+
+        ``num_rows`` is required to correctly compute the output in case
+        ``len(values) == 0``
+
+        Implementing this function is an optimization. Certain window
+        functions are not affected by the window frame definition or
+        the query doesn't have a frame, and ``evaluate`` skips the
+        (costly) window frame boundary calculation and the overhead of
+        calling ``evaluate`` for each output row.
+
+        For example, the `LAG` built in window function does not use
+        the values of its window frame (it can be computed in one shot
+        on the entire partition with ``Self::evaluate_all`` regardless of the
+        window defined in the ``OVER`` clause)
+
+        .. code-block:: text
+
+            lag(x, 1) OVER (ORDER BY z ROWS BETWEEN 2 PRECEDING AND 3 FOLLOWING)
+
+        However, ``avg()`` computes the average in the window and thus
+        does use its window frame.
+
+        .. code-block:: text
+
+            avg(x) OVER (PARTITION BY y ORDER BY z ROWS BETWEEN 2 PRECEDING AND 3 FOLLOWING)
+        """  # noqa: W505, E501
+
+    def evaluate(
+        self, values: list[pa.Array], eval_range: tuple[int, int]
+    ) -> pa.Scalar:
+        """Evaluate window function on a range of rows in an input partition.
+
+        This is the simplest and most general function to implement
+        but also the least performant as it creates output one row at
+        a time. It is typically much faster to implement stateful
+        evaluation using one of the other specialized methods on this
+        trait.
+
+        Returns a [`ScalarValue`] that is the value of the window
+        function within `range` for the entire partition. Argument
+        `values` contains the evaluation result of function arguments
+        and evaluation results of ORDER BY expressions. If function has a
+        single argument, `values[1..]` will contain ORDER BY expression results.
+        """
+
+    def evaluate_all_with_rank(
+        self, num_rows: int, ranks_in_partition: list[tuple[int, int]]
+    ) -> pa.Array:
+        """Called for window functions that only need the rank of a row.
+
+        Evaluate the partition evaluator against the partition using
+        the row ranks. For example, ``rank(col("a"))`` produces
+
+        .. code-block:: text
+
+            a | rank
+            - + ----
+            A | 1
+            A | 1
+            C | 3
+            D | 4
+            D | 4
+
+        For this case, `num_rows` would be `5` and the
+        `ranks_in_partition` would be called with
+
+        .. code-block:: text
+
+            [
+                (0,1),
+                (2,2),
+                (3,4),
+            ]
+
+        The user must implement this method if ``include_rank`` returns True.
+        """
+
+    def supports_bounded_execution(self) -> bool:
+        """Can the window function be incrementally computed using bounded memory?"""
+        return False
+
+    def uses_window_frame(self) -> bool:
+        """Does the window function use the values from the window frame?"""
+        return False
+
+    def include_rank(self) -> bool:
+        """Can this function be evaluated with (only) rank?"""
+        return False
+
+
+class WindowUDFExportable(Protocol):
+    """Type hint for object that has __datafusion_window_udf__ PyCapsule."""
+
+    def __datafusion_window_udf__(self) -> object: ...  # noqa: D105
+
+
+class WindowUDF:
+    """Class for performing window user-defined functions (UDF).
+
+    Window UDFs operate on a partition of rows. See
+    also :py:class:`ScalarUDF` for operating on a row by row basis.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        func: Callable[[], WindowEvaluator],
+        input_types: list[pa.DataType],
+        return_type: pa.DataType,
+        volatility: Volatility | str,
+    ) -> None:
+        """Instantiate a user-defined window function (UDWF).
+
+        See :py:func:`udwf` for a convenience function and argument
+        descriptions.
+        """
+        if hasattr(func, "__datafusion_window_udf__"):
+            self._udwf = df_internal.WindowUDF.from_pycapsule(func)
+            return
+        self._udwf = df_internal.WindowUDF(
+            name, func, input_types, return_type, str(volatility)
+        )
+
+    def __repr__(self) -> str:
+        """Print a string representation of the Window UDF."""
+        return self._udwf.__repr__()
+
+    def __call__(self, *args: Expr) -> Expr:
+        """Execute the UDWF.
+
+        This function is not typically called by an end user. These calls will
+        occur during the evaluation of the dataframe.
+        """
+        args_raw = [arg.expr for arg in args]
+        return Expr(self._udwf.__call__(*args_raw))
+
+    @overload
+    @staticmethod
+    def udwf(
+        input_types: pa.DataType | list[pa.DataType],
+        return_type: pa.DataType,
+        volatility: Volatility | str,
+        name: str | None = None,
+    ) -> Callable[..., WindowUDF]: ...
+
+    @overload
+    @staticmethod
+    def udwf(
+        func: Callable[[], WindowEvaluator],
+        input_types: pa.DataType | list[pa.DataType],
+        return_type: pa.DataType,
+        volatility: Volatility | str,
+        name: str | None = None,
+    ) -> WindowUDF: ...
+
+    @staticmethod
+    def udwf(*args: Any, **kwargs: Any):  # noqa: D417
+        """Create a new User-Defined Window Function (UDWF).
+
+        This class can be used both as either a function or a decorator.
+
+        Usage:
+            - As a function: ``udwf(func, input_types, return_type, volatility, name)``.
+            - As a decorator: ``@udwf(input_types, return_type, volatility, name)``.
+              When using ``udwf`` as a decorator, do not pass ``func`` explicitly.
+
+        Function example::
+
+            import pyarrow as pa
+
+            class BiasedNumbers(WindowEvaluator):
+                def __init__(self, start: int = 0) -> None:
+                    self.start = start
+
+                def evaluate_all(self, values: list[pa.Array],
+                    num_rows: int) -> pa.Array:
+                    return pa.array([self.start + i for i in range(num_rows)])
+
+            def bias_10() -> BiasedNumbers:
+                return BiasedNumbers(10)
+
+            udwf1 = udwf(BiasedNumbers, pa.int64(), pa.int64(), "immutable")
+            udwf2 = udwf(bias_10, pa.int64(), pa.int64(), "immutable")
+            udwf3 = udwf(lambda: BiasedNumbers(20), pa.int64(), pa.int64(), "immutable")
+
+
+        Decorator example::
+
+            @udwf(pa.int64(), pa.int64(), "immutable")
+            def biased_numbers() -> BiasedNumbers:
+                return BiasedNumbers(10)
+
+        Args:
+            func: Only needed when calling as a function. Skip this argument when
+                using ``udwf`` as a decorator. If you have a Rust backed WindowUDF
+                within a PyCapsule, you can pass this parameter and ignore the rest.
+                They will be determined directly from the underlying function. See
+                the online documentation for more information.
+            input_types: The data types of the arguments.
+            return_type: The data type of the return value.
+            volatility: See :py:class:`Volatility` for allowed values.
+            name: A descriptive name for the function.
+
+        Returns:
+            A user-defined window function that can be used in window function calls.
+        """
+        if hasattr(args[0], "__datafusion_window_udf__"):
+            return WindowUDF.from_pycapsule(args[0])
+
+        if args and callable(args[0]):
+            # Case 1: Used as a function, require the first parameter to be callable
+            return WindowUDF._create_window_udf(*args, **kwargs)
+        # Case 2: Used as a decorator with parameters
+        return WindowUDF._create_window_udf_decorator(*args, **kwargs)
+
+    @staticmethod
+    def _create_window_udf(
+        func: Callable[[], WindowEvaluator],
+        input_types: pa.DataType | list[pa.DataType],
+        return_type: pa.DataType,
+        volatility: Volatility | str,
+        name: str | None = None,
+    ) -> WindowUDF:
+        """Create a WindowUDF instance from function arguments."""
+        if not callable(func):
+            msg = "`func` must be callable."
+            raise TypeError(msg)
+        if not isinstance(func(), WindowEvaluator):
+            msg = "`func` must implement the abstract base class WindowEvaluator"
+            raise TypeError(msg)
+
+        name = name or func.__qualname__.lower()
+        input_types = (
+            [input_types] if isinstance(input_types, pa.DataType) else input_types
+        )
+
+        return WindowUDF(name, func, input_types, return_type, volatility)
+
+    @staticmethod
+    def _get_default_name(func: Callable) -> str:
+        """Get the default name for a function based on its attributes."""
+        if hasattr(func, "__qualname__"):
+            return func.__qualname__.lower()
+        return func.__class__.__name__.lower()
+
+    @staticmethod
+    def _normalize_input_types(
+        input_types: pa.DataType | list[pa.DataType],
+    ) -> list[pa.DataType]:
+        """Convert a single DataType to a list if needed."""
+        if isinstance(input_types, pa.DataType):
+            return [input_types]
+        return input_types
+
+    @staticmethod
+    def _create_window_udf_decorator(
+        input_types: pa.DataType | list[pa.DataType],
+        return_type: pa.DataType,
+        volatility: Volatility | str,
+        name: str | None = None,
+    ) -> Callable[[Callable[[], WindowEvaluator]], Callable[..., Expr]]:
+        """Create a decorator for a WindowUDF."""
+
+        def decorator(func: Callable[[], WindowEvaluator]) -> Callable[..., Expr]:
+            udwf_caller = WindowUDF._create_window_udf(
+                func, input_types, return_type, volatility, name
+            )
+
+            @functools.wraps(func)
+            def wrapper(*args: Any, **kwargs: Any) -> Expr:
+                return udwf_caller(*args, **kwargs)
+
+            return wrapper
+
+        return decorator
+
+    @staticmethod
+    def from_pycapsule(func: WindowUDFExportable) -> WindowUDF:
+        """Create a Window UDF from WindowUDF PyCapsule object.
+
+        This function will instantiate a Window UDF that uses a DataFusion
+        WindowUDF that is exported via the FFI bindings.
+        """
+        name = str(func.__class__)
+        return WindowUDF(
+            name=name,
+            func=func,
+            input_types=None,
+            return_type=None,
+            volatility=None,
+        )
+
+
+class TableFunction:
+    """Class for performing user-defined table functions (UDTF).
+
+    Table functions generate new table providers based on the
+    input expressions.
+    """
+
+    def __init__(
+        self, name: str, func: Callable[[], any], ctx: SessionContext | None = None
+    ) -> None:
+        """Instantiate a user-defined table function (UDTF).
+
+        See :py:func:`udtf` for a convenience function and argument
+        descriptions.
+        """
+        self._udtf = df_internal.TableFunction(name, func, ctx)
+
+    def __call__(self, *args: Expr) -> Any:
+        """Execute the UDTF and return a table provider."""
+        args_raw = [arg.expr for arg in args]
+        return self._udtf.__call__(*args_raw)
+
+    @overload
+    @staticmethod
+    def udtf(
+        name: str,
+    ) -> Callable[..., Any]: ...
+
+    @overload
+    @staticmethod
+    def udtf(
+        func: Callable[[], Any],
+        name: str,
+    ) -> TableFunction: ...
+
+    @staticmethod
+    def udtf(*args: Any, **kwargs: Any):
+        """Create a new User-Defined Table Function (UDTF)."""
+        if args and callable(args[0]):
+            # Case 1: Used as a function, require the first parameter to be callable
+            return TableFunction._create_table_udf(*args, **kwargs)
+        if args and hasattr(args[0], "__datafusion_table_function__"):
+            # Case 2: We have a datafusion FFI provided function
+            return TableFunction(args[1], args[0])
+        # Case 3: Used as a decorator with parameters
+        return TableFunction._create_table_udf_decorator(*args, **kwargs)
+
+    @staticmethod
+    def _create_table_udf(
+        func: Callable[..., Any],
+        name: str,
+    ) -> TableFunction:
+        """Create a TableFunction instance from function arguments."""
+        if not callable(func):
+            msg = "`func` must be callable."
+            raise TypeError(msg)
+
+        return TableFunction(name, func)
+
+    @staticmethod
+    def _create_table_udf_decorator(
+        name: str | None = None,
+    ) -> Callable[[Callable[[], WindowEvaluator]], Callable[..., Expr]]:
+        """Create a decorator for a WindowUDF."""
+
+        def decorator(func: Callable[[], WindowEvaluator]) -> Callable[..., Expr]:
+            return TableFunction._create_table_udf(func, name)
+
+        return decorator
+
+    def __repr__(self) -> str:
+        """User printable representation."""
+        return self._udtf.__repr__()
+
+
+# Convenience exports so we can import instead of treating as
+# variables at the package root
+udf = ScalarUDF.udf
+udaf = AggregateUDF.udaf
+udwf = WindowUDF.udwf
+udtf = TableFunction.udtf
diff --git a/datafusion/tests/__init__.py b/python/tests/__init__.py
similarity index 100%
rename from datafusion/tests/__init__.py
rename to python/tests/__init__.py
diff --git a/datafusion/tests/conftest.py b/python/tests/conftest.py
similarity index 78%
rename from datafusion/tests/conftest.py
rename to python/tests/conftest.py
index a4eec41e2..26ed7281d 100644
--- a/datafusion/tests/conftest.py
+++ b/python/tests/conftest.py
@@ -15,9 +15,10 @@
 # specific language governing permissions and limitations
 # under the License.
 
-import pytest
-from datafusion import SessionContext
 import pyarrow as pa
+import pytest
+from datafusion import DataFrame, SessionContext
+from pyarrow.csv import write_csv
 
 
 @pytest.fixture
@@ -37,7 +38,7 @@ def database(ctx, tmp_path):
         ],
         names=["int", "str", "float"],
     )
-    pa.csv.write_csv(table, path)
+    write_csv(table, path)
 
     ctx.register_csv("csv", path)
     ctx.register_csv("csv1", str(path))
@@ -48,3 +49,12 @@ def database(ctx, tmp_path):
         delimiter=",",
         schema_infer_max_records=10,
     )
+
+
+@pytest.fixture
+def fail_collect(monkeypatch):
+    def _fail_collect(self, *args, **kwargs):  # pragma: no cover - failure path
+        msg = "collect should not be called"
+        raise AssertionError(msg)
+
+    monkeypatch.setattr(DataFrame, "collect", _fail_collect)
diff --git a/datafusion/tests/data_test_context/data.json b/python/tests/data_test_context/data.json
similarity index 100%
rename from datafusion/tests/data_test_context/data.json
rename to python/tests/data_test_context/data.json
diff --git a/datafusion/tests/generic.py b/python/tests/generic.py
similarity index 68%
rename from datafusion/tests/generic.py
rename to python/tests/generic.py
index 1f984a40a..1b98fdf9e 100644
--- a/datafusion/tests/generic.py
+++ b/python/tests/generic.py
@@ -16,6 +16,7 @@
 # under the License.
 
 import datetime
+from datetime import timezone
 
 import numpy as np
 import pyarrow as pa
@@ -26,33 +27,31 @@
 
 
 def data():
-    np.random.seed(1)
+    rng = np.random.default_rng(1)
     data = np.concatenate(
         [
-            np.random.normal(0, 0.01, size=50),
-            np.random.normal(50, 0.01, size=50),
+            rng.normal(0, 0.01, size=50),
+            rng.normal(50, 0.01, size=50),
         ]
     )
     return pa.array(data)
 
 
 def data_with_nans():
-    np.random.seed(0)
-    data = np.random.normal(0, 0.01, size=50)
-    mask = np.random.randint(0, 2, size=50)
-    data[mask == 0] = np.NaN
+    rng = np.random.default_rng(0)
+    data = rng.normal(0, 0.01, size=50)
+    mask = rng.normal(0, 2, size=50)
+    data[mask == 0] = np.nan
     return data
 
 
 def data_datetime(f):
     data = [
-        datetime.datetime.now(),
-        datetime.datetime.now() - datetime.timedelta(days=1),
-        datetime.datetime.now() + datetime.timedelta(days=1),
+        datetime.datetime.now(tz=timezone.utc),
+        datetime.datetime.now(tz=timezone.utc) - datetime.timedelta(days=1),
+        datetime.datetime.now(tz=timezone.utc) + datetime.timedelta(days=1),
     ]
-    return pa.array(
-        data, type=pa.timestamp(f), mask=np.array([False, True, False])
-    )
+    return pa.array(data, type=pa.timestamp(f), mask=np.array([False, True, False]))
 
 
 def data_date32():
@@ -61,9 +60,7 @@ def data_date32():
         datetime.date(1980, 1, 1),
         datetime.date(2030, 1, 1),
     ]
-    return pa.array(
-        data, type=pa.date32(), mask=np.array([False, True, False])
-    )
+    return pa.array(data, type=pa.date32(), mask=np.array([False, True, False]))
 
 
 def data_timedelta(f):
@@ -72,9 +69,7 @@ def data_timedelta(f):
         datetime.timedelta(days=1),
         datetime.timedelta(seconds=1),
     ]
-    return pa.array(
-        data, type=pa.duration(f), mask=np.array([False, True, False])
-    )
+    return pa.array(data, type=pa.duration(f), mask=np.array([False, True, False]))
 
 
 def data_binary_other():
diff --git a/python/tests/test_aggregation.py b/python/tests/test_aggregation.py
new file mode 100644
index 000000000..240332848
--- /dev/null
+++ b/python/tests/test_aggregation.py
@@ -0,0 +1,480 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import numpy as np
+import pyarrow as pa
+import pytest
+from datafusion import SessionContext, column, lit
+from datafusion import functions as f
+from datafusion.common import NullTreatment
+
+
+@pytest.fixture
+def df():
+    ctx = SessionContext()
+
+    # create a RecordBatch and a new DataFrame from it
+    batch = pa.RecordBatch.from_arrays(
+        [
+            pa.array([1, 2, 3]),
+            pa.array([4, 4, 6]),
+            pa.array([9, 8, 5]),
+            pa.array([True, True, False]),
+            pa.array([1, 2, None]),
+        ],
+        names=["a", "b", "c", "d", "e"],
+    )
+    return ctx.create_dataframe([[batch]])
+
+
+@pytest.fixture
+def df_partitioned():
+    ctx = SessionContext()
+
+    # create a RecordBatch and a new DataFrame from it
+    batch = pa.RecordBatch.from_arrays(
+        [
+            pa.array([0, 1, 2, 3, 4, 5, 6]),
+            pa.array([7, None, 7, 8, 9, None, 9]),
+            pa.array(["A", "A", "A", "A", "B", "B", "B"]),
+        ],
+        names=["a", "b", "c"],
+    )
+
+    return ctx.create_dataframe([[batch]])
+
+
+@pytest.fixture
+def df_aggregate_100():
+    ctx = SessionContext()
+    ctx.register_csv("aggregate_test_data", "./testing/data/csv/aggregate_test_100.csv")
+    return ctx.table("aggregate_test_data")
+
+
+@pytest.mark.parametrize(
+    ("agg_expr", "calc_expected"),
+    [
+        (f.avg(column("a")), lambda a, b, c, d: np.array(np.average(a))),
+        (
+            f.corr(column("a"), column("b")),
+            lambda a, b, c, d: np.array(np.corrcoef(a, b)[0][1]),
+        ),
+        (f.count(column("a")), lambda a, b, c, d: pa.array([len(a)])),
+        # Sample (co)variance -> ddof=1
+        # Population (co)variance -> ddof=0
+        (
+            f.covar(column("a"), column("b")),
+            lambda a, b, c, d: np.array(np.cov(a, b, ddof=1)[0][1]),
+        ),
+        (
+            f.covar_pop(column("a"), column("c")),
+            lambda a, b, c, d: np.array(np.cov(a, c, ddof=0)[0][1]),
+        ),
+        (
+            f.covar_samp(column("b"), column("c")),
+            lambda a, b, c, d: np.array(np.cov(b, c, ddof=1)[0][1]),
+        ),
+        # f.grouping(col_a),  # noqa: ERA001 No physical plan implemented yet
+        (f.max(column("a")), lambda a, b, c, d: np.array(np.max(a))),
+        (f.mean(column("b")), lambda a, b, c, d: np.array(np.mean(b))),
+        (f.median(column("b")), lambda a, b, c, d: np.array(np.median(b))),
+        (f.min(column("a")), lambda a, b, c, d: np.array(np.min(a))),
+        (f.sum(column("b")), lambda a, b, c, d: np.array(np.sum(b.to_pylist()))),
+        # Sample stdev -> ddof=1
+        # Population stdev -> ddof=0
+        (f.stddev(column("a")), lambda a, b, c, d: np.array(np.std(a, ddof=1))),
+        (f.stddev_pop(column("b")), lambda a, b, c, d: np.array(np.std(b, ddof=0))),
+        (f.stddev_samp(column("c")), lambda a, b, c, d: np.array(np.std(c, ddof=1))),
+        (f.var(column("a")), lambda a, b, c, d: np.array(np.var(a, ddof=1))),
+        (f.var_pop(column("b")), lambda a, b, c, d: np.array(np.var(b, ddof=0))),
+        (f.var_samp(column("c")), lambda a, b, c, d: np.array(np.var(c, ddof=1))),
+    ],
+)
+def test_aggregation_stats(df, agg_expr, calc_expected):
+    df = df.select("a", "b", "c", "d")
+    agg_df = df.aggregate([], [agg_expr])
+    result = agg_df.collect()[0]
+    values_a, values_b, values_c, values_d = df.collect()[0]
+    expected = calc_expected(values_a, values_b, values_c, values_d)
+    np.testing.assert_array_almost_equal(result.column(0), expected)
+
+
+@pytest.mark.parametrize(
+    ("agg_expr", "expected", "array_sort"),
+    [
+        (f.approx_distinct(column("b")), pa.array([2], type=pa.uint64()), False),
+        (
+            f.approx_distinct(
+                column("b"),
+                filter=column("a") != lit(3),
+            ),
+            pa.array([1], type=pa.uint64()),
+            False,
+        ),
+        (f.approx_median(column("b")), pa.array([4]), False),
+        (f.median(column("b"), distinct=True), pa.array([5]), False),
+        (f.median(column("b"), filter=column("a") != 2), pa.array([5]), False),
+        (f.approx_median(column("b"), filter=column("a") != 2), pa.array([5]), False),
+        (f.approx_percentile_cont(column("b"), 0.5), pa.array([4]), False),
+        (
+            f.approx_percentile_cont(
+                column("b").sort(ascending=True, nulls_first=False),
+                0.5,
+                num_centroids=2,
+            ),
+            pa.array([4]),
+            False,
+        ),
+        (
+            f.approx_percentile_cont_with_weight(column("b"), lit(0.6), 0.5),
+            pa.array([4], type=pa.float64()),
+            False,
+        ),
+        (
+            f.approx_percentile_cont_with_weight(
+                column("b").sort(ascending=False, nulls_first=False), lit(0.6), 0.5
+            ),
+            pa.array([4], type=pa.float64()),
+            False,
+        ),
+        (
+            f.approx_percentile_cont_with_weight(
+                column("b"), lit(0.6), 0.5, filter=column("a") != lit(3)
+            ),
+            pa.array([4], type=pa.float64()),
+            False,
+        ),
+        (f.array_agg(column("b")), pa.array([[4, 4, 6]]), False),
+        (f.array_agg(column("b"), distinct=True), pa.array([[4, 6]]), True),
+        (
+            f.array_agg(column("e"), filter=column("e").is_not_null()),
+            pa.array([[1, 2]]),
+            False,
+        ),
+        (
+            f.array_agg(column("b"), order_by=[column("c")]),
+            pa.array([[6, 4, 4]]),
+            False,
+        ),
+        (
+            f.array_agg(column("b"), order_by=column("c")),
+            pa.array([[6, 4, 4]]),
+            False,
+        ),
+        (f.avg(column("b"), filter=column("a") != lit(1)), pa.array([5.0]), False),
+        (f.sum(column("b"), filter=column("a") != lit(1)), pa.array([10]), False),
+        (f.count(column("b"), distinct=True), pa.array([2]), False),
+        (f.count(column("b"), filter=column("a") != 3), pa.array([2]), False),
+        (f.count(), pa.array([3]), False),
+        (f.count(column("e")), pa.array([2]), False),
+        (f.count_star(filter=column("a") != 3), pa.array([2]), False),
+        (f.max(column("a"), filter=column("a") != lit(3)), pa.array([2]), False),
+        (f.min(column("a"), filter=column("a") != lit(1)), pa.array([2]), False),
+        (
+            f.stddev(column("a"), filter=column("a") != lit(2)),
+            pa.array([np.sqrt(2)]),
+            False,
+        ),
+        (
+            f.stddev_pop(column("a"), filter=column("a") != lit(2)),
+            pa.array([1.0]),
+            False,
+        ),
+    ],
+)
+def test_aggregation(df, agg_expr, expected, array_sort):
+    agg_df = df.aggregate([], [agg_expr.alias("agg_expr")])
+    if array_sort:
+        agg_df = agg_df.select(f.array_sort(column("agg_expr")))
+    agg_df.show()
+    result = agg_df.collect()[0]
+
+    assert result.column(0) == expected
+
+
+@pytest.mark.parametrize(
+    ("name", "expr", "expected"),
+    [
+        (
+            "approx_percentile_cont",
+            f.approx_percentile_cont(column("c3"), 0.95, num_centroids=200),
+            [73, 68, 122, 124, 115],
+        ),
+        (
+            "approx_perc_cont_few_centroids",
+            f.approx_percentile_cont(column("c3"), 0.95, num_centroids=5),
+            [72, 68, 119, 124, 115],
+        ),
+        (
+            "approx_perc_cont_filtered",
+            f.approx_percentile_cont(
+                column("c3"), 0.95, num_centroids=200, filter=column("c3") > lit(0)
+            ),
+            [83, 68, 122, 124, 117],
+        ),
+        (
+            "corr",
+            f.corr(column("c3"), column("c2")),
+            [-0.1056, -0.2808, 0.0023, 0.0022, -0.2473],
+        ),
+        (
+            "corr_w_filter",
+            f.corr(column("c3"), column("c2"), filter=column("c3") > lit(0)),
+            [-0.3298, 0.2925, 0.2467, -0.2269, 0.0358],
+        ),
+        (
+            "covar_pop",
+            f.covar_pop(column("c3"), column("c2")),
+            [-7.2857, -25.6731, 0.2222, 0.2469, -20.2857],
+        ),
+        (
+            "covar_pop_w_filter",
+            f.covar_pop(column("c3"), column("c2"), filter=column("c3") > lit(0)),
+            [-9.25, 9.0579, 13.7521, -9.9669, 1.1641],
+        ),
+        (
+            "covar_samp",
+            f.covar_samp(column("c3"), column("c2")),
+            [-7.65, -27.0994, 0.2333, 0.2614, -21.3],
+        ),
+        (
+            "covar_samp_w_filter",
+            f.covar_samp(column("c3"), column("c2"), filter=column("c3") > lit(0)),
+            [-10.5714, 9.9636, 15.1273, -10.9636, 1.2417],
+        ),
+        (
+            "var_samp",
+            f.var_samp(column("c2")),
+            [1.9286, 2.2047, 1.6333, 2.1438, 1.6],
+        ),
+        (
+            "var_samp_w_filter",
+            f.var_samp(column("c2"), filter=column("c3") > lit(0)),
+            [1.4286, 2.4182, 1.8545, 1.4727, 1.6292],
+        ),
+        (
+            "var_pop",
+            f.var_pop(column("c2")),
+            [1.8367, 2.0886, 1.5556, 2.0247, 1.5238],
+        ),
+        (
+            "var_pop_w_filter",
+            f.var_pop(column("c2"), filter=column("c3") > lit(0)),
+            [1.25, 2.1983, 1.686, 1.3388, 1.5273],
+        ),
+    ],
+)
+def test_aggregate_100(df_aggregate_100, name, expr, expected):
+    # https://github.com/apache/datafusion/blob/bddb6415a50746d2803dd908d19c3758952d74f9/datafusion/sqllogictest/test_files/aggregate.slt#L1490-L1498
+
+    df = (
+        df_aggregate_100.aggregate(
+            [column("c1")],
+            [expr.alias(name)],
+        )
+        .select("c1", f.round(column(name), lit(4)).alias(name))
+        .sort(column("c1").sort(ascending=True))
+    )
+    df.show()
+
+    expected_dict = {
+        "c1": ["a", "b", "c", "d", "e"],
+        name: expected,
+    }
+
+    assert df.collect()[0].to_pydict() == expected_dict
+
+
+data_test_bitwise_and_boolean_functions = [
+    ("bit_and", f.bit_and(column("a")), [0]),
+    ("bit_and_filter", f.bit_and(column("a"), filter=column("a") != lit(2)), [1]),
+    ("bit_or", f.bit_or(column("b")), [6]),
+    ("bit_or_filter", f.bit_or(column("b"), filter=column("a") != lit(3)), [4]),
+    ("bit_xor", f.bit_xor(column("c")), [4]),
+    ("bit_xor_distinct", f.bit_xor(column("b"), distinct=True), [2]),
+    ("bit_xor_filter", f.bit_xor(column("b"), filter=column("a") != lit(3)), [0]),
+    (
+        "bit_xor_filter_distinct",
+        f.bit_xor(column("b"), distinct=True, filter=column("a") != lit(3)),
+        [4],
+    ),
+    ("bool_and", f.bool_and(column("d")), [False]),
+    ("bool_and_filter", f.bool_and(column("d"), filter=column("a") != lit(3)), [True]),
+    ("bool_or", f.bool_or(column("d")), [True]),
+    ("bool_or_filter", f.bool_or(column("d"), filter=column("a") == lit(3)), [False]),
+]
+
+
+@pytest.mark.parametrize(
+    ("name", "expr", "result"), data_test_bitwise_and_boolean_functions
+)
+def test_bit_and_bool_fns(df, name, expr, result):
+    df = df.aggregate([], [expr.alias(name)])
+
+    expected = {
+        name: result,
+    }
+
+    assert df.collect()[0].to_pydict() == expected
+
+
+@pytest.mark.parametrize(
+    ("name", "expr", "result"),
+    [
+        ("first_value", f.first_value(column("a")), [0, 4]),
+        (
+            "first_value_ordered",
+            f.first_value(column("a"), order_by=[column("a").sort(ascending=False)]),
+            [3, 6],
+        ),
+        (
+            "first_value_with_null",
+            f.first_value(
+                column("b"),
+                order_by=[column("b").sort(ascending=True)],
+                null_treatment=NullTreatment.RESPECT_NULLS,
+            ),
+            [None, None],
+        ),
+        (
+            "first_value_no_list_order_by",
+            f.first_value(
+                column("b"),
+                order_by=column("b"),
+                null_treatment=NullTreatment.RESPECT_NULLS,
+            ),
+            [None, None],
+        ),
+        (
+            "first_value_ignore_null",
+            f.first_value(
+                column("b"),
+                order_by=[column("b").sort(ascending=True)],
+                null_treatment=NullTreatment.IGNORE_NULLS,
+            ),
+            [7, 9],
+        ),
+        (
+            "last_value_ordered",
+            f.last_value(column("a"), order_by=[column("a").sort(ascending=False)]),
+            [0, 4],
+        ),
+        (
+            "last_value_no_list_ordered",
+            f.last_value(column("a"), order_by=column("a")),
+            [3, 6],
+        ),
+        (
+            "last_value_with_null",
+            f.last_value(
+                column("b"),
+                order_by=[column("b").sort(ascending=True, nulls_first=False)],
+                null_treatment=NullTreatment.RESPECT_NULLS,
+            ),
+            [None, None],
+        ),
+        (
+            "last_value_ignore_null",
+            f.last_value(
+                column("b"),
+                order_by=[column("b").sort(ascending=True)],
+                null_treatment=NullTreatment.IGNORE_NULLS,
+            ),
+            [8, 9],
+        ),
+        (
+            "nth_value_ordered",
+            f.nth_value(column("a"), 2, order_by=[column("a").sort(ascending=False)]),
+            [2, 5],
+        ),
+        (
+            "nth_value_no_list_ordered",
+            f.nth_value(column("a"), 2, order_by=column("a").sort(ascending=False)),
+            [2, 5],
+        ),
+        (
+            "nth_value_with_null",
+            f.nth_value(
+                column("b"),
+                3,
+                order_by=[column("b").sort(ascending=True, nulls_first=False)],
+                null_treatment=NullTreatment.RESPECT_NULLS,
+            ),
+            [8, None],
+        ),
+        (
+            "nth_value_ignore_null",
+            f.nth_value(
+                column("b"),
+                2,
+                order_by=[column("b").sort(ascending=True)],
+                null_treatment=NullTreatment.IGNORE_NULLS,
+            ),
+            [7, 9],
+        ),
+    ],
+)
+def test_first_last_value(df_partitioned, name, expr, result) -> None:
+    df = df_partitioned.aggregate([column("c")], [expr.alias(name)]).sort(column("c"))
+
+    expected = {
+        "c": ["A", "B"],
+        name: result,
+    }
+
+    assert df.collect()[0].to_pydict() == expected
+
+
+@pytest.mark.parametrize(
+    ("name", "expr", "result"),
+    [
+        ("string_agg", f.string_agg(column("a"), ","), "one,two,three,two"),
+        ("string_agg", f.string_agg(column("b"), ""), "03124"),
+        (
+            "string_agg",
+            f.string_agg(column("a"), ",", filter=column("b") != lit(3)),
+            "one,three,two",
+        ),
+        (
+            "string_agg",
+            f.string_agg(column("a"), ",", order_by=[column("b")]),
+            "one,three,two,two",
+        ),
+        (
+            "string_agg",
+            f.string_agg(column("a"), ",", order_by=column("b")),
+            "one,three,two,two",
+        ),
+    ],
+)
+def test_string_agg(name, expr, result) -> None:
+    ctx = SessionContext()
+
+    df = ctx.from_pydict(
+        {
+            "a": ["one", "two", None, "three", "two"],
+            "b": [0, 3, 1, 2, 4],
+        }
+    )
+
+    df = df.aggregate([], [expr.alias(name)])
+
+    expected = {
+        name: [result],
+    }
+    df.show()
+    assert df.collect()[0].to_pydict() == expected
diff --git a/python/tests/test_catalog.py b/python/tests/test_catalog.py
new file mode 100644
index 000000000..9310da506
--- /dev/null
+++ b/python/tests/test_catalog.py
@@ -0,0 +1,316 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import datafusion as dfn
+import pyarrow as pa
+import pyarrow.dataset as ds
+import pytest
+from datafusion import Catalog, SessionContext, Table, udtf
+
+if TYPE_CHECKING:
+    from datafusion.catalog import CatalogProvider, CatalogProviderExportable
+
+
+# Note we take in `database` as a variable even though we don't use
+# it because that will cause the fixture to set up the context with
+# the tables we need.
+def test_basic(ctx, database):
+    with pytest.raises(KeyError):
+        ctx.catalog("non-existent")
+
+    default = ctx.catalog()
+    assert default.names() == {"public"}
+
+    for db in [default.schema("public"), default.schema()]:
+        assert db.names() == {"csv1", "csv", "csv2"}
+
+    table = db.table("csv")
+    assert table.kind == "physical"
+    assert table.schema == pa.schema(
+        [
+            pa.field("int", pa.int64(), nullable=True),
+            pa.field("str", pa.string(), nullable=True),
+            pa.field("float", pa.float64(), nullable=True),
+        ]
+    )
+
+
+def create_dataset() -> Table:
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+    dataset = ds.dataset([batch])
+    return Table(dataset)
+
+
+class CustomSchemaProvider(dfn.catalog.SchemaProvider):
+    def __init__(self):
+        self.tables = {"table1": create_dataset()}
+
+    def table_names(self) -> set[str]:
+        return set(self.tables.keys())
+
+    def register_table(self, name: str, table: Table):
+        self.tables[name] = table
+
+    def deregister_table(self, name, cascade: bool = True):
+        del self.tables[name]
+
+    def table(self, name: str) -> Table | None:
+        return self.tables[name]
+
+    def table_exist(self, name: str) -> bool:
+        return name in self.tables
+
+
+class CustomErrorSchemaProvider(CustomSchemaProvider):
+    def table(self, name: str) -> Table | None:
+        message = f"{name} is not an acceptable name"
+        raise ValueError(message)
+
+
+class CustomCatalogProvider(dfn.catalog.CatalogProvider):
+    def __init__(self):
+        self.schemas = {"my_schema": CustomSchemaProvider()}
+
+    def schema_names(self) -> set[str]:
+        return set(self.schemas.keys())
+
+    def schema(self, name: str):
+        return self.schemas[name]
+
+    def register_schema(self, name: str, schema: dfn.catalog.Schema):
+        self.schemas[name] = schema
+
+    def deregister_schema(self, name, cascade: bool):
+        del self.schemas[name]
+
+
+class CustomCatalogProviderList(dfn.catalog.CatalogProviderList):
+    def __init__(self):
+        self.catalogs = {"my_catalog": CustomCatalogProvider()}
+
+    def catalog_names(self) -> set[str]:
+        return set(self.catalogs.keys())
+
+    def catalog(self, name: str) -> Catalog | None:
+        return self.catalogs[name]
+
+    def register_catalog(
+        self, name: str, catalog: CatalogProviderExportable | CatalogProvider | Catalog
+    ) -> None:
+        self.catalogs[name] = catalog
+
+
+def test_python_catalog_provider_list(ctx: SessionContext):
+    ctx.register_catalog_provider_list(CustomCatalogProviderList())
+
+    # Ensure `datafusion` catalog does not exist since
+    # we replaced the catalog list
+    assert ctx.catalog_names() == {"my_catalog"}
+
+    # Ensure registering works
+    ctx.register_catalog_provider("second_catalog", Catalog.memory_catalog())
+    assert ctx.catalog_names() == {"my_catalog", "second_catalog"}
+
+
+def test_python_catalog_provider(ctx: SessionContext):
+    ctx.register_catalog_provider("my_catalog", CustomCatalogProvider())
+
+    # Check the default catalog provider
+    assert ctx.catalog("datafusion").names() == {"public"}
+
+    my_catalog = ctx.catalog("my_catalog")
+    assert my_catalog.names() == {"my_schema"}
+
+    my_catalog.register_schema("second_schema", CustomSchemaProvider())
+    assert my_catalog.schema_names() == {"my_schema", "second_schema"}
+
+    my_catalog.deregister_schema("my_schema")
+    assert my_catalog.schema_names() == {"second_schema"}
+
+
+def test_in_memory_providers(ctx: SessionContext):
+    catalog = dfn.catalog.Catalog.memory_catalog()
+    ctx.register_catalog_provider("in_mem_catalog", catalog)
+
+    assert ctx.catalog_names() == {"datafusion", "in_mem_catalog"}
+
+    schema = dfn.catalog.Schema.memory_schema()
+    catalog.register_schema("in_mem_schema", schema)
+
+    schema.register_table("my_table", create_dataset())
+
+    batches = ctx.sql("select * from in_mem_catalog.in_mem_schema.my_table").collect()
+
+    assert len(batches) == 1
+    assert batches[0].column(0) == pa.array([1, 2, 3])
+    assert batches[0].column(1) == pa.array([4, 5, 6])
+
+
+def test_python_schema_provider(ctx: SessionContext):
+    catalog = ctx.catalog()
+
+    catalog.deregister_schema("public")
+
+    catalog.register_schema("test_schema1", CustomSchemaProvider())
+    assert catalog.names() == {"test_schema1"}
+
+    catalog.register_schema("test_schema2", CustomSchemaProvider())
+    catalog.deregister_schema("test_schema1")
+    assert catalog.names() == {"test_schema2"}
+
+
+def test_python_table_provider(ctx: SessionContext):
+    catalog = ctx.catalog()
+
+    catalog.register_schema("custom_schema", CustomSchemaProvider())
+    schema = catalog.schema("custom_schema")
+
+    assert schema.table_names() == {"table1"}
+
+    schema.deregister_table("table1")
+    schema.register_table("table2", create_dataset())
+    assert schema.table_names() == {"table2"}
+
+    # Use the default schema instead of our custom schema
+
+    schema = catalog.schema()
+
+    schema.register_table("table3", create_dataset())
+    assert schema.table_names() == {"table3"}
+
+    schema.deregister_table("table3")
+    schema.register_table("table4", create_dataset())
+    assert schema.table_names() == {"table4"}
+
+
+def test_schema_register_table_with_pyarrow_dataset(ctx: SessionContext):
+    schema = ctx.catalog().schema()
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+    dataset = ds.dataset([batch])
+    table_name = "pa_dataset"
+
+    try:
+        schema.register_table(table_name, dataset)
+        assert table_name in schema.table_names()
+
+        result = ctx.sql(f"SELECT a, b FROM {table_name}").collect()
+
+        assert len(result) == 1
+        assert result[0].column(0) == pa.array([1, 2, 3])
+        assert result[0].column(1) == pa.array([4, 5, 6])
+    finally:
+        schema.deregister_table(table_name)
+
+
+def test_exception_not_mangled(ctx: SessionContext):
+    """Test registering all python providers and running a query against them."""
+
+    catalog_name = "custom_catalog"
+    schema_name = "custom_schema"
+
+    ctx.register_catalog_provider(catalog_name, CustomCatalogProvider())
+
+    catalog = ctx.catalog(catalog_name)
+
+    # Clean out previous schemas if they exist so we can start clean
+    for schema_name in catalog.schema_names():
+        catalog.deregister_schema(schema_name, cascade=False)
+
+    catalog.register_schema(schema_name, CustomErrorSchemaProvider())
+
+    schema = catalog.schema(schema_name)
+
+    for table_name in schema.table_names():
+        schema.deregister_table(table_name)
+
+    schema.register_table("test_table", create_dataset())
+
+    with pytest.raises(ValueError, match=r"^test_table is not an acceptable name$"):
+        ctx.sql(f"select * from {catalog_name}.{schema_name}.test_table")
+
+
+def test_in_end_to_end_python_providers(ctx: SessionContext):
+    """Test registering all python providers and running a query against them."""
+
+    all_catalog_names = [
+        "datafusion",
+        "custom_catalog",
+        "in_mem_catalog",
+    ]
+
+    all_schema_names = [
+        "custom_schema",
+        "in_mem_schema",
+    ]
+
+    ctx.register_catalog_provider(all_catalog_names[1], CustomCatalogProvider())
+    ctx.register_catalog_provider(
+        all_catalog_names[2], dfn.catalog.Catalog.memory_catalog()
+    )
+
+    for catalog_name in all_catalog_names:
+        catalog = ctx.catalog(catalog_name)
+
+        # Clean out previous schemas if they exist so we can start clean
+        for schema_name in catalog.schema_names():
+            catalog.deregister_schema(schema_name, cascade=False)
+
+        catalog.register_schema(all_schema_names[0], CustomSchemaProvider())
+        catalog.register_schema(all_schema_names[1], dfn.catalog.Schema.memory_schema())
+
+        for schema_name in all_schema_names:
+            schema = catalog.schema(schema_name)
+
+            for table_name in schema.table_names():
+                schema.deregister_table(table_name)
+
+            schema.register_table("test_table", create_dataset())
+
+    for catalog_name in all_catalog_names:
+        for schema_name in all_schema_names:
+            table_full_name = f"{catalog_name}.{schema_name}.test_table"
+
+            batches = ctx.sql(f"select * from {table_full_name}").collect()
+
+            assert len(batches) == 1
+            assert batches[0].column(0) == pa.array([1, 2, 3])
+            assert batches[0].column(1) == pa.array([4, 5, 6])
+
+
+def test_register_python_function_as_udtf(ctx: SessionContext):
+    basic_table = Table(ctx.sql("SELECT 3 AS value"))
+
+    @udtf("my_table_function")
+    def my_table_function_udtf() -> Table:
+        return basic_table
+
+    ctx.register_udtf(my_table_function_udtf)
+
+    result = ctx.sql("SELECT * FROM my_table_function()").collect()
+    assert len(result) == 1
+    assert len(result[0]) == 1
+    assert len(result[0][0]) == 1
+    assert result[0][0][0].as_py() == 3
diff --git a/python/tests/test_concurrency.py b/python/tests/test_concurrency.py
new file mode 100644
index 000000000..f790f9473
--- /dev/null
+++ b/python/tests/test_concurrency.py
@@ -0,0 +1,126 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor
+
+import pyarrow as pa
+from datafusion import Config, SessionContext, col, lit
+from datafusion import functions as f
+from datafusion.common import SqlSchema
+
+
+def _run_in_threads(fn, count: int = 8) -> None:
+    with ThreadPoolExecutor(max_workers=count) as executor:
+        futures = [executor.submit(fn, i) for i in range(count)]
+        for future in futures:
+            # Propagate any exception raised in the worker thread.
+            future.result()
+
+
+def test_concurrent_access_to_shared_structures() -> None:
+    """Exercise SqlSchema, Config, and DataFrame concurrently."""
+
+    schema = SqlSchema("concurrency")
+    config = Config()
+    ctx = SessionContext()
+
+    batch = pa.record_batch([pa.array([1, 2, 3], type=pa.int32())], names=["value"])
+    df = ctx.create_dataframe([[batch]])
+
+    config_key = "datafusion.execution.batch_size"
+    expected_rows = batch.num_rows
+
+    def worker(index: int) -> None:
+        schema.name = f"concurrency-{index}"
+        assert schema.name.startswith("concurrency-")
+        # Exercise getters that use internal locks.
+        assert isinstance(schema.tables, list)
+        assert isinstance(schema.views, list)
+        assert isinstance(schema.functions, list)
+
+        config.set(config_key, str(1024 + index))
+        assert config.get(config_key) is not None
+        # Access the full config map to stress lock usage.
+        assert config_key in config.get_all()
+
+        batches = df.collect()
+        assert sum(batch.num_rows for batch in batches) == expected_rows
+
+    _run_in_threads(worker, count=12)
+
+
+def test_config_set_during_get_all() -> None:
+    """Ensure config writes proceed while another thread reads all entries."""
+
+    config = Config()
+    key = "datafusion.execution.batch_size"
+
+    def reader() -> None:
+        for _ in range(200):
+            # get_all should not hold the lock while converting to Python objects
+            config.get_all()
+
+    def writer() -> None:
+        for index in range(200):
+            config.set(key, str(1024 + index))
+
+    with ThreadPoolExecutor(max_workers=2) as executor:
+        reader_future = executor.submit(reader)
+        writer_future = executor.submit(writer)
+        reader_future.result(timeout=10)
+        writer_future.result(timeout=10)
+
+    assert config.get(key) is not None
+
+
+def test_case_builder_reuse_from_multiple_threads() -> None:
+    """Ensure the case builder can be safely reused across threads."""
+
+    ctx = SessionContext()
+    values = pa.array([0, 1, 2, 3, 4], type=pa.int32())
+    df = ctx.create_dataframe([[pa.record_batch([values], names=["value"])]])
+
+    base_builder = f.case(col("value"))
+
+    def add_case(i: int) -> None:
+        nonlocal base_builder
+        base_builder = base_builder.when(lit(i), lit(f"value-{i}"))
+
+    _run_in_threads(add_case, count=8)
+
+    with ThreadPoolExecutor(max_workers=2) as executor:
+        otherwise_future = executor.submit(base_builder.otherwise, lit("default"))
+        case_expr = otherwise_future.result()
+
+    result = df.select(case_expr.alias("label")).collect()
+    assert sum(batch.num_rows for batch in result) == len(values)
+
+    predicate_builder = f.when(col("value") == lit(0), lit("zero"))
+
+    def add_predicate(i: int) -> None:
+        predicate_builder.when(col("value") == lit(i + 1), lit(f"value-{i + 1}"))
+
+    _run_in_threads(add_predicate, count=4)
+
+    with ThreadPoolExecutor(max_workers=2) as executor:
+        end_future = executor.submit(predicate_builder.end)
+        predicate_expr = end_future.result()
+
+    result = df.select(predicate_expr.alias("label")).collect()
+    assert sum(batch.num_rows for batch in result) == len(values)
diff --git a/datafusion/tests/test_config.py b/python/tests/test_config.py
similarity index 91%
rename from datafusion/tests/test_config.py
rename to python/tests/test_config.py
index 960e72c94..c1d7f97e1 100644
--- a/datafusion/tests/test_config.py
+++ b/python/tests/test_config.py
@@ -15,8 +15,8 @@
 # specific language governing permissions and limitations
 # under the License.
 
-from datafusion import Config
 import pytest
+from datafusion import Config
 
 
 @pytest.fixture
@@ -35,10 +35,7 @@ def test_get_then_set(config):
 
 def test_get_all(config):
     config_dict = config.get_all()
-    assert (
-        config_dict["datafusion.catalog.create_default_catalog_and_schema"]
-        == "true"
-    )
+    assert config_dict["datafusion.catalog.create_default_catalog_and_schema"] == "true"
 
 
 def test_get_invalid_config(config):
diff --git a/python/tests/test_context.py b/python/tests/test_context.py
new file mode 100644
index 000000000..5df6ed20f
--- /dev/null
+++ b/python/tests/test_context.py
@@ -0,0 +1,872 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+import datetime as dt
+import gzip
+import pathlib
+
+import pyarrow as pa
+import pyarrow.dataset as ds
+import pytest
+from datafusion import (
+    CsvReadOptions,
+    DataFrame,
+    RuntimeEnvBuilder,
+    SessionConfig,
+    SessionContext,
+    SQLOptions,
+    Table,
+    column,
+    literal,
+)
+
+
+def test_create_context_no_args():
+    SessionContext()
+
+
+def test_create_context_session_config_only():
+    SessionContext(config=SessionConfig())
+
+
+def test_create_context_runtime_config_only():
+    SessionContext(runtime=RuntimeEnvBuilder())
+
+
+@pytest.mark.parametrize("path_to_str", [True, False])
+def test_runtime_configs(tmp_path, path_to_str):
+    path1 = tmp_path / "dir1"
+    path2 = tmp_path / "dir2"
+
+    path1 = str(path1) if path_to_str else path1
+    path2 = str(path2) if path_to_str else path2
+
+    runtime = RuntimeEnvBuilder().with_disk_manager_specified(path1, path2)
+    config = SessionConfig().with_default_catalog_and_schema("foo", "bar")
+    ctx = SessionContext(config, runtime)
+    assert ctx is not None
+
+    db = ctx.catalog("foo").schema("bar")
+    assert db is not None
+
+
+@pytest.mark.parametrize("path_to_str", [True, False])
+def test_temporary_files(tmp_path, path_to_str):
+    path = str(tmp_path) if path_to_str else tmp_path
+
+    runtime = RuntimeEnvBuilder().with_temp_file_path(path)
+    config = SessionConfig().with_default_catalog_and_schema("foo", "bar")
+    ctx = SessionContext(config, runtime)
+    assert ctx is not None
+
+    db = ctx.catalog("foo").schema("bar")
+    assert db is not None
+
+
+def test_create_context_with_all_valid_args():
+    runtime = RuntimeEnvBuilder().with_disk_manager_os().with_fair_spill_pool(10000000)
+    config = (
+        SessionConfig()
+        .with_create_default_catalog_and_schema(enabled=True)
+        .with_default_catalog_and_schema("foo", "bar")
+        .with_target_partitions(1)
+        .with_information_schema(enabled=True)
+        .with_repartition_joins(enabled=False)
+        .with_repartition_aggregations(enabled=False)
+        .with_repartition_windows(enabled=False)
+        .with_parquet_pruning(enabled=False)
+    )
+
+    ctx = SessionContext(config, runtime)
+
+    # verify that at least some of the arguments worked
+    ctx.catalog("foo").schema("bar")
+    with pytest.raises(KeyError):
+        ctx.catalog("datafusion")
+
+
+def test_register_record_batches(ctx):
+    # create a RecordBatch and register it as memtable
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+
+    ctx.register_record_batches("t", [[batch]])
+
+    assert ctx.catalog().schema().names() == {"t"}
+
+    result = ctx.sql("SELECT a+b, a-b FROM t").collect()
+
+    assert result[0].column(0) == pa.array([5, 7, 9])
+    assert result[0].column(1) == pa.array([-3, -3, -3])
+
+
+def test_create_dataframe_registers_unique_table_name(ctx):
+    # create a RecordBatch and register it as memtable
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+
+    df = ctx.create_dataframe([[batch]])
+    tables = list(ctx.catalog().schema().names())
+
+    assert df
+    assert len(tables) == 1
+    assert len(tables[0]) == 33
+    assert tables[0].startswith("c")
+    # ensure that the rest of the table name contains
+    # only hexadecimal numbers
+    for c in tables[0][1:]:
+        assert c in "0123456789abcdef"
+
+
+def test_create_dataframe_registers_with_defined_table_name(ctx):
+    # create a RecordBatch and register it as memtable
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+
+    df = ctx.create_dataframe([[batch]], name="tbl")
+    tables = list(ctx.catalog().schema().names())
+
+    assert df
+    assert len(tables) == 1
+    assert tables[0] == "tbl"
+
+
+def test_from_arrow_table(ctx):
+    # create a PyArrow table
+    data = {"a": [1, 2, 3], "b": [4, 5, 6]}
+    table = pa.Table.from_pydict(data)
+
+    # convert to DataFrame
+    df = ctx.from_arrow(table)
+    tables = list(ctx.catalog().schema().names())
+
+    assert df
+    assert len(tables) == 1
+    assert isinstance(df, DataFrame)
+    assert set(df.schema().names) == {"a", "b"}
+    assert df.collect()[0].num_rows == 3
+
+
+def record_batch_generator(num_batches: int):
+    schema = pa.schema([("a", pa.int64()), ("b", pa.int64())])
+    for _i in range(num_batches):
+        yield pa.RecordBatch.from_arrays(
+            [pa.array([1, 2, 3]), pa.array([4, 5, 6])], schema=schema
+        )
+
+
+@pytest.mark.parametrize(
+    "source",
+    [
+        # __arrow_c_array__ sources
+        pa.array([{"a": 1, "b": 4}, {"a": 2, "b": 5}, {"a": 3, "b": 6}]),
+        # __arrow_c_stream__ sources
+        pa.RecordBatch.from_pydict({"a": [1, 2, 3], "b": [4, 5, 6]}),
+        pa.RecordBatchReader.from_batches(
+            pa.schema([("a", pa.int64()), ("b", pa.int64())]), record_batch_generator(1)
+        ),
+        pa.Table.from_pydict({"a": [1, 2, 3], "b": [4, 5, 6]}),
+    ],
+)
+def test_from_arrow_sources(ctx, source) -> None:
+    df = ctx.from_arrow(source)
+    assert df
+    assert isinstance(df, DataFrame)
+    assert df.schema().names == ["a", "b"]
+    assert df.count() == 3
+
+
+def test_from_arrow_table_with_name(ctx):
+    # create a PyArrow table
+    data = {"a": [1, 2, 3], "b": [4, 5, 6]}
+    table = pa.Table.from_pydict(data)
+
+    # convert to DataFrame with optional name
+    df = ctx.from_arrow(table, name="tbl")
+    tables = list(ctx.catalog().schema().names())
+
+    assert df
+    assert tables[0] == "tbl"
+
+
+def test_from_arrow_table_empty(ctx):
+    data = {"a": [], "b": []}
+    schema = pa.schema([("a", pa.int32()), ("b", pa.string())])
+    table = pa.Table.from_pydict(data, schema=schema)
+
+    # convert to DataFrame
+    df = ctx.from_arrow(table)
+    tables = list(ctx.catalog().schema().names())
+
+    assert df
+    assert len(tables) == 1
+    assert isinstance(df, DataFrame)
+    assert set(df.schema().names) == {"a", "b"}
+    assert len(df.collect()) == 0
+
+
+def test_from_arrow_table_empty_no_schema(ctx):
+    data = {"a": [], "b": []}
+    table = pa.Table.from_pydict(data)
+
+    # convert to DataFrame
+    df = ctx.from_arrow(table)
+    tables = list(ctx.catalog().schema().names())
+
+    assert df
+    assert len(tables) == 1
+    assert isinstance(df, DataFrame)
+    assert set(df.schema().names) == {"a", "b"}
+    assert len(df.collect()) == 0
+
+
+def test_from_pylist(ctx):
+    # create a dataframe from Python list
+    data = [
+        {"a": 1, "b": 4},
+        {"a": 2, "b": 5},
+        {"a": 3, "b": 6},
+    ]
+
+    df = ctx.from_pylist(data)
+    tables = list(ctx.catalog().schema().names())
+
+    assert df
+    assert len(tables) == 1
+    assert isinstance(df, DataFrame)
+    assert set(df.schema().names) == {"a", "b"}
+    assert df.collect()[0].num_rows == 3
+
+
+def test_from_pydict(ctx):
+    # create a dataframe from Python dictionary
+    data = {"a": [1, 2, 3], "b": [4, 5, 6]}
+
+    df = ctx.from_pydict(data)
+    tables = list(ctx.catalog().schema().names())
+
+    assert df
+    assert len(tables) == 1
+    assert isinstance(df, DataFrame)
+    assert set(df.schema().names) == {"a", "b"}
+    assert df.collect()[0].num_rows == 3
+
+
+def test_from_pandas(ctx):
+    # create a dataframe from pandas dataframe
+    pd = pytest.importorskip("pandas")
+    data = {"a": [1, 2, 3], "b": [4, 5, 6]}
+    pandas_df = pd.DataFrame(data)
+
+    df = ctx.from_pandas(pandas_df)
+    tables = list(ctx.catalog().schema().names())
+
+    assert df
+    assert len(tables) == 1
+    assert isinstance(df, DataFrame)
+    assert set(df.schema().names) == {"a", "b"}
+    assert df.collect()[0].num_rows == 3
+
+
+def test_from_polars(ctx):
+    # create a dataframe from Polars dataframe
+    pd = pytest.importorskip("polars")
+    data = {"a": [1, 2, 3], "b": [4, 5, 6]}
+    polars_df = pd.DataFrame(data)
+
+    df = ctx.from_polars(polars_df)
+    tables = list(ctx.catalog().schema().names())
+
+    assert df
+    assert len(tables) == 1
+    assert isinstance(df, DataFrame)
+    assert set(df.schema().names) == {"a", "b"}
+    assert df.collect()[0].num_rows == 3
+
+
+def test_register_table(ctx, database):
+    default = ctx.catalog()
+    public = default.schema("public")
+    assert public.names() == {"csv", "csv1", "csv2"}
+    table = public.table("csv")
+
+    ctx.register_table("csv3", table)
+    assert public.names() == {"csv", "csv1", "csv2", "csv3"}
+
+
+def test_read_table_from_catalog(ctx, database):
+    default = ctx.catalog()
+    public = default.schema("public")
+    assert public.names() == {"csv", "csv1", "csv2"}
+
+    table = public.table("csv")
+    table_df = ctx.read_table(table)
+    table_df.show()
+
+
+def test_read_table_from_df(ctx):
+    df = ctx.from_pydict({"a": [1, 2]})
+    result = ctx.read_table(df).collect()
+    assert [b.to_pydict() for b in result] == [{"a": [1, 2]}]
+
+
+def test_read_table_from_dataset(ctx):
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+    dataset = ds.dataset([batch])
+
+    result = ctx.read_table(dataset).collect()
+
+    assert result[0].column(0) == pa.array([1, 2, 3])
+    assert result[0].column(1) == pa.array([4, 5, 6])
+
+
+def test_deregister_table(ctx, database):
+    default = ctx.catalog()
+    public = default.schema("public")
+    assert public.names() == {"csv", "csv1", "csv2"}
+
+    ctx.deregister_table("csv")
+    assert public.names() == {"csv1", "csv2"}
+
+
+def test_register_table_from_dataframe(ctx):
+    df = ctx.from_pydict({"a": [1, 2]})
+    ctx.register_table("df_tbl", df)
+    result = ctx.sql("SELECT * FROM df_tbl").collect()
+    assert [b.to_pydict() for b in result] == [{"a": [1, 2]}]
+
+
+@pytest.mark.parametrize("temporary", [True, False])
+def test_register_table_from_dataframe_into_view(ctx, temporary):
+    df = ctx.from_pydict({"a": [1, 2]})
+    table = df.into_view(temporary=temporary)
+    assert isinstance(table, Table)
+    if temporary:
+        assert table.kind == "temporary"
+    else:
+        assert table.kind == "view"
+
+    ctx.register_table("view_tbl", table)
+    result = ctx.sql("SELECT * FROM view_tbl").collect()
+    assert [b.to_pydict() for b in result] == [{"a": [1, 2]}]
+
+
+def test_table_from_dataframe(ctx):
+    df = ctx.from_pydict({"a": [1, 2]})
+    table = Table(df)
+    assert isinstance(table, Table)
+    ctx.register_table("from_dataframe_tbl", table)
+    result = ctx.sql("SELECT * FROM from_dataframe_tbl").collect()
+    assert [b.to_pydict() for b in result] == [{"a": [1, 2]}]
+
+
+def test_table_from_dataframe_internal(ctx):
+    df = ctx.from_pydict({"a": [1, 2]})
+    table = Table(df.df)
+    assert isinstance(table, Table)
+    ctx.register_table("from_internal_dataframe_tbl", table)
+    result = ctx.sql("SELECT * FROM from_internal_dataframe_tbl").collect()
+    assert [b.to_pydict() for b in result] == [{"a": [1, 2]}]
+
+
+def test_register_dataset(ctx):
+    # create a RecordBatch and register it as a pyarrow.dataset.Dataset
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+    dataset = ds.dataset([batch])
+    ctx.register_dataset("t", dataset)
+
+    assert ctx.catalog().schema().names() == {"t"}
+
+    result = ctx.sql("SELECT a+b, a-b FROM t").collect()
+
+    assert result[0].column(0) == pa.array([5, 7, 9])
+    assert result[0].column(1) == pa.array([-3, -3, -3])
+
+
+def test_dataset_filter(ctx, capfd):
+    # create a RecordBatch and register it as a pyarrow.dataset.Dataset
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+    dataset = ds.dataset([batch])
+    ctx.register_dataset("t", dataset)
+
+    assert ctx.catalog().schema().names() == {"t"}
+    df = ctx.sql("SELECT a+b, a-b FROM t WHERE a BETWEEN 2 and 3 AND b > 5")
+
+    # Make sure the filter was pushed down in Physical Plan
+    df.explain()
+    captured = capfd.readouterr()
+    assert "filter_expr=(((a >= 2) and (a <= 3)) and (b > 5))" in captured.out
+
+    result = df.collect()
+
+    assert result[0].column(0) == pa.array([9])
+    assert result[0].column(1) == pa.array([-3])
+
+
+def test_dataset_count(ctx):
+    # `datafusion-python` issue: https://github.com/apache/datafusion-python/issues/800
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+    dataset = ds.dataset([batch])
+    ctx.register_dataset("t", dataset)
+
+    # Testing the dataframe API
+    df = ctx.table("t")
+    assert df.count() == 3
+
+    # Testing the SQL API
+    count = ctx.sql("SELECT COUNT(*) FROM t")
+    count = count.collect()
+    assert count[0].column(0) == pa.array([3])
+
+
+def test_pyarrow_predicate_pushdown_is_null(ctx, capfd):
+    """Ensure that pyarrow filter gets pushed down for `IsNull`"""
+    # create a RecordBatch and register it as a pyarrow.dataset.Dataset
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6]), pa.array([7, None, 9])],
+        names=["a", "b", "c"],
+    )
+    dataset = ds.dataset([batch])
+    ctx.register_dataset("t", dataset)
+    # Make sure the filter was pushed down in Physical Plan
+    df = ctx.sql("SELECT a FROM t WHERE c is NULL")
+    df.explain()
+    captured = capfd.readouterr()
+    assert "filter_expr=is_null(c, {nan_is_null=false})" in captured.out
+
+    result = df.collect()
+    assert result[0].column(0) == pa.array([2])
+
+
+def test_pyarrow_predicate_pushdown_timestamp(ctx, tmpdir, capfd):
+    """Ensure that pyarrow filter gets pushed down for timestamp"""
+    # Ref: https://github.com/apache/datafusion-python/issues/703
+
+    # create pyarrow dataset with no actual files
+    col_type = pa.timestamp("ns", "+00:00")
+    nyd_2000 = pa.scalar(dt.datetime(2000, 1, 1, tzinfo=dt.timezone.utc), col_type)
+    pa_dataset_fs = pa.fs.SubTreeFileSystem(str(tmpdir), pa.fs.LocalFileSystem())
+    pa_dataset_format = pa.dataset.ParquetFileFormat()
+    pa_dataset_partition = pa.dataset.field("a") <= nyd_2000
+    fragments = [
+        # NOTE: we never actually make this file.
+        # Working predicate pushdown means it never gets accessed
+        pa_dataset_format.make_fragment(
+            "1.parquet",
+            filesystem=pa_dataset_fs,
+            partition_expression=pa_dataset_partition,
+        )
+    ]
+    pa_dataset = pa.dataset.FileSystemDataset(
+        fragments,
+        pa.schema([pa.field("a", col_type)]),
+        pa_dataset_format,
+        pa_dataset_fs,
+    )
+
+    ctx.register_dataset("t", pa_dataset)
+
+    # the partition for our only fragment is for a < 2000-01-01.
+    # so querying for a > 2024-01-01 should not touch any files
+    df = ctx.sql("SELECT * FROM t WHERE a > '2024-01-01T00:00:00+00:00'")
+    assert df.collect() == []
+
+
+def test_dataset_filter_nested_data(ctx):
+    # create Arrow StructArrays to test nested data types
+    data = pa.StructArray.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+    batch = pa.RecordBatch.from_arrays(
+        [data],
+        names=["nested_data"],
+    )
+    dataset = ds.dataset([batch])
+    ctx.register_dataset("t", dataset)
+
+    assert ctx.catalog().schema().names() == {"t"}
+
+    df = ctx.table("t")
+
+    # This filter will not be pushed down to DatasetExec since it
+    # isn't supported
+    df = df.filter(column("nested_data")["b"] > literal(5)).select(
+        column("nested_data")["a"] + column("nested_data")["b"],
+        column("nested_data")["a"] - column("nested_data")["b"],
+    )
+
+    result = df.collect()
+
+    assert result[0].column(0) == pa.array([9])
+    assert result[0].column(1) == pa.array([-3])
+
+
+def test_table_exist(ctx):
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+    dataset = ds.dataset([batch])
+    ctx.register_dataset("t", dataset)
+
+    assert ctx.table_exist("t") is True
+
+
+def test_table_not_found(ctx):
+    from uuid import uuid4
+
+    with pytest.raises(KeyError):
+        ctx.table(f"not-found-{uuid4()}")
+
+
+def test_read_json(ctx):
+    path = pathlib.Path(__file__).parent.resolve()
+
+    # Default
+    test_data_path = path / "data_test_context" / "data.json"
+    df = ctx.read_json(test_data_path)
+    result = df.collect()
+
+    assert result[0].column(0) == pa.array(["a", "b", "c"])
+    assert result[0].column(1) == pa.array([1, 2, 3])
+
+    # Schema
+    schema = pa.schema(
+        [
+            pa.field("A", pa.string(), nullable=True),
+        ]
+    )
+    df = ctx.read_json(test_data_path, schema=schema)
+    result = df.collect()
+
+    assert result[0].column(0) == pa.array(["a", "b", "c"])
+    assert result[0].schema == schema
+
+    # File extension
+    test_data_path = path / "data_test_context" / "data.json"
+    df = ctx.read_json(test_data_path, file_extension=".json")
+    result = df.collect()
+
+    assert result[0].column(0) == pa.array(["a", "b", "c"])
+    assert result[0].column(1) == pa.array([1, 2, 3])
+
+
+def test_read_json_compressed(ctx, tmp_path):
+    path = pathlib.Path(__file__).parent.resolve()
+    test_data_path = path / "data_test_context" / "data.json"
+
+    # File compression type
+    gzip_path = tmp_path / "data.json.gz"
+
+    with (
+        pathlib.Path.open(test_data_path, "rb") as csv_file,
+        gzip.open(gzip_path, "wb") as gzipped_file,
+    ):
+        gzipped_file.writelines(csv_file)
+
+    df = ctx.read_json(gzip_path, file_extension=".gz", file_compression_type="gz")
+    result = df.collect()
+
+    assert result[0].column(0) == pa.array(["a", "b", "c"])
+    assert result[0].column(1) == pa.array([1, 2, 3])
+
+
+def test_read_csv(ctx):
+    csv_df = ctx.read_csv(path="testing/data/csv/aggregate_test_100.csv")
+    csv_df.select(column("c1")).show()
+
+
+def test_read_csv_list(ctx):
+    csv_df = ctx.read_csv(path=["testing/data/csv/aggregate_test_100.csv"])
+    expected = csv_df.count() * 2
+
+    double_csv_df = ctx.read_csv(
+        path=[
+            "testing/data/csv/aggregate_test_100.csv",
+            "testing/data/csv/aggregate_test_100.csv",
+        ]
+    )
+    actual = double_csv_df.count()
+
+    double_csv_df.select(column("c1")).show()
+    assert actual == expected
+
+
+def test_read_csv_compressed(ctx, tmp_path):
+    test_data_path = pathlib.Path("testing/data/csv/aggregate_test_100.csv")
+
+    expected = ctx.read_csv(test_data_path).collect()
+
+    # File compression type
+    gzip_path = tmp_path / "aggregate_test_100.csv.gz"
+
+    with (
+        pathlib.Path.open(test_data_path, "rb") as csv_file,
+        gzip.open(gzip_path, "wb") as gzipped_file,
+    ):
+        gzipped_file.writelines(csv_file)
+
+    csv_df = ctx.read_csv(gzip_path, file_extension=".gz", file_compression_type="gz")
+    assert csv_df.collect() == expected
+
+    csv_df = ctx.read_csv(
+        gzip_path,
+        options=CsvReadOptions(file_extension=".gz", file_compression_type="gz"),
+    )
+    assert csv_df.collect() == expected
+
+
+def test_read_parquet(ctx):
+    parquet_df = ctx.read_parquet(path="parquet/data/alltypes_plain.parquet")
+    parquet_df.show()
+    assert parquet_df is not None
+
+    path = pathlib.Path.cwd() / "parquet/data/alltypes_plain.parquet"
+    parquet_df = ctx.read_parquet(path=path)
+    assert parquet_df is not None
+
+
+def test_read_avro(ctx):
+    avro_df = ctx.read_avro(path="testing/data/avro/alltypes_plain.avro")
+    avro_df.show()
+    assert avro_df is not None
+
+    path = pathlib.Path.cwd() / "testing/data/avro/alltypes_plain.avro"
+    avro_df = ctx.read_avro(path=path)
+    assert avro_df is not None
+
+
+def test_create_sql_options():
+    SQLOptions()
+
+
+def test_sql_with_options_no_ddl(ctx):
+    sql = "CREATE TABLE IF NOT EXISTS valuetable AS VALUES(1,'HELLO'),(12,'DATAFUSION')"
+    ctx.sql(sql)
+    options = SQLOptions().with_allow_ddl(allow=False)
+    with pytest.raises(Exception, match="DDL"):
+        ctx.sql_with_options(sql, options=options)
+
+
+def test_sql_with_options_no_dml(ctx):
+    table_name = "t"
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+    dataset = ds.dataset([batch])
+    ctx.register_dataset(table_name, dataset)
+    sql = f'INSERT INTO "{table_name}" VALUES (1, 2), (2, 3);'
+    ctx.sql(sql)
+    options = SQLOptions().with_allow_dml(allow=False)
+    with pytest.raises(Exception, match="DML"):
+        ctx.sql_with_options(sql, options=options)
+
+
+def test_sql_with_options_no_statements(ctx):
+    sql = "SET time zone = 1;"
+    ctx.sql(sql)
+    options = SQLOptions().with_allow_statements(allow=False)
+    with pytest.raises(Exception, match="SetVariable"):
+        ctx.sql_with_options(sql, options=options)
+
+
+@pytest.fixture
+def batch():
+    return pa.RecordBatch.from_arrays(
+        [pa.array([4, 5, 6])],
+        names=["a"],
+    )
+
+
+def test_create_dataframe_with_global_ctx(batch):
+    ctx = SessionContext.global_ctx()
+
+    df = ctx.create_dataframe([[batch]])
+
+    result = df.collect()[0].column(0)
+
+    assert result == pa.array([4, 5, 6])
+
+
+def test_csv_read_options_builder_pattern():
+    """Test CsvReadOptions builder pattern."""
+    from datafusion import CsvReadOptions
+
+    options = (
+        CsvReadOptions()
+        .with_has_header(False)  # noqa: FBT003
+        .with_delimiter("|")
+        .with_quote("'")
+        .with_schema_infer_max_records(2000)
+        .with_truncated_rows(True)  # noqa: FBT003
+        .with_newlines_in_values(True)  # noqa: FBT003
+        .with_file_extension(".tsv")
+    )
+    assert options.has_header is False
+    assert options.delimiter == "|"
+    assert options.quote == "'"
+    assert options.schema_infer_max_records == 2000
+    assert options.truncated_rows is True
+    assert options.newlines_in_values is True
+    assert options.file_extension == ".tsv"
+
+
+def read_csv_with_options_inner(
+    tmp_path: pathlib.Path,
+    csv_content: str,
+    options: CsvReadOptions,
+    expected: pa.RecordBatch,
+    as_read: bool,
+    global_ctx: bool,
+) -> None:
+    from datafusion import SessionContext
+
+    # Create a test CSV file
+    group_dir = tmp_path / "group=a"
+    group_dir.mkdir(exist_ok=True)
+
+    csv_path = group_dir / "test.csv"
+    csv_path.write_text(csv_content, newline="\n")
+
+    ctx = SessionContext()
+
+    if as_read:
+        if global_ctx:
+            from datafusion.io import read_csv
+
+            df = read_csv(str(tmp_path), options=options)
+        else:
+            df = ctx.read_csv(str(tmp_path), options=options)
+    else:
+        ctx.register_csv("test_table", str(tmp_path), options=options)
+        df = ctx.sql("SELECT * FROM test_table")
+    df.show()
+
+    # Verify the data
+    result = df.collect()
+    assert len(result) == 1
+    assert result[0] == expected
+
+
+@pytest.mark.parametrize(
+    ("as_read", "global_ctx"),
+    [
+        (True, True),
+        (True, False),
+        (False, False),
+    ],
+)
+def test_read_csv_with_options(tmp_path, as_read, global_ctx):
+    """Test reading CSV with CsvReadOptions."""
+
+    csv_content = "Alice;30;|New York; NY|\nBob;25\n#Charlie;35;Paris\nPhil;75;Detroit' MI\nKarin;50;|Stockholm\nSweden|"  # noqa: E501
+
+    # Some of the read options are difficult to test in combination
+    # such as schema and schema_infer_max_records so run multiple tests
+    # file_sort_order doesn't impact reading, but included here to ensure
+    # all options parse correctly
+    options = CsvReadOptions(
+        has_header=False,
+        delimiter=";",
+        quote="|",
+        terminator="\n",
+        escape="\\",
+        comment="#",
+        newlines_in_values=True,
+        schema_infer_max_records=1,
+        null_regex="[pP]+aris",
+        truncated_rows=True,
+        file_sort_order=[[column("column_1").sort(), column("column_2")], ["column_3"]],
+    )
+
+    expected = pa.RecordBatch.from_arrays(
+        [
+            pa.array(["Alice", "Bob", "Phil", "Karin"]),
+            pa.array([30, 25, 75, 50]),
+            pa.array(["New York; NY", None, "Detroit' MI", "Stockholm\nSweden"]),
+        ],
+        names=["column_1", "column_2", "column_3"],
+    )
+
+    read_csv_with_options_inner(
+        tmp_path, csv_content, options, expected, as_read, global_ctx
+    )
+
+    schema = pa.schema(
+        [
+            pa.field("name", pa.string(), nullable=False),
+            pa.field("age", pa.float32(), nullable=False),
+            pa.field("location", pa.string(), nullable=True),
+        ]
+    )
+    options.with_schema(schema)
+
+    expected = pa.RecordBatch.from_arrays(
+        [
+            pa.array(["Alice", "Bob", "Phil", "Karin"]),
+            pa.array([30.0, 25.0, 75.0, 50.0]),
+            pa.array(["New York; NY", None, "Detroit' MI", "Stockholm\nSweden"]),
+        ],
+        schema=schema,
+    )
+
+    read_csv_with_options_inner(
+        tmp_path, csv_content, options, expected, as_read, global_ctx
+    )
+
+    csv_content = "name,age\nAlice,30\nBob,25\nCharlie,35\nDiego,40\nEmily,15"
+
+    expected = pa.RecordBatch.from_arrays(
+        [
+            pa.array(["Alice", "Bob", "Charlie", "Diego", "Emily"]),
+            pa.array([30, 25, 35, 40, 15]),
+            pa.array(["a", "a", "a", "a", "a"]),
+        ],
+        schema=pa.schema(
+            [
+                pa.field("name", pa.string(), nullable=True),
+                pa.field("age", pa.int64(), nullable=True),
+                pa.field("group", pa.string(), nullable=False),
+            ]
+        ),
+    )
+    options = CsvReadOptions(
+        table_partition_cols=[("group", pa.string())],
+    )
+
+    read_csv_with_options_inner(
+        tmp_path, csv_content, options, expected, as_read, global_ctx
+    )
diff --git a/python/tests/test_dataframe.py b/python/tests/test_dataframe.py
new file mode 100644
index 000000000..759d6278c
--- /dev/null
+++ b/python/tests/test_dataframe.py
@@ -0,0 +1,3571 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+import ctypes
+import datetime
+import itertools
+import os
+import re
+import threading
+import time
+from pathlib import Path
+from typing import Any
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+import pytest
+from datafusion import (
+    DataFrame,
+    InsertOp,
+    ParquetColumnOptions,
+    ParquetWriterOptions,
+    RecordBatch,
+    SessionContext,
+    WindowFrame,
+    column,
+    literal,
+    udf,
+)
+from datafusion import (
+    col as df_col,
+)
+from datafusion import (
+    functions as f,
+)
+from datafusion.dataframe import DataFrameWriteOptions
+from datafusion.dataframe_formatter import (
+    DataFrameHtmlFormatter,
+    configure_formatter,
+    get_formatter,
+    reset_formatter,
+)
+from datafusion.expr import EXPR_TYPE_ERROR, Window
+from pyarrow.csv import write_csv
+
+pa_cffi = pytest.importorskip("pyarrow.cffi")
+
+MB = 1024 * 1024
+
+
+@pytest.fixture
+def ctx():
+    return SessionContext()
+
+
+@pytest.fixture
+def df(ctx):
+    # create a RecordBatch and a new DataFrame from it
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6]), pa.array([8, 5, 8])],
+        names=["a", "b", "c"],
+    )
+
+    return ctx.from_arrow(batch)
+
+
+@pytest.fixture
+def large_df():
+    ctx = SessionContext()
+
+    rows = 100000
+    data = {
+        "a": list(range(rows)),
+        "b": [f"s-{i}" for i in range(rows)],
+        "c": [float(i + 0.1) for i in range(rows)],
+    }
+    batch = pa.record_batch(data)
+
+    return ctx.from_arrow(batch)
+
+
+@pytest.fixture
+def large_multi_batch_df():
+    """Create a DataFrame with multiple record batches for testing stream behavior.
+
+    This fixture creates 10 batches of 10,000 rows each (100,000 rows total),
+    ensuring the DataFrame spans multiple batches. This is essential for testing
+    that memory limits actually cause early stream termination rather than
+    truncating all collected data.
+    """
+    ctx = SessionContext()
+
+    # Create multiple batches, each with 10,000 rows
+    batches = []
+    rows_per_batch = 10000
+    num_batches = 10
+
+    for batch_idx in range(num_batches):
+        start_row = batch_idx * rows_per_batch
+        end_row = start_row + rows_per_batch
+        data = {
+            "a": list(range(start_row, end_row)),
+            "b": [f"s-{i}" for i in range(start_row, end_row)],
+            "c": [float(i + 0.1) for i in range(start_row, end_row)],
+        }
+        batch = pa.record_batch(data)
+        batches.append(batch)
+
+    # Register as record batches to maintain multi-batch structure
+    # Using [batches] wraps list in another list as required by register_record_batches
+    ctx.register_record_batches("large_multi_batch_data", [batches])
+    return ctx.table("large_multi_batch_data")
+
+
+@pytest.fixture
+def struct_df():
+    ctx = SessionContext()
+
+    # create a RecordBatch and a new DataFrame from it
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([{"c": 1}, {"c": 2}, {"c": 3}]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+
+    return ctx.create_dataframe([[batch]])
+
+
+@pytest.fixture
+def nested_df():
+    ctx = SessionContext()
+
+    # create a RecordBatch and a new DataFrame from it
+    # Intentionally make each array of different length
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([[1], [2, 3], [4, 5, 6], None]), pa.array([7, 8, 9, 10])],
+        names=["a", "b"],
+    )
+
+    return ctx.create_dataframe([[batch]])
+
+
+@pytest.fixture
+def aggregate_df():
+    ctx = SessionContext()
+    ctx.register_csv("test", "testing/data/csv/aggregate_test_100.csv")
+    return ctx.sql("select c1, sum(c2) from test group by c1")
+
+
+@pytest.fixture
+def partitioned_df():
+    ctx = SessionContext()
+
+    # create a RecordBatch and a new DataFrame from it
+    batch = pa.RecordBatch.from_arrays(
+        [
+            pa.array([0, 1, 2, 3, 4, 5, 6]),
+            pa.array([7, None, 7, 8, 9, None, 9]),
+            pa.array(["A", "A", "A", "A", "B", "B", "B"]),
+        ],
+        names=["a", "b", "c"],
+    )
+
+    return ctx.create_dataframe([[batch]])
+
+
+@pytest.fixture
+def clean_formatter_state():
+    """Reset the HTML formatter after each test."""
+    reset_formatter()
+
+
+@pytest.fixture
+def null_df():
+    """Create a DataFrame with null values of different types."""
+    ctx = SessionContext()
+
+    # Create a RecordBatch with nulls across different types
+    batch = pa.RecordBatch.from_arrays(
+        [
+            pa.array([1, None, 3, None], type=pa.int64()),
+            pa.array([4.5, 6.7, None, None], type=pa.float64()),
+            pa.array(["a", None, "c", None], type=pa.string()),
+            pa.array([True, None, False, None], type=pa.bool_()),
+            pa.array(
+                [10957, None, 18993, None], type=pa.date32()
+            ),  # 2000-01-01, null, 2022-01-01, null
+            pa.array(
+                [946684800000, None, 1640995200000, None], type=pa.date64()
+            ),  # 2000-01-01, null, 2022-01-01, null
+        ],
+        names=[
+            "int_col",
+            "float_col",
+            "str_col",
+            "bool_col",
+            "date32_col",
+            "date64_col",
+        ],
+    )
+
+    return ctx.create_dataframe([[batch]])
+
+
+# custom style for testing with html formatter
+class CustomStyleProvider:
+    def get_cell_style(self) -> str:
+        return (
+            "background-color: #f5f5f5; color: #333; padding: 8px; border: "
+            "1px solid #ddd;"
+        )
+
+    def get_header_style(self) -> str:
+        return (
+            "background-color: #4285f4; color: white; font-weight: bold; "
+            "padding: 10px; border: 1px solid #3367d6;"
+        )
+
+
+def count_table_rows(html_content: str) -> int:
+    """Count the number of table rows in HTML content.
+    Args:
+        html_content: HTML string to analyze
+    Returns:
+        Number of table rows found (number of <tr> tags)
+    """
+    return len(re.findall(r"<tr", html_content))
+
+
+def test_select(df):
+    df_1 = df.select(
+        column("a") + column("b"),
+        column("a") - column("b"),
+    )
+
+    # execute and collect the first (and only) batch
+    result = df_1.collect()[0]
+
+    assert result.column(0) == pa.array([5, 7, 9])
+    assert result.column(1) == pa.array([-3, -3, -3])
+
+    df_2 = df.select("b", "a")
+
+    # execute and collect the first (and only) batch
+    result = df_2.collect()[0]
+
+    assert result.column(0) == pa.array([4, 5, 6])
+    assert result.column(1) == pa.array([1, 2, 3])
+
+
+def test_select_exprs(df):
+    df_1 = df.select_exprs(
+        "a + b",
+        "a - b",
+    )
+
+    # execute and collect the first (and only) batch
+    result = df_1.collect()[0]
+
+    assert result.column(0) == pa.array([5, 7, 9])
+    assert result.column(1) == pa.array([-3, -3, -3])
+
+    df_2 = df.select_exprs("b", "a")
+
+    # execute and collect the first (and only) batch
+    result = df_2.collect()[0]
+
+    assert result.column(0) == pa.array([4, 5, 6])
+    assert result.column(1) == pa.array([1, 2, 3])
+
+    df_3 = df.select_exprs(
+        "abs(a + b)",
+        "abs(a - b)",
+    )
+
+    # execute and collect the first (and only) batch
+    result = df_3.collect()[0]
+
+    assert result.column(0) == pa.array([5, 7, 9])
+    assert result.column(1) == pa.array([3, 3, 3])
+
+
+def test_drop_quoted_columns():
+    ctx = SessionContext()
+    batch = pa.RecordBatch.from_arrays([pa.array([1, 2, 3])], names=["ID_For_Students"])
+    df = ctx.create_dataframe([[batch]])
+    # here we must quote to match the original column name
+    assert df.drop('"ID_For_Students"').schema().names == []
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])], names=["a", "b"]
+    )
+    df = ctx.create_dataframe([[batch]])
+    # with a lower case column, both 'a' and '"a"' work
+    assert df.drop("a").schema().names == ["b"]
+    df = ctx.create_dataframe([[batch]])
+    assert df.drop('"a"').schema().names == ["b"]
+
+
+def test_select_mixed_expr_string(df):
+    df = df.select(column("b"), "a")
+
+    # execute and collect the first (and only) batch
+    result = df.collect()[0]
+
+    assert result.column(0) == pa.array([4, 5, 6])
+    assert result.column(1) == pa.array([1, 2, 3])
+
+
+def test_select_unsupported(df):
+    with pytest.raises(
+        TypeError,
+        match=f"Expected Expr or column name.*{re.escape(EXPR_TYPE_ERROR)}",
+    ):
+        df.select(1)
+
+
+def test_filter(df):
+    df1 = df.filter(column("a") > literal(2)).select(
+        column("a") + column("b"),
+        column("a") - column("b"),
+    )
+
+    # execute and collect the first (and only) batch
+    result = df1.collect()[0]
+
+    assert result.column(0) == pa.array([9])
+    assert result.column(1) == pa.array([-3])
+
+    df.show()
+    # verify that if there is no filter applied, internal dataframe is unchanged
+    df2 = df.filter()
+    assert df.df == df2.df
+
+    df3 = df.filter(column("a") > literal(1), column("b") != literal(6))
+    result = df3.collect()[0]
+
+    assert result.column(0) == pa.array([2])
+    assert result.column(1) == pa.array([5])
+    assert result.column(2) == pa.array([5])
+
+
+def test_filter_string_predicates(df):
+    df_str = df.filter("a > 2")
+    result = df_str.collect()[0]
+
+    assert result.column(0) == pa.array([3])
+    assert result.column(1) == pa.array([6])
+    assert result.column(2) == pa.array([8])
+
+    df_mixed = df.filter("a > 1", column("b") != literal(6))
+    result_mixed = df_mixed.collect()[0]
+
+    assert result_mixed.column(0) == pa.array([2])
+    assert result_mixed.column(1) == pa.array([5])
+    assert result_mixed.column(2) == pa.array([5])
+
+    df_strings = df.filter("a > 1", "b < 6")
+    result_strings = df_strings.collect()[0]
+
+    assert result_strings.column(0) == pa.array([2])
+    assert result_strings.column(1) == pa.array([5])
+    assert result_strings.column(2) == pa.array([5])
+
+
+def test_parse_sql_expr(df):
+    plan1 = df.filter(df.parse_sql_expr("a > 2")).logical_plan()
+    plan2 = df.filter(column("a") > literal(2)).logical_plan()
+    # object equality not implemented but string representation should match
+    assert str(plan1) == str(plan2)
+
+    df1 = df.filter(df.parse_sql_expr("a > 2")).select(
+        column("a") + column("b"),
+        column("a") - column("b"),
+    )
+
+    # execute and collect the first (and only) batch
+    result = df1.collect()[0]
+
+    assert result.column(0) == pa.array([9])
+    assert result.column(1) == pa.array([-3])
+
+    df.show()
+    # verify that if there is no filter applied, internal dataframe is unchanged
+    df2 = df.filter()
+    assert df.df == df2.df
+
+    df3 = df.filter(df.parse_sql_expr("a > 1"), df.parse_sql_expr("b != 6"))
+    result = df3.collect()[0]
+
+    assert result.column(0) == pa.array([2])
+    assert result.column(1) == pa.array([5])
+    assert result.column(2) == pa.array([5])
+
+
+def test_show_empty(df, capsys):
+    df_empty = df.filter(column("a") > literal(3))
+    df_empty.show()
+    captured = capsys.readouterr()
+    assert "DataFrame has no rows" in captured.out
+
+
+def test_sort(df):
+    df = df.sort(column("b").sort(ascending=False))
+
+    table = pa.Table.from_batches(df.collect())
+    expected = {"a": [3, 2, 1], "b": [6, 5, 4], "c": [8, 5, 8]}
+
+    assert table.to_pydict() == expected
+
+
+def test_sort_string_and_expression_equivalent(df):
+    from datafusion import col
+
+    result_str = df.sort("a").to_pydict()
+    result_expr = df.sort(col("a")).to_pydict()
+    assert result_str == result_expr
+
+
+def test_sort_unsupported(df):
+    with pytest.raises(
+        TypeError,
+        match=f"Expected Expr or column name.*{re.escape(EXPR_TYPE_ERROR)}",
+    ):
+        df.sort(1)
+
+
+def test_aggregate_string_and_expression_equivalent(df):
+    from datafusion import col
+
+    result_str = df.aggregate("a", [f.count()]).sort("a").to_pydict()
+    result_expr = df.aggregate(col("a"), [f.count()]).sort("a").to_pydict()
+    assert result_str == result_expr
+
+
+def test_aggregate_tuple_group_by(df):
+    result_list = df.aggregate(["a"], [f.count()]).sort("a").to_pydict()
+    result_tuple = df.aggregate(("a",), [f.count()]).sort("a").to_pydict()
+    assert result_tuple == result_list
+
+
+def test_aggregate_tuple_aggs(df):
+    result_list = df.aggregate("a", [f.count()]).sort("a").to_pydict()
+    result_tuple = df.aggregate("a", (f.count(),)).sort("a").to_pydict()
+    assert result_tuple == result_list
+
+
+def test_filter_string_equivalent(df):
+    df1 = df.filter("a > 1").to_pydict()
+    df2 = df.filter(column("a") > literal(1)).to_pydict()
+    assert df1 == df2
+
+
+def test_filter_string_invalid(df):
+    with pytest.raises(Exception) as excinfo:
+        df.filter("this is not valid sql").collect()
+    assert "Expected Expr" not in str(excinfo.value)
+
+
+def test_drop(df):
+    df = df.drop("c")
+
+    # execute and collect the first (and only) batch
+    result = df.collect()[0]
+
+    assert df.schema().names == ["a", "b"]
+    assert result.column(0) == pa.array([1, 2, 3])
+    assert result.column(1) == pa.array([4, 5, 6])
+
+
+def test_limit(df):
+    df = df.limit(1)
+
+    # execute and collect the first (and only) batch
+    result = df.collect()[0]
+
+    assert len(result.column(0)) == 1
+    assert len(result.column(1)) == 1
+
+
+def test_limit_with_offset(df):
+    # only 3 rows, but limit past the end to ensure that offset is working
+    df = df.limit(5, offset=2)
+
+    # execute and collect the first (and only) batch
+    result = df.collect()[0]
+
+    assert len(result.column(0)) == 1
+    assert len(result.column(1)) == 1
+
+
+def test_head(df):
+    df = df.head(1)
+
+    # execute and collect the first (and only) batch
+    result = df.collect()[0]
+
+    assert result.column(0) == pa.array([1])
+    assert result.column(1) == pa.array([4])
+    assert result.column(2) == pa.array([8])
+
+
+def test_tail(df):
+    df = df.tail(1)
+
+    # execute and collect the first (and only) batch
+    result = df.collect()[0]
+
+    assert result.column(0) == pa.array([3])
+    assert result.column(1) == pa.array([6])
+    assert result.column(2) == pa.array([8])
+
+
+def test_with_column_sql_expression(df):
+    df = df.with_column("c", "a + b")
+
+    # execute and collect the first (and only) batch
+    result = df.collect()[0]
+
+    assert result.schema.field(0).name == "a"
+    assert result.schema.field(1).name == "b"
+    assert result.schema.field(2).name == "c"
+
+    assert result.column(0) == pa.array([1, 2, 3])
+    assert result.column(1) == pa.array([4, 5, 6])
+    assert result.column(2) == pa.array([5, 7, 9])
+
+
+def test_with_column(df):
+    df = df.with_column("c", column("a") + column("b"))
+
+    # execute and collect the first (and only) batch
+    result = df.collect()[0]
+
+    assert result.schema.field(0).name == "a"
+    assert result.schema.field(1).name == "b"
+    assert result.schema.field(2).name == "c"
+
+    assert result.column(0) == pa.array([1, 2, 3])
+    assert result.column(1) == pa.array([4, 5, 6])
+    assert result.column(2) == pa.array([5, 7, 9])
+
+
+def test_with_columns(df):
+    df = df.with_columns(
+        (column("a") + column("b")).alias("c"),
+        (column("a") + column("b")).alias("d"),
+        [
+            (column("a") + column("b")).alias("e"),
+            (column("a") + column("b")).alias("f"),
+        ],
+        g=(column("a") + column("b")),
+    )
+
+    # execute and collect the first (and only) batch
+    result = df.collect()[0]
+
+    assert result.schema.field(0).name == "a"
+    assert result.schema.field(1).name == "b"
+    assert result.schema.field(2).name == "c"
+    assert result.schema.field(3).name == "d"
+    assert result.schema.field(4).name == "e"
+    assert result.schema.field(5).name == "f"
+    assert result.schema.field(6).name == "g"
+
+    assert result.column(0) == pa.array([1, 2, 3])
+    assert result.column(1) == pa.array([4, 5, 6])
+    assert result.column(2) == pa.array([5, 7, 9])
+    assert result.column(3) == pa.array([5, 7, 9])
+    assert result.column(4) == pa.array([5, 7, 9])
+    assert result.column(5) == pa.array([5, 7, 9])
+    assert result.column(6) == pa.array([5, 7, 9])
+
+
+def test_with_columns_str(df):
+    df = df.with_columns(
+        "a + b as c",
+        "a + b as d",
+        [
+            "a + b as e",
+            "a + b as f",
+        ],
+        g="a + b",
+    )
+
+    # execute and collect the first (and only) batch
+    result = df.collect()[0]
+
+    assert result.schema.field(0).name == "a"
+    assert result.schema.field(1).name == "b"
+    assert result.schema.field(2).name == "c"
+    assert result.schema.field(3).name == "d"
+    assert result.schema.field(4).name == "e"
+    assert result.schema.field(5).name == "f"
+    assert result.schema.field(6).name == "g"
+
+    assert result.column(0) == pa.array([1, 2, 3])
+    assert result.column(1) == pa.array([4, 5, 6])
+    assert result.column(2) == pa.array([5, 7, 9])
+    assert result.column(3) == pa.array([5, 7, 9])
+    assert result.column(4) == pa.array([5, 7, 9])
+    assert result.column(5) == pa.array([5, 7, 9])
+    assert result.column(6) == pa.array([5, 7, 9])
+
+
+def test_cast(df):
+    df = df.cast({"a": pa.float16(), "b": pa.list_(pa.uint32())})
+    expected = pa.schema(
+        [("a", pa.float16()), ("b", pa.list_(pa.uint32())), ("c", pa.int64())]
+    )
+
+    assert df.schema() == expected
+
+
+def test_iter_batches(df):
+    batches = []
+    for batch in df:
+        batches.append(batch)  # noqa: PERF402
+
+    # Delete DataFrame to ensure RecordBatches remain valid
+    del df
+
+    assert len(batches) == 1
+
+    batch = batches[0]
+    assert isinstance(batch, RecordBatch)
+    pa_batch = batch.to_pyarrow()
+    assert pa_batch.column(0).to_pylist() == [1, 2, 3]
+    assert pa_batch.column(1).to_pylist() == [4, 5, 6]
+    assert pa_batch.column(2).to_pylist() == [8, 5, 8]
+
+
+def test_iter_returns_datafusion_recordbatch(df):
+    for batch in df:
+        assert isinstance(batch, RecordBatch)
+
+
+def test_execute_stream_basic(df):
+    stream = df.execute_stream()
+    batches = list(stream)
+
+    assert len(batches) == 1
+    assert isinstance(batches[0], RecordBatch)
+    pa_batch = batches[0].to_pyarrow()
+    assert pa_batch.column(0).to_pylist() == [1, 2, 3]
+    assert pa_batch.column(1).to_pylist() == [4, 5, 6]
+    assert pa_batch.column(2).to_pylist() == [8, 5, 8]
+
+
+def test_with_column_renamed(df):
+    df = df.with_column("c", column("a") + column("b")).with_column_renamed("c", "sum")
+
+    result = df.collect()[0]
+
+    assert result.schema.field(0).name == "a"
+    assert result.schema.field(1).name == "b"
+    assert result.schema.field(2).name == "sum"
+
+
+def test_unnest(nested_df):
+    nested_df = nested_df.unnest_columns("a")
+
+    # execute and collect the first (and only) batch
+    result = nested_df.collect()[0]
+
+    assert result.column(0) == pa.array([1, 2, 3, 4, 5, 6, None])
+    assert result.column(1) == pa.array([7, 8, 8, 9, 9, 9, 10])
+
+
+def test_unnest_without_nulls(nested_df):
+    nested_df = nested_df.unnest_columns("a", preserve_nulls=False)
+
+    # execute and collect the first (and only) batch
+    result = nested_df.collect()[0]
+
+    assert result.column(0) == pa.array([1, 2, 3, 4, 5, 6])
+    assert result.column(1) == pa.array([7, 8, 8, 9, 9, 9])
+
+
+def test_join():
+    ctx = SessionContext()
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+    df = ctx.create_dataframe([[batch]], "l")
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2]), pa.array([8, 10])],
+        names=["a", "c"],
+    )
+    df1 = ctx.create_dataframe([[batch]], "r")
+
+    df2 = df.join(df1, on="a", how="inner")
+    df2 = df2.sort(column("a"))
+    table = pa.Table.from_batches(df2.collect())
+
+    expected = {"a": [1, 2], "c": [8, 10], "b": [4, 5]}
+    assert table.to_pydict() == expected
+
+    # Test the default behavior for dropping duplicate keys
+    # Since we may have a duplicate column name and pa.Table()
+    # hides the fact, instead we need to explicitly check the
+    # resultant arrays.
+    df2 = df.join(
+        df1, left_on="a", right_on="a", how="inner", coalesce_duplicate_keys=True
+    )
+    df2 = df2.sort(column("a"))
+    result = df2.collect()[0]
+    assert result.num_columns == 3
+    assert result.column(0) == pa.array([1, 2], pa.int64())
+    assert result.column(1) == pa.array([4, 5], pa.int64())
+    assert result.column(2) == pa.array([8, 10], pa.int64())
+
+    df2 = df.join(
+        df1, left_on="a", right_on="a", how="inner", coalesce_duplicate_keys=False
+    )
+    df2 = df2.sort(column("l.a"))
+    result = df2.collect()[0]
+    assert result.num_columns == 4
+    assert result.column(0) == pa.array([1, 2], pa.int64())
+    assert result.column(1) == pa.array([4, 5], pa.int64())
+    assert result.column(2) == pa.array([1, 2], pa.int64())
+    assert result.column(3) == pa.array([8, 10], pa.int64())
+
+    # Verify we don't make a breaking change to pre-43.0.0
+    # where users would pass join_keys as a positional argument
+    df2 = df.join(df1, (["a"], ["a"]), how="inner")
+    df2 = df2.sort(column("a"))
+    table = pa.Table.from_batches(df2.collect())
+
+    expected = {"a": [1, 2], "c": [8, 10], "b": [4, 5]}
+    assert table.to_pydict() == expected
+
+
+def test_join_invalid_params():
+    ctx = SessionContext()
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+    df = ctx.create_dataframe([[batch]], "l")
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2]), pa.array([8, 10])],
+        names=["a", "c"],
+    )
+    df1 = ctx.create_dataframe([[batch]], "r")
+
+    with pytest.deprecated_call():
+        df2 = df.join(df1, join_keys=(["a"], ["a"]), how="inner")
+        df2.show()
+        df2 = df2.sort(column("a"))
+        table = pa.Table.from_batches(df2.collect())
+
+        expected = {"a": [1, 2], "c": [8, 10], "b": [4, 5]}
+        assert table.to_pydict() == expected
+
+    with pytest.raises(
+        ValueError, match=r"`left_on` or `right_on` should not provided with `on`"
+    ):
+        df2 = df.join(df1, on="a", how="inner", right_on="test")
+
+    with pytest.raises(
+        ValueError, match=r"`left_on` and `right_on` should both be provided."
+    ):
+        df2 = df.join(df1, left_on="a", how="inner")
+
+    with pytest.raises(
+        ValueError, match=r"either `on` or `left_on` and `right_on` should be provided."
+    ):
+        df2 = df.join(df1, how="inner")
+
+
+def test_join_on():
+    ctx = SessionContext()
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+    df = ctx.create_dataframe([[batch]], "l")
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2]), pa.array([-8, 10])],
+        names=["a", "c"],
+    )
+    df1 = ctx.create_dataframe([[batch]], "r")
+
+    df2 = df.join_on(df1, column("l.a").__eq__(column("r.a")), how="inner")
+    df2.show()
+    df2 = df2.sort(column("l.a"))
+    table = pa.Table.from_batches(df2.collect())
+
+    expected = {"a": [1, 2], "c": [-8, 10], "b": [4, 5]}
+    assert table.to_pydict() == expected
+
+    df3 = df.join_on(
+        df1,
+        column("l.a").__eq__(column("r.a")),
+        column("l.a").__lt__(column("r.c")),
+        how="inner",
+    )
+    df3.show()
+    df3 = df3.sort(column("l.a"))
+    table = pa.Table.from_batches(df3.collect())
+    expected = {"a": [2], "c": [10], "b": [5]}
+    assert table.to_pydict() == expected
+
+
+def test_join_full_with_drop_duplicate_keys():
+    ctx = SessionContext()
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 3, 5, 7, 9]), pa.array([True, True, True, True, True])],
+        names=["log_time", "key_frame"],
+    )
+    key_frame = ctx.create_dataframe([[batch]])
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([2, 4, 6, 8, 10])],
+        names=["log_time"],
+    )
+    query_times = ctx.create_dataframe([[batch]])
+
+    merged = query_times.join(
+        key_frame,
+        left_on="log_time",
+        right_on="log_time",
+        how="full",
+        coalesce_duplicate_keys=True,
+    )
+    merged = merged.sort(column("log_time"))
+    result = merged.collect()[0]
+
+    assert result.num_columns == 2
+    assert result.column(0).to_pylist() == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+
+def test_join_on_invalid_expr():
+    ctx = SessionContext()
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2]), pa.array([4, 5])],
+        names=["a", "b"],
+    )
+    df = ctx.create_dataframe([[batch]], "l")
+    df1 = ctx.create_dataframe([[batch]], "r")
+
+    with pytest.raises(
+        TypeError, match=r"Use col\(\)/column\(\) or lit\(\)/literal\(\)"
+    ):
+        df.join_on(df1, "a")
+
+
+def test_aggregate_invalid_aggs(df):
+    with pytest.raises(
+        TypeError, match=r"Use col\(\)/column\(\) or lit\(\)/literal\(\)"
+    ):
+        df.aggregate([], "a")
+
+
+def test_distinct():
+    ctx = SessionContext()
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3, 1, 2, 3]), pa.array([4, 5, 6, 4, 5, 6])],
+        names=["a", "b"],
+    )
+    df_a = ctx.create_dataframe([[batch]]).distinct().sort(column("a"))
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+    df_b = ctx.create_dataframe([[batch]]).sort(column("a"))
+
+    assert df_a.collect() == df_b.collect()
+
+
+data_test_window_functions = [
+    (
+        "row",
+        f.row_number(order_by=[column("b"), column("a").sort(ascending=False)]),
+        [4, 2, 3, 5, 7, 1, 6],
+    ),
+    (
+        "row_w_params",
+        f.row_number(
+            order_by=[column("b"), column("a")],
+            partition_by=[column("c")],
+        ),
+        [2, 1, 3, 4, 2, 1, 3],
+    ),
+    (
+        "row_w_params_no_lists",
+        f.row_number(
+            order_by=column("b"),
+            partition_by=column("c"),
+        ),
+        [2, 1, 3, 4, 2, 1, 3],
+    ),
+    ("rank", f.rank(order_by=[column("b")]), [3, 1, 3, 5, 6, 1, 6]),
+    (
+        "rank_w_params",
+        f.rank(order_by=[column("b"), column("a")], partition_by=[column("c")]),
+        [2, 1, 3, 4, 2, 1, 3],
+    ),
+    (
+        "rank_w_params_no_lists",
+        f.rank(order_by=column("a"), partition_by=column("c")),
+        [1, 2, 3, 4, 1, 2, 3],
+    ),
+    (
+        "dense_rank",
+        f.dense_rank(order_by=[column("b")]),
+        [2, 1, 2, 3, 4, 1, 4],
+    ),
+    (
+        "dense_rank_w_params",
+        f.dense_rank(order_by=[column("b"), column("a")], partition_by=[column("c")]),
+        [2, 1, 3, 4, 2, 1, 3],
+    ),
+    (
+        "dense_rank_w_params_no_lists",
+        f.dense_rank(order_by=column("a"), partition_by=column("c")),
+        [1, 2, 3, 4, 1, 2, 3],
+    ),
+    (
+        "percent_rank",
+        f.round(f.percent_rank(order_by=[column("b")]), literal(3)),
+        [0.333, 0.0, 0.333, 0.667, 0.833, 0.0, 0.833],
+    ),
+    (
+        "percent_rank_w_params",
+        f.round(
+            f.percent_rank(
+                order_by=[column("b"), column("a")], partition_by=[column("c")]
+            ),
+            literal(3),
+        ),
+        [0.333, 0.0, 0.667, 1.0, 0.5, 0.0, 1.0],
+    ),
+    (
+        "percent_rank_w_params_no_lists",
+        f.round(
+            f.percent_rank(order_by=column("a"), partition_by=column("c")),
+            literal(3),
+        ),
+        [0.0, 0.333, 0.667, 1.0, 0.0, 0.5, 1.0],
+    ),
+    (
+        "cume_dist",
+        f.round(f.cume_dist(order_by=[column("b")]), literal(3)),
+        [0.571, 0.286, 0.571, 0.714, 1.0, 0.286, 1.0],
+    ),
+    (
+        "cume_dist_w_params",
+        f.round(
+            f.cume_dist(
+                order_by=[column("b"), column("a")], partition_by=[column("c")]
+            ),
+            literal(3),
+        ),
+        [0.5, 0.25, 0.75, 1.0, 0.667, 0.333, 1.0],
+    ),
+    (
+        "cume_dist_w_params_no_lists",
+        f.round(
+            f.cume_dist(order_by=column("a"), partition_by=column("c")),
+            literal(3),
+        ),
+        [0.25, 0.5, 0.75, 1.0, 0.333, 0.667, 1.0],
+    ),
+    (
+        "ntile",
+        f.ntile(2, order_by=[column("b")]),
+        [1, 1, 1, 2, 2, 1, 2],
+    ),
+    (
+        "ntile_w_params",
+        f.ntile(2, order_by=[column("b"), column("a")], partition_by=[column("c")]),
+        [1, 1, 2, 2, 1, 1, 2],
+    ),
+    (
+        "ntile_w_params_no_lists",
+        f.ntile(2, order_by=column("b"), partition_by=column("c")),
+        [1, 1, 2, 2, 1, 1, 2],
+    ),
+    ("lead", f.lead(column("b"), order_by=[column("b")]), [7, None, 8, 9, 9, 7, None]),
+    (
+        "lead_w_params",
+        f.lead(
+            column("b"),
+            shift_offset=2,
+            default_value=-1,
+            order_by=[column("b"), column("a")],
+            partition_by=[column("c")],
+        ),
+        [8, 7, -1, -1, -1, 9, -1],
+    ),
+    (
+        "lead_w_params_no_lists",
+        f.lead(
+            column("b"),
+            shift_offset=2,
+            default_value=-1,
+            order_by=column("b"),
+            partition_by=column("c"),
+        ),
+        [8, 7, -1, -1, -1, 9, -1],
+    ),
+    ("lag", f.lag(column("b"), order_by=[column("b")]), [None, None, 7, 7, 8, None, 9]),
+    (
+        "lag_w_params",
+        f.lag(
+            column("b"),
+            shift_offset=2,
+            default_value=-1,
+            order_by=[column("b"), column("a")],
+            partition_by=[column("c")],
+        ),
+        [-1, -1, None, 7, -1, -1, None],
+    ),
+    (
+        "lag_w_params_no_lists",
+        f.lag(
+            column("b"),
+            shift_offset=2,
+            default_value=-1,
+            order_by=column("b"),
+            partition_by=column("c"),
+        ),
+        [-1, -1, None, 7, -1, -1, None],
+    ),
+    (
+        "first_value",
+        f.first_value(column("a")).over(
+            Window(partition_by=[column("c")], order_by=[column("b")])
+        ),
+        [1, 1, 1, 1, 5, 5, 5],
+    ),
+    (
+        "first_value_without_list_args",
+        f.first_value(column("a")).over(
+            Window(partition_by=column("c"), order_by=column("b"))
+        ),
+        [1, 1, 1, 1, 5, 5, 5],
+    ),
+    (
+        "first_value_order_by_string",
+        f.first_value(column("a")).over(
+            Window(partition_by=[column("c")], order_by="b")
+        ),
+        [1, 1, 1, 1, 5, 5, 5],
+    ),
+    (
+        "last_value",
+        f.last_value(column("a")).over(
+            Window(
+                partition_by=[column("c")],
+                order_by=[column("b")],
+                window_frame=WindowFrame("rows", None, None),
+            )
+        ),
+        [3, 3, 3, 3, 6, 6, 6],
+    ),
+    (
+        "3rd_value",
+        f.nth_value(column("b"), 3).over(Window(order_by=[column("a")])),
+        [None, None, 7, 7, 7, 7, 7],
+    ),
+    (
+        "avg",
+        f.round(f.avg(column("b")).over(Window(order_by=[column("a")])), literal(3)),
+        [7.0, 7.0, 7.0, 7.333, 7.75, 7.75, 8.0],
+    ),
+]
+
+
+@pytest.mark.parametrize(("name", "expr", "result"), data_test_window_functions)
+def test_window_functions(partitioned_df, name, expr, result):
+    df = partitioned_df.select(
+        column("a"), column("b"), column("c"), f.alias(expr, name)
+    )
+    df.sort(column("a")).show()
+    table = pa.Table.from_batches(df.collect())
+
+    expected = {
+        "a": [0, 1, 2, 3, 4, 5, 6],
+        "b": [7, None, 7, 8, 9, None, 9],
+        "c": ["A", "A", "A", "A", "B", "B", "B"],
+        name: result,
+    }
+
+    assert table.sort_by("a").to_pydict() == expected
+
+
+@pytest.mark.parametrize("partition", ["c", df_col("c")])
+def test_rank_partition_by_accepts_string(partitioned_df, partition):
+    """Passing a string to partition_by should match using col()."""
+    df = partitioned_df.select(
+        f.rank(order_by=column("a"), partition_by=partition).alias("r")
+    )
+    table = pa.Table.from_batches(df.sort(column("a")).collect())
+    assert table.column("r").to_pylist() == [1, 2, 3, 4, 1, 2, 3]
+
+
+@pytest.mark.parametrize("partition", ["c", df_col("c")])
+def test_window_partition_by_accepts_string(partitioned_df, partition):
+    """Window.partition_by accepts string identifiers."""
+    expr = f.first_value(column("a")).over(
+        Window(partition_by=partition, order_by=column("b"))
+    )
+    df = partitioned_df.select(expr.alias("fv"))
+    table = pa.Table.from_batches(df.sort(column("a")).collect())
+    assert table.column("fv").to_pylist() == [1, 1, 1, 1, 5, 5, 5]
+
+
+@pytest.mark.parametrize(
+    ("units", "start_bound", "end_bound"),
+    [
+        (units, start_bound, end_bound)
+        for units in ("rows", "range")
+        for start_bound in (None, 0, 1)
+        for end_bound in (None, 0, 1)
+    ]
+    + [
+        ("groups", 0, 0),
+    ],
+)
+def test_valid_window_frame(units, start_bound, end_bound):
+    WindowFrame(units, start_bound, end_bound)
+
+
+@pytest.mark.parametrize(
+    ("units", "start_bound", "end_bound"),
+    [
+        ("invalid-units", 0, None),
+        ("invalid-units", None, 0),
+        ("invalid-units", None, None),
+        ("groups", None, 0),
+        ("groups", 0, None),
+        ("groups", None, None),
+    ],
+)
+def test_invalid_window_frame(units, start_bound, end_bound):
+    with pytest.raises(NotImplementedError, match=f"(?i){units}"):
+        WindowFrame(units, start_bound, end_bound)
+
+
+def test_window_frame_defaults_match_postgres(partitioned_df):
+    col_a = column("a")
+
+    # When order is not set, the default frame should be unbounded preceding to
+    # unbounded following. When order is set, the default frame is unbounded preceding
+    # to current row.
+    no_order = f.avg(col_a).over(Window()).alias("over_no_order")
+    with_order = f.avg(col_a).over(Window(order_by=[col_a])).alias("over_with_order")
+    df = partitioned_df.select(col_a, no_order, with_order)
+
+    expected = {
+        "a": [0, 1, 2, 3, 4, 5, 6],
+        "over_no_order": [3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0],
+        "over_with_order": [0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0],
+    }
+
+    assert df.sort(col_a).to_pydict() == expected
+
+
+def _build_last_value_df(df):
+    return df.select(
+        f.last_value(column("a"))
+        .over(
+            Window(
+                partition_by=[column("c")],
+                order_by=[column("b")],
+                window_frame=WindowFrame("rows", None, None),
+            )
+        )
+        .alias("expr"),
+        f.last_value(column("a"))
+        .over(
+            Window(
+                partition_by=[column("c")],
+                order_by="b",
+                window_frame=WindowFrame("rows", None, None),
+            )
+        )
+        .alias("str"),
+    )
+
+
+def _build_nth_value_df(df):
+    return df.select(
+        f.nth_value(column("b"), 3).over(Window(order_by=[column("a")])).alias("expr"),
+        f.nth_value(column("b"), 3).over(Window(order_by="a")).alias("str"),
+    )
+
+
+def _build_rank_df(df):
+    return df.select(
+        f.rank(order_by=[column("b")]).alias("expr"),
+        f.rank(order_by="b").alias("str"),
+    )
+
+
+def _build_array_agg_df(df):
+    return df.aggregate(
+        [column("c")],
+        [
+            f.array_agg(column("a"), order_by=[column("a")]).alias("expr"),
+            f.array_agg(column("a"), order_by="a").alias("str"),
+        ],
+    ).sort(column("c"))
+
+
+@pytest.mark.parametrize(
+    ("builder", "expected"),
+    [
+        pytest.param(_build_last_value_df, [3, 3, 3, 3, 6, 6, 6], id="last_value"),
+        pytest.param(_build_nth_value_df, [None, None, 7, 7, 7, 7, 7], id="nth_value"),
+        pytest.param(_build_rank_df, [1, 1, 3, 3, 5, 6, 6], id="rank"),
+        pytest.param(_build_array_agg_df, [[0, 1, 2, 3], [4, 5, 6]], id="array_agg"),
+    ],
+)
+def test_order_by_string_equivalence(partitioned_df, builder, expected):
+    df = builder(partitioned_df)
+    table = pa.Table.from_batches(df.collect())
+    assert table.column("expr").to_pylist() == expected
+    assert table.column("expr").to_pylist() == table.column("str").to_pylist()
+
+
+def test_html_formatter_cell_dimension(df, clean_formatter_state):
+    """Test configuring the HTML formatter with different options."""
+    # Configure with custom settings
+    configure_formatter(
+        max_width=500,
+        max_height=200,
+        enable_cell_expansion=False,
+    )
+
+    html_output = df._repr_html_()
+
+    # Verify our configuration was applied
+    assert "max-height: 200px" in html_output
+    assert "max-width: 500px" in html_output
+    # With cell expansion disabled, we shouldn't see expandable-container elements
+    assert "expandable-container" not in html_output
+
+
+def test_html_formatter_custom_style_provider(df, clean_formatter_state):
+    """Test using custom style providers with the HTML formatter."""
+
+    # Configure with custom style provider
+    configure_formatter(style_provider=CustomStyleProvider())
+
+    html_output = df._repr_html_()
+
+    # Verify our custom styles were applied
+    assert "background-color: #4285f4" in html_output
+    assert "color: white" in html_output
+    assert "background-color: #f5f5f5" in html_output
+
+
+def test_html_formatter_type_formatters(df, clean_formatter_state):
+    """Test registering custom type formatters for specific data types."""
+
+    # Get current formatter and register custom formatters
+    formatter = get_formatter()
+
+    # Format integers with color based on value
+    # Using int as the type for the formatter will work since we convert
+    # Arrow scalar values to Python native types in _get_cell_value
+    def format_int(value):
+        return f'<span style="color: {"red" if value > 2 else "blue"}">{value}</span>'
+
+    formatter.register_formatter(int, format_int)
+
+    html_output = df._repr_html_()
+
+    # Our test dataframe has values 1,2,3 so we should see:
+    assert '<span style="color: blue">1</span>' in html_output
+
+
+def test_html_formatter_custom_cell_builder(df, clean_formatter_state):
+    """Test using a custom cell builder function."""
+
+    # Create a custom cell builder with distinct styling for different value ranges
+    def custom_cell_builder(value, row, col, table_id):
+        try:
+            num_value = int(value)
+            if num_value > 5:  # Values > 5 get green background with indicator
+                return (
+                    '<td style="background-color: #d9f0d3" '
+                    f'data-test="high">{value}-high</td>'
+                )
+            if num_value < 3:  # Values < 3 get blue background with indicator
+                return (
+                    '<td style="background-color: #d3e9f0" '
+                    f'data-test="low">{value}-low</td>'
+                )
+        except (ValueError, TypeError):
+            pass
+
+        # Default styling for other cells (3, 4, 5)
+        return f'<td style="border: 1px solid #ddd" data-test="mid">{value}-mid</td>'
+
+    # Set our custom cell builder
+    formatter = get_formatter()
+    formatter.set_custom_cell_builder(custom_cell_builder)
+
+    html_output = df._repr_html_()
+
+    # Extract cells with specific styling using regex
+    low_cells = re.findall(
+        r'<td style="background-color: #d3e9f0"[^>]*>(\d+)-low</td>', html_output
+    )
+    mid_cells = re.findall(
+        r'<td style="border: 1px solid #ddd"[^>]*>(\d+)-mid</td>', html_output
+    )
+    high_cells = re.findall(
+        r'<td style="background-color: #d9f0d3"[^>]*>(\d+)-high</td>', html_output
+    )
+
+    # Sort the extracted values for consistent comparison
+    low_cells = sorted(map(int, low_cells))
+    mid_cells = sorted(map(int, mid_cells))
+    high_cells = sorted(map(int, high_cells))
+
+    # Verify specific values have the correct styling applied
+    assert low_cells == [1, 2]  # Values < 3
+    assert mid_cells == [3, 4, 5, 5]  # Values 3-5
+    assert high_cells == [6, 8, 8]  # Values > 5
+
+    # Verify the exact content with styling appears in the output
+    assert (
+        '<td style="background-color: #d3e9f0" data-test="low">1-low</td>'
+        in html_output
+    )
+    assert (
+        '<td style="background-color: #d3e9f0" data-test="low">2-low</td>'
+        in html_output
+    )
+    assert (
+        '<td style="border: 1px solid #ddd" data-test="mid">3-mid</td>' in html_output
+    )
+    assert (
+        '<td style="border: 1px solid #ddd" data-test="mid">4-mid</td>' in html_output
+    )
+    assert (
+        '<td style="background-color: #d9f0d3" data-test="high">6-high</td>'
+        in html_output
+    )
+    assert (
+        '<td style="background-color: #d9f0d3" data-test="high">8-high</td>'
+        in html_output
+    )
+
+    # Count occurrences to ensure all cells are properly styled
+    assert html_output.count("-low</td>") == 2  # Two low values (1, 2)
+    assert html_output.count("-mid</td>") == 4  # Four mid values (3, 4, 5, 5)
+    assert html_output.count("-high</td>") == 3  # Three high values (6, 8, 8)
+
+    # Create a custom cell builder that changes background color based on value
+    def custom_cell_builder(value, row, col, table_id):
+        # Handle numeric values regardless of their exact type
+        try:
+            num_value = int(value)
+            if num_value > 5:  # Values > 5 get green background
+                return f'<td style="background-color: #d9f0d3">{value}</td>'
+            if num_value < 3:  # Values < 3 get light blue background
+                return f'<td style="background-color: #d3e9f0">{value}</td>'
+        except (ValueError, TypeError):
+            pass
+
+        # Default styling for other cells
+        return f'<td style="border: 1px solid #ddd">{value}</td>'
+
+    # Set our custom cell builder
+    formatter = get_formatter()
+    formatter.set_custom_cell_builder(custom_cell_builder)
+
+    html_output = df._repr_html_()
+
+    # Verify our custom cell styling was applied
+    assert "background-color: #d3e9f0" in html_output  # For values 1,2
+
+
+def test_html_formatter_custom_header_builder(df, clean_formatter_state):
+    """Test using a custom header builder function."""
+
+    # Create a custom header builder with tooltips
+    def custom_header_builder(field):
+        tooltips = {
+            "a": "Primary key column",
+            "b": "Secondary values",
+            "c": "Additional data",
+        }
+        tooltip = tooltips.get(field.name, "")
+        return (
+            f'<th style="background-color: #333; color: white" '
+            f'title="{tooltip}">{field.name}</th>'
+        )
+
+    # Set our custom header builder
+    formatter = get_formatter()
+    formatter.set_custom_header_builder(custom_header_builder)
+
+    html_output = df._repr_html_()
+
+    # Verify our custom headers were applied
+    assert 'title="Primary key column"' in html_output
+    assert 'title="Secondary values"' in html_output
+    assert "background-color: #333; color: white" in html_output
+
+
+def test_html_formatter_complex_customization(df, clean_formatter_state):
+    """Test combining multiple customization options together."""
+
+    # Create a dark mode style provider
+    class DarkModeStyleProvider:
+        def get_cell_style(self) -> str:
+            return (
+                "background-color: #222; color: #eee; "
+                "padding: 8px; border: 1px solid #444;"
+            )
+
+        def get_header_style(self) -> str:
+            return (
+                "background-color: #111; color: #fff; padding: 10px; "
+                "border: 1px solid #333;"
+            )
+
+    # Configure with dark mode style
+    configure_formatter(
+        max_cell_length=10,
+        style_provider=DarkModeStyleProvider(),
+        custom_css="""
+            .datafusion-table {
+                font-family: monospace;
+                border-collapse: collapse;
+            }
+            .datafusion-table tr:hover td {
+                background-color: #444 !important;
+            }
+        """,
+    )
+
+    # Add type formatters for special formatting - now working with native int values
+    formatter = get_formatter()
+    formatter.register_formatter(
+        int,
+        lambda n: f'<span style="color: {"#5af" if n % 2 == 0 else "#f5a"}">{n}</span>',
+    )
+
+    html_output = df._repr_html_()
+
+    # Verify our customizations were applied
+    assert "background-color: #222" in html_output
+    assert "background-color: #111" in html_output
+    assert ".datafusion-table" in html_output
+    assert "color: #5af" in html_output  # Even numbers
+
+
+def test_html_formatter_memory(df, clean_formatter_state):
+    """Test the memory and row control parameters in DataFrameHtmlFormatter."""
+    configure_formatter(max_memory_bytes=10, min_rows=1)
+    html_output = df._repr_html_()
+
+    # Count the number of table rows in the output
+    tr_count = count_table_rows(html_output)
+    # With a tiny memory limit of 10 bytes, the formatter should display
+    # the minimum number of rows (1) plus a message about truncation
+    assert tr_count == 2  # 1 for header row, 1 for data row
+    assert "data truncated" in html_output.lower()
+
+    configure_formatter(max_memory_bytes=10 * MB, min_rows=1)
+    html_output = df._repr_html_()
+    # With larger memory limit and min_rows=2, should display all rows
+    tr_count = count_table_rows(html_output)
+    # Table should have header row (1) + 3 data rows = 4 rows
+    assert tr_count == 4
+    # No truncation message should appear
+    assert "data truncated" not in html_output.lower()
+
+
+def test_html_formatter_memory_boundary_conditions(large_df, clean_formatter_state):
+    """Test memory limit behavior at boundary conditions with large dataset.
+
+    This test validates that the formatter correctly handles edge cases when
+    the memory limit is reached with a large dataset (100,000 rows), ensuring
+    that min_rows constraint is properly respected while respecting memory limits.
+    Uses large_df to actually test memory limit behavior with realistic data sizes.
+    """
+
+    # Get the raw size of the data to test boundary conditions
+    # First, capture output with no limits
+    # NOTE: max_rows=200000 is set well above the dataset size (100k rows) to ensure
+    # we're testing memory limits, not row limits. Default max_rows=10 would
+    # truncate before memory limit is reached.
+    configure_formatter(max_memory_bytes=10 * MB, min_rows=1, max_rows=200000)
+    unrestricted_output = large_df._repr_html_()
+    unrestricted_rows = count_table_rows(unrestricted_output)
+
+    # Test 1: Very small memory limit should still respect min_rows
+    # With large dataset, this should definitely hit memory limit before min_rows
+    configure_formatter(max_memory_bytes=10, min_rows=1)
+    html_output = large_df._repr_html_()
+    tr_count = count_table_rows(html_output)
+    assert tr_count >= 2  # At least header + 1 data row (minimum)
+    # Should show truncation since we limited memory so aggressively
+    assert "data truncated" in html_output.lower()
+
+    # Test 2: Memory limit at default size (2MB) should truncate the large dataset
+    # Default max_rows would truncate at 10 rows, so we don't set it here to test
+    # that memory limit is respected even with default row limit
+    configure_formatter(max_memory_bytes=2 * MB, min_rows=1)
+    html_output = large_df._repr_html_()
+    tr_count = count_table_rows(html_output)
+    assert tr_count >= 2  # At least header + min_rows
+    # Should be truncated since full dataset is much larger than 2MB
+    assert tr_count < unrestricted_rows
+
+    # Test 3: Very large memory limit should show much more data
+    # NOTE: max_rows=200000 is critical here - without it, default max_rows=10
+    # would limit output to 10 rows even though we have 100MB of memory available
+    configure_formatter(max_memory_bytes=100 * MB, min_rows=1, max_rows=200000)
+    html_output = large_df._repr_html_()
+    tr_count = count_table_rows(html_output)
+    # Should show significantly more rows, possibly all
+    assert tr_count > 100  # Should show substantially more rows
+
+    # Test 4: Min rows should override memory limit
+    # With tiny memory and larger min_rows, min_rows should win
+    configure_formatter(max_memory_bytes=10, min_rows=2)
+    html_output = large_df._repr_html_()
+    tr_count = count_table_rows(html_output)
+    assert tr_count >= 3  # At least header + 2 data rows (min_rows)
+    # Should show truncation message despite min_rows being satisfied
+    assert "data truncated" in html_output.lower()
+
+    # Test 5: With reasonable memory and min_rows settings
+    # NOTE: max_rows=200000 ensures we test memory limit behavior, not row limit
+    configure_formatter(max_memory_bytes=2 * MB, min_rows=10, max_rows=200000)
+    html_output = large_df._repr_html_()
+    tr_count = count_table_rows(html_output)
+    assert tr_count >= 11  # header + at least 10 data rows (min_rows)
+    # Should be truncated due to memory limit
+    assert tr_count < unrestricted_rows
+
+
+def test_html_formatter_stream_early_termination(
+    large_multi_batch_df, clean_formatter_state
+):
+    """Test that memory limits cause early stream termination with multi-batch data.
+
+    This test specifically validates that the formatter stops collecting data when
+    the memory limit is reached, rather than collecting all data and then truncating.
+    The large_multi_batch_df fixture creates 10 record batches, allowing us to verify
+    that not all batches are consumed when memory limit is hit.
+
+    Key difference from test_html_formatter_memory_boundary_conditions:
+    - Uses multi-batch DataFrame to verify stream termination behavior
+    - Tests with memory limit exceeded by 2-3 batches but not 1 batch
+    - Verifies partial data + truncation message + respects min_rows
+    """
+
+    # Get baseline: how much data fits without memory limit
+    configure_formatter(max_memory_bytes=100 * MB, min_rows=1, max_rows=200000)
+    unrestricted_output = large_multi_batch_df._repr_html_()
+    unrestricted_rows = count_table_rows(unrestricted_output)
+
+    # Test 1: Memory limit exceeded by ~2 batches (each batch ~10k rows)
+    # With 1 batch (~1-2MB), we should have space. With 2-3 batches, we exceed limit.
+    # Set limit to ~3MB to ensure we collect ~1 batch before hitting limit
+    configure_formatter(max_memory_bytes=3 * MB, min_rows=1, max_rows=200000)
+    html_output = large_multi_batch_df._repr_html_()
+    tr_count = count_table_rows(html_output)
+
+    # Should show significant truncation (not all 100k rows)
+    assert tr_count < unrestricted_rows, "Should be truncated by memory limit"
+    assert tr_count >= 2, "Should respect min_rows"
+    assert "data truncated" in html_output.lower(), "Should indicate truncation"
+
+    # Test 2: Very tight memory limit should still respect min_rows
+    # Even with tiny memory (10 bytes), should show at least min_rows
+    configure_formatter(max_memory_bytes=10, min_rows=5, max_rows=200000)
+    html_output = large_multi_batch_df._repr_html_()
+    tr_count = count_table_rows(html_output)
+
+    assert tr_count >= 6, "Should show header + at least min_rows (5)"
+    assert "data truncated" in html_output.lower(), "Should indicate truncation"
+
+    # Test 3: Memory limit should take precedence over max_rows in early termination
+    # With max_rows=100 but small memory limit, should terminate early due to memory
+    configure_formatter(max_memory_bytes=2 * MB, min_rows=1, max_rows=100)
+    html_output = large_multi_batch_df._repr_html_()
+    tr_count = count_table_rows(html_output)
+
+    # Should be truncated by memory limit (showing more than max_rows would suggest
+    # but less than unrestricted)
+    assert tr_count >= 2, "Should respect min_rows"
+    assert tr_count < unrestricted_rows, "Should be truncated"
+    # Output should indicate why truncation occurred
+    assert "data truncated" in html_output.lower()
+
+
+def test_html_formatter_max_rows(df, clean_formatter_state):
+    configure_formatter(min_rows=2, max_rows=2)
+    html_output = df._repr_html_()
+
+    tr_count = count_table_rows(html_output)
+    # Table should have header row (1) + 2 data rows = 3 rows
+    assert tr_count == 3
+
+    configure_formatter(min_rows=2, max_rows=3)
+    html_output = df._repr_html_()
+
+    tr_count = count_table_rows(html_output)
+    # Table should have header row (1) + 3 data rows = 4 rows
+    assert tr_count == 4
+
+
+def test_html_formatter_validation():
+    # Test validation for invalid parameters
+
+    with pytest.raises(ValueError, match="max_cell_length must be a positive integer"):
+        DataFrameHtmlFormatter(max_cell_length=0)
+
+    with pytest.raises(ValueError, match="max_width must be a positive integer"):
+        DataFrameHtmlFormatter(max_width=0)
+
+    with pytest.raises(ValueError, match="max_height must be a positive integer"):
+        DataFrameHtmlFormatter(max_height=0)
+
+    with pytest.raises(ValueError, match="max_memory_bytes must be a positive integer"):
+        DataFrameHtmlFormatter(max_memory_bytes=0)
+
+    with pytest.raises(ValueError, match="max_memory_bytes must be a positive integer"):
+        DataFrameHtmlFormatter(max_memory_bytes=-100)
+
+    with pytest.raises(ValueError, match="min_rows must be a positive integer"):
+        DataFrameHtmlFormatter(min_rows=0)
+
+    with pytest.raises(ValueError, match="min_rows must be a positive integer"):
+        DataFrameHtmlFormatter(min_rows=-5)
+
+    with pytest.raises(ValueError, match="max_rows must be a positive integer"):
+        DataFrameHtmlFormatter(max_rows=0)
+
+    with pytest.raises(ValueError, match="max_rows must be a positive integer"):
+        DataFrameHtmlFormatter(max_rows=-10)
+
+    with pytest.raises(
+        ValueError, match="min_rows must be less than or equal to max_rows"
+    ):
+        DataFrameHtmlFormatter(min_rows=5, max_rows=4)
+
+
+def test_repr_rows_backward_compatibility(clean_formatter_state):
+    """Test that repr_rows parameter still works as deprecated alias."""
+    # Should work when not conflicting with max_rows
+    with pytest.warns(DeprecationWarning, match="repr_rows parameter is deprecated"):
+        formatter = DataFrameHtmlFormatter(repr_rows=15, min_rows=10)
+    assert formatter.max_rows == 15
+    assert formatter.repr_rows == 15
+
+    # Should fail when conflicting with max_rows
+    with pytest.raises(ValueError, match="Cannot specify both repr_rows and max_rows"):
+        DataFrameHtmlFormatter(repr_rows=5, max_rows=10)
+
+    # Setting repr_rows via property should warn
+    formatter2 = DataFrameHtmlFormatter()
+    with pytest.warns(DeprecationWarning, match="repr_rows is deprecated"):
+        formatter2.repr_rows = 7
+    assert formatter2.max_rows == 7
+    assert formatter2.repr_rows == 7
+
+
+def test_configure_formatter(df, clean_formatter_state):
+    """Test using custom style providers with the HTML formatter and configured
+    parameters."""
+
+    # these are non-default values
+    max_cell_length = 10
+    max_width = 500
+    max_height = 30
+    max_memory_bytes = 3 * MB
+    min_rows = 2
+    max_rows = 2
+    enable_cell_expansion = False
+    show_truncation_message = False
+    use_shared_styles = False
+
+    reset_formatter()
+    formatter_default = get_formatter()
+
+    assert formatter_default.max_cell_length != max_cell_length
+    assert formatter_default.max_width != max_width
+    assert formatter_default.max_height != max_height
+    assert formatter_default.max_memory_bytes != max_memory_bytes
+    assert formatter_default.min_rows != min_rows
+    assert formatter_default.max_rows != max_rows
+    assert formatter_default.enable_cell_expansion != enable_cell_expansion
+    assert formatter_default.show_truncation_message != show_truncation_message
+    assert formatter_default.use_shared_styles != use_shared_styles
+
+    # Configure with custom style provider and additional parameters
+    configure_formatter(
+        max_cell_length=max_cell_length,
+        max_width=max_width,
+        max_height=max_height,
+        max_memory_bytes=max_memory_bytes,
+        min_rows=min_rows,
+        max_rows=max_rows,
+        enable_cell_expansion=enable_cell_expansion,
+        show_truncation_message=show_truncation_message,
+        use_shared_styles=use_shared_styles,
+    )
+    formatter_custom = get_formatter()
+    assert formatter_custom.max_cell_length == max_cell_length
+    assert formatter_custom.max_width == max_width
+    assert formatter_custom.max_height == max_height
+    assert formatter_custom.max_memory_bytes == max_memory_bytes
+    assert formatter_custom.min_rows == min_rows
+    assert formatter_custom.max_rows == max_rows
+    assert formatter_custom.enable_cell_expansion == enable_cell_expansion
+    assert formatter_custom.show_truncation_message == show_truncation_message
+    assert formatter_custom.use_shared_styles == use_shared_styles
+
+
+def test_configure_formatter_invalid_params(clean_formatter_state):
+    """Test that configure_formatter rejects invalid parameters."""
+    with pytest.raises(ValueError, match="Invalid formatter parameters"):
+        configure_formatter(invalid_param=123)
+
+    # Test with multiple parameters, one valid and one invalid
+    with pytest.raises(ValueError, match="Invalid formatter parameters"):
+        configure_formatter(max_width=500, not_a_real_param="test")
+
+    # Test with multiple invalid parameters
+    with pytest.raises(ValueError, match="Invalid formatter parameters"):
+        configure_formatter(fake_param1="test", fake_param2=456)
+
+
+def test_get_dataframe(tmp_path):
+    ctx = SessionContext()
+
+    path = tmp_path / "test.csv"
+    table = pa.Table.from_arrays(
+        [
+            [1, 2, 3, 4],
+            ["a", "b", "c", "d"],
+            [1.1, 2.2, 3.3, 4.4],
+        ],
+        names=["int", "str", "float"],
+    )
+    write_csv(table, path)
+
+    ctx.register_csv("csv", path)
+
+    df = ctx.table("csv")
+    assert isinstance(df, DataFrame)
+
+
+def test_struct_select(struct_df):
+    df = struct_df.select(
+        column("a")["c"] + column("b"),
+        column("a")["c"] - column("b"),
+    )
+
+    # execute and collect the first (and only) batch
+    result = df.collect()[0]
+
+    assert result.column(0) == pa.array([5, 7, 9])
+    assert result.column(1) == pa.array([-3, -3, -3])
+
+
+def test_explain(df):
+    df = df.select(
+        column("a") + column("b"),
+        column("a") - column("b"),
+    )
+    df.explain()
+
+
+def test_logical_plan(aggregate_df):
+    plan = aggregate_df.logical_plan()
+
+    expected = "Projection: test.c1, sum(test.c2)"
+
+    assert expected == plan.display()
+
+    expected = (
+        "Projection: test.c1, sum(test.c2)\n"
+        "  Aggregate: groupBy=[[test.c1]], aggr=[[sum(test.c2)]]\n"
+        "    TableScan: test"
+    )
+
+    assert expected == plan.display_indent()
+
+
+def test_optimized_logical_plan(aggregate_df):
+    plan = aggregate_df.optimized_logical_plan()
+
+    expected = "Aggregate: groupBy=[[test.c1]], aggr=[[sum(test.c2)]]"
+
+    assert expected == plan.display()
+
+    expected = (
+        "Aggregate: groupBy=[[test.c1]], aggr=[[sum(test.c2)]]\n"
+        "  TableScan: test projection=[c1, c2]"
+    )
+
+    assert expected == plan.display_indent()
+
+
+def test_execution_plan(aggregate_df):
+    plan = aggregate_df.execution_plan()
+
+    expected = (
+        "AggregateExec: mode=FinalPartitioned, gby=[c1@0 as c1], aggr=[sum(test.c2)]\n"
+    )
+
+    assert expected == plan.display()
+
+    # Check the number of partitions is as expected.
+    assert isinstance(plan.partition_count, int)
+
+    expected = (
+        "ProjectionExec: expr=[c1@0 as c1, SUM(test.c2)@1 as SUM(test.c2)]\n"
+        "  Aggregate: groupBy=[[test.c1]], aggr=[[SUM(test.c2)]]\n"
+        "    TableScan: test projection=[c1, c2]"
+    )
+
+    indent = plan.display_indent()
+
+    # indent plan will be different for everyone due to absolute path
+    # to filename, so we just check for some expected content
+    assert "AggregateExec:" in indent
+    assert "RepartitionExec:" in indent
+    assert "DataSourceExec:" in indent
+    assert "file_type=csv" in indent
+
+    ctx = SessionContext()
+    rows_returned = 0
+    for idx in range(plan.partition_count):
+        stream = ctx.execute(plan, idx)
+        try:
+            batch = stream.next()
+            assert batch is not None
+            rows_returned += len(batch.to_pyarrow()[0])
+        except StopIteration:
+            # This is one of the partitions with no values
+            pass
+        with pytest.raises(StopIteration):
+            stream.next()
+
+    assert rows_returned == 5
+
+
+@pytest.mark.asyncio
+async def test_async_iteration_of_df(aggregate_df):
+    rows_returned = 0
+    async for batch in aggregate_df:
+        assert batch is not None
+        rows_returned += len(batch.to_pyarrow()[0])
+
+    assert rows_returned == 5
+
+
+def test_repartition(df):
+    df.repartition(2)
+
+
+def test_repartition_by_hash(df):
+    df.repartition_by_hash(column("a"), num=2)
+
+
+def test_repartition_by_hash_sql_expression(df):
+    df.repartition_by_hash("a", num=2)
+
+
+def test_repartition_by_hash_mix(df):
+    df.repartition_by_hash(column("a"), "b", num=2)
+
+
+def test_intersect():
+    ctx = SessionContext()
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+    df_a = ctx.create_dataframe([[batch]])
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([3, 4, 5]), pa.array([6, 7, 8])],
+        names=["a", "b"],
+    )
+    df_b = ctx.create_dataframe([[batch]])
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([3]), pa.array([6])],
+        names=["a", "b"],
+    )
+    df_c = ctx.create_dataframe([[batch]]).sort(column("a"))
+
+    df_a_i_b = df_a.intersect(df_b).sort(column("a"))
+
+    assert df_c.collect() == df_a_i_b.collect()
+
+
+def test_except_all():
+    ctx = SessionContext()
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+    df_a = ctx.create_dataframe([[batch]])
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([3, 4, 5]), pa.array([6, 7, 8])],
+        names=["a", "b"],
+    )
+    df_b = ctx.create_dataframe([[batch]])
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2]), pa.array([4, 5])],
+        names=["a", "b"],
+    )
+    df_c = ctx.create_dataframe([[batch]]).sort(column("a"))
+
+    df_a_e_b = df_a.except_all(df_b).sort(column("a"))
+
+    assert df_c.collect() == df_a_e_b.collect()
+
+
+def test_collect_partitioned():
+    ctx = SessionContext()
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+
+    assert [[batch]] == ctx.create_dataframe([[batch]]).collect_partitioned()
+
+
+def test_collect_column(ctx: SessionContext):
+    batch_1 = pa.RecordBatch.from_pydict({"a": [1, 2, 3]})
+    batch_2 = pa.RecordBatch.from_pydict({"a": [4, 5, 6]})
+    batch_3 = pa.RecordBatch.from_pydict({"a": [7, 8, 9]})
+
+    ctx.register_record_batches("t", [[batch_1, batch_2], [batch_3]])
+
+    result = ctx.table("t").sort(column("a")).collect_column("a")
+    expected = pa.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
+    assert result == expected
+
+
+def test_union(ctx):
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+    df_a = ctx.create_dataframe([[batch]])
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([3, 4, 5]), pa.array([6, 7, 8])],
+        names=["a", "b"],
+    )
+    df_b = ctx.create_dataframe([[batch]])
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3, 3, 4, 5]), pa.array([4, 5, 6, 6, 7, 8])],
+        names=["a", "b"],
+    )
+    df_c = ctx.create_dataframe([[batch]]).sort(column("a"))
+
+    df_a_u_b = df_a.union(df_b).sort(column("a"))
+
+    assert df_c.collect() == df_a_u_b.collect()
+
+
+def test_union_distinct(ctx):
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+    df_a = ctx.create_dataframe([[batch]])
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([3, 4, 5]), pa.array([6, 7, 8])],
+        names=["a", "b"],
+    )
+    df_b = ctx.create_dataframe([[batch]])
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3, 4, 5]), pa.array([4, 5, 6, 7, 8])],
+        names=["a", "b"],
+    )
+    df_c = ctx.create_dataframe([[batch]]).sort(column("a"))
+
+    df_a_u_b = df_a.union(df_b, distinct=True).sort(column("a"))
+
+    assert df_c.collect() == df_a_u_b.collect()
+    assert df_c.collect() == df_a_u_b.collect()
+
+
+def test_cache(df):
+    assert df.cache().collect() == df.collect()
+
+
+def test_count(df):
+    # Get number of rows
+    assert df.count() == 3
+
+
+def test_to_pandas(df):
+    # Skip test if pandas is not installed
+    pd = pytest.importorskip("pandas")
+
+    # Convert datafusion dataframe to pandas dataframe
+    pandas_df = df.to_pandas()
+    assert isinstance(pandas_df, pd.DataFrame)
+    assert pandas_df.shape == (3, 3)
+    assert set(pandas_df.columns) == {"a", "b", "c"}
+
+
+def test_empty_to_pandas(df):
+    # Skip test if pandas is not installed
+    pd = pytest.importorskip("pandas")
+
+    # Convert empty datafusion dataframe to pandas dataframe
+    pandas_df = df.limit(0).to_pandas()
+    assert isinstance(pandas_df, pd.DataFrame)
+    assert pandas_df.shape == (0, 3)
+    assert set(pandas_df.columns) == {"a", "b", "c"}
+
+
+def test_to_polars(df):
+    # Skip test if polars is not installed
+    pl = pytest.importorskip("polars")
+
+    # Convert datafusion dataframe to polars dataframe
+    polars_df = df.to_polars()
+    assert isinstance(polars_df, pl.DataFrame)
+    assert polars_df.shape == (3, 3)
+    assert set(polars_df.columns) == {"a", "b", "c"}
+
+
+def test_empty_to_polars(df):
+    # Skip test if polars is not installed
+    pl = pytest.importorskip("polars")
+
+    # Convert empty datafusion dataframe to polars dataframe
+    polars_df = df.limit(0).to_polars()
+    assert isinstance(polars_df, pl.DataFrame)
+    assert polars_df.shape == (0, 3)
+    assert set(polars_df.columns) == {"a", "b", "c"}
+
+
+def test_to_arrow_table(df):
+    # Convert datafusion dataframe to pyarrow Table
+    pyarrow_table = df.to_arrow_table()
+    assert isinstance(pyarrow_table, pa.Table)
+    assert pyarrow_table.shape == (3, 3)
+    assert set(pyarrow_table.column_names) == {"a", "b", "c"}
+
+
+def test_parquet_non_null_column_to_pyarrow(ctx, tmp_path):
+    path = tmp_path.joinpath("t.parquet")
+
+    ctx.sql("create table t_(a int not null)").collect()
+    ctx.sql("insert into t_ values (1), (2), (3)").collect()
+    ctx.sql(f"copy (select * from t_) to '{path}'").collect()
+
+    ctx.register_parquet("t", path)
+    pyarrow_table = ctx.sql("select max(a) as m from t").to_arrow_table()
+    assert pyarrow_table.to_pydict() == {"m": [3]}
+
+
+def test_parquet_empty_batch_to_pyarrow(ctx, tmp_path):
+    path = tmp_path.joinpath("t.parquet")
+
+    ctx.sql("create table t_(a int not null)").collect()
+    ctx.sql("insert into t_ values (1), (2), (3)").collect()
+    ctx.sql(f"copy (select * from t_) to '{path}'").collect()
+
+    ctx.register_parquet("t", path)
+    pyarrow_table = ctx.sql("select * from t limit 0").to_arrow_table()
+    assert pyarrow_table.schema == pa.schema(
+        [
+            pa.field("a", pa.int32(), nullable=False),
+        ]
+    )
+
+
+def test_parquet_null_aggregation_to_pyarrow(ctx, tmp_path):
+    path = tmp_path.joinpath("t.parquet")
+
+    ctx.sql("create table t_(a int not null)").collect()
+    ctx.sql("insert into t_ values (1), (2), (3)").collect()
+    ctx.sql(f"copy (select * from t_) to '{path}'").collect()
+
+    ctx.register_parquet("t", path)
+    pyarrow_table = ctx.sql(
+        "select max(a) as m from (select * from t where a < 0)"
+    ).to_arrow_table()
+    assert pyarrow_table.to_pydict() == {"m": [None]}
+    assert pyarrow_table.schema == pa.schema(
+        [
+            pa.field("m", pa.int32(), nullable=True),
+        ]
+    )
+
+
+def test_execute_stream(df):
+    stream = df.execute_stream()
+    assert all(batch is not None for batch in stream)
+    assert not list(stream)  # after one iteration the generator must be exhausted
+
+
+@pytest.mark.asyncio
+async def test_execute_stream_async(df):
+    stream = df.execute_stream()
+    batches = [batch async for batch in stream]
+
+    assert all(batch is not None for batch in batches)
+
+    # After consuming all batches, the stream should be exhausted
+    remaining_batches = [batch async for batch in stream]
+    assert not remaining_batches
+
+
+@pytest.mark.parametrize("schema", [True, False])
+def test_execute_stream_to_arrow_table(df, schema):
+    stream = df.execute_stream()
+
+    if schema:
+        pyarrow_table = pa.Table.from_batches(
+            (batch.to_pyarrow() for batch in stream), schema=df.schema()
+        )
+    else:
+        pyarrow_table = pa.Table.from_batches(batch.to_pyarrow() for batch in stream)
+
+    assert isinstance(pyarrow_table, pa.Table)
+    assert pyarrow_table.shape == (3, 3)
+    assert set(pyarrow_table.column_names) == {"a", "b", "c"}
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("schema", [True, False])
+async def test_execute_stream_to_arrow_table_async(df, schema):
+    stream = df.execute_stream()
+
+    if schema:
+        pyarrow_table = pa.Table.from_batches(
+            [batch.to_pyarrow() async for batch in stream], schema=df.schema()
+        )
+    else:
+        pyarrow_table = pa.Table.from_batches(
+            [batch.to_pyarrow() async for batch in stream]
+        )
+
+    assert isinstance(pyarrow_table, pa.Table)
+    assert pyarrow_table.shape == (3, 3)
+    assert set(pyarrow_table.column_names) == {"a", "b", "c"}
+
+
+def test_execute_stream_partitioned(df):
+    streams = df.execute_stream_partitioned()
+    assert all(batch is not None for stream in streams for batch in stream)
+    assert all(
+        not list(stream) for stream in streams
+    )  # after one iteration all generators must be exhausted
+
+
+@pytest.mark.asyncio
+async def test_execute_stream_partitioned_async(df):
+    streams = df.execute_stream_partitioned()
+
+    for stream in streams:
+        batches = [batch async for batch in stream]
+        assert all(batch is not None for batch in batches)
+
+        # Ensure the stream is exhausted after iteration
+        remaining_batches = [batch async for batch in stream]
+        assert not remaining_batches
+
+
+def test_empty_to_arrow_table(df):
+    # Convert empty datafusion dataframe to pyarrow Table
+    pyarrow_table = df.limit(0).to_arrow_table()
+    assert isinstance(pyarrow_table, pa.Table)
+    assert pyarrow_table.shape == (0, 3)
+    assert set(pyarrow_table.column_names) == {"a", "b", "c"}
+
+
+def test_iter_batches_dataframe(fail_collect):
+    ctx = SessionContext()
+
+    batch1 = pa.record_batch([pa.array([1])], names=["a"])
+    batch2 = pa.record_batch([pa.array([2])], names=["a"])
+    df = ctx.create_dataframe([[batch1], [batch2]])
+
+    expected = [batch1, batch2]
+    results = [b.to_pyarrow() for b in df]
+
+    assert len(results) == len(expected)
+    for exp in expected:
+        assert any(got.equals(exp) for got in results)
+
+
+def test_arrow_c_stream_to_table_and_reader(fail_collect):
+    ctx = SessionContext()
+
+    # Create a DataFrame with two separate record batches
+    batch1 = pa.record_batch([pa.array([1])], names=["a"])
+    batch2 = pa.record_batch([pa.array([2])], names=["a"])
+    df = ctx.create_dataframe([[batch1], [batch2]])
+
+    table = pa.Table.from_batches(batch.to_pyarrow() for batch in df)
+    batches = table.to_batches()
+
+    assert len(batches) == 2
+    expected = [batch1, batch2]
+    for exp in expected:
+        assert any(got.equals(exp) for got in batches)
+    assert table.schema == df.schema()
+    assert table.column("a").num_chunks == 2
+
+    reader = pa.RecordBatchReader.from_stream(df)
+    assert isinstance(reader, pa.RecordBatchReader)
+    reader_table = pa.Table.from_batches(reader)
+    expected = pa.Table.from_batches([batch1, batch2])
+    assert reader_table.equals(expected)
+
+
+def test_arrow_c_stream_order():
+    ctx = SessionContext()
+
+    batch1 = pa.record_batch([pa.array([1])], names=["a"])
+    batch2 = pa.record_batch([pa.array([2])], names=["a"])
+
+    df = ctx.create_dataframe([[batch1, batch2]])
+
+    table = pa.Table.from_batches(batch.to_pyarrow() for batch in df)
+    expected = pa.Table.from_batches([batch1, batch2])
+
+    assert table.equals(expected)
+    col = table.column("a")
+    assert col.chunk(0)[0].as_py() == 1
+    assert col.chunk(1)[0].as_py() == 2
+
+
+def test_arrow_c_stream_schema_selection(fail_collect):
+    ctx = SessionContext()
+
+    batch = pa.RecordBatch.from_arrays(
+        [
+            pa.array([1, 2]),
+            pa.array([3, 4]),
+            pa.array([5, 6]),
+        ],
+        names=["a", "b", "c"],
+    )
+    df = ctx.create_dataframe([[batch]])
+
+    requested_schema = pa.schema([("c", pa.int64()), ("a", pa.int64())])
+
+    c_schema = pa_cffi.ffi.new("struct ArrowSchema*")
+    address = int(pa_cffi.ffi.cast("uintptr_t", c_schema))
+    requested_schema._export_to_c(address)
+    capsule_new = ctypes.pythonapi.PyCapsule_New
+    capsule_new.restype = ctypes.py_object
+    capsule_new.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_void_p]
+
+    reader = pa.RecordBatchReader.from_stream(df, schema=requested_schema)
+
+    assert reader.schema == requested_schema
+
+    batches = list(reader)
+
+    assert len(batches) == 1
+    expected_batch = pa.record_batch(
+        [pa.array([5, 6]), pa.array([1, 2])], names=["c", "a"]
+    )
+    assert batches[0].equals(expected_batch)
+
+
+def test_arrow_c_stream_schema_mismatch(fail_collect):
+    ctx = SessionContext()
+
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2]), pa.array([3, 4])], names=["a", "b"]
+    )
+    df = ctx.create_dataframe([[batch]])
+
+    bad_schema = pa.schema([("a", pa.string())])
+
+    c_schema = pa_cffi.ffi.new("struct ArrowSchema*")
+    address = int(pa_cffi.ffi.cast("uintptr_t", c_schema))
+    bad_schema._export_to_c(address)
+
+    capsule_new = ctypes.pythonapi.PyCapsule_New
+    capsule_new.restype = ctypes.py_object
+    capsule_new.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_void_p]
+    bad_capsule = capsule_new(ctypes.c_void_p(address), b"arrow_schema", None)
+
+    with pytest.raises(Exception, match="Fail to merge schema"):
+        df.__arrow_c_stream__(bad_capsule)
+
+
+def test_to_pylist(df):
+    # Convert datafusion dataframe to Python list
+    pylist = df.to_pylist()
+    assert isinstance(pylist, list)
+    assert pylist == [
+        {"a": 1, "b": 4, "c": 8},
+        {"a": 2, "b": 5, "c": 5},
+        {"a": 3, "b": 6, "c": 8},
+    ]
+
+
+def test_to_pydict(df):
+    # Convert datafusion dataframe to Python dictionary
+    pydict = df.to_pydict()
+    assert isinstance(pydict, dict)
+    assert pydict == {"a": [1, 2, 3], "b": [4, 5, 6], "c": [8, 5, 8]}
+
+
+def test_describe(df):
+    # Calculate statistics
+    df = df.describe()
+
+    # Collect the result
+    result = df.to_pydict()
+
+    assert result == {
+        "describe": [
+            "count",
+            "null_count",
+            "mean",
+            "std",
+            "min",
+            "max",
+            "median",
+        ],
+        "a": [3.0, 0.0, 2.0, 1.0, 1.0, 3.0, 2.0],
+        "b": [3.0, 0.0, 5.0, 1.0, 4.0, 6.0, 5.0],
+        "c": [3.0, 0.0, 7.0, 1.7320508075688772, 5.0, 8.0, 8.0],
+    }
+
+
+@pytest.mark.parametrize("path_to_str", [True, False])
+def test_write_csv(ctx, df, tmp_path, path_to_str):
+    path = str(tmp_path) if path_to_str else tmp_path
+
+    df.write_csv(path, with_header=True)
+
+    ctx.register_csv("csv", path)
+    result = ctx.table("csv").to_pydict()
+    expected = df.to_pydict()
+
+    assert result == expected
+
+
+def generate_test_write_params() -> list[tuple]:
+    # Overwrite and Replace are not implemented for many table writers
+    insert_ops = [InsertOp.APPEND, None]
+    sort_by_cases = [
+        (None, [1, 2, 3], "unsorted"),
+        (column("c"), [2, 1, 3], "single_column_expr"),
+        (column("a").sort(ascending=False), [3, 2, 1], "single_sort_expr"),
+        ([column("c"), column("b")], [2, 1, 3], "list_col_expr"),
+        (
+            [column("c").sort(ascending=False), column("b").sort(ascending=False)],
+            [3, 1, 2],
+            "list_sort_expr",
+        ),
+    ]
+
+    formats = ["csv", "json", "parquet", "table"]
+
+    return [
+        pytest.param(
+            output_format,
+            insert_op,
+            sort_by,
+            expected_a,
+            id=f"{output_format}_{test_id}",
+        )
+        for output_format, insert_op, (
+            sort_by,
+            expected_a,
+            test_id,
+        ) in itertools.product(formats, insert_ops, sort_by_cases)
+    ]
+
+
+@pytest.mark.parametrize(
+    ("output_format", "insert_op", "sort_by", "expected_a"),
+    generate_test_write_params(),
+)
+def test_write_files_with_options(
+    ctx, df, tmp_path, output_format, insert_op, sort_by, expected_a
+) -> None:
+    write_options = DataFrameWriteOptions(insert_operation=insert_op, sort_by=sort_by)
+
+    if output_format == "csv":
+        df.write_csv(tmp_path, with_header=True, write_options=write_options)
+        ctx.register_csv("test_table", tmp_path)
+    elif output_format == "json":
+        df.write_json(tmp_path, write_options=write_options)
+        ctx.register_json("test_table", tmp_path)
+    elif output_format == "parquet":
+        df.write_parquet(tmp_path, write_options=write_options)
+        ctx.register_parquet("test_table", tmp_path)
+    elif output_format == "table":
+        batch = pa.RecordBatch.from_arrays([[], [], []], schema=df.schema())
+        ctx.register_record_batches("test_table", [[batch]])
+        ctx.table("test_table").show()
+        df.write_table("test_table", write_options=write_options)
+
+    result = ctx.table("test_table").to_pydict()["a"]
+    ctx.table("test_table").show()
+
+    assert result == expected_a
+
+
+@pytest.mark.parametrize("path_to_str", [True, False])
+def test_write_json(ctx, df, tmp_path, path_to_str):
+    path = str(tmp_path) if path_to_str else tmp_path
+
+    df.write_json(path)
+
+    ctx.register_json("json", path)
+    result = ctx.table("json").to_pydict()
+    expected = df.to_pydict()
+
+    assert result == expected
+
+
+@pytest.mark.parametrize("path_to_str", [True, False])
+def test_write_parquet(df, tmp_path, path_to_str):
+    path = str(tmp_path) if path_to_str else tmp_path
+
+    df.write_parquet(str(path))
+    result = pq.read_table(str(path)).to_pydict()
+    expected = df.to_pydict()
+
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    ("compression", "compression_level"),
+    [("gzip", 6), ("brotli", 7), ("zstd", 15)],
+)
+def test_write_compressed_parquet(df, tmp_path, compression, compression_level):
+    path = tmp_path
+
+    df.write_parquet(
+        str(path), compression=compression, compression_level=compression_level
+    )
+
+    # test that the actual compression scheme is the one written
+    for _root, _dirs, files in os.walk(path):
+        for file in files:
+            if file.endswith(".parquet"):
+                metadata = pq.ParquetFile(tmp_path / file).metadata.to_dict()
+                for row_group in metadata["row_groups"]:
+                    for columns in row_group["columns"]:
+                        assert columns["compression"].lower() == compression
+
+    result = pq.read_table(str(path)).to_pydict()
+    expected = df.to_pydict()
+
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    ("compression", "compression_level"),
+    [("gzip", 12), ("brotli", 15), ("zstd", 23), ("wrong", 12)],
+)
+def test_write_compressed_parquet_wrong_compression_level(
+    df, tmp_path, compression, compression_level
+):
+    path = tmp_path
+
+    with pytest.raises(ValueError):
+        df.write_parquet(
+            str(path),
+            compression=compression,
+            compression_level=compression_level,
+        )
+
+
+@pytest.mark.parametrize("compression", ["wrong"])
+def test_write_compressed_parquet_invalid_compression(df, tmp_path, compression):
+    path = tmp_path
+
+    with pytest.raises(ValueError):
+        df.write_parquet(str(path), compression=compression)
+
+
+# not testing lzo because it it not implemented yet
+# https://github.com/apache/arrow-rs/issues/6970
+@pytest.mark.parametrize("compression", ["zstd", "brotli", "gzip"])
+def test_write_compressed_parquet_default_compression_level(df, tmp_path, compression):
+    # Test write_parquet with zstd, brotli, gzip default compression level,
+    # ie don't specify compression level
+    # should complete without error
+    path = tmp_path
+
+    df.write_parquet(str(path), compression=compression)
+
+
+def test_write_parquet_with_options_default_compression(df, tmp_path):
+    """Test that the default compression is ZSTD."""
+    df.write_parquet(tmp_path)
+
+    for file in tmp_path.rglob("*.parquet"):
+        metadata = pq.ParquetFile(file).metadata.to_dict()
+        for row_group in metadata["row_groups"]:
+            for col in row_group["columns"]:
+                assert col["compression"].lower() == "zstd"
+
+
+@pytest.mark.parametrize(
+    "compression",
+    ["gzip(6)", "brotli(7)", "zstd(15)", "snappy", "uncompressed"],
+)
+def test_write_parquet_with_options_compression(df, tmp_path, compression):
+    import re
+
+    path = tmp_path
+    df.write_parquet_with_options(
+        str(path), ParquetWriterOptions(compression=compression)
+    )
+
+    # test that the actual compression scheme is the one written
+    for _root, _dirs, files in os.walk(path):
+        for file in files:
+            if file.endswith(".parquet"):
+                metadata = pq.ParquetFile(tmp_path / file).metadata.to_dict()
+                for row_group in metadata["row_groups"]:
+                    for col in row_group["columns"]:
+                        assert col["compression"].lower() == re.sub(
+                            r"\(\d+\)", "", compression
+                        )
+
+    result = pq.read_table(str(path)).to_pydict()
+    expected = df.to_pydict()
+
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "compression",
+    ["gzip(12)", "brotli(15)", "zstd(23)"],
+)
+def test_write_parquet_with_options_wrong_compression_level(df, tmp_path, compression):
+    path = tmp_path
+
+    with pytest.raises(Exception, match=r"valid compression range .*? exceeded."):
+        df.write_parquet_with_options(
+            str(path), ParquetWriterOptions(compression=compression)
+        )
+
+
+@pytest.mark.parametrize("compression", ["wrong", "wrong(12)"])
+def test_write_parquet_with_options_invalid_compression(df, tmp_path, compression):
+    path = tmp_path
+
+    with pytest.raises(Exception, match="Unknown or unsupported parquet compression"):
+        df.write_parquet_with_options(
+            str(path), ParquetWriterOptions(compression=compression)
+        )
+
+
+@pytest.mark.parametrize(
+    ("writer_version", "format_version"),
+    [("1.0", "1.0"), ("2.0", "2.6"), (None, "1.0")],
+)
+def test_write_parquet_with_options_writer_version(
+    df, tmp_path, writer_version, format_version
+):
+    """Test the Parquet writer version. Note that writer_version=2.0 results in
+    format_version=2.6"""
+    if writer_version is None:
+        df.write_parquet_with_options(tmp_path, ParquetWriterOptions())
+    else:
+        df.write_parquet_with_options(
+            tmp_path, ParquetWriterOptions(writer_version=writer_version)
+        )
+
+    for file in tmp_path.rglob("*.parquet"):
+        parquet = pq.ParquetFile(file)
+        metadata = parquet.metadata.to_dict()
+        assert metadata["format_version"] == format_version
+
+
+@pytest.mark.parametrize("writer_version", ["1.2.3", "custom-version", "0"])
+def test_write_parquet_with_options_wrong_writer_version(df, tmp_path, writer_version):
+    """Test that invalid writer versions in Parquet throw an exception."""
+    with pytest.raises(Exception, match="Invalid parquet writer version"):
+        df.write_parquet_with_options(
+            tmp_path, ParquetWriterOptions(writer_version=writer_version)
+        )
+
+
+@pytest.mark.parametrize("dictionary_enabled", [True, False, None])
+def test_write_parquet_with_options_dictionary_enabled(
+    df, tmp_path, dictionary_enabled
+):
+    """Test enabling/disabling the dictionaries in Parquet."""
+    df.write_parquet_with_options(
+        tmp_path, ParquetWriterOptions(dictionary_enabled=dictionary_enabled)
+    )
+    # by default, the dictionary is enabled, so None results in True
+    result = dictionary_enabled if dictionary_enabled is not None else True
+
+    for file in tmp_path.rglob("*.parquet"):
+        parquet = pq.ParquetFile(file)
+        metadata = parquet.metadata.to_dict()
+
+        for row_group in metadata["row_groups"]:
+            for col in row_group["columns"]:
+                assert col["has_dictionary_page"] == result
+
+
+@pytest.mark.parametrize(
+    ("statistics_enabled", "has_statistics"),
+    [("page", True), ("chunk", True), ("none", False), (None, True)],
+)
+def test_write_parquet_with_options_statistics_enabled(
+    df, tmp_path, statistics_enabled, has_statistics
+):
+    """Test configuring the statistics in Parquet. In pyarrow we can only check for
+    column-level statistics, so "page" and "chunk" are tested in the same way."""
+    df.write_parquet_with_options(
+        tmp_path, ParquetWriterOptions(statistics_enabled=statistics_enabled)
+    )
+
+    for file in tmp_path.rglob("*.parquet"):
+        parquet = pq.ParquetFile(file)
+        metadata = parquet.metadata.to_dict()
+
+        for row_group in metadata["row_groups"]:
+            for col in row_group["columns"]:
+                if has_statistics:
+                    assert col["statistics"] is not None
+                else:
+                    assert col["statistics"] is None
+
+
+@pytest.mark.parametrize("max_row_group_size", [1000, 5000, 10000, 100000])
+def test_write_parquet_with_options_max_row_group_size(
+    large_df, tmp_path, max_row_group_size
+):
+    """Test configuring the max number of rows per group in Parquet. These test cases
+    guarantee that the number of rows for each row group is max_row_group_size, given
+    the total number of rows is a multiple of max_row_group_size."""
+    path = f"{tmp_path}/t.parquet"
+    large_df.write_parquet_with_options(
+        path, ParquetWriterOptions(max_row_group_size=max_row_group_size)
+    )
+
+    parquet = pq.ParquetFile(path)
+    metadata = parquet.metadata.to_dict()
+    for row_group in metadata["row_groups"]:
+        assert row_group["num_rows"] == max_row_group_size
+
+
+@pytest.mark.parametrize("created_by", ["datafusion", "datafusion-python", "custom"])
+def test_write_parquet_with_options_created_by(df, tmp_path, created_by):
+    """Test configuring the created by metadata in Parquet."""
+    df.write_parquet_with_options(tmp_path, ParquetWriterOptions(created_by=created_by))
+
+    for file in tmp_path.rglob("*.parquet"):
+        parquet = pq.ParquetFile(file)
+        metadata = parquet.metadata.to_dict()
+        assert metadata["created_by"] == created_by
+
+
+@pytest.mark.parametrize("statistics_truncate_length", [5, 25, 50])
+def test_write_parquet_with_options_statistics_truncate_length(
+    df, tmp_path, statistics_truncate_length
+):
+    """Test configuring the truncate limit in Parquet's row-group-level statistics."""
+    ctx = SessionContext()
+    data = {
+        "a": [
+            "a_the_quick_brown_fox_jumps_over_the_lazy_dog",
+            "m_the_quick_brown_fox_jumps_over_the_lazy_dog",
+            "z_the_quick_brown_fox_jumps_over_the_lazy_dog",
+        ],
+        "b": ["a_smaller", "m_smaller", "z_smaller"],
+    }
+    df = ctx.from_arrow(pa.record_batch(data))
+    df.write_parquet_with_options(
+        tmp_path,
+        ParquetWriterOptions(statistics_truncate_length=statistics_truncate_length),
+    )
+
+    for file in tmp_path.rglob("*.parquet"):
+        parquet = pq.ParquetFile(file)
+        metadata = parquet.metadata.to_dict()
+
+        for row_group in metadata["row_groups"]:
+            for col in row_group["columns"]:
+                statistics = col["statistics"]
+                assert len(statistics["min"]) <= statistics_truncate_length
+                assert len(statistics["max"]) <= statistics_truncate_length
+
+
+def test_write_parquet_with_options_default_encoding(tmp_path):
+    """Test that, by default, Parquet files are written with dictionary encoding.
+    Note that dictionary encoding is not used for boolean values, so it is not tested
+    here."""
+    ctx = SessionContext()
+    data = {
+        "a": [1, 2, 3],
+        "b": ["1", "2", "3"],
+        "c": [1.01, 2.02, 3.03],
+    }
+    df = ctx.from_arrow(pa.record_batch(data))
+    df.write_parquet_with_options(tmp_path, ParquetWriterOptions())
+
+    for file in tmp_path.rglob("*.parquet"):
+        parquet = pq.ParquetFile(file)
+        metadata = parquet.metadata.to_dict()
+
+        for row_group in metadata["row_groups"]:
+            for col in row_group["columns"]:
+                assert col["encodings"] == ("PLAIN", "RLE", "RLE_DICTIONARY")
+
+
+@pytest.mark.parametrize(
+    ("encoding", "data_types", "result"),
+    [
+        ("plain", ["int", "float", "str", "bool"], ("PLAIN", "RLE")),
+        ("rle", ["bool"], ("RLE",)),
+        ("delta_binary_packed", ["int"], ("RLE", "DELTA_BINARY_PACKED")),
+        ("delta_length_byte_array", ["str"], ("RLE", "DELTA_LENGTH_BYTE_ARRAY")),
+        ("delta_byte_array", ["str"], ("RLE", "DELTA_BYTE_ARRAY")),
+        ("byte_stream_split", ["int", "float"], ("RLE", "BYTE_STREAM_SPLIT")),
+    ],
+)
+def test_write_parquet_with_options_encoding(tmp_path, encoding, data_types, result):
+    """Test different encodings in Parquet in their respective support column types."""
+    ctx = SessionContext()
+
+    data = {}
+    for data_type in data_types:
+        if data_type == "int":
+            data["int"] = [1, 2, 3]
+        elif data_type == "float":
+            data["float"] = [1.01, 2.02, 3.03]
+        elif data_type == "str":
+            data["str"] = ["a", "b", "c"]
+        elif data_type == "bool":
+            data["bool"] = [True, False, True]
+
+    df = ctx.from_arrow(pa.record_batch(data))
+    df.write_parquet_with_options(
+        tmp_path, ParquetWriterOptions(encoding=encoding, dictionary_enabled=False)
+    )
+
+    for file in tmp_path.rglob("*.parquet"):
+        parquet = pq.ParquetFile(file)
+        metadata = parquet.metadata.to_dict()
+
+        for row_group in metadata["row_groups"]:
+            for col in row_group["columns"]:
+                assert col["encodings"] == result
+
+
+@pytest.mark.parametrize("encoding", ["bit_packed"])
+def test_write_parquet_with_options_unsupported_encoding(df, tmp_path, encoding):
+    """Test that unsupported Parquet encodings do not work."""
+    # BaseException is used since this throws a Rust panic: https://github.com/PyO3/pyo3/issues/3519
+    with pytest.raises(BaseException, match=r"Encoding .*? is not supported"):
+        df.write_parquet_with_options(tmp_path, ParquetWriterOptions(encoding=encoding))
+
+
+@pytest.mark.parametrize("encoding", ["non_existent", "unknown", "plain123"])
+def test_write_parquet_with_options_invalid_encoding(df, tmp_path, encoding):
+    """Test that invalid Parquet encodings do not work."""
+    with pytest.raises(Exception, match="Unknown or unsupported parquet encoding"):
+        df.write_parquet_with_options(tmp_path, ParquetWriterOptions(encoding=encoding))
+
+
+@pytest.mark.parametrize("encoding", ["plain_dictionary", "rle_dictionary"])
+def test_write_parquet_with_options_dictionary_encoding_fallback(
+    df, tmp_path, encoding
+):
+    """Test that the dictionary encoding cannot be used as fallback in Parquet."""
+    # BaseException is used since this throws a Rust panic: https://github.com/PyO3/pyo3/issues/3519
+    with pytest.raises(
+        BaseException, match="Dictionary encoding can not be used as fallback encoding"
+    ):
+        df.write_parquet_with_options(tmp_path, ParquetWriterOptions(encoding=encoding))
+
+
+def test_write_parquet_with_options_bloom_filter(df, tmp_path):
+    """Test Parquet files with and without (default) bloom filters. Since pyarrow does
+    not expose any information about bloom filters, the easiest way to confirm that they
+    are actually written is to compare the file size."""
+    path_no_bloom_filter = tmp_path / "1"
+    path_bloom_filter = tmp_path / "2"
+
+    df.write_parquet_with_options(path_no_bloom_filter, ParquetWriterOptions())
+    df.write_parquet_with_options(
+        path_bloom_filter, ParquetWriterOptions(bloom_filter_on_write=True)
+    )
+
+    size_no_bloom_filter = 0
+    for file in path_no_bloom_filter.rglob("*.parquet"):
+        size_no_bloom_filter += Path(file).stat().st_size
+
+    size_bloom_filter = 0
+    for file in path_bloom_filter.rglob("*.parquet"):
+        size_bloom_filter += Path(file).stat().st_size
+
+    assert size_no_bloom_filter < size_bloom_filter
+
+
+def test_write_parquet_with_options_column_options(df, tmp_path):
+    """Test writing Parquet files with different options for each column, which replace
+    the global configs (when provided)."""
+    data = {
+        "a": [1, 2, 3],
+        "b": ["a", "b", "c"],
+        "c": [False, True, False],
+        "d": [1.01, 2.02, 3.03],
+        "e": [4, 5, 6],
+    }
+
+    column_specific_options = {
+        "a": ParquetColumnOptions(statistics_enabled="none"),
+        "b": ParquetColumnOptions(encoding="plain", dictionary_enabled=False),
+        "c": ParquetColumnOptions(
+            compression="snappy", encoding="rle", dictionary_enabled=False
+        ),
+        "d": ParquetColumnOptions(
+            compression="zstd(6)",
+            encoding="byte_stream_split",
+            dictionary_enabled=False,
+            statistics_enabled="none",
+        ),
+        # column "e" will use the global configs
+    }
+
+    results = {
+        "a": {
+            "statistics": False,
+            "compression": "brotli",
+            "encodings": ("PLAIN", "RLE", "RLE_DICTIONARY"),
+        },
+        "b": {
+            "statistics": True,
+            "compression": "brotli",
+            "encodings": ("PLAIN", "RLE"),
+        },
+        "c": {
+            "statistics": True,
+            "compression": "snappy",
+            "encodings": ("RLE",),
+        },
+        "d": {
+            "statistics": False,
+            "compression": "zstd",
+            "encodings": ("RLE", "BYTE_STREAM_SPLIT"),
+        },
+        "e": {
+            "statistics": True,
+            "compression": "brotli",
+            "encodings": ("PLAIN", "RLE", "RLE_DICTIONARY"),
+        },
+    }
+
+    ctx = SessionContext()
+    df = ctx.from_arrow(pa.record_batch(data))
+    df.write_parquet_with_options(
+        tmp_path,
+        ParquetWriterOptions(
+            compression="brotli(8)", column_specific_options=column_specific_options
+        ),
+    )
+
+    for file in tmp_path.rglob("*.parquet"):
+        parquet = pq.ParquetFile(file)
+        metadata = parquet.metadata.to_dict()
+
+        for row_group in metadata["row_groups"]:
+            for col in row_group["columns"]:
+                column_name = col["path_in_schema"]
+                result = results[column_name]
+                assert (col["statistics"] is not None) == result["statistics"]
+                assert col["compression"].lower() == result["compression"].lower()
+                assert col["encodings"] == result["encodings"]
+
+
+def test_write_parquet_options(df, tmp_path):
+    options = ParquetWriterOptions(compression="gzip", compression_level=6)
+    df.write_parquet(str(tmp_path), options)
+
+    result = pq.read_table(str(tmp_path)).to_pydict()
+    expected = df.to_pydict()
+
+    assert result == expected
+
+
+def test_write_parquet_options_error(df, tmp_path):
+    options = ParquetWriterOptions(compression="gzip", compression_level=6)
+    with pytest.raises(ValueError):
+        df.write_parquet(str(tmp_path), options, compression_level=1)
+
+
+def test_write_table(ctx, df):
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3])],
+        names=["a"],
+    )
+
+    ctx.register_record_batches("t", [[batch]])
+
+    df = ctx.table("t").with_column("a", column("a") * literal(-1))
+
+    ctx.table("t").show()
+
+    df.write_table("t")
+    result = ctx.table("t").sort(column("a")).collect()[0][0].to_pylist()
+    expected = [-3, -2, -1, 1, 2, 3]
+
+    assert result == expected
+
+
+def test_dataframe_export(df) -> None:
+    # Guarantees that we have the canonical implementation
+    # reading our dataframe export
+    table = pa.table(df)
+    assert table.num_columns == 3
+    assert table.num_rows == 3
+
+    desired_schema = pa.schema([("a", pa.int64())])
+
+    # Verify we can request a schema
+    table = pa.table(df, schema=desired_schema)
+    assert table.num_columns == 1
+    assert table.num_rows == 3
+
+    # Expect a table of nulls if the schema don't overlap
+    desired_schema = pa.schema([("g", pa.string())])
+    table = pa.table(df, schema=desired_schema)
+    assert table.num_columns == 1
+    assert table.num_rows == 3
+    for i in range(3):
+        assert table[0][i].as_py() is None
+
+    # Expect an error when we cannot convert schema
+    desired_schema = pa.schema([("a", pa.float32())])
+    failed_convert = False
+    try:
+        table = pa.table(df, schema=desired_schema)
+    except Exception:
+        failed_convert = True
+    assert failed_convert
+
+    # Expect an error when we have a not set non-nullable
+    desired_schema = pa.schema([("g", pa.string(), False)])
+    failed_convert = False
+    try:
+        table = pa.table(df, schema=desired_schema)
+    except Exception:
+        failed_convert = True
+    assert failed_convert
+
+
+def test_dataframe_transform(df):
+    def add_string_col(df_internal) -> DataFrame:
+        return df_internal.with_column("string_col", literal("string data"))
+
+    def add_with_parameter(df_internal, value: Any) -> DataFrame:
+        return df_internal.with_column("new_col", literal(value))
+
+    df = df.transform(add_string_col).transform(add_with_parameter, 3)
+
+    result = df.to_pydict()
+
+    assert result["a"] == [1, 2, 3]
+    assert result["string_col"] == ["string data" for _i in range(3)]
+    assert result["new_col"] == [3 for _i in range(3)]
+
+
+def test_dataframe_repr_html_structure(df, clean_formatter_state) -> None:
+    """Test that DataFrame._repr_html_ produces expected HTML output structure."""
+
+    output = df._repr_html_()
+
+    # Since we've added a fair bit of processing to the html output, lets just verify
+    # the values we are expecting in the table exist. Use regex and ignore everything
+    # between the <th></th> and <td></td>. We also don't want the closing > on the
+    # td and th segments because that is where the formatting data is written.
+
+    headers = ["a", "b", "c"]
+    headers = [f"<th(.*?)>{v}</th>" for v in headers]
+    header_pattern = "(.*?)".join(headers)
+    header_matches = re.findall(header_pattern, output, re.DOTALL)
+    assert len(header_matches) == 1
+
+    # Update the pattern to handle values that may be wrapped in spans
+    body_data = [[1, 4, 8], [2, 5, 5], [3, 6, 8]]
+
+    body_lines = [
+        f"<td(.*?)>(?:<span[^>]*?>)?{v}(?:</span>)?</td>"
+        for inner in body_data
+        for v in inner
+    ]
+    body_pattern = "(.*?)".join(body_lines)
+
+    body_matches = re.findall(body_pattern, output, re.DOTALL)
+
+    assert len(body_matches) == 1, "Expected pattern of values not found in HTML output"
+
+
+def test_dataframe_repr_html_values(df, clean_formatter_state):
+    """Test that DataFrame._repr_html_ contains the expected data values."""
+    html = df._repr_html_()
+    assert html is not None
+
+    # Create a more flexible pattern that handles values being wrapped in spans
+    # This pattern will match the sequence of values 1,4,8,2,5,5,3,6,8 regardless
+    # of formatting
+    pattern = re.compile(
+        r"<td[^>]*?>(?:<span[^>]*?>)?1(?:</span>)?</td>.*?"
+        r"<td[^>]*?>(?:<span[^>]*?>)?4(?:</span>)?</td>.*?"
+        r"<td[^>]*?>(?:<span[^>]*?>)?8(?:</span>)?</td>.*?"
+        r"<td[^>]*?>(?:<span[^>]*?>)?2(?:</span>)?</td>.*?"
+        r"<td[^>]*?>(?:<span[^>]*?>)?5(?:</span>)?</td>.*?"
+        r"<td[^>]*?>(?:<span[^>]*?>)?5(?:</span>)?</td>.*?"
+        r"<td[^>]*?>(?:<span[^>]*?>)?3(?:</span>)?</td>.*?"
+        r"<td[^>]*?>(?:<span[^>]*?>)?6(?:</span>)?</td>.*?"
+        r"<td[^>]*?>(?:<span[^>]*?>)?8(?:</span>)?</td>",
+        re.DOTALL,
+    )
+
+    # Print debug info if the test fails
+    matches = re.findall(pattern, html)
+    if not matches:
+        print(f"HTML output snippet: {html[:500]}...")  # noqa: T201
+
+    assert len(matches) > 0, "Expected pattern of values not found in HTML output"
+
+
+def test_html_formatter_shared_styles(df, clean_formatter_state):
+    """Test that shared styles work correctly across multiple tables."""
+
+    # First, ensure we're using shared styles
+    configure_formatter(use_shared_styles=True)
+
+    html_first = df._repr_html_()
+    html_second = df._repr_html_()
+
+    assert "<script>" in html_first
+    assert "df-styles" in html_first
+    assert "<script>" in html_second
+    assert "df-styles" in html_second
+    assert "<style>" not in html_first
+    assert "<style>" not in html_second
+
+
+def test_html_formatter_no_shared_styles(df, clean_formatter_state):
+    """Test that styles are always included when shared styles are disabled."""
+
+    # Configure formatter to NOT use shared styles
+    configure_formatter(use_shared_styles=False)
+
+    html_first = df._repr_html_()
+    html_second = df._repr_html_()
+
+    assert "<script>" in html_first
+    assert "<script>" in html_second
+    assert "df-styles" in html_first
+    assert "df-styles" in html_second
+    assert "<style>" not in html_first
+    assert "<style>" not in html_second
+
+
+def test_html_formatter_manual_format_html(clean_formatter_state):
+    """Test direct usage of format_html method with shared styles."""
+
+    # Create sample data
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+
+    formatter = get_formatter()
+
+    html_first = formatter.format_html([batch], batch.schema)
+    html_second = formatter.format_html([batch], batch.schema)
+
+    assert "<script>" in html_first
+    assert "<script>" in html_second
+    assert "df-styles" in html_first
+    assert "df-styles" in html_second
+    assert "<style>" not in html_first
+    assert "<style>" not in html_second
+
+    # Create a new formatter with shared_styles=False
+    local_formatter = DataFrameHtmlFormatter(use_shared_styles=False)
+
+    # Both calls should include styles
+    local_html_1 = local_formatter.format_html([batch], batch.schema)
+    local_html_2 = local_formatter.format_html([batch], batch.schema)
+
+    assert "<script>" in local_html_1
+    assert "<script>" in local_html_2
+    assert "df-styles" in local_html_1
+    assert "df-styles" in local_html_2
+    assert "<style>" not in local_html_1
+    assert "<style>" not in local_html_2
+
+
+def test_html_formatter_backward_compatibility_repr_rows(df, clean_formatter_state):
+    """Test backward compatibility with custom formatter using deprecated repr_rows.
+
+    This test validates that the Rust code correctly handles custom formatter
+    implementations that only have the deprecated `repr_rows` attribute.
+
+    This is critical for supporting custom formatters created before `max_rows`
+    was added. Users should be able to pass their custom formatter objects
+    without breaking the rendering pipeline.
+    """
+
+    # Create a custom formatter class that ONLY has repr_rows (simulating old code)
+    class LegacyCustomFormatter:
+        """Simulates a custom formatter created before max_rows existed."""
+
+        def __init__(self):
+            # Only set repr_rows, not max_rows (as old formatters would)
+            self.repr_rows = 5
+            self.max_memory_bytes = 2 * MB
+            self.min_rows = 2
+
+        def format_html(self, batches, schema):
+            """Minimal format_html implementation for testing."""
+            # Just return valid HTML to pass validation
+            return "<table><tr><td>test</td></tr></table>"
+
+    # Use the legacy formatter with DataFusion (currently unused)
+    _ = LegacyCustomFormatter()
+
+    # This should not raise an error even though max_rows doesn't exist
+    # The Rust code should fall back to repr_rows
+    html_output = df._repr_html_()
+
+    # Verify that rendering succeeded
+    assert isinstance(html_output, str)
+    assert len(html_output) > 0
+
+    # Verify it's valid HTML (basic check)
+    assert "<table" in html_output.lower() or "data truncated" in html_output.lower()
+
+
+def test_fill_null_basic(null_df):
+    """Test basic fill_null functionality with a single value."""
+    # Fill all nulls with 0
+    filled_df = null_df.fill_null(0)
+
+    result = filled_df.collect()[0]
+
+    # Check that nulls were filled with 0 (or equivalent)
+    assert result.column(0) == pa.array([1, 0, 3, 0])
+    assert result.column(1) == pa.array([4.5, 6.7, 0.0, 0.0])
+    # String column should be filled with "0"
+    assert result.column(2) == pa.array(["a", "0", "c", "0"])
+    # Boolean column should be filled with False (0 converted to bool)
+    assert result.column(3) == pa.array([True, False, False, False])
+
+
+def test_fill_null_subset(null_df):
+    """Test filling nulls only in a subset of columns."""
+    # Fill nulls only in numeric columns
+    filled_df = null_df.fill_null(0, subset=["int_col", "float_col"])
+
+    result = filled_df.collect()[0]
+
+    # Check that nulls were filled only in specified columns
+    assert result.column(0) == pa.array([1, 0, 3, 0])
+    assert result.column(1) == pa.array([4.5, 6.7, 0.0, 0.0])
+    # These should still have nulls
+    assert None in result.column(2).to_pylist()
+    assert None in result.column(3).to_pylist()
+
+
+def test_fill_null_str_column(null_df):
+    """Test filling nulls in string columns with different values."""
+    # Fill string nulls with a replacement string
+    filled_df = null_df.fill_null("N/A", subset=["str_col"])
+
+    result = filled_df.collect()[0]
+
+    # Check that string nulls were filled with "N/A"
+    assert result.column(2).to_pylist() == ["a", "N/A", "c", "N/A"]
+
+    # Other columns should be unchanged
+    assert None in result.column(0).to_pylist()
+    assert None in result.column(1).to_pylist()
+    assert None in result.column(3).to_pylist()
+
+    # Fill with an empty string
+    filled_df = null_df.fill_null("", subset=["str_col"])
+    result = filled_df.collect()[0]
+    assert result.column(2).to_pylist() == ["a", "", "c", ""]
+
+
+def test_fill_null_bool_column(null_df):
+    """Test filling nulls in boolean columns with different values."""
+    # Fill bool nulls with True
+    filled_df = null_df.fill_null(value=True, subset=["bool_col"])
+
+    result = filled_df.collect()[0]
+
+    # Check that bool nulls were filled with True
+    assert result.column(3).to_pylist() == [True, True, False, True]
+
+    # Other columns should be unchanged
+    assert None in result.column(0).to_pylist()
+
+    # Fill bool nulls with False
+    filled_df = null_df.fill_null(value=False, subset=["bool_col"])
+    result = filled_df.collect()[0]
+    assert result.column(3).to_pylist() == [True, False, False, False]
+
+
+def test_fill_null_date32_column(null_df):
+    """Test filling nulls in date32 columns."""
+
+    # Fill date32 nulls with a specific date (1970-01-01)
+    epoch_date = datetime.date(1970, 1, 1)
+    filled_df = null_df.fill_null(epoch_date, subset=["date32_col"])
+
+    result = filled_df.collect()[0]
+
+    # Check that date32 nulls were filled with epoch date
+    dates = result.column(4).to_pylist()
+    assert dates[0] == datetime.date(2000, 1, 1)  # Original value
+    assert dates[1] == epoch_date  # Filled value
+    assert dates[2] == datetime.date(2022, 1, 1)  # Original value
+    assert dates[3] == epoch_date  # Filled value
+
+    # Other date column should be unchanged
+    assert None in result.column(5).to_pylist()
+
+
+def test_fill_null_date64_column(null_df):
+    """Test filling nulls in date64 columns."""
+
+    # Fill date64 nulls with a specific date (1970-01-01)
+    epoch_date = datetime.date(1970, 1, 1)
+    filled_df = null_df.fill_null(epoch_date, subset=["date64_col"])
+
+    result = filled_df.collect()[0]
+
+    # Check that date64 nulls were filled with epoch date
+    dates = result.column(5).to_pylist()
+    assert dates[0] == datetime.date(2000, 1, 1)  # Original value
+    assert dates[1] == epoch_date  # Filled value
+    assert dates[2] == datetime.date(2022, 1, 1)  # Original value
+    assert dates[3] == epoch_date  # Filled value
+
+    # Other date column should be unchanged
+    assert None in result.column(4).to_pylist()
+
+
+def test_fill_null_type_coercion(null_df):
+    """Test type coercion when filling nulls with values of different types."""
+    # Try to fill string nulls with a number
+    filled_df = null_df.fill_null(42, subset=["str_col"])
+
+    result = filled_df.collect()[0]
+
+    # String nulls should be filled with string representation of the number
+    assert result.column(2).to_pylist() == ["a", "42", "c", "42"]
+
+    # Try to fill bool nulls with a string that converts to True
+    filled_df = null_df.fill_null("true", subset=["bool_col"])
+    result = filled_df.collect()[0]
+
+    # This behavior depends on the implementation - check it works without error
+    # but don't make assertions about exact conversion behavior
+    assert None not in result.column(3).to_pylist()
+
+
+def test_fill_null_multiple_date_columns(null_df):
+    """Test filling nulls in both date column types simultaneously."""
+
+    # Fill both date column types with the same date
+    test_date = datetime.date(2023, 12, 31)
+    filled_df = null_df.fill_null(test_date, subset=["date32_col", "date64_col"])
+
+    result = filled_df.collect()[0]
+
+    # Check both date columns were filled correctly
+    date32_vals = result.column(4).to_pylist()
+    date64_vals = result.column(5).to_pylist()
+
+    assert None not in date32_vals
+    assert None not in date64_vals
+
+    assert date32_vals[1] == test_date
+    assert date32_vals[3] == test_date
+    assert date64_vals[1] == test_date
+    assert date64_vals[3] == test_date
+
+
+def test_fill_null_specific_types(null_df):
+    """Test filling nulls with type-appropriate values."""
+    # Fill with type-specific values
+    filled_df = null_df.fill_null("missing")
+
+    result = filled_df.collect()[0]
+
+    # Check that nulls were filled appropriately by type
+
+    assert result.column(0).to_pylist() == [1, None, 3, None]
+    assert result.column(1).to_pylist() == [4.5, 6.7, None, None]
+    assert result.column(2).to_pylist() == ["a", "missing", "c", "missing"]
+    assert result.column(3).to_pylist() == [True, None, False, None]  # Bool gets False
+    assert result.column(4).to_pylist() == [
+        datetime.date(2000, 1, 1),
+        None,
+        datetime.date(2022, 1, 1),
+        None,
+    ]
+    assert result.column(5).to_pylist() == [
+        datetime.date(2000, 1, 1),
+        None,
+        datetime.date(2022, 1, 1),
+        None,
+    ]
+
+
+def test_fill_null_immutability(null_df):
+    """Test that original DataFrame is unchanged after fill_null."""
+    # Get original values with nulls
+    original = null_df.collect()[0]
+    original_int_nulls = original.column(0).to_pylist().count(None)
+
+    # Apply fill_null
+    _filled_df = null_df.fill_null(0)
+
+    # Check that original is unchanged
+    new_original = null_df.collect()[0]
+    new_original_int_nulls = new_original.column(0).to_pylist().count(None)
+
+    assert original_int_nulls == new_original_int_nulls
+    assert original_int_nulls > 0  # Ensure we actually had nulls in the first place
+
+
+def test_fill_null_empty_df(ctx):
+    """Test fill_null on empty DataFrame."""
+    # Create an empty DataFrame with schema
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([], type=pa.int64()), pa.array([], type=pa.string())],
+        names=["a", "b"],
+    )
+    empty_df = ctx.create_dataframe([[batch]])
+
+    # Fill nulls (should work without errors)
+    filled_df = empty_df.fill_null(0)
+
+    # Should still be empty but with same schema
+    result = filled_df.collect()[0]
+    assert len(result.column(0)) == 0
+    assert len(result.column(1)) == 0
+    assert result.schema.field(0).name == "a"
+    assert result.schema.field(1).name == "b"
+
+
+def test_fill_null_all_null_column(ctx):
+    """Test fill_null on a column with all nulls."""
+    # Create DataFrame with a column of all nulls
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([None, None, None], type=pa.string())],
+        names=["a", "b"],
+    )
+    all_null_df = ctx.create_dataframe([[batch]])
+
+    # Fill nulls with a value
+    filled_df = all_null_df.fill_null("filled")
+
+    # Check that all nulls were filled
+    result = filled_df.collect()[0]
+    assert result.column(1).to_pylist() == ["filled", "filled", "filled"]
+
+
+@udf([pa.int64()], pa.int64(), "immutable")
+def slow_udf(x: pa.Array) -> pa.Array:
+    # This must be longer than the check interval in wait_for_future
+    time.sleep(2.0)
+    return x
+
+
+@pytest.mark.parametrize(
+    ("slow_query", "as_c_stream"),
+    [
+        (True, True),
+        (True, False),
+        (False, True),
+        (False, False),
+    ],
+)
+def test_collect_or_stream_interrupted(slow_query, as_c_stream):  # noqa: C901 PLR0915
+    """Ensure collection responds to ``KeyboardInterrupt`` signals.
+
+    This test issues a long-running query, and consumes the results via
+    either a collect() call or ``__arrow_c_stream__``. It raises
+    ``KeyboardInterrupt`` in the main thread and verifies that the
+    process has interrupted.
+
+    The `slow_query` determines if the query itself is slow via a
+    UDF with a timeout or if it is a fast query that generates many
+    results so it takes a long time to iterate through them all.
+    """
+
+    ctx = SessionContext()
+    df = ctx.sql("select * from generate_series(1, 1000000000000000000)")
+    if slow_query:
+        df = ctx.from_pydict({"a": [1, 2, 3]}).select(slow_udf(column("a")))
+
+    if as_c_stream:
+        reader = pa.RecordBatchReader.from_stream(df)
+
+    read_started = threading.Event()
+    read_exception = []
+    read_thread_id = None
+    max_wait_time = 5.0
+
+    def trigger_interrupt():
+        """Wait for read to start, then raise KeyboardInterrupt in read thread."""
+        if not read_started.wait(timeout=max_wait_time):
+            msg = f"Read operation did not start within {max_wait_time} seconds"
+            raise RuntimeError(msg)
+
+        if read_thread_id is None:
+            msg = "Cannot get read thread ID"
+            raise RuntimeError(msg)
+
+        exception = ctypes.py_object(KeyboardInterrupt)
+        res = ctypes.pythonapi.PyThreadState_SetAsyncExc(
+            ctypes.c_long(read_thread_id), exception
+        )
+        if res != 1:
+            ctypes.pythonapi.PyThreadState_SetAsyncExc(
+                ctypes.c_long(read_thread_id), ctypes.py_object(0)
+            )
+            msg = "Failed to raise KeyboardInterrupt in read thread"
+            raise RuntimeError(msg)
+
+    def read_stream():
+        """Consume the reader, which should be interrupted."""
+        nonlocal read_thread_id
+        read_thread_id = threading.get_ident()
+        try:
+            read_started.set()
+            if as_c_stream:
+                reader.read_all()
+            else:
+                df.collect()
+            # If we get here, the read completed without interruption
+            read_exception.append(RuntimeError("Read completed without interruption"))
+        except KeyboardInterrupt:
+            read_exception.append(KeyboardInterrupt)
+        except Exception as e:
+            read_exception.append(e)
+
+    read_thread = threading.Thread(target=read_stream)
+    read_thread.daemon = True
+    read_thread.start()
+
+    interrupt_thread = threading.Thread(target=trigger_interrupt)
+    interrupt_thread.daemon = True
+    interrupt_thread.start()
+
+    # Wait for the read operation with a timeout
+    read_thread.join(timeout=10.0)
+
+    if read_thread.is_alive():
+        pytest.fail("Stream read operation timed out after 10 seconds")
+
+    # Verify we got the expected KeyboardInterrupt
+    if not read_exception:
+        pytest.fail("No exception was raised during stream read")
+
+    # Check if we got KeyboardInterrupt directly or wrapped in another exception
+    exception = read_exception[0]
+    if not (
+        isinstance(exception, type(KeyboardInterrupt))
+        or "KeyboardInterrupt" in str(exception)
+    ):
+        pytest.fail(f"Expected KeyboardInterrupt, got: {exception}")
+
+    interrupt_thread.join(timeout=1.0)
+
+
+def test_show_select_where_no_rows(capsys) -> None:
+    ctx = SessionContext()
+    df = ctx.sql("SELECT 1 WHERE 1=0")
+    df.show()
+    out = capsys.readouterr().out
+    assert "DataFrame has no rows" in out
+
+
+def test_show_from_empty_batch(capsys) -> None:
+    ctx = SessionContext()
+    batch = pa.record_batch([pa.array([], type=pa.int32())], names=["a"])
+    ctx.create_dataframe([[batch]]).show()
+    out = capsys.readouterr().out
+    assert "| a |" in out
+
+
+@pytest.mark.parametrize("file_sort_order", [[["a"]], [[df_col("a")]]])
+def test_register_parquet_file_sort_order(ctx, tmp_path, file_sort_order):
+    table = pa.table({"a": [1, 2]})
+    path = tmp_path / "file.parquet"
+    pa.parquet.write_table(table, path)
+    ctx.register_parquet("t", path, file_sort_order=file_sort_order)
+    assert "t" in ctx.catalog().schema().names()
+
+
+@pytest.mark.parametrize("file_sort_order", [[["a"]], [[df_col("a")]]])
+def test_register_listing_table_file_sort_order(ctx, tmp_path, file_sort_order):
+    table = pa.table({"a": [1, 2]})
+    dir_path = tmp_path / "dir"
+    dir_path.mkdir()
+    pa.parquet.write_table(table, dir_path / "file.parquet")
+    ctx.register_listing_table(
+        "t", dir_path, schema=table.schema, file_sort_order=file_sort_order
+    )
+    assert "t" in ctx.catalog().schema().names()
+
+
+@pytest.mark.parametrize("file_sort_order", [[["a"]], [[df_col("a")]]])
+def test_read_parquet_file_sort_order(tmp_path, file_sort_order):
+    ctx = SessionContext()
+    table = pa.table({"a": [1, 2]})
+    path = tmp_path / "data.parquet"
+    pa.parquet.write_table(table, path)
+    df = ctx.read_parquet(path, file_sort_order=file_sort_order)
+    assert df.collect()[0].column(0).to_pylist() == [1, 2]
diff --git a/python/tests/test_expr.py b/python/tests/test_expr.py
new file mode 100644
index 000000000..9a287c1f7
--- /dev/null
+++ b/python/tests/test_expr.py
@@ -0,0 +1,1152 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import re
+from concurrent.futures import ThreadPoolExecutor
+from datetime import date, datetime, time, timezone
+from decimal import Decimal
+
+import arro3.core
+import nanoarrow
+import pyarrow as pa
+import pytest
+from datafusion import (
+    SessionContext,
+    col,
+    functions,
+    lit,
+    lit_with_metadata,
+    literal_with_metadata,
+)
+from datafusion.expr import (
+    EXPR_TYPE_ERROR,
+    Aggregate,
+    AggregateFunction,
+    BinaryExpr,
+    Column,
+    CopyTo,
+    CreateIndex,
+    DescribeTable,
+    DmlStatement,
+    DropCatalogSchema,
+    Filter,
+    Limit,
+    Literal,
+    Projection,
+    RecursiveQuery,
+    Sort,
+    TableScan,
+    TransactionEnd,
+    TransactionStart,
+    Values,
+    ensure_expr,
+    ensure_expr_list,
+)
+
+
+@pytest.fixture
+def test_ctx():
+    ctx = SessionContext()
+    ctx.register_csv("test", "testing/data/csv/aggregate_test_100.csv")
+    return ctx
+
+
+def test_projection(test_ctx):
+    df = test_ctx.sql("select c1, 123, c1 < 123 from test")
+    plan = df.logical_plan()
+
+    plan = plan.to_variant()
+    assert isinstance(plan, Projection)
+
+    expr = plan.projections()
+
+    col1 = expr[0].to_variant()
+    assert isinstance(col1, Column)
+    assert col1.name() == "c1"
+    assert col1.qualified_name() == "test.c1"
+
+    col2 = expr[1].to_variant()
+    assert isinstance(col2, Literal)
+    assert col2.data_type() == "Int64"
+    assert col2.value_i64() == 123
+
+    col3 = expr[2].to_variant()
+    assert isinstance(col3, BinaryExpr)
+    assert isinstance(col3.left().to_variant(), Column)
+    assert col3.op() == "<"
+    assert isinstance(col3.right().to_variant(), Literal)
+
+    plan = plan.input()[0].to_variant()
+    assert isinstance(plan, TableScan)
+
+
+def test_filter(test_ctx):
+    df = test_ctx.sql("select c1 from test WHERE c1 > 5")
+    plan = df.logical_plan()
+
+    plan = plan.to_variant()
+    assert isinstance(plan, Projection)
+
+    plan = plan.input()[0].to_variant()
+    assert isinstance(plan, Filter)
+
+
+def test_limit(test_ctx):
+    df = test_ctx.sql("select c1 from test LIMIT 10")
+    plan = df.logical_plan()
+
+    plan = plan.to_variant()
+    assert isinstance(plan, Limit)
+    assert "Skip: None" in str(plan)
+
+    df = test_ctx.sql("select c1 from test LIMIT 10 OFFSET 5")
+    plan = df.logical_plan()
+
+    plan = plan.to_variant()
+    assert isinstance(plan, Limit)
+    assert "Skip: Some(Literal(Int64(5), None))" in str(plan)
+
+
+def test_aggregate_query(test_ctx):
+    df = test_ctx.sql("select c1, count(*) from test group by c1")
+    plan = df.logical_plan()
+
+    projection = plan.to_variant()
+    assert isinstance(projection, Projection)
+
+    aggregate = projection.input()[0].to_variant()
+    assert isinstance(aggregate, Aggregate)
+
+    col1 = aggregate.group_by_exprs()[0].to_variant()
+    assert isinstance(col1, Column)
+    assert col1.name() == "c1"
+    assert col1.qualified_name() == "test.c1"
+
+    col2 = aggregate.aggregate_exprs()[0].to_variant()
+    assert isinstance(col2, AggregateFunction)
+
+
+def test_sort(test_ctx):
+    df = test_ctx.sql("select c1 from test order by c1")
+    plan = df.logical_plan()
+
+    plan = plan.to_variant()
+    assert isinstance(plan, Sort)
+
+
+def test_relational_expr(test_ctx):
+    ctx = SessionContext()
+
+    batch = pa.RecordBatch.from_arrays(
+        [
+            pa.array([1, 2, 3]),
+            pa.array(["alpha", "beta", "gamma"], type=pa.string_view()),
+        ],
+        names=["a", "b"],
+    )
+    df = ctx.create_dataframe([[batch]], name="batch_array")
+
+    assert df.filter(col("a") == 1).count() == 1
+    assert df.filter(col("a") != 1).count() == 2
+    assert df.filter(col("a") >= 1).count() == 3
+    assert df.filter(col("a") > 1).count() == 2
+    assert df.filter(col("a") <= 3).count() == 3
+    assert df.filter(col("a") < 3).count() == 2
+
+    assert df.filter(col("b") == "beta").count() == 1
+    assert df.filter(col("b") != "beta").count() == 2
+
+    assert df.filter(col("a") == "beta").count() == 0
+
+
+def test_expr_to_variant():
+    # Taken from https://github.com/apache/datafusion-python/issues/781
+    from datafusion import SessionContext
+    from datafusion.expr import Filter
+
+    def traverse_logical_plan(plan):
+        cur_node = plan.to_variant()
+        if isinstance(cur_node, Filter):
+            return cur_node.predicate().to_variant()
+        if hasattr(plan, "inputs"):
+            for input_plan in plan.inputs():
+                res = traverse_logical_plan(input_plan)
+                if res is not None:
+                    return res
+        return None
+
+    ctx = SessionContext()
+    data = {"id": [1, 2, 3], "name": ["Alice", "Bob", "Charlie"]}
+    ctx.from_pydict(data, name="table1")
+    query = "SELECT * FROM table1 t1 WHERE t1.name IN ('dfa', 'ad', 'dfre', 'vsa')"
+    logical_plan = ctx.sql(query).optimized_logical_plan()
+    variant = traverse_logical_plan(logical_plan)
+    assert variant is not None
+    assert variant.expr().to_variant().qualified_name() == "table1.name"
+    assert (
+        str(variant.list())
+        == '[Expr(Utf8("dfa")), Expr(Utf8("ad")), Expr(Utf8("dfre")), Expr(Utf8("vsa"))]'  # noqa: E501
+    )
+    assert not variant.negated()
+
+
+def test_case_builder_error_preserves_builder_state():
+    case_builder = functions.when(lit(True), lit(1))
+
+    with pytest.raises(Exception) as exc_info:
+        _ = case_builder.otherwise(lit("bad"))
+
+    err_msg = str(exc_info.value)
+    assert "multiple data types" in err_msg
+    assert "CaseBuilder has already been consumed" not in err_msg
+
+    _ = case_builder.end()
+
+    err_msg = str(exc_info.value)
+    assert "multiple data types" in err_msg
+    assert "CaseBuilder has already been consumed" not in err_msg
+
+
+def test_case_builder_success_preserves_builder_state():
+    ctx = SessionContext()
+    df = ctx.from_pydict({"flag": [False]}, name="tbl")
+
+    case_builder = functions.when(col("flag"), lit("true"))
+
+    expr_default_one = case_builder.otherwise(lit("default-1")).alias("result")
+    result_one = df.select(expr_default_one).collect()
+    assert result_one[0].column(0).to_pylist() == ["default-1"]
+
+    expr_default_two = case_builder.otherwise(lit("default-2")).alias("result")
+    result_two = df.select(expr_default_two).collect()
+    assert result_two[0].column(0).to_pylist() == ["default-2"]
+
+    expr_end_one = case_builder.end().alias("result")
+    end_one = df.select(expr_end_one).collect()
+    assert end_one[0].column(0).to_pylist() == [None]
+
+
+def test_case_builder_when_handles_are_independent():
+    ctx = SessionContext()
+    df = ctx.from_pydict(
+        {
+            "flag": [True, False, False, False],
+            "value": [1, 15, 25, 5],
+        },
+        name="tbl",
+    )
+
+    base_builder = functions.when(col("flag"), lit("flag-true"))
+
+    first_builder = base_builder.when(col("value") > lit(10), lit("gt10"))
+    second_builder = base_builder.when(col("value") > lit(20), lit("gt20"))
+
+    first_builder = first_builder.when(lit(True), lit("final-one"))
+
+    expr_first = first_builder.otherwise(lit("fallback-one")).alias("first")
+    expr_second = second_builder.otherwise(lit("fallback-two")).alias("second")
+
+    result = df.select(expr_first, expr_second).collect()[0]
+
+    assert result.column(0).to_pylist() == [
+        "flag-true",
+        "gt10",
+        "gt10",
+        "final-one",
+    ]
+    assert result.column(1).to_pylist() == [
+        "flag-true",
+        "fallback-two",
+        "gt20",
+        "fallback-two",
+    ]
+
+
+def test_case_builder_when_thread_safe():
+    case_builder = functions.when(lit(True), lit(1))
+
+    def build_expr(value: int) -> bool:
+        builder = case_builder.when(lit(True), lit(value))
+        builder.otherwise(lit(value))
+        return True
+
+    with ThreadPoolExecutor(max_workers=8) as executor:
+        futures = [executor.submit(build_expr, idx) for idx in range(16)]
+        results = [future.result() for future in futures]
+
+    assert all(results)
+
+    # Ensure the shared builder remains usable after concurrent `when` calls.
+    follow_up_builder = case_builder.when(lit(True), lit(42))
+    assert isinstance(follow_up_builder, type(case_builder))
+    follow_up_builder.otherwise(lit(7))
+
+
+def test_expr_getitem() -> None:
+    ctx = SessionContext()
+    data = {
+        "array_values": [[1, 2, 3], [4, 5], [6], []],
+        "struct_values": [
+            {"name": "Alice", "age": 15},
+            {"name": "Bob", "age": 14},
+            {"name": "Charlie", "age": 13},
+            {"name": None, "age": 12},
+        ],
+    }
+    df = ctx.from_pydict(data, name="table1")
+
+    names = df.select(col("struct_values")["name"].alias("name")).collect()
+    names = [r.as_py() for rs in names for r in rs["name"]]
+
+    array_values = df.select(col("array_values")[1].alias("value")).collect()
+    array_values = [r.as_py() for rs in array_values for r in rs["value"]]
+
+    assert names == ["Alice", "Bob", "Charlie", None]
+    assert array_values == [2, 5, None, None]
+
+
+def test_display_name_deprecation():
+    import warnings
+
+    expr = col("foo")
+    with warnings.catch_warnings(record=True) as w:
+        # Cause all warnings to always be triggered
+        warnings.simplefilter("always")
+
+        # should trigger warning
+        name = expr.display_name()
+
+        # Verify some things
+        assert len(w) == 1
+        assert issubclass(w[-1].category, DeprecationWarning)
+        assert "deprecated" in str(w[-1].message)
+
+    # returns appropriate result
+    assert name == expr.schema_name()
+    assert name == "foo"
+
+
+@pytest.fixture
+def df():
+    ctx = SessionContext()
+
+    # create a RecordBatch and a new DataFrame from it
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, None]), pa.array([4, None, 6]), pa.array([None, None, 8])],
+        names=["a", "b", "c"],
+    )
+
+    return ctx.from_arrow(batch)
+
+
+def test_fill_null(df):
+    df = df.select(
+        col("a").fill_null(100).alias("a"),
+        col("b").fill_null(25).alias("b"),
+        col("c").fill_null(1234).alias("c"),
+    )
+    df.show()
+    result = df.collect()[0]
+
+    assert result.column(0) == pa.array([1, 2, 100])
+    assert result.column(1) == pa.array([4, 25, 6])
+    assert result.column(2) == pa.array([1234, 1234, 8])
+
+
+def test_copy_to():
+    ctx = SessionContext()
+    ctx.sql("CREATE TABLE foo (a int, b int)").collect()
+    df = ctx.sql("COPY foo TO bar STORED AS CSV")
+    plan = df.logical_plan()
+    plan = plan.to_variant()
+    assert isinstance(plan, CopyTo)
+
+
+def test_create_index():
+    ctx = SessionContext()
+    ctx.sql("CREATE TABLE foo (a int, b int)").collect()
+    plan = ctx.sql("create index idx on foo (a)").logical_plan()
+    plan = plan.to_variant()
+    assert isinstance(plan, CreateIndex)
+
+
+def test_describe_table():
+    ctx = SessionContext()
+    ctx.sql("CREATE TABLE foo (a int, b int)").collect()
+    plan = ctx.sql("describe foo").logical_plan()
+    plan = plan.to_variant()
+    assert isinstance(plan, DescribeTable)
+
+
+def test_dml_statement():
+    ctx = SessionContext()
+    ctx.sql("CREATE TABLE foo (a int, b int)").collect()
+    plan = ctx.sql("insert into foo values (1, 2)").logical_plan()
+    plan = plan.to_variant()
+    assert isinstance(plan, DmlStatement)
+
+
+def drop_catalog_schema():
+    ctx = SessionContext()
+    plan = ctx.sql("drop schema cat").logical_plan()
+    plan = plan.to_variant()
+    assert isinstance(plan, DropCatalogSchema)
+
+
+def test_recursive_query():
+    ctx = SessionContext()
+    plan = ctx.sql(
+        """
+        WITH RECURSIVE cte AS (
+        SELECT 1 as n
+        UNION ALL
+        SELECT n + 1 FROM cte WHERE n < 5
+        )
+        SELECT * FROM cte;
+        """
+    ).logical_plan()
+    plan = plan.inputs()[0].inputs()[0].to_variant()
+    assert isinstance(plan, RecursiveQuery)
+
+
+def test_values():
+    ctx = SessionContext()
+    plan = ctx.sql("values (1, 'foo'), (2, 'bar')").logical_plan()
+    plan = plan.to_variant()
+    assert isinstance(plan, Values)
+
+
+def test_transaction_start():
+    ctx = SessionContext()
+    plan = ctx.sql("START TRANSACTION").logical_plan()
+    plan = plan.to_variant()
+    assert isinstance(plan, TransactionStart)
+
+
+def test_transaction_end():
+    ctx = SessionContext()
+    plan = ctx.sql("COMMIT").logical_plan()
+    plan = plan.to_variant()
+    assert isinstance(plan, TransactionEnd)
+
+
+def test_col_getattr():
+    ctx = SessionContext()
+    data = {
+        "array_values": [[1, 2, 3], [4, 5], [6], []],
+        "struct_values": [
+            {"name": "Alice", "age": 15},
+            {"name": "Bob", "age": 14},
+            {"name": "Charlie", "age": 13},
+            {"name": None, "age": 12},
+        ],
+    }
+    df = ctx.from_pydict(data, name="table1")
+
+    names = df.select(col.struct_values["name"].alias("name")).collect()
+    names = [r.as_py() for rs in names for r in rs["name"]]
+
+    array_values = df.select(col.array_values[1].alias("value")).collect()
+    array_values = [r.as_py() for rs in array_values for r in rs["value"]]
+
+    assert names == ["Alice", "Bob", "Charlie", None]
+    assert array_values == [2, 5, None, None]
+
+
+def test_alias_with_metadata(df):
+    df = df.select(col("a").alias("b", {"key": "value"}))
+    assert df.schema().field("b").metadata == {b"key": b"value"}
+
+
+# These unit tests are to ensure the expression functions do not regress
+# For the math functions we will use `functions.round` so we can more
+# easily test for equivalence and not worry about floating point precision
+@pytest.mark.parametrize(
+    ("function", "expected_result"),
+    [
+        # Math Functions
+        pytest.param(
+            functions.round(col("a").asin(), lit(4)),
+            pa.array([-0.8481, 0.5236, 0.0, None], type=pa.float64()),
+            id="asin",
+        ),
+        pytest.param(
+            functions.round(col("a").sin(), lit(4)),
+            pa.array([-0.6816, 0.4794, 0.0, None], type=pa.float64()),
+            id="sin",
+        ),
+        pytest.param(
+            # Since log10 of negative returns NaN and you can't test NaN for
+            # equivalence, also do an abs() here.
+            functions.round(col("a").abs().log10(), lit(4)),
+            pa.array([-0.1249, -0.301, -float("inf"), None], type=pa.float64()),
+            id="log10",
+        ),
+        pytest.param(
+            col("a").iszero(),
+            pa.array([False, False, True, None], type=pa.bool_()),
+            id="iszero",
+        ),
+        pytest.param(
+            functions.round(col("a").acos(), lit(4)),
+            pa.array([2.4189, 1.0472, 1.5708, None], type=pa.float64()),
+            id="acos",
+        ),
+        pytest.param(
+            col("e").isnan(),
+            pa.array([False, True, False, None], type=pa.bool_()),
+            id="isnan",
+        ),
+        pytest.param(
+            functions.round(col("a").degrees(), lit(4)),
+            pa.array([-42.9718, 28.6479, 0.0, None], type=pa.float64()),
+            id="degrees",
+        ),
+        pytest.param(
+            functions.round(col("a").asinh(), lit(4)),
+            pa.array([-0.6931, 0.4812, 0.0, None], type=pa.float64()),
+            id="asinh",
+        ),
+        pytest.param(
+            col("a").abs(),
+            pa.array([0.75, 0.5, 0.0, None], type=pa.float64()),
+            id="abs",
+        ),
+        pytest.param(
+            functions.round(col("a").exp(), lit(4)),
+            pa.array([0.4724, 1.6487, 1.0, None], type=pa.float64()),
+            id="exp",
+        ),
+        pytest.param(
+            functions.round(col("a").cosh(), lit(4)),
+            pa.array([1.2947, 1.1276, 1.0, None], type=pa.float64()),
+            id="cosh",
+        ),
+        pytest.param(
+            functions.round(col("a").radians(), lit(4)),
+            pa.array([-0.0131, 0.0087, 0.0, None], type=pa.float64()),
+            id="radians",
+        ),
+        pytest.param(
+            functions.round(col("a").abs().sqrt(), lit(4)),
+            pa.array([0.866, 0.7071, 0.0, None], type=pa.float64()),
+            id="sqrt",
+        ),
+        pytest.param(
+            functions.round(col("a").tanh(), lit(4)),
+            pa.array([-0.6351, 0.4621, 0.0, None], type=pa.float64()),
+            id="tanh",
+        ),
+        pytest.param(
+            functions.round(col("a").atan(), lit(4)),
+            pa.array([-0.6435, 0.4636, 0.0, None], type=pa.float64()),
+            id="atan",
+        ),
+        pytest.param(
+            functions.round(col("a").atanh(), lit(4)),
+            pa.array([-0.973, 0.5493, 0.0, None], type=pa.float64()),
+            id="atanh",
+        ),
+        pytest.param(
+            # large numbers cause an integer overflow so divid to make smaller
+            (col("b") / lit(4)).factorial(),
+            pa.array([1, 3628800, 1, None], type=pa.int64()),
+            id="factorial",
+        ),
+        pytest.param(
+            # Valid values of acosh must be >= 1.0
+            functions.round((col("a").abs() + lit(1.0)).acosh(), lit(4)),
+            pa.array([1.1588, 0.9624, 0.0, None], type=pa.float64()),
+            id="acosh",
+        ),
+        pytest.param(
+            col("a").floor(),
+            pa.array([-1.0, 0.0, 0.0, None], type=pa.float64()),
+            id="floor",
+        ),
+        pytest.param(
+            col("a").ceil(),
+            pa.array([-0.0, 1.0, 0.0, None], type=pa.float64()),
+            id="ceil",
+        ),
+        pytest.param(
+            functions.round(col("a").abs().ln(), lit(4)),
+            pa.array([-0.2877, -0.6931, float("-inf"), None], type=pa.float64()),
+            id="ln",
+        ),
+        pytest.param(
+            functions.round(col("a").tan(), lit(4)),
+            pa.array([-0.9316, 0.5463, 0.0, None], type=pa.float64()),
+            id="tan",
+        ),
+        pytest.param(
+            functions.round(col("a").cbrt(), lit(4)),
+            pa.array([-0.9086, 0.7937, 0.0, None], type=pa.float64()),
+            id="cbrt",
+        ),
+        pytest.param(
+            functions.round(col("a").cos(), lit(4)),
+            pa.array([0.7317, 0.8776, 1.0, None], type=pa.float64()),
+            id="cos",
+        ),
+        pytest.param(
+            functions.round(col("a").sinh(), lit(4)),
+            pa.array([-0.8223, 0.5211, 0.0, None], type=pa.float64()),
+            id="sinh",
+        ),
+        pytest.param(
+            col("a").signum(),
+            pa.array([-1.0, 1.0, 0.0, None], type=pa.float64()),
+            id="signum",
+        ),
+        pytest.param(
+            functions.round(col("a").abs().log2(), lit(4)),
+            pa.array([-0.415, -1.0, float("-inf"), None], type=pa.float64()),
+            id="log2",
+        ),
+        pytest.param(
+            functions.round(col("a").cot(), lit(4)),
+            pa.array([-1.0734, 1.8305, float("inf"), None], type=pa.float64()),
+            id="cot",
+        ),
+        #
+        # String Functions
+        #
+        pytest.param(
+            col("c").reverse(),
+            pa.array(["olleH", " dlrow ", "!", None], type=pa.string()),
+            id="reverse",
+        ),
+        pytest.param(
+            col("c").bit_length(),
+            pa.array([40, 56, 8, None], type=pa.int32()),
+            id="bit_length",
+        ),
+        pytest.param(
+            col("b").to_hex(),
+            pa.array(["ffffffffffffffe2", "2a", "0", None], type=pa.string()),
+            id="to_hex",
+        ),
+        pytest.param(
+            col("c").length(),
+            pa.array([5, 7, 1, None], type=pa.int32()),
+            id="length",
+        ),
+        pytest.param(
+            col("c").lower(),
+            pa.array(["hello", " world ", "!", None], type=pa.string()),
+            id="lower",
+        ),
+        pytest.param(
+            col("c").ascii(),
+            pa.array([72, 32, 33, None], type=pa.int32()),
+            id="ascii",
+        ),
+        pytest.param(
+            col("c").sha512(),
+            pa.array(
+                [
+                    bytes.fromhex(
+                        "3615F80C9D293ED7402687F94B22D58E529B8CC7916F8FAC7FDDF7FBD5AF4CF777D3D795A7A00A16BF7E7F3FB9561EE9BAAE480DA9FE7A18769E71886B03F315"
+                    ),
+                    bytes.fromhex(
+                        "A6758FDA3C2F0B554084E18308EA99B94B54EEE8FDA72697CEA7844E524CC2F2F2EE4CC8BAC87D2E3E7222959FE3D0CA1A841761FDC0D1780F6FE9E39E369500"
+                    ),
+                    bytes.fromhex(
+                        "3831A6A6155E509DEE59A7F451EB35324D8F8F2DF6E3708894740F98FDEE23889F4DE5ADB0C5010DFB555CDA77C8AB5DC902094C52DE3278F35A75EBC25F093A"
+                    ),
+                    None,
+                ],
+                type=pa.binary(),
+            ),
+            id="sha512",
+        ),
+        pytest.param(
+            col("c").sha384(),
+            pa.array(
+                [
+                    bytes.fromhex(
+                        "3519FE5AD2C596EFE3E276A6F351B8FC0B03DB861782490D45F7598EBD0AB5FD5520ED102F38C4A5EC834E98668035FC"
+                    ),
+                    bytes.fromhex(
+                        "A6A38A9AE2CFD0D67F49989AD584632BF7D7A07DAD2277E92326A6A0B37F884A871D6173FB342CFE258E375258ACAAEC"
+                    ),
+                    bytes.fromhex(
+                        "1D0EC8C84EE9521E21F06774DE232367B64DE628474CB5B2E372B699A1F55AE335CC37193EF823E33324DFD9A70738A6"
+                    ),
+                    None,
+                ],
+                type=pa.binary(),
+            ),
+            id="sha384",
+        ),
+        pytest.param(
+            col("c").sha256(),
+            pa.array(
+                [
+                    bytes.fromhex(
+                        "185F8DB32271FE25F561A6FC938B2E264306EC304EDA518007D1764826381969"
+                    ),
+                    bytes.fromhex(
+                        "DE2EF0D77D456EC1CDE2C52F75996F6636A64079297213D548D875A488B03A75"
+                    ),
+                    bytes.fromhex(
+                        "BB7208BC9B5D7C04F1236A82A0093A5E33F40423D5BA8D4266F7092C3BA43B62"
+                    ),
+                    None,
+                ],
+                type=pa.binary(),
+            ),
+            id="sha256",
+        ),
+        pytest.param(
+            col("c").sha224(),
+            pa.array(
+                [
+                    bytes.fromhex(
+                        "4149DA18AA8BFC2B1E382C6C26556D01A92C261B6436DAD5E3BE3FCC"
+                    ),
+                    bytes.fromhex(
+                        "AD6DF6D9ECDDF50AF2A72D5E3144BA813EE954537572C0E8AB3066BE"
+                    ),
+                    bytes.fromhex(
+                        "6641A7E8278BCD49E476E7ACAE158F4105B2952D22AEB2E0B9A231A0"
+                    ),
+                    None,
+                ],
+                type=pa.binary(),
+            ),
+            id="sha224",
+        ),
+        pytest.param(
+            col("c").btrim(),
+            pa.array(["Hello", "world", "!", None], type=pa.string_view()),
+            id="btrim",
+        ),
+        pytest.param(
+            col("c").trim(),
+            pa.array(["Hello", "world", "!", None], type=pa.string_view()),
+            id="trim",
+        ),
+        pytest.param(
+            col("c").md5(),
+            pa.array(
+                [
+                    "8b1a9953c4611296a827abf8c47804d7",
+                    "de802497c24568d9a85d4eb8c2b6e8fe",
+                    "9033e0e305f247c0c3c80d0c7848c8b3",
+                    None,
+                ],
+                type=pa.string_view(),
+            ),
+            id="md5",
+        ),
+        pytest.param(
+            col("c").octet_length(),
+            pa.array([5, 7, 1, None], type=pa.int32()),
+            id="octet_length",
+        ),
+        pytest.param(
+            col("c").character_length(),
+            pa.array([5, 7, 1, None], type=pa.int32()),
+            id="character_length",
+        ),
+        pytest.param(
+            col("c").char_length(),
+            pa.array([5, 7, 1, None], type=pa.int32()),
+            id="char_length",
+        ),
+        pytest.param(
+            col("c").rtrim(),
+            pa.array(["Hello", " world", "!", None], type=pa.string_view()),
+            id="rtrim",
+        ),
+        pytest.param(
+            col("c").ltrim(),
+            pa.array(["Hello", "world ", "!", None], type=pa.string_view()),
+            id="ltrim",
+        ),
+        pytest.param(
+            col("c").upper(),
+            pa.array(["HELLO", " WORLD ", "!", None], type=pa.string()),
+            id="upper",
+        ),
+        pytest.param(
+            lit(65).chr(),
+            pa.array(["A", "A", "A", "A"], type=pa.string()),
+            id="chr",
+        ),
+        #
+        # Time Functions
+        #
+        pytest.param(
+            col("b").from_unixtime(),
+            pa.array(
+                [
+                    datetime(1969, 12, 31, 23, 59, 30, tzinfo=timezone.utc),
+                    datetime(1970, 1, 1, 0, 0, 42, tzinfo=timezone.utc),
+                    datetime(1970, 1, 1, 0, 0, 0, tzinfo=timezone.utc),
+                    None,
+                ],
+                type=pa.timestamp("s"),
+            ),
+            id="from_unixtime",
+        ),
+        pytest.param(
+            col("c").initcap(),
+            pa.array(["Hello", " World ", "!", None], type=pa.string_view()),
+            id="initcap",
+        ),
+        #
+        # Array Functions
+        #
+        pytest.param(
+            col("d").array_pop_back(),
+            pa.array([[-1, 1], [5, 10, 15], [], None], type=pa.list_(pa.int64())),
+            id="array_pop_back",
+        ),
+        pytest.param(
+            col("d").array_pop_front(),
+            pa.array([[1, 0], [10, 15, 20], [], None], type=pa.list_(pa.int64())),
+            id="array_pop_front",
+        ),
+        pytest.param(
+            col("d").array_length(),
+            pa.array([3, 4, 0, None], type=pa.uint64()),
+            id="array_length",
+        ),
+        pytest.param(
+            col("d").list_length(),
+            pa.array([3, 4, 0, None], type=pa.uint64()),
+            id="list_length",
+        ),
+        pytest.param(
+            col("d").array_ndims(),
+            pa.array([1, 1, 1, None], type=pa.uint64()),
+            id="array_ndims",
+        ),
+        pytest.param(
+            col("d").list_ndims(),
+            pa.array([1, 1, 1, None], type=pa.uint64()),
+            id="list_ndims",
+        ),
+        pytest.param(
+            col("d").array_dims(),
+            pa.array([[3], [4], None, None], type=pa.list_(pa.uint64())),
+            id="array_dims",
+        ),
+        pytest.param(
+            col("d").array_empty(),
+            pa.array([False, False, True, None], type=pa.bool_()),
+            id="array_empty",
+        ),
+        pytest.param(
+            col("d").list_distinct(),
+            pa.array(
+                [[-1, 1, 0], [5, 10, 15, 20], [], None], type=pa.list_(pa.int64())
+            ),
+            id="list_distinct",
+        ),
+        pytest.param(
+            col("d").array_distinct(),
+            pa.array(
+                [[-1, 1, 0], [5, 10, 15, 20], [], None], type=pa.list_(pa.int64())
+            ),
+            id="array_distinct",
+        ),
+        pytest.param(
+            col("d").cardinality(),
+            pa.array([3, 4, 0, None], type=pa.uint64()),
+            id="cardinality",
+        ),
+        pytest.param(
+            col("f").flatten(),
+            pa.array(
+                [[-1, 1, 0, 4, 4], [5, 10, 15, 20, 3], [], []],
+                type=pa.list_(pa.int64()),
+            ),
+            id="flatten",
+        ),
+        pytest.param(
+            col("d").list_dims(),
+            pa.array([[3], [4], None, None], type=pa.list_(pa.uint64())),
+            id="list_dims",
+        ),
+        pytest.param(
+            col("d").empty(),
+            pa.array([False, False, True, None], type=pa.bool_()),
+            id="empty",
+        ),
+        #
+        # Other Tests
+        #
+        pytest.param(
+            col("d").arrow_typeof(),
+            pa.array(
+                [
+                    "List(Int64)",
+                    "List(Int64)",
+                    "List(Int64)",
+                    "List(Int64)",
+                ],
+                type=pa.string(),
+            ),
+            id="arrow_typeof",
+        ),
+    ],
+)
+def test_expr_functions(ctx, function, expected_result):
+    batch = pa.RecordBatch.from_arrays(
+        [
+            pa.array([-0.75, 0.5, 0.0, None], type=pa.float64()),
+            pa.array([-30, 42, 0, None], type=pa.int64()),
+            pa.array(["Hello", " world ", "!", None], type=pa.string_view()),
+            pa.array(
+                [[-1, 1, 0], [5, 10, 15, 20], [], None], type=pa.list_(pa.int64())
+            ),
+            pa.array([-0.75, float("nan"), 0.0, None], type=pa.float64()),
+            pa.array(
+                [[[-1, 1, 0], [4, 4]], [[5, 10, 15, 20], [3]], [[]], [None]],
+                type=pa.list_(pa.list_(pa.int64())),
+            ),
+        ],
+        names=["a", "b", "c", "d", "e", "f"],
+    )
+    df = ctx.create_dataframe([[batch]]).select(function)
+    result = df.collect()
+
+    assert len(result) == 1
+    assert result[0].column(0).equals(expected_result)
+
+
+def test_literal_metadata(ctx):
+    result = (
+        ctx.from_pydict({"a": [1]})
+        .select(
+            lit(1).alias("no_metadata"),
+            lit_with_metadata(2, {"key1": "value1"}).alias("lit_with_metadata_fn"),
+            literal_with_metadata(3, {"key2": "value2"}).alias(
+                "literal_with_metadata_fn"
+            ),
+        )
+        .collect()
+    )
+
+    expected_schema = pa.schema(
+        [
+            pa.field("no_metadata", pa.int64(), nullable=False),
+            pa.field(
+                "lit_with_metadata_fn",
+                pa.int64(),
+                nullable=False,
+                metadata={"key1": "value1"},
+            ),
+            pa.field(
+                "literal_with_metadata_fn",
+                pa.int64(),
+                nullable=False,
+                metadata={"key2": "value2"},
+            ),
+        ]
+    )
+
+    expected = pa.RecordBatch.from_pydict(
+        {
+            "no_metadata": pa.array([1]),
+            "lit_with_metadata_fn": pa.array([2]),
+            "literal_with_metadata_fn": pa.array([3]),
+        },
+        schema=expected_schema,
+    )
+
+    assert result[0] == expected
+
+    # Testing result[0].schema == expected_schema does not check each key/value pair
+    # so we want to explicitly test these
+    for expected_field in expected_schema:
+        actual_field = result[0].schema.field(expected_field.name)
+        assert expected_field.metadata == actual_field.metadata
+
+
+def test_scalar_conversion() -> None:
+    class WrappedPyArrow:
+        """Wrapper class for testing __arrow_c_array__."""
+
+        def __init__(self, val: pa.Array) -> None:
+            self.val = val
+
+        def __arrow_c_array__(self, requested_schema=None):
+            return self.val.__arrow_c_array__(requested_schema=requested_schema)
+
+    expected_value = lit(1)
+    assert str(expected_value) == "Expr(Int64(1))"
+
+    # Test pyarrow imports
+    assert expected_value == lit(pa.scalar(1))
+    assert expected_value == lit(pa.scalar(1, type=pa.int32()))
+
+    # Test nanoarrow
+    na_scalar = nanoarrow.Array([1], nanoarrow.int32())[0]
+    assert expected_value == lit(na_scalar)
+
+    # Test pyo3
+    arro3_scalar = arro3.core.Scalar(1, type=arro3.core.DataType.int32())
+    assert expected_value == lit(arro3_scalar)
+
+    generic_scalar = WrappedPyArrow(pa.array([1]))
+    assert expected_value == lit(generic_scalar)
+
+    expected_value = lit([1, 2, 3])
+    assert str(expected_value) == "Expr(List([1, 2, 3]))"
+
+    assert expected_value == lit(pa.scalar([1, 2, 3]))
+
+    na_array = nanoarrow.Array([1, 2, 3], nanoarrow.int32())
+    assert expected_value == lit(na_array)
+
+    arro3_array = arro3.core.Array([1, 2, 3], type=arro3.core.DataType.int32())
+    assert expected_value == lit(arro3_array)
+
+    generic_array = WrappedPyArrow(pa.array([1, 2, 3]))
+    assert expected_value == lit(generic_array)
+
+
+def test_ensure_expr():
+    e = col("a")
+    assert ensure_expr(e) is e.expr
+    with pytest.raises(TypeError, match=re.escape(EXPR_TYPE_ERROR)):
+        ensure_expr("a")
+
+
+def test_ensure_expr_list_string():
+    with pytest.raises(TypeError, match=re.escape(EXPR_TYPE_ERROR)):
+        ensure_expr_list("a")
+
+
+def test_ensure_expr_list_bytes():
+    with pytest.raises(TypeError, match=re.escape(EXPR_TYPE_ERROR)):
+        ensure_expr_list(b"a")
+
+
+def test_ensure_expr_list_bytearray():
+    with pytest.raises(TypeError, match=re.escape(EXPR_TYPE_ERROR)):
+        ensure_expr_list(bytearray(b"a"))
+
+
+@pytest.mark.parametrize(
+    "value",
+    [
+        # Boolean
+        pa.scalar(True, type=pa.bool_()),  # noqa: FBT003
+        pa.scalar(False, type=pa.bool_()),  # noqa: FBT003
+        # Integers - signed
+        pa.scalar(127, type=pa.int8()),
+        pa.scalar(-128, type=pa.int8()),
+        pa.scalar(32767, type=pa.int16()),
+        pa.scalar(-32768, type=pa.int16()),
+        pa.scalar(2147483647, type=pa.int32()),
+        pa.scalar(-2147483648, type=pa.int32()),
+        pa.scalar(9223372036854775807, type=pa.int64()),
+        pa.scalar(-9223372036854775808, type=pa.int64()),
+        # Integers - unsigned
+        pa.scalar(255, type=pa.uint8()),
+        pa.scalar(65535, type=pa.uint16()),
+        pa.scalar(4294967295, type=pa.uint32()),
+        pa.scalar(18446744073709551615, type=pa.uint64()),
+        # Floating point
+        pa.scalar(3.14, type=pa.float32()),
+        pa.scalar(3.141592653589793, type=pa.float64()),
+        pa.scalar(float("inf"), type=pa.float64()),
+        pa.scalar(float("-inf"), type=pa.float64()),
+        # Decimal
+        pa.scalar(Decimal("123.45"), type=pa.decimal128(10, 2)),
+        pa.scalar(Decimal("-999999.999"), type=pa.decimal128(12, 3)),
+        pa.scalar(Decimal("0.00001"), type=pa.decimal128(10, 5)),
+        pa.scalar(Decimal("123.45"), type=pa.decimal256(20, 2)),
+        # Strings
+        pa.scalar("hello world", type=pa.string()),
+        pa.scalar("", type=pa.string()),
+        pa.scalar("unicode: 日本語 🎉", type=pa.string()),
+        pa.scalar("hello", type=pa.large_string()),
+        # Binary
+        pa.scalar(b"binary data", type=pa.binary()),
+        pa.scalar(b"", type=pa.binary()),
+        pa.scalar(b"\x00\x01\x02\xff", type=pa.binary()),
+        pa.scalar(b"large binary", type=pa.large_binary()),
+        pa.scalar(b"fixed!", type=pa.binary(6)),  # fixed size binary
+        # Date
+        pa.scalar(date(2023, 8, 18), type=pa.date32()),
+        pa.scalar(date(1970, 1, 1), type=pa.date32()),
+        pa.scalar(date(2023, 8, 18), type=pa.date64()),
+        # Time
+        pa.scalar(time(12, 30, 45), type=pa.time32("s")),
+        pa.scalar(time(12, 30, 45, 123000), type=pa.time32("ms")),
+        pa.scalar(time(12, 30, 45, 123456), type=pa.time64("us")),
+        pa.scalar(
+            12 * 3600 * 10**9 + 30 * 60 * 10**9, type=pa.time64("ns")
+        ),  # raw nanos
+        # Timestamp - various resolutions
+        pa.scalar(1692335046, type=pa.timestamp("s")),
+        pa.scalar(1692335046618, type=pa.timestamp("ms")),
+        pa.scalar(1692335046618897, type=pa.timestamp("us")),
+        pa.scalar(1692335046618897499, type=pa.timestamp("ns")),
+        # Timestamp with timezone
+        pa.scalar(1692335046, type=pa.timestamp("s", tz="UTC")),
+        pa.scalar(1692335046618897, type=pa.timestamp("us", tz="America/New_York")),
+        pa.scalar(1692335046618897499, type=pa.timestamp("ns", tz="Europe/London")),
+        # Duration
+        pa.scalar(3600, type=pa.duration("s")),
+        pa.scalar(3600000, type=pa.duration("ms")),
+        pa.scalar(3600000000, type=pa.duration("us")),
+        pa.scalar(3600000000000, type=pa.duration("ns")),
+        # Interval
+        pa.scalar((1, 15, 3600000000000), type=pa.month_day_nano_interval()),
+        pa.scalar((0, 0, 0), type=pa.month_day_nano_interval()),
+        pa.scalar((12, 30, 0), type=pa.month_day_nano_interval()),
+        # Null
+        pa.scalar(None, type=pa.null()),
+        pa.scalar(None, type=pa.int64()),
+        pa.scalar(None, type=pa.string()),
+        # List types
+        pa.scalar([1, 2, 3], type=pa.list_(pa.int64())),
+        pa.scalar([], type=pa.list_(pa.int64())),
+        pa.scalar(["a", "b", "c"], type=pa.list_(pa.string())),
+        pa.scalar([[1, 2], [3, 4]], type=pa.list_(pa.list_(pa.int64()))),
+        pa.scalar([1, 2, 3], type=pa.large_list(pa.int64())),
+        # Fixed size list
+        pa.scalar([1, 2, 3], type=pa.list_(pa.int64(), 3)),
+        # Struct
+        pa.scalar(
+            {"x": 1, "y": 2}, type=pa.struct([("x", pa.int64()), ("y", pa.int64())])
+        ),
+        pa.scalar(
+            {"name": "Alice", "age": 30},
+            type=pa.struct([("name", pa.string()), ("age", pa.int32())]),
+        ),
+        pa.scalar(
+            {"nested": {"a": 1}},
+            type=pa.struct([("nested", pa.struct([("a", pa.int64())]))]),
+        ),
+        # Map
+        pa.scalar([("key1", 1), ("key2", 2)], type=pa.map_(pa.string(), pa.int64())),
+    ],
+    ids=lambda v: f"{v.type}",
+)
+def test_round_trip_pyscalar_value(ctx: SessionContext, value: pa.Scalar):
+    df = ctx.sql("select 1 as a")
+    df = df.select(lit(value))
+    assert pa.table(df)[0][0] == value
diff --git a/python/tests/test_functions.py b/python/tests/test_functions.py
new file mode 100644
index 000000000..37d349c58
--- /dev/null
+++ b/python/tests/test_functions.py
@@ -0,0 +1,1437 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+import math
+from datetime import date, datetime, time, timezone
+
+import numpy as np
+import pyarrow as pa
+import pytest
+from datafusion import SessionContext, column, literal, string_literal
+from datafusion import functions as f
+
+np.seterr(invalid="ignore")
+
+DEFAULT_TZ = timezone.utc
+
+
+@pytest.fixture
+def df():
+    ctx = SessionContext()
+    # create a RecordBatch and a new DataFrame from it
+    batch = pa.RecordBatch.from_arrays(
+        [
+            pa.array(["Hello", "World", "!"], type=pa.string_view()),
+            pa.array([4, 5, 6]),
+            pa.array(["hello ", " world ", " !"], type=pa.string_view()),
+            pa.array(
+                [
+                    datetime(2022, 12, 31, tzinfo=DEFAULT_TZ),
+                    datetime(2027, 6, 26, tzinfo=DEFAULT_TZ),
+                    datetime(2020, 7, 2, tzinfo=DEFAULT_TZ),
+                ]
+            ),
+            pa.array([False, True, True]),
+        ],
+        names=["a", "b", "c", "d", "e"],
+    )
+    return ctx.create_dataframe([[batch]])
+
+
+def test_named_struct(df):
+    df = df.with_column(
+        "d",
+        f.named_struct(
+            [
+                ("a", column("a")),
+                ("b", column("b")),
+                ("c", column("c")),
+            ]
+        ),
+    )
+
+    expected = """DataFrame()
++-------+---+---------+------------------------------+-------+
+| a     | b | c       | d                            | e     |
++-------+---+---------+------------------------------+-------+
+| Hello | 4 | hello   | {a: Hello, b: 4, c: hello }  | false |
+| World | 5 |  world  | {a: World, b: 5, c:  world } | true  |
+| !     | 6 |  !      | {a: !, b: 6, c:  !}          | true  |
++-------+---+---------+------------------------------+-------+
+""".strip()
+    assert str(df) == expected
+
+
+def test_literal(df):
+    df = df.select(
+        literal(1),
+        literal("1"),
+        literal("OK"),
+        literal(3.14),
+        literal(value=True),
+        literal(b"hello world"),
+    )
+    result = df.collect()
+    assert len(result) == 1
+    result = result[0]
+    assert result.column(0) == pa.array([1] * 3)
+    assert result.column(1) == pa.array(["1"] * 3, type=pa.string_view())
+    assert result.column(2) == pa.array(["OK"] * 3, type=pa.string_view())
+    assert result.column(3) == pa.array([3.14] * 3)
+    assert result.column(4) == pa.array([True] * 3)
+    assert result.column(5) == pa.array([b"hello world"] * 3)
+
+
+def test_lit_arith(df):
+    """Test literals with arithmetic operations"""
+    df = df.select(
+        literal(1) + column("b"), f.concat(column("a").cast(pa.string()), literal("!"))
+    )
+    result = df.collect()
+    assert len(result) == 1
+    result = result[0]
+
+    assert result.column(0) == pa.array([5, 6, 7])
+    assert result.column(1) == pa.array(
+        ["Hello!", "World!", "!!"], type=pa.string_view()
+    )
+
+
+def test_math_functions():
+    ctx = SessionContext()
+    # create a RecordBatch and a new DataFrame from it
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([0.1, -0.7, 0.55]), pa.array([float("nan"), 0, 2.0])],
+        names=["value", "na_value"],
+    )
+    df = ctx.create_dataframe([[batch]])
+
+    values = np.array([0.1, -0.7, 0.55])
+    na_values = np.array([np.nan, 0, 2.0])
+    col_v = column("value")
+    col_nav = column("na_value")
+    df = df.select(
+        f.abs(col_v),
+        f.sin(col_v),
+        f.cos(col_v),
+        f.tan(col_v),
+        f.asin(col_v),
+        f.acos(col_v),
+        f.exp(col_v),
+        f.ln(col_v + literal(pa.scalar(1))),
+        f.log2(col_v + literal(pa.scalar(1))),
+        f.log10(col_v + literal(pa.scalar(1))),
+        f.random(),
+        f.atan(col_v),
+        f.atan2(col_v, literal(pa.scalar(1.1))),
+        f.ceil(col_v),
+        f.floor(col_v),
+        f.power(col_v, literal(pa.scalar(3))),
+        f.pow(col_v, literal(pa.scalar(4))),
+        f.round(col_v),
+        f.round(col_v, literal(pa.scalar(3))),
+        f.sqrt(col_v),
+        f.signum(col_v),
+        f.trunc(col_v),
+        f.asinh(col_v),
+        f.acosh(col_v),
+        f.atanh(col_v),
+        f.cbrt(col_v),
+        f.cosh(col_v),
+        f.degrees(col_v),
+        f.gcd(literal(9), literal(3)),
+        f.lcm(literal(6), literal(4)),
+        f.nanvl(col_nav, literal(5)),
+        f.pi(),
+        f.radians(col_v),
+        f.sinh(col_v),
+        f.tanh(col_v),
+        f.factorial(literal(6)),
+        f.isnan(col_nav),
+        f.iszero(col_nav),
+        f.log(literal(3), col_v + literal(pa.scalar(1))),
+    )
+    batches = df.collect()
+    assert len(batches) == 1
+    result = batches[0]
+
+    np.testing.assert_array_almost_equal(result.column(0), np.abs(values))
+    np.testing.assert_array_almost_equal(result.column(1), np.sin(values))
+    np.testing.assert_array_almost_equal(result.column(2), np.cos(values))
+    np.testing.assert_array_almost_equal(result.column(3), np.tan(values))
+    np.testing.assert_array_almost_equal(result.column(4), np.arcsin(values))
+    np.testing.assert_array_almost_equal(result.column(5), np.arccos(values))
+    np.testing.assert_array_almost_equal(result.column(6), np.exp(values))
+    np.testing.assert_array_almost_equal(result.column(7), np.log(values + 1.0))
+    np.testing.assert_array_almost_equal(result.column(8), np.log2(values + 1.0))
+    np.testing.assert_array_almost_equal(result.column(9), np.log10(values + 1.0))
+    np.testing.assert_array_less(result.column(10), np.ones_like(values))
+    np.testing.assert_array_almost_equal(result.column(11), np.arctan(values))
+    np.testing.assert_array_almost_equal(result.column(12), np.arctan2(values, 1.1))
+    np.testing.assert_array_almost_equal(result.column(13), np.ceil(values))
+    np.testing.assert_array_almost_equal(result.column(14), np.floor(values))
+    np.testing.assert_array_almost_equal(result.column(15), np.power(values, 3))
+    np.testing.assert_array_almost_equal(result.column(16), np.power(values, 4))
+    np.testing.assert_array_almost_equal(result.column(17), np.round(values))
+    np.testing.assert_array_almost_equal(result.column(18), np.round(values, 3))
+    np.testing.assert_array_almost_equal(result.column(19), np.sqrt(values))
+    np.testing.assert_array_almost_equal(result.column(20), np.sign(values))
+    np.testing.assert_array_almost_equal(result.column(21), np.trunc(values))
+    np.testing.assert_array_almost_equal(result.column(22), np.arcsinh(values))
+    np.testing.assert_array_almost_equal(result.column(23), np.arccosh(values))
+    np.testing.assert_array_almost_equal(result.column(24), np.arctanh(values))
+    np.testing.assert_array_almost_equal(result.column(25), np.cbrt(values))
+    np.testing.assert_array_almost_equal(result.column(26), np.cosh(values))
+    np.testing.assert_array_almost_equal(result.column(27), np.degrees(values))
+    np.testing.assert_array_almost_equal(result.column(28), np.gcd(9, 3))
+    np.testing.assert_array_almost_equal(result.column(29), np.lcm(6, 4))
+    np.testing.assert_array_almost_equal(
+        result.column(30), np.where(np.isnan(na_values), 5, na_values)
+    )
+    np.testing.assert_array_almost_equal(result.column(31), np.pi)
+    np.testing.assert_array_almost_equal(result.column(32), np.radians(values))
+    np.testing.assert_array_almost_equal(result.column(33), np.sinh(values))
+    np.testing.assert_array_almost_equal(result.column(34), np.tanh(values))
+    np.testing.assert_array_almost_equal(result.column(35), math.factorial(6))
+    np.testing.assert_array_almost_equal(result.column(36), np.isnan(na_values))
+    np.testing.assert_array_almost_equal(result.column(37), na_values == 0)
+    np.testing.assert_array_almost_equal(
+        result.column(38), np.emath.logn(3, values + 1.0)
+    )
+
+
+def py_indexof(arr, v):
+    try:
+        return arr.index(v) + 1
+    except ValueError:
+        return np.nan
+
+
+def py_arr_remove(arr, v, n=None):
+    new_arr = arr[:]
+    found = 0
+    try:
+        while found != n:
+            new_arr.remove(v)
+            found += 1
+    except ValueError:
+        pass
+
+    return new_arr
+
+
+def py_arr_replace(arr, from_, to, n=None):
+    new_arr = arr[:]
+    found = 0
+    try:
+        while found != n:
+            idx = new_arr.index(from_)
+            new_arr[idx] = to
+            found += 1
+    except ValueError:
+        pass
+
+    return new_arr
+
+
+def py_arr_resize(arr, size, value):
+    arr = np.asarray(arr)
+    return np.pad(
+        arr,
+        [(0, size - arr.shape[0])],
+        "constant",
+        constant_values=value,
+    )
+
+
+def py_flatten(arr):
+    result = []
+    for elem in arr:
+        if isinstance(elem, list):
+            result.extend(py_flatten(elem))
+        else:
+            result.append(elem)
+    return result
+
+
+@pytest.mark.parametrize(
+    ("stmt", "py_expr"),
+    [
+        (
+            lambda col: f.array_append(col, literal(99.0)),
+            lambda data: [np.append(arr, 99.0) for arr in data],
+        ),
+        (
+            lambda col: f.array_push_back(col, literal(99.0)),
+            lambda data: [np.append(arr, 99.0) for arr in data],
+        ),
+        (
+            lambda col: f.list_append(col, literal(99.0)),
+            lambda data: [np.append(arr, 99.0) for arr in data],
+        ),
+        (
+            lambda col: f.list_push_back(col, literal(99.0)),
+            lambda data: [np.append(arr, 99.0) for arr in data],
+        ),
+        (
+            lambda col: f.array_concat(col, col),
+            lambda data: [np.concatenate([arr, arr]) for arr in data],
+        ),
+        (
+            lambda col: f.array_cat(col, col),
+            lambda data: [np.concatenate([arr, arr]) for arr in data],
+        ),
+        (
+            lambda col: f.list_cat(col, col),
+            lambda data: [np.concatenate([arr, arr]) for arr in data],
+        ),
+        (
+            lambda col: f.list_concat(col, col),
+            lambda data: [np.concatenate([arr, arr]) for arr in data],
+        ),
+        (
+            f.array_dims,
+            lambda data: [[len(r)] for r in data],
+        ),
+        (
+            lambda col: f.array_sort(f.array_distinct(col)),
+            lambda data: [sorted(set(r)) for r in data],
+        ),
+        (
+            lambda col: f.list_sort(f.list_distinct(col)),
+            lambda data: [sorted(set(r)) for r in data],
+        ),
+        (
+            f.list_dims,
+            lambda data: [[len(r)] for r in data],
+        ),
+        (
+            lambda col: f.array_element(col, literal(1)),
+            lambda data: [r[0] for r in data],
+        ),
+        (
+            f.array_empty,
+            lambda data: [len(r) == 0 for r in data],
+        ),
+        (
+            f.empty,
+            lambda data: [len(r) == 0 for r in data],
+        ),
+        (
+            lambda col: f.array_extract(col, literal(1)),
+            lambda data: [r[0] for r in data],
+        ),
+        (
+            lambda col: f.list_element(col, literal(1)),
+            lambda data: [r[0] for r in data],
+        ),
+        (
+            lambda col: f.list_extract(col, literal(1)),
+            lambda data: [r[0] for r in data],
+        ),
+        (
+            f.array_length,
+            lambda data: [len(r) for r in data],
+        ),
+        (
+            f.list_length,
+            lambda data: [len(r) for r in data],
+        ),
+        (
+            lambda col: f.array_has(col, literal(1.0)),
+            lambda data: [1.0 in r for r in data],
+        ),
+        (
+            lambda col: f.array_has_all(
+                col, f.make_array(*[literal(v) for v in [1.0, 3.0, 5.0]])
+            ),
+            lambda data: [np.all([v in r for v in [1.0, 3.0, 5.0]]) for r in data],
+        ),
+        (
+            lambda col: f.array_has_any(
+                col, f.make_array(*[literal(v) for v in [1.0, 3.0, 5.0]])
+            ),
+            lambda data: [np.any([v in r for v in [1.0, 3.0, 5.0]]) for r in data],
+        ),
+        (
+            lambda col: f.array_position(col, literal(1.0)),
+            lambda data: [py_indexof(r, 1.0) for r in data],
+        ),
+        (
+            lambda col: f.array_indexof(col, literal(1.0)),
+            lambda data: [py_indexof(r, 1.0) for r in data],
+        ),
+        (
+            lambda col: f.list_position(col, literal(1.0)),
+            lambda data: [py_indexof(r, 1.0) for r in data],
+        ),
+        (
+            lambda col: f.list_indexof(col, literal(1.0)),
+            lambda data: [py_indexof(r, 1.0) for r in data],
+        ),
+        (
+            lambda col: f.array_positions(col, literal(1.0)),
+            lambda data: [[i + 1 for i, _v in enumerate(r) if _v == 1.0] for r in data],
+        ),
+        (
+            lambda col: f.list_positions(col, literal(1.0)),
+            lambda data: [[i + 1 for i, _v in enumerate(r) if _v == 1.0] for r in data],
+        ),
+        (
+            f.array_ndims,
+            lambda data: [np.array(r).ndim for r in data],
+        ),
+        (
+            f.list_ndims,
+            lambda data: [np.array(r).ndim for r in data],
+        ),
+        (
+            lambda col: f.array_prepend(literal(99.0), col),
+            lambda data: [np.insert(arr, 0, 99.0) for arr in data],
+        ),
+        (
+            lambda col: f.array_push_front(literal(99.0), col),
+            lambda data: [np.insert(arr, 0, 99.0) for arr in data],
+        ),
+        (
+            lambda col: f.list_prepend(literal(99.0), col),
+            lambda data: [np.insert(arr, 0, 99.0) for arr in data],
+        ),
+        (
+            lambda col: f.list_push_front(literal(99.0), col),
+            lambda data: [np.insert(arr, 0, 99.0) for arr in data],
+        ),
+        (
+            f.array_pop_back,
+            lambda data: [arr[:-1] for arr in data],
+        ),
+        (
+            f.array_pop_front,
+            lambda data: [arr[1:] for arr in data],
+        ),
+        (
+            lambda col: f.array_remove(col, literal(3.0)),
+            lambda data: [py_arr_remove(arr, 3.0, 1) for arr in data],
+        ),
+        (
+            lambda col: f.list_remove(col, literal(3.0)),
+            lambda data: [py_arr_remove(arr, 3.0, 1) for arr in data],
+        ),
+        (
+            lambda col: f.array_remove_n(col, literal(3.0), literal(2)),
+            lambda data: [py_arr_remove(arr, 3.0, 2) for arr in data],
+        ),
+        (
+            lambda col: f.list_remove_n(col, literal(3.0), literal(2)),
+            lambda data: [py_arr_remove(arr, 3.0, 2) for arr in data],
+        ),
+        (
+            lambda col: f.array_remove_all(col, literal(3.0)),
+            lambda data: [py_arr_remove(arr, 3.0) for arr in data],
+        ),
+        (
+            lambda col: f.list_remove_all(col, literal(3.0)),
+            lambda data: [py_arr_remove(arr, 3.0) for arr in data],
+        ),
+        (
+            lambda col: f.array_repeat(col, literal(2)),
+            lambda data: [[arr] * 2 for arr in data],
+        ),
+        (
+            lambda col: f.list_repeat(col, literal(2)),
+            lambda data: [[arr] * 2 for arr in data],
+        ),
+        (
+            lambda col: f.array_replace(col, literal(3.0), literal(4.0)),
+            lambda data: [py_arr_replace(arr, 3.0, 4.0, 1) for arr in data],
+        ),
+        (
+            lambda col: f.list_replace(col, literal(3.0), literal(4.0)),
+            lambda data: [py_arr_replace(arr, 3.0, 4.0, 1) for arr in data],
+        ),
+        (
+            lambda col: f.array_replace_n(col, literal(3.0), literal(4.0), literal(1)),
+            lambda data: [py_arr_replace(arr, 3.0, 4.0, 1) for arr in data],
+        ),
+        (
+            lambda col: f.list_replace_n(col, literal(3.0), literal(4.0), literal(2)),
+            lambda data: [py_arr_replace(arr, 3.0, 4.0, 2) for arr in data],
+        ),
+        (
+            lambda col: f.array_replace_all(col, literal(3.0), literal(4.0)),
+            lambda data: [py_arr_replace(arr, 3.0, 4.0) for arr in data],
+        ),
+        (
+            lambda col: f.list_replace_all(col, literal(3.0), literal(4.0)),
+            lambda data: [py_arr_replace(arr, 3.0, 4.0) for arr in data],
+        ),
+        (
+            lambda col: f.array_sort(col, descending=True, null_first=True),
+            lambda data: [np.sort(arr)[::-1] for arr in data],
+        ),
+        (
+            lambda col: f.list_sort(col, descending=False, null_first=False),
+            lambda data: [np.sort(arr) for arr in data],
+        ),
+        (
+            lambda col: f.array_slice(col, literal(2), literal(4)),
+            lambda data: [arr[1:4] for arr in data],
+        ),
+        pytest.param(
+            lambda col: f.list_slice(col, literal(-1), literal(2)),
+            lambda data: [arr[-1:2] for arr in data],
+        ),
+        (
+            lambda col: col[:3],
+            lambda data: [arr[:3] for arr in data],
+        ),
+        (
+            lambda col: col[1:3],
+            lambda data: [arr[1:3] for arr in data],
+        ),
+        (
+            lambda col: col[1:4:2],
+            lambda data: [arr[1:4:2] for arr in data],
+        ),
+        (
+            lambda col: col[literal(1) : literal(4)],
+            lambda data: [arr[1:4] for arr in data],
+        ),
+        (
+            lambda col: col[column("indices") : column("indices") + literal(2)],
+            lambda data: [[2.0, 3.0], [], [6.0]],
+        ),
+        (
+            lambda col: col[literal(1) : literal(4) : literal(2)],
+            lambda data: [arr[1:4:2] for arr in data],
+        ),
+        (
+            lambda col: f.array_sort(f.array_intersect(col, literal([3.0, 4.0]))),
+            lambda data: [np.intersect1d(arr, [3.0, 4.0]) for arr in data],
+        ),
+        (
+            lambda col: f.list_sort(f.list_intersect(col, literal([3.0, 4.0]))),
+            lambda data: [np.intersect1d(arr, [3.0, 4.0]) for arr in data],
+        ),
+        (
+            lambda col: f.array_sort(f.array_union(col, literal([12.0, 999.0]))),
+            lambda data: [np.union1d(arr, [12.0, 999.0]) for arr in data],
+        ),
+        (
+            lambda col: f.list_sort(f.list_union(col, literal([12.0, 999.0]))),
+            lambda data: [np.union1d(arr, [12.0, 999.0]) for arr in data],
+        ),
+        (
+            lambda col: f.array_except(col, literal([3.0])),
+            lambda data: [np.setdiff1d(arr, [3.0]) for arr in data],
+        ),
+        (
+            lambda col: f.list_except(col, literal([3.0])),
+            lambda data: [np.setdiff1d(arr, [3.0]) for arr in data],
+        ),
+        (
+            lambda col: f.array_resize(col, literal(10), literal(0.0)),
+            lambda data: [py_arr_resize(arr, 10, 0.0) for arr in data],
+        ),
+        (
+            lambda col: f.list_resize(col, literal(10), literal(0.0)),
+            lambda data: [py_arr_resize(arr, 10, 0.0) for arr in data],
+        ),
+        (
+            lambda col: f.range(literal(1), literal(5), literal(2)),
+            lambda data: [np.arange(1, 5, 2)],
+        ),
+    ],
+)
+def test_array_functions(stmt, py_expr):
+    data = [[1.0, 2.0, 3.0, 3.0], [4.0, 5.0, 3.0], [6.0]]
+    indices = [1, 3, 0]
+    ctx = SessionContext()
+    batch = pa.RecordBatch.from_arrays(
+        [np.array(data, dtype=object), indices], names=["arr", "indices"]
+    )
+    df = ctx.create_dataframe([[batch]])
+
+    col = column("arr")
+    query_result = df.select(stmt(col)).collect()[0].column(0)
+    for a, b in zip(query_result, py_expr(data), strict=False):
+        np.testing.assert_array_almost_equal(
+            np.array(a.as_py(), dtype=float), np.array(b, dtype=float)
+        )
+
+
+def test_array_function_flatten():
+    data = [[1.0, 2.0, 3.0, 3.0], [4.0, 5.0, 3.0], [6.0]]
+    ctx = SessionContext()
+    batch = pa.RecordBatch.from_arrays([np.array(data, dtype=object)], names=["arr"])
+    df = ctx.create_dataframe([[batch]])
+
+    stmt = f.flatten(literal(data))
+    py_expr = [py_flatten(data)]
+    query_result = df.select(stmt).collect()[0].column(0)
+    for a, b in zip(query_result, py_expr, strict=False):
+        np.testing.assert_array_almost_equal(
+            np.array(a.as_py(), dtype=float), np.array(b, dtype=float)
+        )
+
+
+def test_array_function_cardinality():
+    data = [[1, 2, 3], [4, 4, 5, 6]]
+    ctx = SessionContext()
+    batch = pa.RecordBatch.from_arrays([np.array(data, dtype=object)], names=["arr"])
+    df = ctx.create_dataframe([[batch]])
+
+    stmt = f.cardinality(column("arr"))
+    py_expr = [len(arr) for arr in data]  # Expected lengths: [3, 3]
+    # assert py_expr lengths
+
+    query_result = df.select(stmt).collect()[0].column(0)
+
+    for a, b in zip(query_result, py_expr, strict=False):
+        np.testing.assert_array_equal(
+            np.array([a.as_py()], dtype=int), np.array([b], dtype=int)
+        )
+
+
+@pytest.mark.parametrize("make_func", [f.make_array, f.make_list])
+def test_make_array_functions(make_func):
+    ctx = SessionContext()
+    batch = pa.RecordBatch.from_arrays(
+        [
+            pa.array(["Hello", "World", "!"], type=pa.string()),
+            pa.array([4, 5, 6]),
+            pa.array(["hello ", " world ", " !"], type=pa.string()),
+        ],
+        names=["a", "b", "c"],
+    )
+    df = ctx.create_dataframe([[batch]])
+
+    stmt = make_func(
+        column("a").cast(pa.string()),
+        column("b").cast(pa.string()),
+        column("c").cast(pa.string()),
+    )
+    py_expr = [
+        ["Hello", "4", "hello "],
+        ["World", "5", " world "],
+        ["!", "6", " !"],
+    ]
+
+    query_result = df.select(stmt).collect()[0].column(0)
+    for a, b in zip(query_result, py_expr, strict=False):
+        np.testing.assert_array_equal(
+            np.array(a.as_py(), dtype=str), np.array(b, dtype=str)
+        )
+
+
+@pytest.mark.parametrize(
+    ("stmt", "py_expr"),
+    [
+        (
+            f.array_to_string(column("arr"), literal(",")),
+            lambda data: [",".join([str(int(v)) for v in r]) for r in data],
+        ),
+        (
+            f.array_join(column("arr"), literal(",")),
+            lambda data: [",".join([str(int(v)) for v in r]) for r in data],
+        ),
+        (
+            f.list_to_string(column("arr"), literal(",")),
+            lambda data: [",".join([str(int(v)) for v in r]) for r in data],
+        ),
+        (
+            f.list_join(column("arr"), literal(",")),
+            lambda data: [",".join([str(int(v)) for v in r]) for r in data],
+        ),
+    ],
+)
+def test_array_function_obj_tests(stmt, py_expr):
+    data = [[1.0, 2.0, 3.0, 3.0], [4.0, 5.0, 3.0], [6.0]]
+    ctx = SessionContext()
+    batch = pa.RecordBatch.from_arrays([np.array(data, dtype=object)], names=["arr"])
+    df = ctx.create_dataframe([[batch]])
+    query_result = np.array(df.select(stmt).collect()[0].column(0))
+    for a, b in zip(query_result, py_expr(data), strict=False):
+        assert a == b
+
+
+@pytest.mark.parametrize(
+    ("function", "expected_result"),
+    [
+        (
+            f.ascii(column("a")),
+            pa.array([72, 87, 33], type=pa.int32()),
+        ),  # H = 72; W = 87; ! = 33
+        (
+            f.bit_length(column("a").cast(pa.string())),
+            pa.array([40, 40, 8], type=pa.int32()),
+        ),
+        (
+            f.btrim(literal(" World ")),
+            pa.array(["World", "World", "World"], type=pa.string_view()),
+        ),
+        (f.character_length(column("a")), pa.array([5, 5, 1], type=pa.int32())),
+        (f.chr(literal(68)), pa.array(["D", "D", "D"])),
+        (
+            f.concat_ws("-", column("a"), literal("test")),
+            pa.array(["Hello-test", "World-test", "!-test"]),
+        ),
+        (
+            f.concat(column("a").cast(pa.string()), literal("?")),
+            pa.array(["Hello?", "World?", "!?"], type=pa.string_view()),
+        ),
+        (
+            f.initcap(column("c")),
+            pa.array(["Hello ", " World ", " !"], type=pa.string_view()),
+        ),
+        (
+            f.left(column("a"), literal(3)),
+            pa.array(["Hel", "Wor", "!"], type=pa.string_view()),
+        ),
+        (f.length(column("c")), pa.array([6, 7, 2], type=pa.int32())),
+        (f.lower(column("a")), pa.array(["hello", "world", "!"])),
+        (f.lpad(column("a"), literal(7)), pa.array(["  Hello", "  World", "      !"])),
+        (
+            f.ltrim(column("c")),
+            pa.array(["hello ", "world ", "!"], type=pa.string_view()),
+        ),
+        (
+            f.md5(column("a")),
+            pa.array(
+                [
+                    "8b1a9953c4611296a827abf8c47804d7",
+                    "f5a7924e621e84c9280a9a27e1bcb7f6",
+                    "9033e0e305f247c0c3c80d0c7848c8b3",
+                ],
+                type=pa.string_view(),
+            ),
+        ),
+        (f.octet_length(column("a")), pa.array([5, 5, 1], type=pa.int32())),
+        (
+            f.repeat(column("a"), literal(2)),
+            pa.array(["HelloHello", "WorldWorld", "!!"]),
+        ),
+        (
+            f.replace(column("a"), literal("l"), literal("?")),
+            pa.array(["He??o", "Wor?d", "!"]),
+        ),
+        (f.reverse(column("a")), pa.array(["olleH", "dlroW", "!"])),
+        (
+            f.right(column("a"), literal(4)),
+            pa.array(["ello", "orld", "!"], type=pa.string_view()),
+        ),
+        (
+            f.rpad(column("a"), literal(8)),
+            pa.array(["Hello   ", "World   ", "!       "]),
+        ),
+        (
+            f.rtrim(column("c")),
+            pa.array(["hello", " world", " !"], type=pa.string_view()),
+        ),
+        (
+            f.split_part(column("a"), literal("l"), literal(1)),
+            pa.array(["He", "Wor", "!"]),
+        ),
+        (f.starts_with(column("a"), literal("Wor")), pa.array([False, True, False])),
+        (f.strpos(column("a"), literal("o")), pa.array([5, 2, 0], type=pa.int32())),
+        (
+            f.substr(column("a"), literal(3)),
+            pa.array(["llo", "rld", ""], type=pa.string_view()),
+        ),
+        (
+            f.translate(column("a"), literal("or"), literal("ld")),
+            pa.array(["Helll", "Wldld", "!"]),
+        ),
+        (f.trim(column("c")), pa.array(["hello", "world", "!"], type=pa.string_view())),
+        (f.upper(column("c")), pa.array(["HELLO ", " WORLD ", " !"])),
+        (f.ends_with(column("a"), literal("llo")), pa.array([True, False, False])),
+        (
+            f.overlay(column("a"), literal("--"), literal(2)),
+            pa.array(["H--lo", "W--ld", "--"]),
+        ),
+        (
+            f.regexp_like(column("a"), literal("(ell|orl)")),
+            pa.array([True, True, False]),
+        ),
+        (
+            f.regexp_match(column("a"), literal("(ell|orl)")),
+            pa.array([["ell"], ["orl"], None], type=pa.list_(pa.string_view())),
+        ),
+        (
+            f.regexp_replace(column("a"), literal("(ell|orl)"), literal("-")),
+            pa.array(["H-o", "W-d", "!"], type=pa.string_view()),
+        ),
+        (
+            f.regexp_count(column("a"), literal("(ell|orl)"), start=literal(1)),
+            pa.array([1, 1, 0], type=pa.int64()),
+        ),
+        (
+            f.regexp_count(column("a"), literal("(ell|orl)")),
+            pa.array([1, 1, 0], type=pa.int64()),
+        ),
+        (
+            f.regexp_instr(column("a"), literal("(ell|orl)")),
+            pa.array([2, 2, 0], type=pa.int64()),
+        ),
+        (
+            f.regexp_instr(column("a"), literal("([lr])"), n=literal(2)),
+            pa.array([4, 4, 0], type=pa.int64()),
+        ),
+        (
+            f.regexp_instr(
+                column("a"),
+                literal("(x)?([hw])"),
+                start=literal(1),
+                n=literal(1),
+                flags=literal("i"),
+                sub_expr=literal(2),
+            ),
+            pa.array([1, 1, 0], type=pa.int64()),
+        ),
+        (
+            f.regexp_instr(column("a"), literal("([hw])"), flags=literal("i")),
+            pa.array([1, 1, 0], type=pa.int64()),
+        ),
+        (
+            f.regexp_instr(column("a"), literal("(x)?([HW])"), sub_expr=literal(2)),
+            pa.array([1, 1, 0], type=pa.int64()),
+        ),
+    ],
+)
+def test_string_functions(df, function, expected_result):
+    df = df.select(function)
+    result = df.collect()
+    assert len(result) == 1
+    result = result[0]
+    assert result.column(0) == expected_result
+
+
+def test_hash_functions(df):
+    exprs = [
+        f.digest(column("a"), literal(m))
+        for m in (
+            "md5",
+            "sha224",
+            "sha256",
+            "sha384",
+            "sha512",
+            "blake2s",
+            "blake3",
+        )
+    ]
+    df = df.select(
+        *exprs,
+        f.sha224(column("a")),
+        f.sha256(column("a")),
+        f.sha384(column("a")),
+        f.sha512(column("a")),
+    )
+    result = df.collect()
+    assert len(result) == 1
+    result = result[0]
+    b = bytearray.fromhex
+    assert result.column(0) == pa.array(
+        [
+            b("8B1A9953C4611296A827ABF8C47804D7"),
+            b("F5A7924E621E84C9280A9A27E1BCB7F6"),
+            b("9033E0E305F247C0C3C80D0C7848C8B3"),
+        ]
+    )
+    assert result.column(1) == pa.array(
+        [
+            b("4149DA18AA8BFC2B1E382C6C26556D01A92C261B6436DAD5E3BE3FCC"),
+            b("12972632B6D3B6AA52BD6434552F08C1303D56B817119406466E9236"),
+            b("6641A7E8278BCD49E476E7ACAE158F4105B2952D22AEB2E0B9A231A0"),
+        ]
+    )
+    assert result.column(2) == pa.array(
+        [
+            b("185F8DB32271FE25F561A6FC938B2E264306EC304EDA518007D1764826381969"),
+            b("78AE647DC5544D227130A0682A51E30BC7777FBB6D8A8F17007463A3ECD1D524"),
+            b("BB7208BC9B5D7C04F1236A82A0093A5E33F40423D5BA8D4266F7092C3BA43B62"),
+        ]
+    )
+    assert result.column(3) == pa.array(
+        [
+            b(
+                "3519FE5AD2C596EFE3E276A6F351B8FC"
+                "0B03DB861782490D45F7598EBD0AB5FD"
+                "5520ED102F38C4A5EC834E98668035FC"
+            ),
+            b(
+                "ED7CED84875773603AF90402E42C65F3"
+                "B48A5E77F84ADC7A19E8F3E8D3101010"
+                "22F552AEC70E9E1087B225930C1D260A"
+            ),
+            b(
+                "1D0EC8C84EE9521E21F06774DE232367"
+                "B64DE628474CB5B2E372B699A1F55AE3"
+                "35CC37193EF823E33324DFD9A70738A6"
+            ),
+        ]
+    )
+    assert result.column(4) == pa.array(
+        [
+            b(
+                "3615F80C9D293ED7402687F94B22D58E"
+                "529B8CC7916F8FAC7FDDF7FBD5AF4CF7"
+                "77D3D795A7A00A16BF7E7F3FB9561EE9"
+                "BAAE480DA9FE7A18769E71886B03F315"
+            ),
+            b(
+                "8EA77393A42AB8FA92500FB077A9509C"
+                "C32BC95E72712EFA116EDAF2EDFAE34F"
+                "BB682EFDD6C5DD13C117E08BD4AAEF71"
+                "291D8AACE2F890273081D0677C16DF0F"
+            ),
+            b(
+                "3831A6A6155E509DEE59A7F451EB3532"
+                "4D8F8F2DF6E3708894740F98FDEE2388"
+                "9F4DE5ADB0C5010DFB555CDA77C8AB5D"
+                "C902094C52DE3278F35A75EBC25F093A"
+            ),
+        ]
+    )
+    assert result.column(5) == pa.array(
+        [
+            b("F73A5FBF881F89B814871F46E26AD3FA37CB2921C5E8561618639015B3CCBB71"),
+            b("B792A0383FB9E7A189EC150686579532854E44B71AC394831DAED169BA85CCC5"),
+            b("27988A0E51812297C77A433F635233346AEE29A829DCF4F46E0F58F402C6CFCB"),
+        ]
+    )
+    assert result.column(6) == pa.array(
+        [
+            b("FBC2B0516EE8744D293B980779178A3508850FDCFE965985782C39601B65794F"),
+            b("BF73D18575A736E4037D45F9E316085B86C19BE6363DE6AA789E13DEAACC1C4E"),
+            b("C8D11B9F7237E4034ADBCD2005735F9BC4C597C75AD89F4492BEC8F77D15F7EB"),
+        ]
+    )
+    assert result.column(7) == result.column(1)  # SHA-224
+    assert result.column(8) == result.column(2)  # SHA-256
+    assert result.column(9) == result.column(3)  # SHA-384
+    assert result.column(10) == result.column(4)  # SHA-512
+
+
+def test_temporal_functions(df):
+    df = df.select(
+        f.date_part(literal("month"), column("d")),
+        f.datepart(literal("year"), column("d")),
+        f.date_trunc(literal("month"), column("d")),
+        f.datetrunc(literal("day"), column("d")),
+        f.date_bin(
+            literal("15 minutes").cast(pa.string()),
+            column("d"),
+            literal("2001-01-01 00:02:30").cast(pa.string()),
+        ),
+        f.from_unixtime(literal(1673383974)),
+        f.to_timestamp(literal("2023-09-07 05:06:14.523952")),
+        f.to_timestamp_seconds(literal("2023-09-07 05:06:14.523952")),
+        f.to_timestamp_millis(literal("2023-09-07 05:06:14.523952")),
+        f.to_timestamp_micros(literal("2023-09-07 05:06:14.523952")),
+        f.extract(literal("day"), column("d")),
+        f.to_timestamp(
+            literal("2023-09-07 05:06:14.523952000"), literal("%Y-%m-%d %H:%M:%S.%f")
+        ),
+        f.to_timestamp_seconds(
+            literal("2023-09-07 05:06:14.523952000"), literal("%Y-%m-%d %H:%M:%S.%f")
+        ),
+        f.to_timestamp_millis(
+            literal("2023-09-07 05:06:14.523952000"), literal("%Y-%m-%d %H:%M:%S.%f")
+        ),
+        f.to_timestamp_micros(
+            literal("2023-09-07 05:06:14.523952000"), literal("%Y-%m-%d %H:%M:%S.%f")
+        ),
+        f.to_timestamp_nanos(literal("2023-09-07 05:06:14.523952")),
+        f.to_timestamp_nanos(
+            literal("2023-09-07 05:06:14.523952000"), literal("%Y-%m-%d %H:%M:%S.%f")
+        ),
+        f.to_time(literal("12:30:45")),
+        f.to_time(literal("12-30-45"), literal("%H-%M-%S")),
+        f.to_date(literal("2017-05-31")),
+        f.to_date(literal("2017-05-31"), literal("%Y-%m-%d")),
+        f.to_local_time(column("d")),
+        f.to_char(column("d"), literal("%d-%m-%Y")),
+    )
+    result = df.collect()
+    assert len(result) == 1
+    result = result[0]
+    assert result.column(0) == pa.array([12, 6, 7], type=pa.int32())
+    assert result.column(1) == pa.array([2022, 2027, 2020], type=pa.int32())
+    assert result.column(2) == pa.array(
+        [
+            datetime(2022, 12, 1, tzinfo=DEFAULT_TZ),
+            datetime(2027, 6, 1, tzinfo=DEFAULT_TZ),
+            datetime(2020, 7, 1, tzinfo=DEFAULT_TZ),
+        ],
+        type=pa.timestamp("us", tz=DEFAULT_TZ),
+    )
+    assert result.column(3) == pa.array(
+        [
+            datetime(2022, 12, 31, tzinfo=DEFAULT_TZ),
+            datetime(2027, 6, 26, tzinfo=DEFAULT_TZ),
+            datetime(2020, 7, 2, tzinfo=DEFAULT_TZ),
+        ],
+        type=pa.timestamp("us", tz=DEFAULT_TZ),
+    )
+    assert result.column(4) == pa.array(
+        [
+            datetime(2022, 12, 30, 23, 47, 30, tzinfo=DEFAULT_TZ),
+            datetime(2027, 6, 25, 23, 47, 30, tzinfo=DEFAULT_TZ),
+            datetime(2020, 7, 1, 23, 47, 30, tzinfo=DEFAULT_TZ),
+        ],
+        type=pa.timestamp("ns", tz=DEFAULT_TZ),
+    )
+    assert result.column(5) == pa.array(
+        [datetime(2023, 1, 10, 20, 52, 54, tzinfo=DEFAULT_TZ)] * 3,
+        type=pa.timestamp("s"),
+    )
+    assert result.column(6) == pa.array(
+        [datetime(2023, 9, 7, 5, 6, 14, 523952, tzinfo=DEFAULT_TZ)] * 3,
+        type=pa.timestamp("ns"),
+    )
+    assert result.column(7) == pa.array(
+        [datetime(2023, 9, 7, 5, 6, 14, tzinfo=DEFAULT_TZ)] * 3, type=pa.timestamp("s")
+    )
+    assert result.column(8) == pa.array(
+        [datetime(2023, 9, 7, 5, 6, 14, 523000, tzinfo=DEFAULT_TZ)] * 3,
+        type=pa.timestamp("ms"),
+    )
+    assert result.column(9) == pa.array(
+        [datetime(2023, 9, 7, 5, 6, 14, 523952, tzinfo=DEFAULT_TZ)] * 3,
+        type=pa.timestamp("us"),
+    )
+    assert result.column(10) == pa.array([31, 26, 2], type=pa.int32())
+    assert result.column(11) == pa.array(
+        [datetime(2023, 9, 7, 5, 6, 14, 523952, tzinfo=DEFAULT_TZ)] * 3,
+        type=pa.timestamp("ns"),
+    )
+    assert result.column(12) == pa.array(
+        [datetime(2023, 9, 7, 5, 6, 14, tzinfo=DEFAULT_TZ)] * 3,
+        type=pa.timestamp("s"),
+    )
+    assert result.column(13) == pa.array(
+        [datetime(2023, 9, 7, 5, 6, 14, 523000, tzinfo=DEFAULT_TZ)] * 3,
+        type=pa.timestamp("ms"),
+    )
+    assert result.column(14) == pa.array(
+        [datetime(2023, 9, 7, 5, 6, 14, 523952, tzinfo=DEFAULT_TZ)] * 3,
+        type=pa.timestamp("us"),
+    )
+    assert result.column(15) == pa.array(
+        [datetime(2023, 9, 7, 5, 6, 14, 523952, tzinfo=DEFAULT_TZ)] * 3,
+        type=pa.timestamp("ns"),
+    )
+    assert result.column(16) == pa.array(
+        [datetime(2023, 9, 7, 5, 6, 14, 523952, tzinfo=DEFAULT_TZ)] * 3,
+        type=pa.timestamp("ns"),
+    )
+    assert result.column(17) == pa.array(
+        [time(12, 30, 45)] * 3,
+        type=pa.time64("ns"),
+    )
+    assert result.column(18) == pa.array(
+        [time(12, 30, 45)] * 3,
+        type=pa.time64("ns"),
+    )
+    assert result.column(19) == pa.array(
+        [date(2017, 5, 31)] * 3,
+        type=pa.date32(),
+    )
+    assert result.column(20) == pa.array(
+        [date(2017, 5, 31)] * 3,
+        type=pa.date32(),
+    )
+    assert result.column(21) == pa.array(
+        [
+            datetime(2022, 12, 31, tzinfo=DEFAULT_TZ),
+            datetime(2027, 6, 26, tzinfo=DEFAULT_TZ),
+            datetime(2020, 7, 2, tzinfo=DEFAULT_TZ),
+        ],
+        type=pa.timestamp("us"),
+    )
+
+    assert result.column(22) == pa.array(
+        [
+            "31-12-2022",
+            "26-06-2027",
+            "02-07-2020",
+        ],
+        type=pa.string(),
+    )
+
+
+def test_to_time_invalid_input(df):
+    with pytest.raises(Exception, match=r"Error parsing 'not-a-time' as time"):
+        df.select(f.to_time(literal("not-a-time"))).collect()
+
+
+def test_to_time_mismatched_formatter(df):
+    with pytest.raises(Exception, match=r"Error parsing '12:30:45' as time"):
+        df.select(f.to_time(literal("12:30:45"), literal("%Y-%m-%d"))).collect()
+
+
+def test_to_date_invalid_input(df):
+    with pytest.raises(Exception, match=r"Date32"):
+        df.select(f.to_date(literal("not-a-date"))).collect()
+
+
+def test_temporal_formatter_requires_expr():
+    with pytest.raises(AttributeError, match="'str' object has no attribute 'expr'"):
+        f.to_time(literal("12:30:45"), "not-an-expr")
+
+
+def test_today_returns_date32(df):
+    result = df.select(f.today().alias("today")).collect()[0]
+    assert result.column(0).type == pa.date32()
+
+
+def test_today_alias_matches_current_date(df):
+    result = df.select(
+        f.current_date().alias("current_date"),
+        f.today().alias("today"),
+    ).collect()[0]
+
+    assert result.column(0) == result.column(1)
+
+
+def test_arrow_cast(df):
+    df = df.select(
+        # we use `string_literal` to return utf8 instead of `literal` which returns
+        # utf8view because datafusion.arrow_cast expects a utf8 instead of utf8view
+        # https://github.com/apache/datafusion/blob/86740bfd3d9831d6b7c1d0e1bf4a21d91598a0ac/datafusion/functions/src/core/arrow_cast.rs#L179
+        f.arrow_cast(column("b"), string_literal("Float64")).alias("b_as_float"),
+        f.arrow_cast(column("b"), string_literal("Int32")).alias("b_as_int"),
+    )
+    result = df.collect()
+    assert len(result) == 1
+    result = result[0]
+
+    assert result.column(0) == pa.array([4.0, 5.0, 6.0], type=pa.float64())
+    assert result.column(1) == pa.array([4, 5, 6], type=pa.int32())
+
+
+def test_case(df):
+    df = df.select(
+        f.case(column("b")).when(literal(4), literal(10)).otherwise(literal(8)),
+        f.case(column("a"))
+        .when(literal("Hello"), literal("Hola"))
+        .when(literal("World"), literal("Mundo"))
+        .otherwise(literal("!!")),
+        f.case(column("a"))
+        .when(literal("Hello"), literal("Hola"))
+        .when(literal("World"), literal("Mundo"))
+        .end(),
+    )
+
+    result = df.collect()
+    result = result[0]
+    assert result.column(0) == pa.array([10, 8, 8])
+    assert result.column(1) == pa.array(["Hola", "Mundo", "!!"], type=pa.string_view())
+    assert result.column(2) == pa.array(["Hola", "Mundo", None], type=pa.string_view())
+
+
+def test_when_with_no_base(df):
+    df.show()
+    df = df.select(
+        column("b"),
+        f.when(column("b") > literal(5), literal("too big"))
+        .when(column("b") < literal(5), literal("too small"))
+        .otherwise(literal("just right"))
+        .alias("goldilocks"),
+        f.when(column("a") == literal("Hello"), column("a")).end().alias("greeting"),
+    )
+    df.show()
+
+    result = df.collect()
+    result = result[0]
+    assert result.column(0) == pa.array([4, 5, 6])
+    assert result.column(1) == pa.array(
+        ["too small", "just right", "too big"], type=pa.string_view()
+    )
+    assert result.column(2) == pa.array(["Hello", None, None], type=pa.string_view())
+
+
+def test_regr_funcs_sql(df):
+    # test case base on
+    # https://github.com/apache/arrow-datafusion/blob/d1361d56b9a9e0c165d3d71a8df6795d2a5f51dd/datafusion/core/tests/sqllogictests/test_files/aggregate.slt#L2330
+    ctx = SessionContext()
+    result = ctx.sql(
+        "select regr_slope(1,1), regr_intercept(1,1), "
+        "regr_count(1,1), regr_r2(1,1), regr_avgx(1,1), "
+        "regr_avgy(1,1), regr_sxx(1,1), regr_syy(1,1), "
+        "regr_sxy(1,1);"
+    ).collect()
+
+    assert result[0].column(0) == pa.array([None], type=pa.float64())
+    assert result[0].column(1) == pa.array([None], type=pa.float64())
+    assert result[0].column(2) == pa.array([1], type=pa.uint64())
+    assert result[0].column(3) == pa.array([None], type=pa.float64())
+    assert result[0].column(4) == pa.array([1], type=pa.float64())
+    assert result[0].column(5) == pa.array([1], type=pa.float64())
+    assert result[0].column(6) == pa.array([0], type=pa.float64())
+    assert result[0].column(7) == pa.array([0], type=pa.float64())
+    assert result[0].column(8) == pa.array([0], type=pa.float64())
+
+
+def test_regr_funcs_sql_2():
+    # test case based on `regr_*() basic tests
+    # https://github.com/apache/datafusion/blob/d1361d56b9a9e0c165d3d71a8df6795d2a5f51dd/datafusion/core/tests/sqllogictests/test_files/aggregate.slt#L2358C1-L2374C1
+    ctx = SessionContext()
+
+    # Perform the regression functions using SQL
+    result_sql = ctx.sql(
+        "select "
+        "regr_slope(column2, column1), "
+        "regr_intercept(column2, column1), "
+        "regr_count(column2, column1), "
+        "regr_r2(column2, column1), "
+        "regr_avgx(column2, column1), "
+        "regr_avgy(column2, column1), "
+        "regr_sxx(column2, column1), "
+        "regr_syy(column2, column1), "
+        "regr_sxy(column2, column1) "
+        "from (values (1,2), (2,4), (3,6))"
+    ).collect()
+
+    # Assertions for SQL results
+    assert result_sql[0].column(0) == pa.array([2], type=pa.float64())
+    assert result_sql[0].column(1) == pa.array([0], type=pa.float64())
+    assert result_sql[0].column(2) == pa.array([3], type=pa.uint64())
+    assert result_sql[0].column(3) == pa.array([1], type=pa.float64())
+    assert result_sql[0].column(4) == pa.array([2], type=pa.float64())
+    assert result_sql[0].column(5) == pa.array([4], type=pa.float64())
+    assert result_sql[0].column(6) == pa.array([2], type=pa.float64())
+    assert result_sql[0].column(7) == pa.array([8], type=pa.float64())
+    assert result_sql[0].column(8) == pa.array([4], type=pa.float64())
+
+
+@pytest.mark.parametrize(
+    ("func", "expected"),
+    [
+        pytest.param(f.regr_slope(column("c2"), column("c1")), [4.6], id="regr_slope"),
+        pytest.param(
+            f.regr_slope(column("c2"), column("c1"), filter=column("c1") > literal(2)),
+            [8],
+            id="regr_slope_filter",
+        ),
+        pytest.param(
+            f.regr_intercept(column("c2"), column("c1")), [-4], id="regr_intercept"
+        ),
+        pytest.param(
+            f.regr_intercept(
+                column("c2"), column("c1"), filter=column("c1") > literal(2)
+            ),
+            [-16],
+            id="regr_intercept_filter",
+        ),
+        pytest.param(f.regr_count(column("c2"), column("c1")), [4], id="regr_count"),
+        pytest.param(
+            f.regr_count(column("c2"), column("c1"), filter=column("c1") > literal(2)),
+            [2],
+            id="regr_count_filter",
+        ),
+        pytest.param(f.regr_r2(column("c2"), column("c1")), [0.92], id="regr_r2"),
+        pytest.param(
+            f.regr_r2(column("c2"), column("c1"), filter=column("c1") > literal(2)),
+            [1.0],
+            id="regr_r2_filter",
+        ),
+        pytest.param(f.regr_avgx(column("c2"), column("c1")), [2.5], id="regr_avgx"),
+        pytest.param(
+            f.regr_avgx(column("c2"), column("c1"), filter=column("c1") > literal(2)),
+            [3.5],
+            id="regr_avgx_filter",
+        ),
+        pytest.param(f.regr_avgy(column("c2"), column("c1")), [7.5], id="regr_avgy"),
+        pytest.param(
+            f.regr_avgy(column("c2"), column("c1"), filter=column("c1") > literal(2)),
+            [12.0],
+            id="regr_avgy_filter",
+        ),
+        pytest.param(f.regr_sxx(column("c2"), column("c1")), [5.0], id="regr_sxx"),
+        pytest.param(
+            f.regr_sxx(column("c2"), column("c1"), filter=column("c1") > literal(2)),
+            [0.5],
+            id="regr_sxx_filter",
+        ),
+        pytest.param(f.regr_syy(column("c2"), column("c1")), [115.0], id="regr_syy"),
+        pytest.param(
+            f.regr_syy(column("c2"), column("c1"), filter=column("c1") > literal(2)),
+            [32.0],
+            id="regr_syy_filter",
+        ),
+        pytest.param(f.regr_sxy(column("c2"), column("c1")), [23.0], id="regr_sxy"),
+        pytest.param(
+            f.regr_sxy(column("c2"), column("c1"), filter=column("c1") > literal(2)),
+            [4.0],
+            id="regr_sxy_filter",
+        ),
+    ],
+)
+def test_regr_funcs_df(func, expected):
+    # test case based on `regr_*() basic tests
+    # https://github.com/apache/datafusion/blob/d1361d56b9a9e0c165d3d71a8df6795d2a5f51dd/datafusion/core/tests/sqllogictests/test_files/aggregate.slt#L2358C1-L2374C1
+
+    ctx = SessionContext()
+
+    # Create a DataFrame
+    data = {"c1": [1, 2, 3, 4, 5, None], "c2": [2, 4, 8, 16, None, 64]}
+    df = ctx.from_pydict(data, name="test_table")
+
+    # Perform the regression function using DataFrame API
+    df = df.aggregate([], [func.alias("result")])
+    df.show()
+
+    expected_dict = {
+        "result": expected,
+    }
+
+    assert df.collect()[0].to_pydict() == expected_dict
+
+
+def test_binary_string_functions(df):
+    df = df.select(
+        f.encode(column("a").cast(pa.string()), literal("base64").cast(pa.string())),
+        f.decode(
+            f.encode(
+                column("a").cast(pa.string()), literal("base64").cast(pa.string())
+            ),
+            literal("base64").cast(pa.string()),
+        ),
+    )
+    result = df.collect()
+    assert len(result) == 1
+    result = result[0]
+    assert result.column(0) == pa.array(["SGVsbG8", "V29ybGQ", "IQ"])
+    assert pa.array(result.column(1)).cast(pa.string()) == pa.array(
+        ["Hello", "World", "!"]
+    )
+
+
+@pytest.mark.parametrize(
+    ("python_datatype", "name", "expected"),
+    [
+        pytest.param(bool, "e", pa.bool_(), id="bool"),
+        pytest.param(int, "b", pa.int64(), id="int"),
+        pytest.param(float, "b", pa.float64(), id="float"),
+        pytest.param(str, "b", pa.string(), id="str"),
+    ],
+)
+def test_cast(df, python_datatype, name: str, expected):
+    df = df.select(
+        column(name).cast(python_datatype).alias("actual"),
+        column(name).cast(expected).alias("expected"),
+    )
+    result = df.collect()
+    result = result[0]
+    assert result.column(0) == result.column(1)
+
+
+@pytest.mark.parametrize(
+    ("negated", "low", "high", "expected"),
+    [
+        pytest.param(False, 3, 5, {"filtered": [4, 5]}),
+        pytest.param(False, 4, 5, {"filtered": [4, 5]}),
+        pytest.param(True, 3, 5, {"filtered": [6]}),
+        pytest.param(True, 4, 6, []),
+    ],
+)
+def test_between(df, negated, low, high, expected):
+    df = df.filter(column("b").between(low, high, negated=negated)).select(
+        column("b").alias("filtered")
+    )
+
+    actual = df.collect()
+
+    if expected:
+        actual = actual[0].to_pydict()
+        assert actual == expected
+    else:
+        assert len(actual) == 0  # the rows are empty
+
+
+def test_between_default(df):
+    df = df.filter(column("b").between(3, 5)).select(column("b").alias("filtered"))
+    expected = {"filtered": [4, 5]}
+
+    actual = df.collect()[0].to_pydict()
+    assert actual == expected
+
+
+def test_alias_with_metadata(df):
+    df = df.select(f.alias(f.col("a"), "b", {"key": "value"}))
+    assert df.schema().field("b").metadata == {b"key": b"value"}
+
+
+def test_coalesce(df):
+    # Create a DataFrame with null values
+    ctx = SessionContext()
+    batch = pa.RecordBatch.from_arrays(
+        [
+            pa.array(["Hello", None, "!"]),  # string column with null
+            pa.array([4, None, 6]),  # integer column with null
+            pa.array(["hello ", None, " !"]),  # string column with null
+            pa.array(
+                [
+                    datetime(2022, 12, 31, tzinfo=DEFAULT_TZ),
+                    None,
+                    datetime(2020, 7, 2, tzinfo=DEFAULT_TZ),
+                ]
+            ),  # datetime with null
+            pa.array([False, None, True]),  # boolean column with null
+        ],
+        names=["a", "b", "c", "d", "e"],
+    )
+    df_with_nulls = ctx.create_dataframe([[batch]])
+
+    # Test coalesce with different data types
+    result_df = df_with_nulls.select(
+        f.coalesce(column("a"), literal("default")).alias("a_coalesced"),
+        f.coalesce(column("b"), literal(0)).alias("b_coalesced"),
+        f.coalesce(column("c"), literal("default")).alias("c_coalesced"),
+        f.coalesce(column("d"), literal(datetime(2000, 1, 1, tzinfo=DEFAULT_TZ))).alias(
+            "d_coalesced"
+        ),
+        f.coalesce(column("e"), literal(value=False)).alias("e_coalesced"),
+    )
+
+    result = result_df.collect()[0]
+
+    # Verify results
+    assert result.column(0) == pa.array(
+        ["Hello", "default", "!"], type=pa.string_view()
+    )
+    assert result.column(1) == pa.array([4, 0, 6], type=pa.int64())
+    assert result.column(2) == pa.array(
+        ["hello ", "default", " !"], type=pa.string_view()
+    )
+    assert result.column(3).to_pylist() == [
+        datetime(2022, 12, 31, tzinfo=DEFAULT_TZ),
+        datetime(2000, 1, 1, tzinfo=DEFAULT_TZ),
+        datetime(2020, 7, 2, tzinfo=DEFAULT_TZ),
+    ]
+    assert result.column(4) == pa.array([False, False, True], type=pa.bool_())
+
+    # Test multiple arguments
+    result_df = df_with_nulls.select(
+        f.coalesce(column("a"), literal(None), literal("fallback")).alias(
+            "multi_coalesce"
+        )
+    )
+    result = result_df.collect()[0]
+    assert result.column(0) == pa.array(
+        ["Hello", "fallback", "!"], type=pa.string_view()
+    )
diff --git a/datafusion/tests/test_imports.py b/python/tests/test_imports.py
similarity index 88%
rename from datafusion/tests/test_imports.py
rename to python/tests/test_imports.py
index 766ddce89..fca94b35a 100644
--- a/datafusion/tests/test_imports.py
+++ b/python/tests/test_imports.py
@@ -15,77 +15,69 @@
 # specific language governing permissions and limitations
 # under the License.
 
-import pytest
-
 import datafusion
+import pytest
 from datafusion import (
     AggregateUDF,
     DataFrame,
-    SessionContext,
     ScalarUDF,
+    SessionContext,
     functions,
 )
-
 from datafusion.common import (
-    DFField,
     DFSchema,
 )
-
 from datafusion.expr import (
-    Expr,
-    Column,
-    Literal,
-    BinaryExpr,
-    AggregateFunction,
-    Projection,
-    TableScan,
-    Filter,
-    Limit,
     Aggregate,
-    Sort,
-    Analyze,
-    Join,
-    JoinType,
-    JoinConstraint,
-    CrossJoin,
-    Union,
-    Like,
-    ILike,
-    SimilarTo,
-    ScalarVariable,
+    AggregateFunction,
     Alias,
-    GetIndexedField,
-    Not,
-    IsNotNull,
-    IsTrue,
-    IsFalse,
-    IsUnknown,
-    IsNotTrue,
-    IsNotFalse,
-    IsNotUnknown,
-    Negative,
-    ScalarFunction,
-    BuiltinScalarFunction,
-    InList,
-    Exists,
-    Subquery,
-    InSubquery,
-    ScalarSubquery,
-    GroupingSet,
-    Placeholder,
+    Analyze,
+    Between,
+    BinaryExpr,
     Case,
     Cast,
-    TryCast,
-    SubqueryAlias,
-    Between,
-    Explain,
-    Extension,
+    Column,
     CreateMemoryTable,
     CreateView,
     Distinct,
     DropTable,
-    Repartition,
+    Exists,
+    Explain,
+    Expr,
+    Extension,
+    Filter,
+    GroupingSet,
+    ILike,
+    InList,
+    InSubquery,
+    IsFalse,
+    IsNotFalse,
+    IsNotNull,
+    IsNotTrue,
+    IsNotUnknown,
+    IsTrue,
+    IsUnknown,
+    Join,
+    JoinConstraint,
+    JoinType,
+    Like,
+    Limit,
+    Literal,
+    Negative,
+    Not,
     Partitioning,
+    Placeholder,
+    Projection,
+    Repartition,
+    ScalarSubquery,
+    ScalarVariable,
+    SimilarTo,
+    Sort,
+    Subquery,
+    SubqueryAlias,
+    TableScan,
+    TryCast,
+    Union,
 )
 
 
@@ -98,13 +90,24 @@ def test_datafusion_python_version():
 
 
 def test_class_module_is_datafusion():
+    # context
     for klass in [
         SessionContext,
+    ]:
+        assert klass.__module__ == "datafusion.context"
+
+    # dataframe
+    for klass in [
         DataFrame,
-        ScalarUDF,
+    ]:
+        assert klass.__module__ == "datafusion.dataframe"
+
+    # udf
+    for klass in [
         AggregateUDF,
+        ScalarUDF,
     ]:
-        assert klass.__module__ == "datafusion"
+        assert klass.__module__ == "datafusion.user_defined"
 
     # expressions
     for klass in [Expr, Column, Literal, BinaryExpr, AggregateFunction]:
@@ -122,14 +125,12 @@ def test_class_module_is_datafusion():
         Join,
         JoinType,
         JoinConstraint,
-        CrossJoin,
         Union,
         Like,
         ILike,
         SimilarTo,
         ScalarVariable,
         Alias,
-        GetIndexedField,
         Not,
         IsNotNull,
         IsTrue,
@@ -139,8 +140,6 @@ def test_class_module_is_datafusion():
         IsNotFalse,
         IsNotUnknown,
         Negative,
-        ScalarFunction,
-        BuiltinScalarFunction,
         InList,
         Exists,
         Subquery,
@@ -165,19 +164,20 @@ def test_class_module_is_datafusion():
         assert klass.__module__ == "datafusion.expr"
 
     # schema
-    for klass in [DFField, DFSchema]:
+    for klass in [DFSchema]:
         assert klass.__module__ == "datafusion.common"
 
 
 def test_import_from_functions_submodule():
-    from datafusion.functions import abs, sin  # noqa
+    from datafusion.functions import abs as df_abs
+    from datafusion.functions import sin
 
-    assert functions.abs is abs
+    assert functions.abs is df_abs
     assert functions.sin is sin
 
     msg = "cannot import name 'foobar' from 'datafusion.functions'"
     with pytest.raises(ImportError, match=msg):
-        from datafusion.functions import foobar  # noqa
+        from datafusion.functions import foobar  # noqa: F401
 
 
 def test_classes_are_inheritable():
diff --git a/datafusion/tests/test_indexing.py b/python/tests/test_indexing.py
similarity index 94%
rename from datafusion/tests/test_indexing.py
rename to python/tests/test_indexing.py
index 9e65c0efd..e4c60b55d 100644
--- a/datafusion/tests/test_indexing.py
+++ b/python/tests/test_indexing.py
@@ -17,7 +17,6 @@
 
 import pyarrow as pa
 import pytest
-
 from datafusion import SessionContext
 
 
@@ -44,7 +43,8 @@ def test_err(df):
     with pytest.raises(Exception) as e_info:
         df["c"]
 
-    assert "Schema error: No field named 'c'" in e_info.value.args[0]
+    for e in ["Schema error", "No field named c"]:
+        assert e in e_info.value.args[0]
 
     with pytest.raises(Exception) as e_info:
         df[1]
diff --git a/python/tests/test_input.py b/python/tests/test_input.py
new file mode 100644
index 000000000..4663f6148
--- /dev/null
+++ b/python/tests/test_input.py
@@ -0,0 +1,32 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import pathlib
+
+from datafusion.input.location import LocationInputPlugin
+
+
+def test_location_input():
+    location_input = LocationInputPlugin()
+
+    cwd = pathlib.Path.cwd()
+    input_file = cwd / "testing/data/parquet/generated_simple_numerics/blogs.parquet"
+    table_name = "blog"
+    tbl = location_input.build_table(str(input_file), table_name)
+    assert tbl.name == "blog"
+    assert len(tbl.columns) == 3
+    assert "blogs.parquet" in tbl.filepaths[0]
diff --git a/python/tests/test_io.py b/python/tests/test_io.py
new file mode 100644
index 000000000..9f56f74d7
--- /dev/null
+++ b/python/tests/test_io.py
@@ -0,0 +1,138 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from pathlib import Path
+
+import pyarrow as pa
+import pytest
+from datafusion import column
+from datafusion.io import read_avro, read_csv, read_json, read_parquet
+
+from .utils import range_table
+
+
+def test_read_json_global_ctx(ctx):
+    path = Path(__file__).parent.resolve()
+
+    # Default
+    test_data_path = Path(path) / "data_test_context" / "data.json"
+    df = read_json(test_data_path)
+    result = df.collect()
+
+    assert result[0].column(0) == pa.array(["a", "b", "c"])
+    assert result[0].column(1) == pa.array([1, 2, 3])
+
+    # Schema
+    schema = pa.schema(
+        [
+            pa.field("A", pa.string(), nullable=True),
+        ]
+    )
+    df = read_json(test_data_path, schema=schema)
+    result = df.collect()
+
+    assert result[0].column(0) == pa.array(["a", "b", "c"])
+    assert result[0].schema == schema
+
+    # File extension
+    test_data_path = Path(path) / "data_test_context" / "data.json"
+    df = read_json(test_data_path, file_extension=".json")
+    result = df.collect()
+
+    assert result[0].column(0) == pa.array(["a", "b", "c"])
+    assert result[0].column(1) == pa.array([1, 2, 3])
+
+
+def test_read_parquet_global():
+    parquet_df = read_parquet(path="parquet/data/alltypes_plain.parquet")
+    parquet_df.show()
+    assert parquet_df is not None
+
+    path = Path.cwd() / "parquet/data/alltypes_plain.parquet"
+    parquet_df = read_parquet(path=path)
+    assert parquet_df is not None
+
+
+def test_read_csv():
+    csv_df = read_csv(path="testing/data/csv/aggregate_test_100.csv")
+    csv_df.select(column("c1")).show()
+
+
+def test_read_csv_list():
+    csv_df = read_csv(path=["testing/data/csv/aggregate_test_100.csv"])
+    expected = csv_df.count() * 2
+
+    double_csv_df = read_csv(
+        path=[
+            "testing/data/csv/aggregate_test_100.csv",
+            "testing/data/csv/aggregate_test_100.csv",
+        ]
+    )
+    actual = double_csv_df.count()
+
+    double_csv_df.select(column("c1")).show()
+    assert actual == expected
+
+
+def test_read_avro():
+    avro_df = read_avro(path="testing/data/avro/alltypes_plain.avro")
+    avro_df.show()
+    assert avro_df is not None
+
+    path = Path.cwd() / "testing/data/avro/alltypes_plain.avro"
+    avro_df = read_avro(path=path)
+    assert avro_df is not None
+
+
+def test_arrow_c_stream_large_dataset(ctx):
+    """DataFrame streaming yields batches incrementally using Arrow APIs.
+
+    This test constructs a DataFrame that would be far larger than available
+    memory if materialized. Use the public API
+    ``pa.RecordBatchReader.from_stream(df)`` (which is same as
+    ``pa.RecordBatchReader._import_from_c_capsule(df.__arrow_c_stream__())``)
+    to read record batches incrementally without collecting the full dataset,
+    so reading a handful of batches should not exhaust process memory.
+    """
+    # Create a very large DataFrame using range; this would be terabytes if collected
+    df = range_table(ctx, 0, 1 << 40)
+
+    reader = pa.RecordBatchReader.from_stream(df)
+
+    # Track RSS before consuming batches
+    # RSS is a practical measure of RAM usage visible to the OS. It excludes memory
+    # that has been swapped out and provides a simple cross-platform-ish indicator
+    # (psutil normalizes per-OS sources).
+    psutil = pytest.importorskip("psutil")
+    process = psutil.Process()
+    start_rss = process.memory_info().rss
+
+    for _ in range(5):
+        batch = reader.read_next_batch()
+        assert batch is not None
+        assert len(batch) > 0
+        current_rss = process.memory_info().rss
+        # Ensure memory usage hasn't grown substantially (>50MB)
+        assert current_rss - start_rss < 50 * 1024 * 1024
+
+
+def test_table_from_arrow_c_stream(ctx, fail_collect):
+    df = range_table(ctx, 0, 10)
+
+    table = pa.table(df)
+    assert table.shape == (10, 1)
+    assert table.column_names == ["value"]
diff --git a/python/tests/test_plans.py b/python/tests/test_plans.py
new file mode 100644
index 000000000..396acbe97
--- /dev/null
+++ b/python/tests/test_plans.py
@@ -0,0 +1,42 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import pytest
+from datafusion import ExecutionPlan, LogicalPlan, SessionContext
+
+
+# Note: We must use CSV because memory tables are currently not supported for
+# conversion to/from protobuf.
+@pytest.fixture
+def df():
+    ctx = SessionContext()
+    return ctx.read_csv(path="testing/data/csv/aggregate_test_100.csv").select("c1")
+
+
+def test_logical_plan_to_proto(ctx, df) -> None:
+    logical_plan_bytes = df.logical_plan().to_proto()
+    logical_plan = LogicalPlan.from_proto(ctx, logical_plan_bytes)
+
+    df_round_trip = ctx.create_dataframe_from_logical_plan(logical_plan)
+
+    assert df.collect() == df_round_trip.collect()
+
+    original_execution_plan = df.execution_plan()
+    execution_plan_bytes = original_execution_plan.to_proto()
+    execution_plan = ExecutionPlan.from_proto(ctx, execution_plan_bytes)
+
+    assert str(original_execution_plan) == str(execution_plan)
diff --git a/python/tests/test_pyclass_frozen.py b/python/tests/test_pyclass_frozen.py
new file mode 100644
index 000000000..33338bf54
--- /dev/null
+++ b/python/tests/test_pyclass_frozen.py
@@ -0,0 +1,106 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""Ensure exposed pyclasses default to frozen."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+PYCLASS_RE = re.compile(
+    r"#\[\s*pyclass\s*(?:\((?P<args>.*?)\))?\s*\]",
+    re.DOTALL,
+)
+ARG_STRING_RE = re.compile(
+    r"(?P<key>[A-Za-z_][A-Za-z0-9_]*)\s*=\s*\"(?P<value>[^\"]+)\"",
+)
+STRUCT_NAME_RE = re.compile(
+    r"\b(?:pub\s+)?(?:struct|enum)\s+" r"(?P<name>[A-Za-z_][A-Za-z0-9_]*)",
+)
+
+
+@dataclass
+class PyClass:
+    module: str
+    name: str
+    frozen: bool
+    source: Path
+
+
+def iter_pyclasses(root: Path) -> Iterator[PyClass]:
+    for path in root.rglob("*.rs"):
+        text = path.read_text(encoding="utf8")
+        for match in PYCLASS_RE.finditer(text):
+            args = match.group("args") or ""
+            frozen = re.search(r"\bfrozen\b", args) is not None
+
+            module = None
+            name = None
+            for arg_match in ARG_STRING_RE.finditer(args):
+                key = arg_match.group("key")
+                value = arg_match.group("value")
+                if key == "module":
+                    module = value
+                elif key == "name":
+                    name = value
+
+            remainder = text[match.end() :]
+            struct_match = STRUCT_NAME_RE.search(remainder)
+            struct_name = struct_match.group("name") if struct_match else None
+
+            yield PyClass(
+                module=module or "datafusion",
+                name=name or struct_name or "<unknown>",
+                frozen=frozen,
+                source=path,
+            )
+
+
+def test_pyclasses_are_frozen() -> None:
+    allowlist = {
+        # NOTE: Any new exceptions must include a justification comment
+        # in the Rust source and, ideally, a follow-up issue to remove
+        # the exemption.
+        ("datafusion.common", "SqlTable"),
+        ("datafusion.common", "SqlView"),
+        ("datafusion.common", "DataTypeMap"),
+        ("datafusion.expr", "TryCast"),
+        ("datafusion.expr", "WriteOp"),
+    }
+
+    unfrozen = [
+        pyclass
+        for pyclass in iter_pyclasses(Path("src"))
+        if not pyclass.frozen and (pyclass.module, pyclass.name) not in allowlist
+    ]
+
+    if unfrozen:
+        msg = (
+            "Found pyclasses missing `frozen`; add them to the allowlist only "
+            "with a justification comment and follow-up plan:\n"
+        )
+        msg += "\n".join(
+            (f"- {pyclass.module}.{pyclass.name} (defined in {pyclass.source})")
+            for pyclass in unfrozen
+        )
+        assert not unfrozen, msg
diff --git a/python/tests/test_sql.py b/python/tests/test_sql.py
new file mode 100644
index 000000000..92c311930
--- /dev/null
+++ b/python/tests/test_sql.py
@@ -0,0 +1,598 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+import gzip
+from pathlib import Path
+
+import numpy as np
+import pyarrow as pa
+import pyarrow.dataset as ds
+import pytest
+from datafusion import SessionContext, col, udf
+from datafusion.object_store import Http
+from pyarrow.csv import write_csv
+
+from . import generic as helpers
+
+
+def test_no_table(ctx):
+    with pytest.raises(
+        ValueError,
+        match=r"^Error during planning: table 'datafusion.public.b' not found$",
+    ):
+        ctx.sql("SELECT a FROM b").collect()
+
+
+def test_register_csv(ctx, tmp_path):
+    path = tmp_path / "test.csv"
+    gzip_path = tmp_path / "test.csv.gz"
+
+    table = pa.Table.from_arrays(
+        [
+            [1, 2, 3, 4],
+            ["a", "b", "c", "d"],
+            [1.1, 2.2, 3.3, 4.4],
+        ],
+        names=["int", "str", "float"],
+    )
+    write_csv(table, path)
+
+    with Path.open(path, "rb") as csv_file, gzip.open(gzip_path, "wb") as gzipped_file:
+        gzipped_file.writelines(csv_file)
+
+    ctx.register_csv("csv", path)
+    ctx.register_csv("csv1", str(path))
+    ctx.register_csv(
+        "csv2",
+        path,
+        has_header=True,
+        delimiter=",",
+        schema_infer_max_records=10,
+    )
+    ctx.register_csv(
+        "csv_gzip",
+        gzip_path,
+        file_extension="gz",
+        file_compression_type="gzip",
+    )
+
+    alternative_schema = pa.schema(
+        [
+            ("some_int", pa.int16()),
+            ("some_bytes", pa.string()),
+            ("some_floats", pa.float32()),
+        ]
+    )
+    ctx.register_csv("csv3", path, schema=alternative_schema)
+
+    assert ctx.catalog().schema().names() == {
+        "csv",
+        "csv1",
+        "csv2",
+        "csv3",
+        "csv_gzip",
+    }
+
+    for table in ["csv", "csv1", "csv2", "csv_gzip"]:
+        result = ctx.sql(f"SELECT COUNT(int) AS cnt FROM {table}").collect()
+        result = pa.Table.from_batches(result)
+        assert result.to_pydict() == {"cnt": [4]}
+
+    result = ctx.sql("SELECT * FROM csv3").collect()
+    result = pa.Table.from_batches(result)
+    assert result.schema == alternative_schema
+
+    with pytest.raises(ValueError, match="delimiter must be a single character"):
+        ctx.register_csv("csv4", path, delimiter="wrong")
+
+    with pytest.raises(
+        ValueError,
+        match="file_compression_type must one of: gzip, bz2, xz, zstd",
+    ):
+        ctx.register_csv("csv4", path, file_compression_type="rar")
+
+
+def test_register_csv_list(ctx, tmp_path):
+    path = tmp_path / "test.csv"
+
+    int_values = [1, 2, 3, 4]
+    table = pa.Table.from_arrays(
+        [
+            int_values,
+            ["a", "b", "c", "d"],
+            [1.1, 2.2, 3.3, 4.4],
+        ],
+        names=["int", "str", "float"],
+    )
+    write_csv(table, path)
+    ctx.register_csv("csv", path)
+
+    csv_df = ctx.table("csv")
+    expected_count = csv_df.count() * 2
+    ctx.register_csv(
+        "double_csv",
+        path=[
+            path,
+            path,
+        ],
+    )
+
+    double_csv_df = ctx.table("double_csv")
+    actual_count = double_csv_df.count()
+    assert actual_count == expected_count
+
+    int_sum = ctx.sql("select sum(int) from double_csv").to_pydict()[
+        "sum(double_csv.int)"
+    ][0]
+    assert int_sum == 2 * sum(int_values)
+
+
+def test_register_http_csv(ctx):
+    url = "https://raw.githubusercontent.com/ibis-project/testing-data/refs/heads/master/csv/diamonds.csv"
+    ctx.register_object_store("", Http(url))
+    ctx.register_csv("remote", url)
+    assert ctx.table_exist("remote")
+    res, *_ = ctx.sql("SELECT COUNT(*) AS total FROM remote").to_pylist()
+    assert res["total"] > 0
+
+
+def test_register_parquet(ctx, tmp_path):
+    path = helpers.write_parquet(tmp_path / "a.parquet", helpers.data())
+    ctx.register_parquet("t", path)
+    ctx.register_parquet("t1", str(path))
+    assert ctx.catalog().schema().names() == {"t", "t1"}
+
+    result = ctx.sql("SELECT COUNT(a) AS cnt FROM t").collect()
+    result = pa.Table.from_batches(result)
+    assert result.to_pydict() == {"cnt": [100]}
+
+
+@pytest.mark.filterwarnings(
+    "ignore:using literals for table_partition_cols data types:DeprecationWarning"
+)
+@pytest.mark.parametrize(
+    ("path_to_str", "legacy_data_type"), [(True, False), (False, False), (False, True)]
+)
+def test_register_parquet_partitioned(ctx, tmp_path, path_to_str, legacy_data_type):
+    dir_root = tmp_path / "dataset_parquet_partitioned"
+    dir_root.mkdir(exist_ok=False)
+    (dir_root / "grp=a").mkdir(exist_ok=False)
+    (dir_root / "grp=b").mkdir(exist_ok=False)
+
+    table = pa.Table.from_arrays(
+        [
+            [1, 2, 3, 4],
+            ["a", "b", "c", "d"],
+            [1.1, 2.2, 3.3, 4.4],
+        ],
+        names=["int", "str", "float"],
+    )
+    pa.parquet.write_table(table.slice(0, 3), dir_root / "grp=a/file.parquet")
+    pa.parquet.write_table(table.slice(3, 4), dir_root / "grp=b/file.parquet")
+
+    dir_root = str(dir_root) if path_to_str else dir_root
+
+    partition_data_type = "string" if legacy_data_type else pa.string()
+
+    if legacy_data_type:
+        with pytest.warns(DeprecationWarning):
+            ctx.register_parquet(
+                "datapp",
+                dir_root,
+                table_partition_cols=[("grp", partition_data_type)],
+                parquet_pruning=True,
+                file_extension=".parquet",
+            )
+    else:
+        ctx.register_parquet(
+            "datapp",
+            dir_root,
+            table_partition_cols=[("grp", partition_data_type)],
+            parquet_pruning=True,
+            file_extension=".parquet",
+        )
+
+    assert ctx.catalog().schema().names() == {"datapp"}
+
+    result = ctx.sql("SELECT grp, COUNT(*) AS cnt FROM datapp GROUP BY grp").collect()
+    result = pa.Table.from_batches(result)
+
+    rd = result.to_pydict()
+    assert dict(zip(rd["grp"], rd["cnt"], strict=False)) == {"a": 3, "b": 1}
+
+
+@pytest.mark.parametrize("path_to_str", [True, False])
+def test_register_dataset(ctx, tmp_path, path_to_str):
+    path = helpers.write_parquet(tmp_path / "a.parquet", helpers.data())
+    path = str(path) if path_to_str else path
+    dataset = ds.dataset(path, format="parquet")
+
+    ctx.register_dataset("t", dataset)
+    assert ctx.catalog().schema().names() == {"t"}
+
+    result = ctx.sql("SELECT COUNT(a) AS cnt FROM t").collect()
+    result = pa.Table.from_batches(result)
+    assert result.to_pydict() == {"cnt": [100]}
+
+
+def test_register_json(ctx, tmp_path):
+    path = Path(__file__).parent.resolve()
+    test_data_path = Path(path) / "data_test_context" / "data.json"
+    gzip_path = tmp_path / "data.json.gz"
+
+    with (
+        Path.open(test_data_path, "rb") as json_file,
+        gzip.open(gzip_path, "wb") as gzipped_file,
+    ):
+        gzipped_file.writelines(json_file)
+
+    ctx.register_json("json", test_data_path)
+    ctx.register_json("json1", str(test_data_path))
+    ctx.register_json(
+        "json2",
+        test_data_path,
+        schema_infer_max_records=10,
+    )
+    ctx.register_json(
+        "json_gzip",
+        gzip_path,
+        file_extension="gz",
+        file_compression_type="gzip",
+    )
+    ctx.register_json(
+        "json_gzip1",
+        str(gzip_path),
+        file_extension="gz",
+        file_compression_type="gzip",
+    )
+
+    alternative_schema = pa.schema(
+        [
+            ("some_int", pa.int16()),
+            ("some_bytes", pa.string()),
+            ("some_floats", pa.float32()),
+        ]
+    )
+    ctx.register_json("json3", path, schema=alternative_schema)
+
+    assert ctx.catalog().schema().names() == {
+        "json",
+        "json1",
+        "json2",
+        "json3",
+        "json_gzip",
+        "json_gzip1",
+    }
+
+    for table in ["json", "json1", "json2", "json_gzip"]:
+        result = ctx.sql(f'SELECT COUNT("B") AS cnt FROM {table}').collect()
+        result = pa.Table.from_batches(result)
+        assert result.to_pydict() == {"cnt": [3]}
+
+    result = ctx.sql("SELECT * FROM json3").collect()
+    result = pa.Table.from_batches(result, alternative_schema)
+    assert result.schema == alternative_schema
+
+    with pytest.raises(
+        ValueError,
+        match="file_compression_type must one of: gzip, bz2, xz, zstd",
+    ):
+        ctx.register_json("json4", gzip_path, file_compression_type="rar")
+
+
+def test_register_avro(ctx):
+    path = "testing/data/avro/alltypes_plain.avro"
+    ctx.register_avro("alltypes_plain", path)
+    result = ctx.sql(
+        "SELECT SUM(tinyint_col) as tinyint_sum FROM alltypes_plain"
+    ).collect()
+    result = pa.Table.from_batches(result).to_pydict()
+    assert result["tinyint_sum"][0] > 0
+
+    alternative_schema = pa.schema(
+        [
+            pa.field("id", pa.int64()),
+        ]
+    )
+
+    ctx.register_avro(
+        "alltypes_plain_schema",
+        path,
+        schema=alternative_schema,
+    )
+    result = ctx.sql("SELECT * FROM alltypes_plain_schema").collect()
+    result = pa.Table.from_batches(result)
+    assert result.schema == alternative_schema
+
+
+def test_execute(ctx, tmp_path):
+    data = [1, 1, 2, 2, 3, 11, 12]
+
+    # single column, "a"
+    path = helpers.write_parquet(tmp_path / "a.parquet", pa.array(data))
+    ctx.register_parquet("t", path)
+
+    assert ctx.catalog().schema().names() == {"t"}
+
+    # count
+    result = ctx.sql("SELECT COUNT(a) AS cnt FROM t WHERE a IS NOT NULL").collect()
+    ctx.sql("SELECT COUNT(a) AS cnt FROM t WHERE a IS NOT NULL").show()
+
+    expected_schema = pa.schema([("cnt", pa.int64(), False)])
+    expected_values = pa.array([7], type=pa.int64())
+    expected = [pa.RecordBatch.from_arrays([expected_values], schema=expected_schema)]
+
+    assert result == expected
+
+    # where
+    expected_values = pa.array([2], type=pa.int64())
+    expected = [pa.RecordBatch.from_arrays([expected_values], schema=expected_schema)]
+    result = ctx.sql("SELECT COUNT(a) AS cnt FROM t WHERE a > 10").collect()
+    assert result == expected
+
+    # group by
+    results = ctx.sql(
+        "SELECT CAST(a as int) AS a, COUNT(a) AS cnt FROM t GROUP BY a"
+    ).collect()
+
+    # group by returns batches
+    result_keys = []
+    result_values = []
+    for result in results:
+        pydict = result.to_pydict()
+        result_keys.extend(pydict["a"])
+        result_values.extend(pydict["cnt"])
+
+    result_keys, result_values = (
+        list(t)
+        for t in zip(
+            *sorted(zip(result_keys, result_values, strict=False)), strict=False
+        )
+    )
+
+    assert result_keys == [1, 2, 3, 11, 12]
+    assert result_values == [2, 2, 1, 1, 1]
+
+    # order by
+    result = ctx.sql(
+        "SELECT a, CAST(a AS int) AS a_int FROM t ORDER BY a DESC LIMIT 2"
+    ).collect()
+    expected_a = pa.array([50.0219, 50.0152], pa.float64())
+    expected_cast = pa.array([50, 50], pa.int32())
+    expected = [pa.RecordBatch.from_arrays([expected_a, expected_cast], ["a", "a_int"])]
+    np.testing.assert_equal(expected[0].column(1), expected[0].column(1))
+
+
+def test_cast(ctx, tmp_path):
+    """Verify that we can cast"""
+    path = helpers.write_parquet(tmp_path / "a.parquet", helpers.data())
+    ctx.register_parquet("t", path)
+
+    valid_types = [
+        "smallint",
+        "int",
+        "bigint",
+        "float(32)",
+        "float(64)",
+        "float",
+    ]
+
+    select = ", ".join([f"CAST(9 AS {t}) AS A{i}" for i, t in enumerate(valid_types)])
+
+    # can execute, which implies that we can cast
+    ctx.sql(f"SELECT {select} FROM t").collect()
+
+
+@pytest.mark.parametrize(
+    ("fn", "input_types", "output_type", "input_values", "expected_values"),
+    [
+        (
+            lambda x: x,
+            [pa.float64()],
+            pa.float64(),
+            [-1.2, None, 1.2],
+            [-1.2, None, 1.2],
+        ),
+        (
+            lambda x: x.is_null(),
+            [pa.float64()],
+            pa.bool_(),
+            [-1.2, None, 1.2],
+            [False, True, False],
+        ),
+    ],
+)
+def test_udf(
+    ctx, tmp_path, fn, input_types, output_type, input_values, expected_values
+):
+    # write to disk
+    path = helpers.write_parquet(tmp_path / "a.parquet", pa.array(input_values))
+    ctx.register_parquet("t", path)
+
+    func = udf(fn, input_types, output_type, name="func", volatility="immutable")
+    ctx.register_udf(func)
+
+    batches = ctx.sql("SELECT func(a) AS tt FROM t").collect()
+    result = batches[0].column(0)
+
+    assert result == pa.array(expected_values)
+
+
+_null_mask = np.array([False, True, False])
+
+
+@pytest.mark.parametrize(
+    "arr",
+    [
+        pa.array(["a", "b", "c"], pa.utf8(), _null_mask),
+        pa.array(["a", "b", "c"], pa.large_utf8(), _null_mask),
+        pa.array([b"1", b"2", b"3"], pa.binary(), _null_mask),
+        pa.array([b"1111", b"2222", b"3333"], pa.large_binary(), _null_mask),
+        pa.array([False, True, True], None, _null_mask),
+        pa.array([0, 1, 2], None),
+        helpers.data_binary_other(),
+        helpers.data_date32(),
+        helpers.data_with_nans(),
+        pytest.param(
+            pa.array([b"1111", b"2222", b"3333"], pa.binary(4), _null_mask),
+            id="binary4",
+        ),
+        # `timestamp[s]` does not roundtrip for pyarrow.parquet: https://github.com/apache/arrow/issues/41382
+        pytest.param(
+            helpers.data_datetime("s"),
+            id="datetime_s",
+            marks=pytest.mark.xfail(
+                reason="pyarrow.parquet does not support timestamp[s] roundtrips"
+            ),
+        ),
+        pytest.param(
+            helpers.data_datetime("ms"),
+            id="datetime_ms",
+        ),
+        pytest.param(
+            helpers.data_datetime("us"),
+            id="datetime_us",
+        ),
+        pytest.param(
+            helpers.data_datetime("ns"),
+            id="datetime_ns",
+        ),
+        # Not writtable to parquet
+        pytest.param(helpers.data_timedelta("s"), id="timedelta_s"),
+        pytest.param(helpers.data_timedelta("ms"), id="timedelta_ms"),
+        pytest.param(helpers.data_timedelta("us"), id="timedelta_us"),
+        pytest.param(helpers.data_timedelta("ns"), id="timedelta_ns"),
+    ],
+)
+def test_simple_select(ctx, tmp_path, arr):
+    path = helpers.write_parquet(tmp_path / "a.parquet", arr)
+    ctx.register_parquet("t", path)
+
+    batches = ctx.sql("SELECT a AS tt FROM t").collect()
+    result = batches[0].column(0)
+
+    # In DF 43.0.0 we now default to having BinaryView and StringView
+    # so the array that is saved to the parquet is slightly different
+    # than the array read. Convert to values for comparison.
+    if isinstance(result, pa.BinaryViewArray | pa.StringViewArray):
+        arr = arr.tolist()
+        result = result.tolist()
+
+    np.testing.assert_equal(result, arr)
+
+
+@pytest.mark.parametrize(
+    "file_sort_order", [None, [[col("int").sort(ascending=True, nulls_first=True)]]]
+)
+@pytest.mark.parametrize("pass_schema", [True, False])
+@pytest.mark.parametrize("path_to_str", [True, False])
+def test_register_listing_table(
+    ctx, tmp_path, pass_schema, file_sort_order, path_to_str
+):
+    dir_root = tmp_path / "dataset_parquet_partitioned"
+    dir_root.mkdir(exist_ok=False)
+    (dir_root / "grp=a/date=2020-10-05").mkdir(exist_ok=False, parents=True)
+    (dir_root / "grp=a/date=2021-10-05").mkdir(exist_ok=False, parents=True)
+    (dir_root / "grp=b/date=2020-10-05").mkdir(exist_ok=False, parents=True)
+
+    table = pa.Table.from_arrays(
+        [
+            [1, 2, 3, 4, 5, 6, 7],
+            ["a", "b", "c", "d", "e", "f", "g"],
+            [1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7],
+        ],
+        names=["int", "str", "float"],
+    )
+    pa.parquet.write_table(
+        table.slice(0, 3), dir_root / "grp=a/date=2020-10-05/file.parquet"
+    )
+    pa.parquet.write_table(
+        table.slice(3, 2), dir_root / "grp=a/date=2021-10-05/file.parquet"
+    )
+    pa.parquet.write_table(
+        table.slice(5, 10), dir_root / "grp=b/date=2020-10-05/file.parquet"
+    )
+
+    dir_root = f"file://{dir_root}/" if path_to_str else dir_root
+
+    ctx.register_listing_table(
+        "my_table",
+        dir_root,
+        table_partition_cols=[("grp", pa.string()), ("date", pa.date64())],
+        file_extension=".parquet",
+        schema=table.schema if pass_schema else None,
+        file_sort_order=file_sort_order,
+    )
+    assert ctx.catalog().schema().names() == {"my_table"}
+
+    result = ctx.sql(
+        "SELECT grp, COUNT(*) AS count FROM my_table GROUP BY grp"
+    ).collect()
+    result = pa.Table.from_batches(result)
+
+    rd = result.to_pydict()
+    assert dict(zip(rd["grp"], rd["count"], strict=False)) == {"a": 5, "b": 2}
+
+    result = ctx.sql(
+        "SELECT grp, COUNT(*) AS count FROM my_table WHERE date='2020-10-05' GROUP BY grp"  # noqa: E501
+    ).collect()
+    result = pa.Table.from_batches(result)
+
+    rd = result.to_pydict()
+    assert dict(zip(rd["grp"], rd["count"], strict=False)) == {"a": 3, "b": 2}
+
+
+def test_parameterized_named_params(ctx, tmp_path) -> None:
+    path = helpers.write_parquet(tmp_path / "a.parquet", helpers.data())
+
+    df = ctx.read_parquet(path)
+    result = ctx.sql(
+        "SELECT COUNT(a) AS cnt, $lit_val as lit_val FROM $replaced_df",
+        lit_val=3,
+        replaced_df=df,
+    ).collect()
+    result = pa.Table.from_batches(result)
+    assert result.to_pydict() == {"cnt": [100], "lit_val": [3]}
+
+
+def test_parameterized_param_values(ctx: SessionContext) -> None:
+    # Test the parameters that should be handled by the parser rather
+    # than our manipulation of the query string by searching for tokens
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3, 4])],
+        names=["a"],
+    )
+
+    ctx.register_record_batches("t", [[batch]])
+    result = ctx.sql("SELECT a FROM t WHERE a < $val", param_values={"val": 3})
+    assert result.to_pydict() == {"a": [1, 2]}
+
+
+def test_parameterized_mixed_query(ctx: SessionContext) -> None:
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3, 4])],
+        names=["a"],
+    )
+    ctx.register_record_batches("t", [[batch]])
+    registered_df = ctx.table("t")
+
+    result = ctx.sql(
+        "SELECT $col_name FROM $df WHERE a < $val",
+        param_values={"val": 3},
+        df=registered_df,
+        col_name="a",
+    )
+    assert result.to_pydict() == {"a": [1, 2]}
diff --git a/datafusion/tests/test_store.py b/python/tests/test_store.py
similarity index 75%
rename from datafusion/tests/test_store.py
rename to python/tests/test_store.py
index d6f0db583..ac9af98f3 100644
--- a/datafusion/tests/test_store.py
+++ b/python/tests/test_store.py
@@ -15,32 +15,24 @@
 # specific language governing permissions and limitations
 # under the License.
 
-import os
-import pytest
+from pathlib import Path
 
+import pytest
 from datafusion import SessionContext
-from datafusion.object_store import LocalFileSystem
-
-
-@pytest.fixture
-def local():
-    return LocalFileSystem()
 
 
 @pytest.fixture
-def ctx(local):
-    ctx = SessionContext()
-    ctx.register_object_store("local", local, None)
-    return ctx
+def ctx():
+    return SessionContext()
 
 
 def test_read_parquet(ctx):
     ctx.register_parquet(
         "test",
-        f"file://{os.getcwd()}/testing/data/parquet",
-        [],
-        True,
-        ".parquet",
+        f"file://{Path.cwd()}/parquet/data/alltypes_plain.parquet",
+        table_partition_cols=[],
+        parquet_pruning=True,
+        file_extension=".parquet",
     )
     df = ctx.sql("SELECT * FROM test")
     assert isinstance(df.collect(), list)
diff --git a/python/tests/test_substrait.py b/python/tests/test_substrait.py
new file mode 100644
index 000000000..a5f59ba7e
--- /dev/null
+++ b/python/tests/test_substrait.py
@@ -0,0 +1,149 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import pyarrow as pa
+import pytest
+from datafusion import SessionContext
+from datafusion import substrait as ss
+
+
+@pytest.fixture
+def ctx():
+    return SessionContext()
+
+
+def test_substrait_serialization(ctx):
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+
+    ctx.register_record_batches("t", [[batch]])
+
+    assert ctx.catalog().schema().names() == {"t"}
+
+    # For now just make sure the method calls blow up
+    substrait_plan = ss.Serde.serialize_to_plan("SELECT * FROM t", ctx)
+    substrait_bytes = substrait_plan.encode()
+    assert isinstance(substrait_bytes, bytes)
+    substrait_bytes = ss.Serde.serialize_bytes("SELECT * FROM t", ctx)
+    substrait_plan = ss.Serde.deserialize_bytes(substrait_bytes)
+    logical_plan = ss.Consumer.from_substrait_plan(ctx, substrait_plan)
+
+    # demonstrate how to create a DataFrame from a deserialized logical plan
+    df = ctx.create_dataframe_from_logical_plan(logical_plan)
+
+    substrait_plan = ss.Producer.to_substrait_plan(df.logical_plan(), ctx)
+
+
+@pytest.mark.parametrize("path_to_str", [True, False])
+def test_substrait_file_serialization(ctx, tmp_path, path_to_str):
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+        names=["a", "b"],
+    )
+
+    ctx.register_record_batches("t", [[batch]])
+
+    assert ctx.catalog().schema().names() == {"t"}
+
+    path = tmp_path / "substrait_plan"
+    path = str(path) if path_to_str else path
+
+    sql_command = "SELECT * FROM T"
+    ss.Serde.serialize(sql_command, ctx, path)
+
+    expected_plan = ss.Serde.serialize_to_plan(sql_command, ctx)
+    actual_plan = ss.Serde.deserialize(path)
+
+    expected_logical_plan = ss.Consumer.from_substrait_plan(ctx, expected_plan)
+    expected_actual_plan = ss.Consumer.from_substrait_plan(ctx, actual_plan)
+
+    assert str(expected_logical_plan) == str(expected_actual_plan)
+
+
+def test_json_processing_round_trip(ctx: SessionContext):
+    ctx.register_record_batches("t", [[pa.record_batch({"a": [1]})]])
+    original_logical_plan = ctx.sql("SELECT * FROM t").logical_plan()
+
+    substrait_plan = ss.Producer.to_substrait_plan(original_logical_plan, ctx)
+    json_plan = substrait_plan.to_json()
+
+    expected = """\
+  "relations": [
+    {
+      "root": {
+        "input": {
+          "project": {
+            "common": {
+              "emit": {
+                "outputMapping": [
+                  1
+                ]
+              }
+            },
+            "input": {
+              "read": {
+                "baseSchema": {
+                  "names": [
+                    "a"
+                  ],
+                  "struct": {
+                    "types": [
+                      {
+                        "i64": {
+                          "nullability": "NULLABILITY_NULLABLE"
+                        }
+                      }
+                    ],
+                    "nullability": "NULLABILITY_REQUIRED"
+                  }
+                },
+                "namedTable": {
+                  "names": [
+                    "t"
+                  ]
+                }
+              }
+            },
+            "expressions": [
+              {
+                "selection": {
+                  "directReference": {
+                    "structField": {}
+                  },
+                  "rootReference": {}
+                }
+              }
+            ]
+          }
+        },
+        "names": [
+          "a"
+        ]
+      }
+    }
+  ]"""
+
+    assert expected in json_plan
+
+    round_trip_substrait_plan = ss.Plan.from_json(json_plan)
+    round_trip_logical_plan = ss.Consumer.from_substrait_plan(
+        ctx, round_trip_substrait_plan
+    )
+
+    assert round_trip_logical_plan == original_logical_plan
diff --git a/python/tests/test_udaf.py b/python/tests/test_udaf.py
new file mode 100644
index 000000000..8cd480e37
--- /dev/null
+++ b/python/tests/test_udaf.py
@@ -0,0 +1,296 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+import pyarrow as pa
+import pyarrow.compute as pc
+import pytest
+from datafusion import Accumulator, column, udaf
+
+
+class Summarize(Accumulator):
+    """Interface of a user-defined accumulation."""
+
+    def __init__(self, initial_value: float = 0.0, as_scalar: bool = False):
+        self._sum = initial_value
+        self.as_scalar = as_scalar
+
+    def state(self) -> list[pa.Scalar]:
+        if self.as_scalar:
+            return [pa.scalar(self._sum)]
+        return [self._sum]
+
+    def update(self, values: pa.Array) -> None:
+        # Not nice since pyarrow scalars can't be summed yet.
+        # This breaks on `None`
+        self._sum = self._sum + pc.sum(values).as_py()
+
+    def merge(self, states: list[pa.Array]) -> None:
+        # Not nice since pyarrow scalars can't be summed yet.
+        # This breaks on `None`
+        self._sum = self._sum + pc.sum(states[0]).as_py()
+
+    def evaluate(self) -> pa.Scalar:
+        if self.as_scalar:
+            return pa.scalar(self._sum)
+        return self._sum
+
+
+class NotSubclassOfAccumulator:
+    pass
+
+
+class MissingMethods(Accumulator):
+    def __init__(self):
+        self._sum = pa.scalar(0)
+
+    def state(self) -> list[pa.Scalar]:
+        return [self._sum]
+
+
+class CollectTimestamps(Accumulator):
+    def __init__(self, wrap_in_scalar: bool):
+        self._values: list[datetime] = []
+        self.wrap_in_scalar = wrap_in_scalar
+
+    def state(self) -> list[pa.Scalar]:
+        if self.wrap_in_scalar:
+            return [pa.scalar(self._values, type=pa.list_(pa.timestamp("ns")))]
+        return [pa.array(self._values, type=pa.timestamp("ns"))]
+
+    def update(self, values: pa.Array) -> None:
+        self._values.extend(values.to_pylist())
+
+    def merge(self, states: list[pa.Array]) -> None:
+        for state in states[0].to_pylist():
+            if state is not None:
+                self._values.extend(state)
+
+    def evaluate(self) -> pa.Scalar:
+        if self.wrap_in_scalar:
+            return pa.scalar(self._values, type=pa.list_(pa.timestamp("ns")))
+        return pa.array(self._values, type=pa.timestamp("ns"))
+
+
+@pytest.fixture
+def df(ctx):
+    # create a RecordBatch and a new DataFrame from it
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 4, 6])],
+        names=["a", "b"],
+    )
+    return ctx.create_dataframe([[batch]], name="test_table")
+
+
+def test_errors(df):
+    with pytest.raises(TypeError):
+        udaf(
+            NotSubclassOfAccumulator,
+            pa.float64(),
+            pa.float64(),
+            [pa.float64()],
+            volatility="immutable",
+        )
+
+    msg = (
+        "Can't instantiate abstract class MissingMethods (without an implementation "
+        "for abstract methods 'evaluate', 'merge', 'update'|with abstract methods "
+        "evaluate, merge, update)"
+    )
+    with pytest.raises(Exception, match=msg):
+        accum = udaf(  # noqa: F841
+            MissingMethods,
+            pa.int64(),
+            pa.int64(),
+            [pa.int64()],
+            volatility="immutable",
+        )
+
+
+def test_udaf_aggregate(df):
+    summarize = udaf(
+        Summarize,
+        pa.float64(),
+        pa.float64(),
+        [pa.float64()],
+        volatility="immutable",
+    )
+
+    df1 = df.aggregate([], [summarize(column("a"))])
+
+    # execute and collect the first (and only) batch
+    result = df1.collect()[0]
+
+    assert result.column(0) == pa.array([1.0 + 2.0 + 3.0])
+
+    df2 = df.aggregate([], [summarize(column("a"))])
+
+    # Run a second time to ensure the state is properly reset
+    result = df2.collect()[0]
+
+    assert result.column(0) == pa.array([1.0 + 2.0 + 3.0])
+
+
+def test_udaf_decorator_aggregate(df):
+    @udaf(pa.float64(), pa.float64(), [pa.float64()], "immutable")
+    def summarize():
+        return Summarize()
+
+    df1 = df.aggregate([], [summarize(column("a"))])
+
+    # execute and collect the first (and only) batch
+    result = df1.collect()[0]
+
+    assert result.column(0) == pa.array([1.0 + 2.0 + 3.0])
+
+    df2 = df.aggregate([], [summarize(column("a"))])
+
+    # Run a second time to ensure the state is properly reset
+    result = df2.collect()[0]
+
+    assert result.column(0) == pa.array([1.0 + 2.0 + 3.0])
+
+
+@pytest.mark.parametrize("as_scalar", [True, False])
+def test_udaf_aggregate_with_arguments(df, as_scalar):
+    bias = 10.0
+
+    summarize = udaf(
+        lambda: Summarize(initial_value=bias, as_scalar=as_scalar),
+        pa.float64(),
+        pa.float64(),
+        [pa.float64()],
+        volatility="immutable",
+    )
+
+    df1 = df.aggregate([], [summarize(column("a"))])
+
+    # execute and collect the first (and only) batch
+    result = df1.collect()[0]
+
+    assert result.column(0) == pa.array([bias + 1.0 + 2.0 + 3.0])
+
+    df2 = df.aggregate([], [summarize(column("a"))])
+
+    # Run a second time to ensure the state is properly reset
+    result = df2.collect()[0]
+
+    assert result.column(0) == pa.array([bias + 1.0 + 2.0 + 3.0])
+
+
+def test_udaf_decorator_aggregate_with_arguments(df):
+    bias = 10.0
+
+    @udaf(pa.float64(), pa.float64(), [pa.float64()], "immutable")
+    def summarize():
+        return Summarize(bias)
+
+    df1 = df.aggregate([], [summarize(column("a"))])
+
+    # execute and collect the first (and only) batch
+    result = df1.collect()[0]
+
+    assert result.column(0) == pa.array([bias + 1.0 + 2.0 + 3.0])
+
+    df2 = df.aggregate([], [summarize(column("a"))])
+
+    # Run a second time to ensure the state is properly reset
+    result = df2.collect()[0]
+
+    assert result.column(0) == pa.array([bias + 1.0 + 2.0 + 3.0])
+
+
+def test_group_by(df):
+    summarize = udaf(
+        Summarize,
+        pa.float64(),
+        pa.float64(),
+        [pa.float64()],
+        volatility="immutable",
+    )
+
+    df = df.aggregate([column("b")], [summarize(column("a"))])
+
+    batches = df.collect()
+
+    arrays = [batch.column(1) for batch in batches]
+    joined = pa.concat_arrays(arrays)
+    assert joined == pa.array([1.0 + 2.0, 3.0])
+
+
+def test_register_udaf(ctx, df) -> None:
+    summarize = udaf(
+        Summarize,
+        pa.float64(),
+        pa.float64(),
+        [pa.float64()],
+        volatility="immutable",
+    )
+
+    ctx.register_udaf(summarize)
+
+    df_result = ctx.sql("select summarize(b) from test_table")
+
+    assert df_result.collect()[0][0][0].as_py() == 14.0
+
+
+@pytest.mark.parametrize("wrap_in_scalar", [True, False])
+def test_udaf_list_timestamp_return(ctx, wrap_in_scalar) -> None:
+    timestamps1 = [
+        datetime(2024, 1, 1, tzinfo=timezone.utc),
+        datetime(2024, 1, 2, tzinfo=timezone.utc),
+    ]
+    timestamps2 = [
+        datetime(2024, 1, 3, tzinfo=timezone.utc),
+        datetime(2024, 1, 4, tzinfo=timezone.utc),
+    ]
+    batch1 = pa.RecordBatch.from_arrays(
+        [pa.array(timestamps1, type=pa.timestamp("ns"))],
+        names=["ts"],
+    )
+    batch2 = pa.RecordBatch.from_arrays(
+        [pa.array(timestamps2, type=pa.timestamp("ns"))],
+        names=["ts"],
+    )
+    df = ctx.create_dataframe([[batch1], [batch2]], name="timestamp_table")
+
+    list_type = pa.list_(
+        pa.field("item", type=pa.timestamp("ns"), nullable=wrap_in_scalar)
+    )
+
+    collect = udaf(
+        lambda: CollectTimestamps(wrap_in_scalar),
+        pa.timestamp("ns"),
+        list_type,
+        [list_type],
+        volatility="immutable",
+    )
+
+    result = df.aggregate([], [collect(column("ts"))]).collect()[0]
+
+    # There is no guarantee about the ordering of the batches, so perform a sort
+    # to get consistent results. Alternatively we could sort on evaluate().
+    assert (
+        result.column(0).values.sort()
+        == pa.array(
+            [[*timestamps1, *timestamps2]],
+            type=list_type,
+        ).values
+    )
diff --git a/python/tests/test_udf.py b/python/tests/test_udf.py
new file mode 100644
index 000000000..b2540fb57
--- /dev/null
+++ b/python/tests/test_udf.py
@@ -0,0 +1,209 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from uuid import UUID
+
+import pyarrow as pa
+import pyarrow.compute as pc
+import pytest
+from datafusion import SessionContext, column, udf
+from datafusion import functions as f
+
+
+@pytest.fixture
+def df(ctx):
+    # create a RecordBatch and a new DataFrame from it
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 4, None])],
+        names=["a", "b"],
+    )
+    return ctx.create_dataframe([[batch]], name="test_table")
+
+
+def test_udf(df):
+    # is_null is a pa function over arrays
+    is_null = udf(
+        lambda x: x.is_null(),
+        [pa.int64()],
+        pa.bool_(),
+        volatility="immutable",
+    )
+
+    df = df.select(is_null(column("b")))
+    result = df.collect()[0].column(0)
+
+    assert result == pa.array([False, False, True])
+
+
+def test_udf_decorator(df):
+    @udf([pa.int64()], pa.bool_(), "immutable")
+    def is_null(x: pa.Array) -> pa.Array:
+        return x.is_null()
+
+    df = df.select(is_null(column("b")))
+    result = df.collect()[0].column(0)
+    assert result == pa.array([False, False, True])
+
+
+def test_register_udf(ctx, df) -> None:
+    is_null = udf(
+        lambda x: x.is_null(),
+        [pa.float64()],
+        pa.bool_(),
+        volatility="immutable",
+        name="is_null",
+    )
+
+    ctx.register_udf(is_null)
+
+    df_result = ctx.sql("select is_null(b) from test_table")
+    result = df_result.collect()[0].column(0)
+
+    assert result == pa.array([False, False, True])
+
+
+class OverThresholdUDF:
+    def __init__(self, threshold: int = 0) -> None:
+        self.threshold = threshold
+
+    def __call__(self, values: pa.Array) -> pa.Array:
+        return pa.array(v.as_py() >= self.threshold for v in values)
+
+
+def test_udf_with_parameters_function(df) -> None:
+    udf_no_param = udf(
+        OverThresholdUDF(),
+        pa.int64(),
+        pa.bool_(),
+        volatility="immutable",
+    )
+
+    df1 = df.select(udf_no_param(column("a")))
+    result = df1.collect()[0].column(0)
+
+    assert result == pa.array([True, True, True])
+
+    udf_with_param = udf(
+        OverThresholdUDF(2),
+        pa.int64(),
+        pa.bool_(),
+        volatility="immutable",
+    )
+
+    df2 = df.select(udf_with_param(column("a")))
+    result = df2.collect()[0].column(0)
+
+    assert result == pa.array([False, True, True])
+
+
+def test_udf_with_parameters_decorator(df) -> None:
+    @udf([pa.int64()], pa.bool_(), "immutable")
+    def udf_no_param(values: pa.Array) -> pa.Array:
+        return OverThresholdUDF()(values)
+
+    df1 = df.select(udf_no_param(column("a")))
+    result = df1.collect()[0].column(0)
+
+    assert result == pa.array([True, True, True])
+
+    @udf([pa.int64()], pa.bool_(), "immutable")
+    def udf_with_param(values: pa.Array) -> pa.Array:
+        return OverThresholdUDF(2)(values)
+
+    df2 = df.select(udf_with_param(column("a")))
+    result = df2.collect()[0].column(0)
+
+    assert result == pa.array([False, True, True])
+
+
+def test_udf_with_metadata(ctx) -> None:
+    @udf([pa.string()], pa.uuid(), "stable")
+    def uuid_from_string(uuid_string):
+        return pa.array((UUID(s).bytes for s in uuid_string.to_pylist()), pa.uuid())
+
+    @udf([pa.uuid()], pa.int64(), "stable")
+    def uuid_version(uuid):
+        return pa.array(s.version for s in uuid.to_pylist())
+
+    batch = pa.record_batch({"idx": pa.array(range(5))})
+    results = (
+        ctx.create_dataframe([[batch]])
+        .with_column("uuid_string", f.uuid())
+        .with_column("uuid", uuid_from_string(column("uuid_string")))
+        .select(uuid_version(column("uuid").alias("uuid_version")))
+        .collect()
+    )
+
+    assert results[0][0].to_pylist() == [4, 4, 4, 4, 4]
+
+
+def test_udf_with_nullability(ctx: SessionContext) -> None:
+    field_nullable_i64 = pa.field("with_nulls", type=pa.int64(), nullable=True)
+    field_non_nullable_i64 = pa.field("no_nulls", type=pa.int64(), nullable=False)
+
+    @udf([field_nullable_i64], field_nullable_i64, "stable")
+    def nullable_abs(input_col):
+        return pc.abs(input_col)
+
+    @udf([field_non_nullable_i64], field_non_nullable_i64, "stable")
+    def non_nullable_abs(input_col):
+        return pc.abs(input_col)
+
+    batch = pa.record_batch(
+        {
+            "with_nulls": pa.array([-2, None, 0, 1, 2]),
+            "no_nulls": pa.array([-2, -1, 0, 1, 2]),
+        },
+        schema=pa.schema(
+            [
+                field_nullable_i64,
+                field_non_nullable_i64,
+            ]
+        ),
+    )
+    ctx.register_record_batches("t", [[batch]])
+    df = ctx.table("t")
+
+    # Input matches expected, nullable
+    df_result = df.select(nullable_abs(column("with_nulls")))
+    returned_field = df_result.schema().field(0)
+    assert returned_field.nullable
+    results = df_result.collect()
+    assert results[0][0].to_pylist() == [2, None, 0, 1, 2]
+
+    # Input coercible to expected, nullable
+    df_result = df.select(nullable_abs(column("no_nulls")))
+    returned_field = df_result.schema().field(0)
+    assert returned_field.nullable
+    results = df_result.collect()
+    assert results[0][0].to_pylist() == [2, 1, 0, 1, 2]
+
+    # Input matches expected, no nulls
+    df_result = df.select(non_nullable_abs(column("no_nulls")))
+    returned_field = df_result.schema().field(0)
+    assert not returned_field.nullable
+    results = df_result.collect()
+    assert results[0][0].to_pylist() == [2, 1, 0, 1, 2]
+
+    # Invalid - requires non-nullable input but that is not possible
+    df_result = df.select(non_nullable_abs(column("with_nulls")))
+    returned_field = df_result.schema().field(0)
+    assert not returned_field.nullable
+
+    with pytest.raises(Exception) as e_info:
+        _results = df_result.collect()
+    assert "Invalid argument error" in str(e_info)
diff --git a/python/tests/test_udtf.py b/python/tests/test_udtf.py
new file mode 100644
index 000000000..925a8ba01
--- /dev/null
+++ b/python/tests/test_udtf.py
@@ -0,0 +1,136 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import pyarrow as pa
+import pyarrow.dataset as ds
+from datafusion import Expr, SessionContext, Table, udtf
+from datafusion.context import TableProviderExportable
+
+
+def python_table_function_inner(
+    num_cols: int, num_rows: int, num_batches: int
+) -> Table:
+    rows = list(range(num_rows))
+    cols = [pa.array(rows) for _ in range(num_cols)]
+    names = [f"row_{i}" for i in range(num_cols)]
+
+    batch = pa.RecordBatch.from_arrays(cols, names=names)
+    batches = [batch for _ in range(num_batches)]
+    dataset = ds.dataset(batches)
+
+    return Table(dataset)
+
+
+def test_python_table_function_with_args_class() -> None:
+    """Test Python TableFunction using a class with arguments."""
+    ctx = SessionContext()
+
+    class ParameterizedTableFunction:
+        """Table function that takes parameters."""
+
+        def __call__(self, num_cols: Expr, num_rows: Expr, num_batches: Expr) -> Table:
+            return python_table_function_inner(
+                num_cols.to_variant().value_i64(),
+                num_rows.to_variant().value_i64(),
+                num_batches.to_variant().value_i64(),
+            )
+
+    # Register the function
+    table_func = ParameterizedTableFunction()
+    table_udtf = udtf(table_func, "param_func")
+    ctx.register_udtf(table_udtf)
+
+    # Call with different parameters
+    result = ctx.sql("SELECT * FROM param_func(5, 10, 2)").collect()
+    assert len(result) == 2
+    assert result[0].num_columns == 5
+    assert result[0].num_rows == 10
+
+
+def test_python_table_function_decorator() -> None:
+    """Test Python TableFunction using decorator syntax."""
+    ctx = SessionContext()
+
+    @udtf("decorated_func")
+    def my_decorated_func(num_cols: Expr, num_rows: Expr, num_batches: Expr) -> Table:
+        return python_table_function_inner(
+            num_cols.to_variant().value_i64(),
+            num_rows.to_variant().value_i64(),
+            num_batches.to_variant().value_i64(),
+        )
+
+    ctx.register_udtf(my_decorated_func)
+
+    result = ctx.sql("SELECT * FROM decorated_func(3, 7, 2)").collect()
+    assert len(result) == 2
+    assert result[0].num_columns == 3
+    assert result[0].num_rows == 7
+
+
+def test_python_table_function_no_args() -> None:
+    """Test Python TableFunction with no arguments."""
+    ctx = SessionContext()
+
+    @udtf("static_func")
+    def static_table_func() -> Table:
+        return python_table_function_inner(2, 3, 1)
+
+    ctx.register_udtf(static_table_func)
+
+    result = ctx.sql("SELECT * FROM static_func()").collect()
+    assert len(result) == 1
+    assert list(result[0].column(0).to_pylist()) == [0, 1, 2]
+    assert list(result[0].column(1).to_pylist()) == [0, 1, 2]
+
+
+def test_python_table_function_single_arg() -> None:
+    """Test Python TableFunction with a single argument."""
+    ctx = SessionContext()
+
+    @udtf("single_arg_func")
+    def single_arg_func(n: Expr) -> TableProviderExportable:
+        return python_table_function_inner(2, n.to_variant().value_i64(), 1)
+
+    ctx.register_udtf(single_arg_func)
+
+    result = ctx.sql("SELECT * FROM single_arg_func(15)").collect()
+    assert len(result) == 1
+    assert result[0].num_columns == 2
+    assert result[0].num_rows == 15
+
+
+def test_python_table_function_with_string_args() -> None:
+    """Test Python TableFunction with string arguments."""
+    ctx = SessionContext()
+
+    @udtf("string_arg_func")
+    def string_arg_func(prefix: Expr) -> TableProviderExportable:
+        prefix_str = prefix.to_variant().value_string()
+        # Create a table with the prefix in column names
+
+        batch = pa.RecordBatch.from_arrays(
+            [pa.array([1, 2, 3]), pa.array([4, 5, 6])],
+            names=[f"{prefix_str}_a", f"{prefix_str}_b"],
+        )
+
+        return Table(ds.dataset([batch]))
+
+    ctx.register_udtf(string_arg_func)
+
+    result = ctx.sql("SELECT * FROM string_arg_func('test')").collect()
+    assert len(result) == 1
+    assert result[0].schema.names == ["test_a", "test_b"]
diff --git a/python/tests/test_udwf.py b/python/tests/test_udwf.py
new file mode 100644
index 000000000..38b935b7e
--- /dev/null
+++ b/python/tests/test_udwf.py
@@ -0,0 +1,468 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from __future__ import annotations
+
+import pyarrow as pa
+import pytest
+from datafusion import SessionContext, column, lit, udwf
+from datafusion import functions as f
+from datafusion.expr import WindowFrame
+from datafusion.user_defined import WindowEvaluator
+
+
+class ExponentialSmoothDefault(WindowEvaluator):
+    def __init__(self, alpha: float = 0.9) -> None:
+        self.alpha = alpha
+
+    def evaluate_all(self, values: list[pa.Array], num_rows: int) -> pa.Array:
+        results = []
+        curr_value = 0.0
+        values = values[0]
+        for idx in range(num_rows):
+            if idx == 0:
+                curr_value = values[idx].as_py()
+            else:
+                curr_value = values[idx].as_py() * self.alpha + curr_value * (
+                    1.0 - self.alpha
+                )
+            results.append(curr_value)
+
+        return pa.array(results)
+
+
+class ExponentialSmoothBounded(WindowEvaluator):
+    def __init__(self, alpha: float = 0.9) -> None:
+        self.alpha = alpha
+
+    def supports_bounded_execution(self) -> bool:
+        return True
+
+    def get_range(self, idx: int, num_rows: int) -> tuple[int, int]:
+        # Override the default range of current row since uses_window_frame is False
+        # So for the purpose of this test we just smooth from the previous row to
+        # current.
+        if idx == 0:
+            return (0, 0)
+        return (idx - 1, idx)
+
+    def evaluate(
+        self, values: list[pa.Array], eval_range: tuple[int, int]
+    ) -> pa.Scalar:
+        (start, stop) = eval_range
+        curr_value = 0.0
+        values = values[0]
+        for idx in range(start, stop + 1):
+            if idx == start:
+                curr_value = values[idx].as_py()
+            else:
+                curr_value = values[idx].as_py() * self.alpha + curr_value * (
+                    1.0 - self.alpha
+                )
+        return pa.scalar(curr_value).cast(pa.float64())
+
+
+class ExponentialSmoothRank(WindowEvaluator):
+    def __init__(self, alpha: float = 0.9) -> None:
+        self.alpha = alpha
+
+    def include_rank(self) -> bool:
+        return True
+
+    def evaluate_all_with_rank(
+        self, num_rows: int, ranks_in_partition: list[tuple[int, int]]
+    ) -> pa.Array:
+        results = []
+        for idx in range(num_rows):
+            if idx == 0:
+                prior_value = 1.0
+            matching_row = [
+                i
+                for i in range(len(ranks_in_partition))
+                if ranks_in_partition[i][0] <= idx and ranks_in_partition[i][1] > idx
+            ][0] + 1
+            curr_value = matching_row * self.alpha + prior_value * (1.0 - self.alpha)
+            results.append(curr_value)
+            prior_value = matching_row
+
+        return pa.array(results)
+
+
+class ExponentialSmoothFrame(WindowEvaluator):
+    def __init__(self, alpha: float = 0.9) -> None:
+        self.alpha = alpha
+
+    def uses_window_frame(self) -> bool:
+        return True
+
+    def evaluate(
+        self, values: list[pa.Array], eval_range: tuple[int, int]
+    ) -> pa.Scalar:
+        (start, stop) = eval_range
+        curr_value = 0.0
+        if len(values) > 1:
+            order_by = values[1]  # noqa: F841
+            values = values[0]
+        else:
+            values = values[0]
+        for idx in range(start, stop):
+            if idx == start:
+                curr_value = values[idx].as_py()
+            else:
+                curr_value = values[idx].as_py() * self.alpha + curr_value * (
+                    1.0 - self.alpha
+                )
+        return pa.scalar(curr_value).cast(pa.float64())
+
+
+class SmoothTwoColumn(WindowEvaluator):
+    """This class demonstrates using two columns.
+
+    If the second column is above a threshold, then smooth over the first column from
+    the previous and next rows.
+    """
+
+    def __init__(self, alpha: float = 0.9) -> None:
+        self.alpha = alpha
+
+    def evaluate_all(self, values: list[pa.Array], num_rows: int) -> pa.Array:
+        results = []
+        values_a = values[0]
+        values_b = values[1]
+        for idx in range(num_rows):
+            if values_b[idx].as_py() > 7:
+                if idx == 0:
+                    results.append(values_a[1].cast(pa.float64()))
+                elif idx == num_rows - 1:
+                    results.append(values_a[num_rows - 2].cast(pa.float64()))
+                else:
+                    results.append(
+                        pa.scalar(
+                            values_a[idx - 1].as_py() * self.alpha
+                            + values_a[idx + 1].as_py() * (1.0 - self.alpha)
+                        )
+                    )
+            else:
+                results.append(values_a[idx].cast(pa.float64()))
+
+        return pa.array(results)
+
+
+class SimpleWindowCount(WindowEvaluator):
+    """A simple window evaluator that counts rows."""
+
+    def __init__(self, base: int = 0) -> None:
+        self.base = base
+
+    def evaluate_all(self, values: list[pa.Array], num_rows: int) -> pa.Array:
+        return pa.array([self.base + i for i in range(num_rows)])
+
+
+class NotSubclassOfWindowEvaluator:
+    pass
+
+
+@pytest.fixture
+def ctx():
+    return SessionContext()
+
+
+@pytest.fixture
+def complex_window_df(ctx):
+    # create a RecordBatch and a new DataFrame from it
+    batch = pa.RecordBatch.from_arrays(
+        [
+            pa.array([0, 1, 2, 3, 4, 5, 6]),
+            pa.array([7, 4, 3, 8, 9, 1, 6]),
+            pa.array(["A", "A", "A", "A", "B", "B", "B"]),
+        ],
+        names=["a", "b", "c"],
+    )
+    return ctx.create_dataframe([[batch]])
+
+
+@pytest.fixture
+def count_window_df(ctx):
+    # create a RecordBatch and a new DataFrame from it
+    batch = pa.RecordBatch.from_arrays(
+        [pa.array([1, 2, 3]), pa.array([4, 4, 6])],
+        names=["a", "b"],
+    )
+    return ctx.create_dataframe([[batch]], name="test_table")
+
+
+def test_udwf_errors(complex_window_df):
+    with pytest.raises(TypeError):
+        udwf(
+            NotSubclassOfWindowEvaluator,
+            pa.float64(),
+            pa.float64(),
+            volatility="immutable",
+        )
+
+
+def test_udwf_errors_with_message():
+    """Test error cases for UDWF creation."""
+    with pytest.raises(
+        TypeError, match="`func` must implement the abstract base class WindowEvaluator"
+    ):
+        udwf(
+            NotSubclassOfWindowEvaluator, pa.int64(), pa.int64(), volatility="immutable"
+        )
+
+
+def test_udwf_basic_usage(count_window_df):
+    """Test basic UDWF usage with a simple counting window function."""
+    simple_count = udwf(
+        SimpleWindowCount, pa.int64(), pa.int64(), volatility="immutable"
+    )
+
+    df = count_window_df.select(
+        simple_count(column("a"))
+        .window_frame(WindowFrame("rows", None, None))
+        .build()
+        .alias("count")
+    )
+    result = df.collect()[0]
+    assert result.column(0) == pa.array([0, 1, 2])
+
+
+def test_udwf_with_args(count_window_df):
+    """Test UDWF with constructor arguments."""
+    count_base10 = udwf(
+        lambda: SimpleWindowCount(10), pa.int64(), pa.int64(), volatility="immutable"
+    )
+
+    df = count_window_df.select(
+        count_base10(column("a"))
+        .window_frame(WindowFrame("rows", None, None))
+        .build()
+        .alias("count")
+    )
+    result = df.collect()[0]
+    assert result.column(0) == pa.array([10, 11, 12])
+
+
+def test_udwf_decorator_basic(count_window_df):
+    """Test UDWF used as a decorator."""
+
+    @udwf([pa.int64()], pa.int64(), "immutable")
+    def window_count() -> WindowEvaluator:
+        return SimpleWindowCount()
+
+    df = count_window_df.select(
+        window_count(column("a"))
+        .window_frame(WindowFrame("rows", None, None))
+        .build()
+        .alias("count")
+    )
+    result = df.collect()[0]
+    assert result.column(0) == pa.array([0, 1, 2])
+
+
+def test_udwf_decorator_with_args(count_window_df):
+    """Test UDWF decorator with constructor arguments."""
+
+    @udwf([pa.int64()], pa.int64(), "immutable")
+    def window_count_base10() -> WindowEvaluator:
+        return SimpleWindowCount(10)
+
+    df = count_window_df.select(
+        window_count_base10(column("a"))
+        .window_frame(WindowFrame("rows", None, None))
+        .build()
+        .alias("count")
+    )
+    result = df.collect()[0]
+    assert result.column(0) == pa.array([10, 11, 12])
+
+
+def test_register_udwf(ctx, count_window_df):
+    """Test registering and using UDWF in SQL context."""
+    window_count = udwf(
+        SimpleWindowCount,
+        [pa.int64()],
+        pa.int64(),
+        volatility="immutable",
+        name="window_count",
+    )
+
+    ctx.register_udwf(window_count)
+    result = ctx.sql(
+        """
+        SELECT window_count(a)
+        OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED
+        FOLLOWING) FROM test_table
+        """
+    ).collect()[0]
+    assert result.column(0) == pa.array([0, 1, 2])
+
+
+smooth_default = udwf(
+    ExponentialSmoothDefault,
+    pa.float64(),
+    pa.float64(),
+    volatility="immutable",
+)
+
+smooth_w_arguments = udwf(
+    lambda: ExponentialSmoothDefault(0.8),
+    pa.float64(),
+    pa.float64(),
+    volatility="immutable",
+)
+
+smooth_bounded = udwf(
+    ExponentialSmoothBounded,
+    pa.float64(),
+    pa.float64(),
+    volatility="immutable",
+)
+
+smooth_rank = udwf(
+    ExponentialSmoothRank,
+    pa.utf8(),
+    pa.float64(),
+    volatility="immutable",
+)
+
+smooth_frame = udwf(
+    ExponentialSmoothFrame,
+    pa.float64(),
+    pa.float64(),
+    volatility="immutable",
+)
+
+smooth_two_col = udwf(
+    SmoothTwoColumn,
+    [pa.int64(), pa.int64()],
+    pa.float64(),
+    volatility="immutable",
+)
+
+data_test_udwf_functions = [
+    (
+        "default_udwf_no_arguments",
+        smooth_default(column("a")),
+        [0, 0.9, 1.89, 2.889, 3.889, 4.889, 5.889],
+    ),
+    (
+        "default_udwf_w_arguments",
+        smooth_w_arguments(column("a")),
+        [0, 0.8, 1.76, 2.752, 3.75, 4.75, 5.75],
+    ),
+    (
+        "default_udwf_partitioned",
+        smooth_default(column("a")).partition_by(column("c")).build(),
+        [0, 0.9, 1.89, 2.889, 4.0, 4.9, 5.89],
+    ),
+    (
+        "default_udwf_ordered",
+        smooth_default(column("a")).order_by(column("b")).build(),
+        [0.551, 1.13, 2.3, 2.755, 3.876, 5.0, 5.513],
+    ),
+    (
+        "bounded_udwf",
+        smooth_bounded(column("a")),
+        [0, 0.9, 1.9, 2.9, 3.9, 4.9, 5.9],
+    ),
+    (
+        "bounded_udwf_ignores_frame",
+        smooth_bounded(column("a"))
+        .window_frame(WindowFrame("rows", None, None))
+        .build(),
+        [0, 0.9, 1.9, 2.9, 3.9, 4.9, 5.9],
+    ),
+    (
+        "rank_udwf",
+        smooth_rank(column("c")).order_by(column("c")).build(),
+        [1, 1, 1, 1, 1.9, 2, 2],
+    ),
+    (
+        "frame_unbounded_udwf",
+        smooth_frame(column("a")).window_frame(WindowFrame("rows", None, None)).build(),
+        [5.889, 5.889, 5.889, 5.889, 5.889, 5.889, 5.889],
+    ),
+    (
+        "frame_bounded_udwf",
+        smooth_frame(column("a")).window_frame(WindowFrame("rows", None, 0)).build(),
+        [0.0, 0.9, 1.89, 2.889, 3.889, 4.889, 5.889],
+    ),
+    (
+        "frame_bounded_udwf",
+        smooth_frame(column("a"))
+        .window_frame(WindowFrame("rows", None, 0))
+        .order_by(column("b"))
+        .build(),
+        [0.551, 1.13, 2.3, 2.755, 3.876, 5.0, 5.513],
+    ),
+    (
+        "two_column_udwf",
+        smooth_two_col(column("a"), column("b")),
+        [0.0, 1.0, 2.0, 2.2, 3.2, 5.0, 6.0],
+    ),
+]
+
+
+@pytest.mark.parametrize(("name", "expr", "expected"), data_test_udwf_functions)
+def test_udwf_functions(complex_window_df, name, expr, expected):
+    df = complex_window_df.select("a", "b", f.round(expr, lit(3)).alias(name))
+
+    # execute and collect the first (and only) batch
+    result = df.sort(column("a")).select(column(name)).collect()[0]
+
+    assert result.column(0) == pa.array(expected)
+
+
+@pytest.mark.parametrize(
+    "udwf_func",
+    [
+        udwf(SimpleWindowCount, pa.int64(), pa.int64(), "immutable"),
+        udwf(SimpleWindowCount, [pa.int64()], pa.int64(), "immutable"),
+        udwf([pa.int64()], pa.int64(), "immutable")(SimpleWindowCount),
+        udwf(pa.int64(), pa.int64(), "immutable")(SimpleWindowCount),
+    ],
+)
+def test_udwf_overloads(udwf_func, count_window_df):
+    df = count_window_df.select(
+        udwf_func(column("a"))
+        .window_frame(WindowFrame("rows", None, None))
+        .build()
+        .alias("count")
+    )
+    result = df.collect()[0]
+    assert result.column(0) == pa.array([0, 1, 2])
+
+
+def test_udwf_named_function(ctx, count_window_df):
+    """Test UDWF with explicit name parameter."""
+    window_count = udwf(
+        SimpleWindowCount,
+        pa.int64(),
+        pa.int64(),
+        volatility="immutable",
+        name="my_custom_counter",
+    )
+
+    ctx.register_udwf(window_count)
+    result = ctx.sql(
+        """
+        SELECT my_custom_counter(a)
+        OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED
+        FOLLOWING) FROM test_table"""
+    ).collect()[0]
+    assert result.column(0) == pa.array([0, 1, 2])
diff --git a/python/tests/test_unparser.py b/python/tests/test_unparser.py
new file mode 100644
index 000000000..c4e05780c
--- /dev/null
+++ b/python/tests/test_unparser.py
@@ -0,0 +1,33 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from datafusion.context import SessionContext
+from datafusion.unparser import Dialect, Unparser
+
+
+def test_unparser():
+    ctx = SessionContext()
+    df = ctx.sql("SELECT 1")
+    for dialect in [
+        Dialect.mysql(),
+        Dialect.postgres(),
+        Dialect.sqlite(),
+        Dialect.duckdb(),
+    ]:
+        unparser = Unparser(dialect)
+        sql = unparser.plan_to_sql(df.logical_plan())
+        assert sql == "SELECT 1"
diff --git a/python/tests/test_view.py b/python/tests/test_view.py
new file mode 100644
index 000000000..1d92cc0d4
--- /dev/null
+++ b/python/tests/test_view.py
@@ -0,0 +1,49 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+
+from datafusion import SessionContext, col, literal
+
+
+def test_register_filtered_dataframe():
+    ctx = SessionContext()
+
+    data = {"a": [1, 2, 3, 4, 5], "b": [10, 20, 30, 40, 50]}
+
+    df = ctx.from_pydict(data, "my_table")
+
+    df_filtered = df.filter(col("a") > literal(2))
+
+    ctx.register_view("view1", df_filtered)
+
+    df_view = ctx.sql("SELECT * FROM view1")
+
+    filtered_results = df_view.collect()
+
+    result_dicts = [batch.to_pydict() for batch in filtered_results]
+
+    expected_results = [{"a": [3, 4, 5], "b": [30, 40, 50]}]
+
+    assert result_dicts == expected_results
+
+    df_results = df.collect()
+
+    df_result_dicts = [batch.to_pydict() for batch in df_results]
+
+    expected_df_results = [{"a": [1, 2, 3, 4, 5], "b": [10, 20, 30, 40, 50]}]
+
+    assert df_result_dicts == expected_df_results
diff --git a/python/tests/test_wrapper_coverage.py b/python/tests/test_wrapper_coverage.py
new file mode 100644
index 000000000..cf6719ecf
--- /dev/null
+++ b/python/tests/test_wrapper_coverage.py
@@ -0,0 +1,102 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import datafusion
+import datafusion.functions
+import datafusion.object_store
+import datafusion.substrait
+import pytest
+
+# EnumType introduced in 3.11. 3.10 and prior it was called EnumMeta.
+try:
+    from enum import EnumType
+except ImportError:
+    from enum import EnumMeta as EnumType
+
+
+def _check_enum_exports(internal_obj, wrapped_obj) -> None:
+    """Check that all enum values are present in wrapped object."""
+    expected_values = [v for v in dir(internal_obj) if not v.startswith("__")]
+    for value in expected_values:
+        assert value in dir(wrapped_obj)
+
+
+def _check_list_attribute(internal_attr, wrapped_attr) -> None:
+    """Check that list attributes match between internal and wrapped objects."""
+    assert isinstance(wrapped_attr, list)
+
+    # We have cases like __all__ that are a list and we want to be certain that
+    # every value in the list in the internal object is also in the wrapper list
+    for val in internal_attr:
+        if isinstance(val, str) and val.startswith("Raw"):
+            assert val[3:] in wrapped_attr
+        else:
+            assert val in wrapped_attr
+
+
+def missing_exports(internal_obj, wrapped_obj) -> None:
+    """
+    Identify if any of the rust exposted structs or functions do not have wrappers.
+
+    Special handling for:
+    - Raw* classes: Internal implementation details that shouldn't be exposed
+    - _global_ctx: Internal implementation detail
+    - __self__, __class__, __repr__: Python special attributes
+    """
+    # Special case enums - EnumType overrides a some of the internal functions,
+    # so check all of the values exist and move on
+    if isinstance(wrapped_obj, EnumType):
+        _check_enum_exports(internal_obj, wrapped_obj)
+        return
+
+    if "__repr__" in internal_obj.__dict__ and "__repr__" not in wrapped_obj.__dict__:
+        pytest.fail(f"Missing __repr__: {internal_obj.__name__}")
+
+    for internal_attr_name in dir(internal_obj):
+        wrapped_attr_name = internal_attr_name.removeprefix("Raw")
+
+        assert wrapped_attr_name in dir(wrapped_obj)
+
+        internal_attr = getattr(internal_obj, internal_attr_name)
+        wrapped_attr = getattr(wrapped_obj, wrapped_attr_name)
+
+        # There are some auto generated attributes that can be None, such as
+        # __kwdefaults__ and __doc__. As long as these are None on the internal
+        # object, it's okay to skip them. However if they do exist on the internal
+        # object they must also exist on the wrapped object.
+        if internal_attr is not None and wrapped_attr is None:
+            pytest.fail(f"Missing attribute: {internal_attr_name}")
+
+        if internal_attr_name in ["__self__", "__class__"]:
+            continue
+
+        if isinstance(internal_attr, list):
+            _check_list_attribute(internal_attr, wrapped_attr)
+        elif hasattr(internal_attr, "__dict__"):
+            # Check all submodules recursively
+            missing_exports(internal_attr, wrapped_attr)
+
+
+def test_datafusion_missing_exports() -> None:
+    """Check for any missing python exports.
+
+    This test verifies that every exposed class, attribute,
+    and function in the internal (pyo3) module - datafusion._internal
+    is also exposed in our python wrappers - datafusion -
+    i.e., the ones exposed to the public.
+    """
+    missing_exports(datafusion._internal, datafusion)
diff --git a/python/tests/utils.py b/python/tests/utils.py
new file mode 100644
index 000000000..00efb6555
--- /dev/null
+++ b/python/tests/utils.py
@@ -0,0 +1,62 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""Testing-only helpers for datafusion-python.
+
+This module contains utilities used by the test-suite that should not be
+exposed as part of the public API. Keep the implementation minimal and
+documented so reviewers can easily see it's test-only.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from datafusion import DataFrame
+    from datafusion.context import SessionContext
+
+
+def range_table(
+    ctx: SessionContext,
+    start: int,
+    stop: int | None = None,
+    step: int = 1,
+    partitions: int | None = None,
+) -> DataFrame:
+    """Create a DataFrame containing a sequence of numbers using SQL RANGE.
+
+    This mirrors the previous ``SessionContext.range`` convenience method but
+    lives in a testing-only module so it doesn't expand the public surface.
+
+    Args:
+        ctx: SessionContext instance to run the SQL against.
+        start: Starting value for the sequence or exclusive stop when ``stop``
+            is ``None``.
+        stop: Exclusive upper bound of the sequence.
+        step: Increment between successive values.
+        partitions: Optional number of partitions for the generated data.
+
+    Returns:
+        DataFrame produced by the range table function.
+    """
+    if stop is None:
+        start, stop = 0, start
+
+    parts = f", {int(partitions)}" if partitions is not None else ""
+    sql = f"SELECT * FROM range({int(start)}, {int(stop)}, {int(step)}{parts})"
+    return ctx.sql(sql)
diff --git a/requirements-310.txt b/requirements-310.txt
deleted file mode 100644
index 332abdbcb..000000000
--- a/requirements-310.txt
+++ /dev/null
@@ -1,209 +0,0 @@
-#
-# This file is autogenerated by pip-compile with python 3.10
-# To update, run:
-#
-#    pip-compile --generate-hashes
-#
-attrs==21.4.0 \
-    --hash=sha256:2d27e3784d7a565d36ab851fe94887c5eccd6a463168875832a1be79c82828b4 \
-    --hash=sha256:626ba8234211db98e869df76230a137c4c40a12d72445c45d5f5b716f076e2fd
-    # via pytest
-black==22.3.0 \
-    --hash=sha256:06f9d8846f2340dfac80ceb20200ea5d1b3f181dd0556b47af4e8e0b24fa0a6b \
-    --hash=sha256:10dbe6e6d2988049b4655b2b739f98785a884d4d6b85bc35133a8fb9a2233176 \
-    --hash=sha256:2497f9c2386572e28921fa8bec7be3e51de6801f7459dffd6e62492531c47e09 \
-    --hash=sha256:30d78ba6bf080eeaf0b7b875d924b15cd46fec5fd044ddfbad38c8ea9171043a \
-    --hash=sha256:328efc0cc70ccb23429d6be184a15ce613f676bdfc85e5fe8ea2a9354b4e9015 \
-    --hash=sha256:35020b8886c022ced9282b51b5a875b6d1ab0c387b31a065b84db7c33085ca79 \
-    --hash=sha256:5795a0375eb87bfe902e80e0c8cfaedf8af4d49694d69161e5bd3206c18618bb \
-    --hash=sha256:5891ef8abc06576985de8fa88e95ab70641de6c1fca97e2a15820a9b69e51b20 \
-    --hash=sha256:637a4014c63fbf42a692d22b55d8ad6968a946b4a6ebc385c5505d9625b6a464 \
-    --hash=sha256:67c8301ec94e3bcc8906740fe071391bce40a862b7be0b86fb5382beefecd968 \
-    --hash=sha256:6d2fc92002d44746d3e7db7cf9313cf4452f43e9ea77a2c939defce3b10b5c82 \
-    --hash=sha256:6ee227b696ca60dd1c507be80a6bc849a5a6ab57ac7352aad1ffec9e8b805f21 \
-    --hash=sha256:863714200ada56cbc366dc9ae5291ceb936573155f8bf8e9de92aef51f3ad0f0 \
-    --hash=sha256:9b542ced1ec0ceeff5b37d69838106a6348e60db7b8fdd245294dc1d26136265 \
-    --hash=sha256:a6342964b43a99dbc72f72812bf88cad8f0217ae9acb47c0d4f141a6416d2d7b \
-    --hash=sha256:ad4efa5fad66b903b4a5f96d91461d90b9507a812b3c5de657d544215bb7877a \
-    --hash=sha256:bc58025940a896d7e5356952228b68f793cf5fcb342be703c3a2669a1488cb72 \
-    --hash=sha256:cc1e1de68c8e5444e8f94c3670bb48a2beef0e91dddfd4fcc29595ebd90bb9ce \
-    --hash=sha256:cee3e11161dde1b2a33a904b850b0899e0424cc331b7295f2a9698e79f9a69a0 \
-    --hash=sha256:e3556168e2e5c49629f7b0f377070240bd5511e45e25a4497bb0073d9dda776a \
-    --hash=sha256:e8477ec6bbfe0312c128e74644ac8a02ca06bcdb8982d4ee06f209be28cdf163 \
-    --hash=sha256:ee8f1f7228cce7dffc2b464f07ce769f478968bfb3dd1254a4c2eeed84928aad \
-    --hash=sha256:fd57160949179ec517d32ac2ac898b5f20d68ed1a9c977346efbac9c2f1e779d
-    # via -r requirements.in
-click==8.1.3 \
-    --hash=sha256:7682dc8afb30297001674575ea00d1814d808d6a36af415a82bd481d37ba7b8e \
-    --hash=sha256:bb4d8133cb15a609f44e8213d9b391b0809795062913b383c62be0ee95b1db48
-    # via black
-flake8==4.0.1 \
-    --hash=sha256:479b1304f72536a55948cb40a32dce8bb0ffe3501e26eaf292c7e60eb5e0428d \
-    --hash=sha256:806e034dda44114815e23c16ef92f95c91e4c71100ff52813adf7132a6ad870d
-    # via -r requirements.in
-iniconfig==1.1.1 \
-    --hash=sha256:011e24c64b7f47f6ebd835bb12a743f2fbe9a26d4cecaa7f53bc4f35ee9da8b3 \
-    --hash=sha256:bc3af051d7d14b2ee5ef9969666def0cd1a000e121eaea580d4a313df4b37f32
-    # via pytest
-isort==5.10.1 \
-    --hash=sha256:6f62d78e2f89b4500b080fe3a81690850cd254227f27f75c3a0c491a1f351ba7 \
-    --hash=sha256:e8443a5e7a020e9d7f97f1d7d9cd17c88bcb3bc7e218bf9cf5095fe550be2951
-    # via -r requirements.in
-maturin==0.14.2 \
-    --hash=sha256:065a0b48259624af1330bbc2d9bd447615ff07603710ad4a839478aa8e9e98cd \
-    --hash=sha256:2966ed9b2e66760ffa5e476dab20c9563dd14efa93ed40b706cbe0a03907d824 \
-    --hash=sha256:50a7a15d02f0b407eb5cf4cbc072d27e302993d5734af71bb6d6c567da8c6396 \
-    --hash=sha256:539545c666506d34474c1133a11e90b4e6b4b6a7e590f5727ae18a49d3b647d2 \
-    --hash=sha256:9f843736fc1c065ffba2dcfc581811c2eb7032c7119ff23012ccde68607e549c \
-    --hash=sha256:ace60890f19a87e4a421fd9753e42e5fb46b11e770feacd8ff6749d3bf114764 \
-    --hash=sha256:ae3a3a754c3b935420eeb1ec34d98d1693251537331feb43277bae7892b7c51a \
-    --hash=sha256:bbaa0689a87124c99adaff99e93dcf415e36f7068d5442f311b49ede4bb7b6c3 \
-    --hash=sha256:c65b00f4a4773bc56ca690d93abd09c85cc59b161a313fba3d03aca1ffbba7ca \
-    --hash=sha256:daefa75e3f03e914924cb5913b40ada47ff646562c3b1874ddaf5b1e4b0f41ef \
-    --hash=sha256:e0b808d1a0b78532c1bcbeb2d01d90281585dc460a966f1949fd337a3fb614c0 \
-    --hash=sha256:ebc722e9661a40c3d36a06ecc0d1c637ae1af3335ea0ab69230f46a71e344088 \
-    --hash=sha256:fa01eeacfd1798cde3ba1c7a0b8d7a889d2ed0e207f4860beb819c5ddd351f43
-    # via -r requirements.in
-mccabe==0.6.1 \
-    --hash=sha256:ab8a6258860da4b6677da4bd2fe5dc2c659cff31b3ee4f7f5d64e79735b80d42 \
-    --hash=sha256:dd8d182285a0fe56bace7f45b5e7d1a6ebcbf524e8f3bd87eb0f125271b8831f
-    # via flake8
-mypy==0.950 \
-    --hash=sha256:0112752a6ff07230f9ec2f71b0d3d4e088a910fdce454fdb6553e83ed0eced7d \
-    --hash=sha256:0384d9f3af49837baa92f559d3fa673e6d2652a16550a9ee07fc08c736f5e6f8 \
-    --hash=sha256:1b333cfbca1762ff15808a0ef4f71b5d3eed8528b23ea1c3fb50543c867d68de \
-    --hash=sha256:1fdeb0a0f64f2a874a4c1f5271f06e40e1e9779bf55f9567f149466fc7a55038 \
-    --hash=sha256:4c653e4846f287051599ed8f4b3c044b80e540e88feec76b11044ddc5612ffed \
-    --hash=sha256:563514c7dc504698fb66bb1cf897657a173a496406f1866afae73ab5b3cdb334 \
-    --hash=sha256:5b231afd6a6e951381b9ef09a1223b1feabe13625388db48a8690f8daa9b71ff \
-    --hash=sha256:5ce6a09042b6da16d773d2110e44f169683d8cc8687e79ec6d1181a72cb028d2 \
-    --hash=sha256:5e7647df0f8fc947388e6251d728189cfadb3b1e558407f93254e35abc026e22 \
-    --hash=sha256:6003de687c13196e8a1243a5e4bcce617d79b88f83ee6625437e335d89dfebe2 \
-    --hash=sha256:61504b9a5ae166ba5ecfed9e93357fd51aa693d3d434b582a925338a2ff57fd2 \
-    --hash=sha256:77423570c04aca807508a492037abbd72b12a1fb25a385847d191cd50b2c9605 \
-    --hash=sha256:a4d9898f46446bfb6405383b57b96737dcfd0a7f25b748e78ef3e8c576bba3cb \
-    --hash=sha256:a952b8bc0ae278fc6316e6384f67bb9a396eb30aced6ad034d3a76120ebcc519 \
-    --hash=sha256:b5b5bd0ffb11b4aba2bb6d31b8643902c48f990cc92fda4e21afac658044f0c0 \
-    --hash=sha256:ca75ecf2783395ca3016a5e455cb322ba26b6d33b4b413fcdedfc632e67941dc \
-    --hash=sha256:cf9c261958a769a3bd38c3e133801ebcd284ffb734ea12d01457cb09eacf7d7b \
-    --hash=sha256:dd4d670eee9610bf61c25c940e9ade2d0ed05eb44227275cce88701fee014b1f \
-    --hash=sha256:e19736af56947addedce4674c0971e5dceef1b5ec7d667fe86bcd2b07f8f9075 \
-    --hash=sha256:eaea21d150fb26d7b4856766e7addcf929119dd19fc832b22e71d942835201ef \
-    --hash=sha256:eaff8156016487c1af5ffa5304c3e3fd183edcb412f3e9c72db349faf3f6e0eb \
-    --hash=sha256:ee0a36edd332ed2c5208565ae6e3a7afc0eabb53f5327e281f2ef03a6bc7687a \
-    --hash=sha256:ef7beb2a3582eb7a9f37beaf38a28acfd801988cde688760aea9e6cc4832b10b
-    # via -r requirements.in
-mypy-extensions==0.4.3 \
-    --hash=sha256:090fedd75945a69ae91ce1303b5824f428daf5a028d2f6ab8a299250a846f15d \
-    --hash=sha256:2d82818f5bb3e369420cb3c4060a7970edba416647068eb4c5343488a6c604a8
-    # via
-    #   black
-    #   mypy
-numpy==1.22.3 \
-    --hash=sha256:07a8c89a04997625236c5ecb7afe35a02af3896c8aa01890a849913a2309c676 \
-    --hash=sha256:08d9b008d0156c70dc392bb3ab3abb6e7a711383c3247b410b39962263576cd4 \
-    --hash=sha256:201b4d0552831f7250a08d3b38de0d989d6f6e4658b709a02a73c524ccc6ffce \
-    --hash=sha256:2c10a93606e0b4b95c9b04b77dc349b398fdfbda382d2a39ba5a822f669a0123 \
-    --hash=sha256:3ca688e1b9b95d80250bca34b11a05e389b1420d00e87a0d12dc45f131f704a1 \
-    --hash=sha256:48a3aecd3b997bf452a2dedb11f4e79bc5bfd21a1d4cc760e703c31d57c84b3e \
-    --hash=sha256:568dfd16224abddafb1cbcce2ff14f522abe037268514dd7e42c6776a1c3f8e5 \
-    --hash=sha256:5bfb1bb598e8229c2d5d48db1860bcf4311337864ea3efdbe1171fb0c5da515d \
-    --hash=sha256:639b54cdf6aa4f82fe37ebf70401bbb74b8508fddcf4797f9fe59615b8c5813a \
-    --hash=sha256:8251ed96f38b47b4295b1ae51631de7ffa8260b5b087808ef09a39a9d66c97ab \
-    --hash=sha256:92bfa69cfbdf7dfc3040978ad09a48091143cffb778ec3b03fa170c494118d75 \
-    --hash=sha256:97098b95aa4e418529099c26558eeb8486e66bd1e53a6b606d684d0c3616b168 \
-    --hash=sha256:a3bae1a2ed00e90b3ba5f7bd0a7c7999b55d609e0c54ceb2b076a25e345fa9f4 \
-    --hash=sha256:c34ea7e9d13a70bf2ab64a2532fe149a9aced424cd05a2c4ba662fd989e3e45f \
-    --hash=sha256:dbc7601a3b7472d559dc7b933b18b4b66f9aa7452c120e87dfb33d02008c8a18 \
-    --hash=sha256:e7927a589df200c5e23c57970bafbd0cd322459aa7b1ff73b7c2e84d6e3eae62 \
-    --hash=sha256:f8c1f39caad2c896bc0018f699882b345b2a63708008be29b1f355ebf6f933fe \
-    --hash=sha256:f950f8845b480cffe522913d35567e29dd381b0dc7e4ce6a4a9f9156417d2430 \
-    --hash=sha256:fade0d4f4d292b6f39951b6836d7a3c7ef5b2347f3c420cd9820a1d90d794802 \
-    --hash=sha256:fdf3c08bce27132395d3c3ba1503cac12e17282358cb4bddc25cc46b0aca07aa
-    # via
-    #   -r requirements.in
-    #   pyarrow
-packaging==21.3 \
-    --hash=sha256:dd47c42927d89ab911e606518907cc2d3a1f38bbd026385970643f9c5b8ecfeb \
-    --hash=sha256:ef103e05f519cdc783ae24ea4e2e0f508a9c99b2d4969652eed6a2e1ea5bd522
-    # via pytest
-pathspec==0.9.0 \
-    --hash=sha256:7d15c4ddb0b5c802d161efc417ec1a2558ea2653c2e8ad9c19098201dc1c993a \
-    --hash=sha256:e564499435a2673d586f6b2130bb5b95f04a3ba06f81b8f895b651a3c76aabb1
-    # via black
-platformdirs==2.5.2 \
-    --hash=sha256:027d8e83a2d7de06bbac4e5ef7e023c02b863d7ea5d079477e722bb41ab25788 \
-    --hash=sha256:58c8abb07dcb441e6ee4b11d8df0ac856038f944ab98b7be6b27b2a3c7feef19
-    # via black
-pluggy==1.0.0 \
-    --hash=sha256:4224373bacce55f955a878bf9cfa763c1e360858e330072059e10bad68531159 \
-    --hash=sha256:74134bbf457f031a36d68416e1509f34bd5ccc019f0bcc952c7b909d06b37bd3
-    # via pytest
-py==1.11.0 \
-    --hash=sha256:51c75c4126074b472f746a24399ad32f6053d1b34b68d2fa41e558e6f4a98719 \
-    --hash=sha256:607c53218732647dff4acdfcd50cb62615cedf612e72d1724fb1a0cc6405b378
-    # via pytest
-pyarrow==8.0.0 \
-    --hash=sha256:03a10daad957970e914920b793f6a49416699e791f4c827927fd4e4d892a5d16 \
-    --hash=sha256:15511ce2f50343f3fd5e9f7c30e4d004da9134e9597e93e9c96c3985928cbe82 \
-    --hash=sha256:1dd482ccb07c96188947ad94d7536ab696afde23ad172df8e18944ec79f55055 \
-    --hash=sha256:25a5f7c7f36df520b0b7363ba9f51c3070799d4b05d587c60c0adaba57763479 \
-    --hash=sha256:3bd201af6e01f475f02be88cf1f6ee9856ab98c11d8bbb6f58347c58cd07be00 \
-    --hash=sha256:3fee786259d986f8c046100ced54d63b0c8c9f7cdb7d1bbe07dc69e0f928141c \
-    --hash=sha256:42b7982301a9ccd06e1dd4fabd2e8e5df74b93ce4c6b87b81eb9e2d86dc79871 \
-    --hash=sha256:4a18a211ed888f1ac0b0ebcb99e2d9a3e913a481120ee9b1fe33d3fedb945d4e \
-    --hash=sha256:51e58778fcb8829fca37fbfaea7f208d5ce7ea89ea133dd13d8ce745278ee6f0 \
-    --hash=sha256:541e7845ce5f27a861eb5b88ee165d931943347eec17b9ff1e308663531c9647 \
-    --hash=sha256:65c7f4cc2be195e3db09296d31a654bb6d8786deebcab00f0e2455fd109d7456 \
-    --hash=sha256:69b043a3fce064ebd9fbae6abc30e885680296e5bd5e6f7353e6a87966cf2ad7 \
-    --hash=sha256:6ea2c54e6b5ecd64e8299d2abb40770fe83a718f5ddc3825ddd5cd28e352cce1 \
-    --hash=sha256:78a6ac39cd793582998dac88ab5c1c1dd1e6503df6672f064f33a21937ec1d8d \
-    --hash=sha256:81b87b782a1366279411f7b235deab07c8c016e13f9af9f7c7b0ee564fedcc8f \
-    --hash=sha256:8392b9a1e837230090fe916415ed4c3433b2ddb1a798e3f6438303c70fbabcfc \
-    --hash=sha256:863be6bad6c53797129610930794a3e797cb7d41c0a30e6794a2ac0e42ce41b8 \
-    --hash=sha256:8cd86e04a899bef43e25184f4b934584861d787cf7519851a8c031803d45c6d8 \
-    --hash=sha256:95c7822eb37663e073da9892f3499fe28e84f3464711a3e555e0c5463fd53a19 \
-    --hash=sha256:98c13b2e28a91b0fbf24b483df54a8d7814c074c2623ecef40dce1fa52f6539b \
-    --hash=sha256:ba2b7aa7efb59156b87987a06f5241932914e4d5bbb74a465306b00a6c808849 \
-    --hash=sha256:c9c97c8e288847e091dfbcdf8ce51160e638346f51919a9e74fe038b2e8aee62 \
-    --hash=sha256:cb06cacc19f3b426681f2f6803cc06ff481e7fe5b3a533b406bc5b2138843d4f \
-    --hash=sha256:ce64bc1da3109ef5ab9e4c60316945a7239c798098a631358e9ab39f6e5529e9 \
-    --hash=sha256:d5ef4372559b191cafe7db8932801eee252bfc35e983304e7d60b6954576a071 \
-    --hash=sha256:d6f1e1040413651819074ef5b500835c6c42e6c446532a1ddef8bc5054e8dba5 \
-    --hash=sha256:deb400df8f19a90b662babceb6dd12daddda6bb357c216e558b207c0770c7654 \
-    --hash=sha256:ea132067ec712d1b1116a841db1c95861508862b21eddbcafefbce8e4b96b867 \
-    --hash=sha256:ece333706a94c1221ced8b299042f85fd88b5db802d71be70024433ddf3aecab \
-    --hash=sha256:edad25522ad509e534400d6ab98cf1872d30c31bc5e947712bfd57def7af15bb
-    # via -r requirements.in
-pycodestyle==2.8.0 \
-    --hash=sha256:720f8b39dde8b293825e7ff02c475f3077124006db4f440dcbc9a20b76548a20 \
-    --hash=sha256:eddd5847ef438ea1c7870ca7eb78a9d47ce0cdb4851a5523949f2601d0cbbe7f
-    # via flake8
-pyflakes==2.4.0 \
-    --hash=sha256:05a85c2872edf37a4ed30b0cce2f6093e1d0581f8c19d7393122da7e25b2b24c \
-    --hash=sha256:3bb3a3f256f4b7968c9c788781e4ff07dce46bdf12339dcda61053375426ee2e
-    # via flake8
-pyparsing==3.0.9 \
-    --hash=sha256:2b020ecf7d21b687f219b71ecad3631f644a47f01403fa1d1036b0c6416d70fb \
-    --hash=sha256:5026bae9a10eeaefb61dab2f09052b9f4307d44aee4eda64b309723d8d206bbc
-    # via packaging
-pytest==7.1.2 \
-    --hash=sha256:13d0e3ccfc2b6e26be000cb6568c832ba67ba32e719443bfe725814d3c42433c \
-    --hash=sha256:a06a0425453864a270bc45e71f783330a7428defb4230fb5e6a731fde06ecd45
-    # via -r requirements.in
-toml==0.10.2 \
-    --hash=sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b \
-    --hash=sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f
-    # via -r requirements.in
-tomli==2.0.1 \
-    --hash=sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc \
-    --hash=sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f
-    # via
-    #   black
-    #   maturin
-    #   mypy
-    #   pytest
-typing-extensions==4.2.0 \
-    --hash=sha256:6657594ee297170d19f67d55c05852a874e7eb634f4f753dbd667855e07c1708 \
-    --hash=sha256:f1c24655a0da0d1b67f07e17a5e6b2a105894e6824b92096378bb3668ef02376
-    # via mypy
diff --git a/requirements-37.txt b/requirements-37.txt
deleted file mode 100644
index 6eff3f822..000000000
--- a/requirements-37.txt
+++ /dev/null
@@ -1,264 +0,0 @@
-#
-# This file is autogenerated by pip-compile with python 3.7
-# To update, run:
-#
-#    pip-compile --generate-hashes
-#
-attrs==21.4.0 \
-    --hash=sha256:2d27e3784d7a565d36ab851fe94887c5eccd6a463168875832a1be79c82828b4 \
-    --hash=sha256:626ba8234211db98e869df76230a137c4c40a12d72445c45d5f5b716f076e2fd
-    # via pytest
-black==22.3.0 \
-    --hash=sha256:06f9d8846f2340dfac80ceb20200ea5d1b3f181dd0556b47af4e8e0b24fa0a6b \
-    --hash=sha256:10dbe6e6d2988049b4655b2b739f98785a884d4d6b85bc35133a8fb9a2233176 \
-    --hash=sha256:2497f9c2386572e28921fa8bec7be3e51de6801f7459dffd6e62492531c47e09 \
-    --hash=sha256:30d78ba6bf080eeaf0b7b875d924b15cd46fec5fd044ddfbad38c8ea9171043a \
-    --hash=sha256:328efc0cc70ccb23429d6be184a15ce613f676bdfc85e5fe8ea2a9354b4e9015 \
-    --hash=sha256:35020b8886c022ced9282b51b5a875b6d1ab0c387b31a065b84db7c33085ca79 \
-    --hash=sha256:5795a0375eb87bfe902e80e0c8cfaedf8af4d49694d69161e5bd3206c18618bb \
-    --hash=sha256:5891ef8abc06576985de8fa88e95ab70641de6c1fca97e2a15820a9b69e51b20 \
-    --hash=sha256:637a4014c63fbf42a692d22b55d8ad6968a946b4a6ebc385c5505d9625b6a464 \
-    --hash=sha256:67c8301ec94e3bcc8906740fe071391bce40a862b7be0b86fb5382beefecd968 \
-    --hash=sha256:6d2fc92002d44746d3e7db7cf9313cf4452f43e9ea77a2c939defce3b10b5c82 \
-    --hash=sha256:6ee227b696ca60dd1c507be80a6bc849a5a6ab57ac7352aad1ffec9e8b805f21 \
-    --hash=sha256:863714200ada56cbc366dc9ae5291ceb936573155f8bf8e9de92aef51f3ad0f0 \
-    --hash=sha256:9b542ced1ec0ceeff5b37d69838106a6348e60db7b8fdd245294dc1d26136265 \
-    --hash=sha256:a6342964b43a99dbc72f72812bf88cad8f0217ae9acb47c0d4f141a6416d2d7b \
-    --hash=sha256:ad4efa5fad66b903b4a5f96d91461d90b9507a812b3c5de657d544215bb7877a \
-    --hash=sha256:bc58025940a896d7e5356952228b68f793cf5fcb342be703c3a2669a1488cb72 \
-    --hash=sha256:cc1e1de68c8e5444e8f94c3670bb48a2beef0e91dddfd4fcc29595ebd90bb9ce \
-    --hash=sha256:cee3e11161dde1b2a33a904b850b0899e0424cc331b7295f2a9698e79f9a69a0 \
-    --hash=sha256:e3556168e2e5c49629f7b0f377070240bd5511e45e25a4497bb0073d9dda776a \
-    --hash=sha256:e8477ec6bbfe0312c128e74644ac8a02ca06bcdb8982d4ee06f209be28cdf163 \
-    --hash=sha256:ee8f1f7228cce7dffc2b464f07ce769f478968bfb3dd1254a4c2eeed84928aad \
-    --hash=sha256:fd57160949179ec517d32ac2ac898b5f20d68ed1a9c977346efbac9c2f1e779d
-    # via -r requirements.in
-click==8.1.3 \
-    --hash=sha256:7682dc8afb30297001674575ea00d1814d808d6a36af415a82bd481d37ba7b8e \
-    --hash=sha256:bb4d8133cb15a609f44e8213d9b391b0809795062913b383c62be0ee95b1db48
-    # via black
-flake8==4.0.1 \
-    --hash=sha256:479b1304f72536a55948cb40a32dce8bb0ffe3501e26eaf292c7e60eb5e0428d \
-    --hash=sha256:806e034dda44114815e23c16ef92f95c91e4c71100ff52813adf7132a6ad870d
-    # via -r requirements.in
-importlib-metadata==4.2.0 ; python_version < "3.8" \
-    --hash=sha256:057e92c15bc8d9e8109738a48db0ccb31b4d9d5cfbee5a8670879a30be66304b \
-    --hash=sha256:b7e52a1f8dec14a75ea73e0891f3060099ca1d8e6a462a4dff11c3e119ea1b31
-    # via
-    #   -r requirements.in
-    #   click
-    #   flake8
-    #   pluggy
-    #   pytest
-iniconfig==1.1.1 \
-    --hash=sha256:011e24c64b7f47f6ebd835bb12a743f2fbe9a26d4cecaa7f53bc4f35ee9da8b3 \
-    --hash=sha256:bc3af051d7d14b2ee5ef9969666def0cd1a000e121eaea580d4a313df4b37f32
-    # via pytest
-isort==5.10.1 \
-    --hash=sha256:6f62d78e2f89b4500b080fe3a81690850cd254227f27f75c3a0c491a1f351ba7 \
-    --hash=sha256:e8443a5e7a020e9d7f97f1d7d9cd17c88bcb3bc7e218bf9cf5095fe550be2951
-    # via -r requirements.in
-maturin==0.14.2 \
-    --hash=sha256:065a0b48259624af1330bbc2d9bd447615ff07603710ad4a839478aa8e9e98cd \
-    --hash=sha256:2966ed9b2e66760ffa5e476dab20c9563dd14efa93ed40b706cbe0a03907d824 \
-    --hash=sha256:50a7a15d02f0b407eb5cf4cbc072d27e302993d5734af71bb6d6c567da8c6396 \
-    --hash=sha256:539545c666506d34474c1133a11e90b4e6b4b6a7e590f5727ae18a49d3b647d2 \
-    --hash=sha256:9f843736fc1c065ffba2dcfc581811c2eb7032c7119ff23012ccde68607e549c \
-    --hash=sha256:ace60890f19a87e4a421fd9753e42e5fb46b11e770feacd8ff6749d3bf114764 \
-    --hash=sha256:ae3a3a754c3b935420eeb1ec34d98d1693251537331feb43277bae7892b7c51a \
-    --hash=sha256:bbaa0689a87124c99adaff99e93dcf415e36f7068d5442f311b49ede4bb7b6c3 \
-    --hash=sha256:c65b00f4a4773bc56ca690d93abd09c85cc59b161a313fba3d03aca1ffbba7ca \
-    --hash=sha256:daefa75e3f03e914924cb5913b40ada47ff646562c3b1874ddaf5b1e4b0f41ef \
-    --hash=sha256:e0b808d1a0b78532c1bcbeb2d01d90281585dc460a966f1949fd337a3fb614c0 \
-    --hash=sha256:ebc722e9661a40c3d36a06ecc0d1c637ae1af3335ea0ab69230f46a71e344088 \
-    --hash=sha256:fa01eeacfd1798cde3ba1c7a0b8d7a889d2ed0e207f4860beb819c5ddd351f43
-    # via -r requirements.in
-mccabe==0.6.1 \
-    --hash=sha256:ab8a6258860da4b6677da4bd2fe5dc2c659cff31b3ee4f7f5d64e79735b80d42 \
-    --hash=sha256:dd8d182285a0fe56bace7f45b5e7d1a6ebcbf524e8f3bd87eb0f125271b8831f
-    # via flake8
-mypy==0.950 \
-    --hash=sha256:0112752a6ff07230f9ec2f71b0d3d4e088a910fdce454fdb6553e83ed0eced7d \
-    --hash=sha256:0384d9f3af49837baa92f559d3fa673e6d2652a16550a9ee07fc08c736f5e6f8 \
-    --hash=sha256:1b333cfbca1762ff15808a0ef4f71b5d3eed8528b23ea1c3fb50543c867d68de \
-    --hash=sha256:1fdeb0a0f64f2a874a4c1f5271f06e40e1e9779bf55f9567f149466fc7a55038 \
-    --hash=sha256:4c653e4846f287051599ed8f4b3c044b80e540e88feec76b11044ddc5612ffed \
-    --hash=sha256:563514c7dc504698fb66bb1cf897657a173a496406f1866afae73ab5b3cdb334 \
-    --hash=sha256:5b231afd6a6e951381b9ef09a1223b1feabe13625388db48a8690f8daa9b71ff \
-    --hash=sha256:5ce6a09042b6da16d773d2110e44f169683d8cc8687e79ec6d1181a72cb028d2 \
-    --hash=sha256:5e7647df0f8fc947388e6251d728189cfadb3b1e558407f93254e35abc026e22 \
-    --hash=sha256:6003de687c13196e8a1243a5e4bcce617d79b88f83ee6625437e335d89dfebe2 \
-    --hash=sha256:61504b9a5ae166ba5ecfed9e93357fd51aa693d3d434b582a925338a2ff57fd2 \
-    --hash=sha256:77423570c04aca807508a492037abbd72b12a1fb25a385847d191cd50b2c9605 \
-    --hash=sha256:a4d9898f46446bfb6405383b57b96737dcfd0a7f25b748e78ef3e8c576bba3cb \
-    --hash=sha256:a952b8bc0ae278fc6316e6384f67bb9a396eb30aced6ad034d3a76120ebcc519 \
-    --hash=sha256:b5b5bd0ffb11b4aba2bb6d31b8643902c48f990cc92fda4e21afac658044f0c0 \
-    --hash=sha256:ca75ecf2783395ca3016a5e455cb322ba26b6d33b4b413fcdedfc632e67941dc \
-    --hash=sha256:cf9c261958a769a3bd38c3e133801ebcd284ffb734ea12d01457cb09eacf7d7b \
-    --hash=sha256:dd4d670eee9610bf61c25c940e9ade2d0ed05eb44227275cce88701fee014b1f \
-    --hash=sha256:e19736af56947addedce4674c0971e5dceef1b5ec7d667fe86bcd2b07f8f9075 \
-    --hash=sha256:eaea21d150fb26d7b4856766e7addcf929119dd19fc832b22e71d942835201ef \
-    --hash=sha256:eaff8156016487c1af5ffa5304c3e3fd183edcb412f3e9c72db349faf3f6e0eb \
-    --hash=sha256:ee0a36edd332ed2c5208565ae6e3a7afc0eabb53f5327e281f2ef03a6bc7687a \
-    --hash=sha256:ef7beb2a3582eb7a9f37beaf38a28acfd801988cde688760aea9e6cc4832b10b
-    # via -r requirements.in
-mypy-extensions==0.4.3 \
-    --hash=sha256:090fedd75945a69ae91ce1303b5824f428daf5a028d2f6ab8a299250a846f15d \
-    --hash=sha256:2d82818f5bb3e369420cb3c4060a7970edba416647068eb4c5343488a6c604a8
-    # via
-    #   black
-    #   mypy
-numpy==1.21.6 \
-    --hash=sha256:1dbe1c91269f880e364526649a52eff93ac30035507ae980d2fed33aaee633ac \
-    --hash=sha256:357768c2e4451ac241465157a3e929b265dfac85d9214074985b1786244f2ef3 \
-    --hash=sha256:3820724272f9913b597ccd13a467cc492a0da6b05df26ea09e78b171a0bb9da6 \
-    --hash=sha256:4391bd07606be175aafd267ef9bea87cf1b8210c787666ce82073b05f202add1 \
-    --hash=sha256:4aa48afdce4660b0076a00d80afa54e8a97cd49f457d68a4342d188a09451c1a \
-    --hash=sha256:58459d3bad03343ac4b1b42ed14d571b8743dc80ccbf27444f266729df1d6f5b \
-    --hash=sha256:5c3c8def4230e1b959671eb959083661b4a0d2e9af93ee339c7dada6759a9470 \
-    --hash=sha256:5f30427731561ce75d7048ac254dbe47a2ba576229250fb60f0fb74db96501a1 \
-    --hash=sha256:643843bcc1c50526b3a71cd2ee561cf0d8773f062c8cbaf9ffac9fdf573f83ab \
-    --hash=sha256:67c261d6c0a9981820c3a149d255a76918278a6b03b6a036800359aba1256d46 \
-    --hash=sha256:67f21981ba2f9d7ba9ade60c9e8cbaa8cf8e9ae51673934480e45cf55e953673 \
-    --hash=sha256:6aaf96c7f8cebc220cdfc03f1d5a31952f027dda050e5a703a0d1c396075e3e7 \
-    --hash=sha256:7c4068a8c44014b2d55f3c3f574c376b2494ca9cc73d2f1bd692382b6dffe3db \
-    --hash=sha256:7c7e5fa88d9ff656e067876e4736379cc962d185d5cd808014a8a928d529ef4e \
-    --hash=sha256:7f5ae4f304257569ef3b948810816bc87c9146e8c446053539947eedeaa32786 \
-    --hash=sha256:82691fda7c3f77c90e62da69ae60b5ac08e87e775b09813559f8901a88266552 \
-    --hash=sha256:8737609c3bbdd48e380d463134a35ffad3b22dc56295eff6f79fd85bd0eeeb25 \
-    --hash=sha256:9f411b2c3f3d76bba0865b35a425157c5dcf54937f82bbeb3d3c180789dd66a6 \
-    --hash=sha256:a6be4cb0ef3b8c9250c19cc122267263093eee7edd4e3fa75395dfda8c17a8e2 \
-    --hash=sha256:bcb238c9c96c00d3085b264e5c1a1207672577b93fa666c3b14a45240b14123a \
-    --hash=sha256:bf2ec4b75d0e9356edea834d1de42b31fe11f726a81dfb2c2112bc1eaa508fcf \
-    --hash=sha256:d136337ae3cc69aa5e447e78d8e1514be8c3ec9b54264e680cf0b4bd9011574f \
-    --hash=sha256:d4bf4d43077db55589ffc9009c0ba0a94fa4908b9586d6ccce2e0b164c86303c \
-    --hash=sha256:d6a96eef20f639e6a97d23e57dd0c1b1069a7b4fd7027482a4c5c451cd7732f4 \
-    --hash=sha256:d9caa9d5e682102453d96a0ee10c7241b72859b01a941a397fd965f23b3e016b \
-    --hash=sha256:dd1c8f6bd65d07d3810b90d02eba7997e32abbdf1277a481d698969e921a3be0 \
-    --hash=sha256:e31f0bb5928b793169b87e3d1e070f2342b22d5245c755e2b81caa29756246c3 \
-    --hash=sha256:ecb55251139706669fdec2ff073c98ef8e9a84473e51e716211b41aa0f18e656 \
-    --hash=sha256:ee5ec40fdd06d62fe5d4084bef4fd50fd4bb6bfd2bf519365f569dc470163ab0 \
-    --hash=sha256:f17e562de9edf691a42ddb1eb4a5541c20dd3f9e65b09ded2beb0799c0cf29bb \
-    --hash=sha256:fdffbfb6832cd0b300995a2b08b8f6fa9f6e856d562800fea9182316d99c4e8e
-    # via
-    #   -r requirements.in
-    #   pyarrow
-packaging==21.3 \
-    --hash=sha256:dd47c42927d89ab911e606518907cc2d3a1f38bbd026385970643f9c5b8ecfeb \
-    --hash=sha256:ef103e05f519cdc783ae24ea4e2e0f508a9c99b2d4969652eed6a2e1ea5bd522
-    # via pytest
-pathspec==0.9.0 \
-    --hash=sha256:7d15c4ddb0b5c802d161efc417ec1a2558ea2653c2e8ad9c19098201dc1c993a \
-    --hash=sha256:e564499435a2673d586f6b2130bb5b95f04a3ba06f81b8f895b651a3c76aabb1
-    # via black
-platformdirs==2.5.2 \
-    --hash=sha256:027d8e83a2d7de06bbac4e5ef7e023c02b863d7ea5d079477e722bb41ab25788 \
-    --hash=sha256:58c8abb07dcb441e6ee4b11d8df0ac856038f944ab98b7be6b27b2a3c7feef19
-    # via black
-pluggy==1.0.0 \
-    --hash=sha256:4224373bacce55f955a878bf9cfa763c1e360858e330072059e10bad68531159 \
-    --hash=sha256:74134bbf457f031a36d68416e1509f34bd5ccc019f0bcc952c7b909d06b37bd3
-    # via pytest
-py==1.11.0 \
-    --hash=sha256:51c75c4126074b472f746a24399ad32f6053d1b34b68d2fa41e558e6f4a98719 \
-    --hash=sha256:607c53218732647dff4acdfcd50cb62615cedf612e72d1724fb1a0cc6405b378
-    # via pytest
-pyarrow==8.0.0 \
-    --hash=sha256:03a10daad957970e914920b793f6a49416699e791f4c827927fd4e4d892a5d16 \
-    --hash=sha256:15511ce2f50343f3fd5e9f7c30e4d004da9134e9597e93e9c96c3985928cbe82 \
-    --hash=sha256:1dd482ccb07c96188947ad94d7536ab696afde23ad172df8e18944ec79f55055 \
-    --hash=sha256:25a5f7c7f36df520b0b7363ba9f51c3070799d4b05d587c60c0adaba57763479 \
-    --hash=sha256:3bd201af6e01f475f02be88cf1f6ee9856ab98c11d8bbb6f58347c58cd07be00 \
-    --hash=sha256:3fee786259d986f8c046100ced54d63b0c8c9f7cdb7d1bbe07dc69e0f928141c \
-    --hash=sha256:42b7982301a9ccd06e1dd4fabd2e8e5df74b93ce4c6b87b81eb9e2d86dc79871 \
-    --hash=sha256:4a18a211ed888f1ac0b0ebcb99e2d9a3e913a481120ee9b1fe33d3fedb945d4e \
-    --hash=sha256:51e58778fcb8829fca37fbfaea7f208d5ce7ea89ea133dd13d8ce745278ee6f0 \
-    --hash=sha256:541e7845ce5f27a861eb5b88ee165d931943347eec17b9ff1e308663531c9647 \
-    --hash=sha256:65c7f4cc2be195e3db09296d31a654bb6d8786deebcab00f0e2455fd109d7456 \
-    --hash=sha256:69b043a3fce064ebd9fbae6abc30e885680296e5bd5e6f7353e6a87966cf2ad7 \
-    --hash=sha256:6ea2c54e6b5ecd64e8299d2abb40770fe83a718f5ddc3825ddd5cd28e352cce1 \
-    --hash=sha256:78a6ac39cd793582998dac88ab5c1c1dd1e6503df6672f064f33a21937ec1d8d \
-    --hash=sha256:81b87b782a1366279411f7b235deab07c8c016e13f9af9f7c7b0ee564fedcc8f \
-    --hash=sha256:8392b9a1e837230090fe916415ed4c3433b2ddb1a798e3f6438303c70fbabcfc \
-    --hash=sha256:863be6bad6c53797129610930794a3e797cb7d41c0a30e6794a2ac0e42ce41b8 \
-    --hash=sha256:8cd86e04a899bef43e25184f4b934584861d787cf7519851a8c031803d45c6d8 \
-    --hash=sha256:95c7822eb37663e073da9892f3499fe28e84f3464711a3e555e0c5463fd53a19 \
-    --hash=sha256:98c13b2e28a91b0fbf24b483df54a8d7814c074c2623ecef40dce1fa52f6539b \
-    --hash=sha256:ba2b7aa7efb59156b87987a06f5241932914e4d5bbb74a465306b00a6c808849 \
-    --hash=sha256:c9c97c8e288847e091dfbcdf8ce51160e638346f51919a9e74fe038b2e8aee62 \
-    --hash=sha256:cb06cacc19f3b426681f2f6803cc06ff481e7fe5b3a533b406bc5b2138843d4f \
-    --hash=sha256:ce64bc1da3109ef5ab9e4c60316945a7239c798098a631358e9ab39f6e5529e9 \
-    --hash=sha256:d5ef4372559b191cafe7db8932801eee252bfc35e983304e7d60b6954576a071 \
-    --hash=sha256:d6f1e1040413651819074ef5b500835c6c42e6c446532a1ddef8bc5054e8dba5 \
-    --hash=sha256:deb400df8f19a90b662babceb6dd12daddda6bb357c216e558b207c0770c7654 \
-    --hash=sha256:ea132067ec712d1b1116a841db1c95861508862b21eddbcafefbce8e4b96b867 \
-    --hash=sha256:ece333706a94c1221ced8b299042f85fd88b5db802d71be70024433ddf3aecab \
-    --hash=sha256:edad25522ad509e534400d6ab98cf1872d30c31bc5e947712bfd57def7af15bb
-    # via -r requirements.in
-pycodestyle==2.8.0 \
-    --hash=sha256:720f8b39dde8b293825e7ff02c475f3077124006db4f440dcbc9a20b76548a20 \
-    --hash=sha256:eddd5847ef438ea1c7870ca7eb78a9d47ce0cdb4851a5523949f2601d0cbbe7f
-    # via flake8
-pyflakes==2.4.0 \
-    --hash=sha256:05a85c2872edf37a4ed30b0cce2f6093e1d0581f8c19d7393122da7e25b2b24c \
-    --hash=sha256:3bb3a3f256f4b7968c9c788781e4ff07dce46bdf12339dcda61053375426ee2e
-    # via flake8
-pyparsing==3.0.9 \
-    --hash=sha256:2b020ecf7d21b687f219b71ecad3631f644a47f01403fa1d1036b0c6416d70fb \
-    --hash=sha256:5026bae9a10eeaefb61dab2f09052b9f4307d44aee4eda64b309723d8d206bbc
-    # via packaging
-pytest==7.1.2 \
-    --hash=sha256:13d0e3ccfc2b6e26be000cb6568c832ba67ba32e719443bfe725814d3c42433c \
-    --hash=sha256:a06a0425453864a270bc45e71f783330a7428defb4230fb5e6a731fde06ecd45
-    # via -r requirements.in
-toml==0.10.2 \
-    --hash=sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b \
-    --hash=sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f
-    # via -r requirements.in
-tomli==2.0.1 \
-    --hash=sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc \
-    --hash=sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f
-    # via
-    #   black
-    #   maturin
-    #   mypy
-    #   pytest
-typed-ast==1.5.3 \
-    --hash=sha256:20d5118e494478ef2d3a2702d964dae830aedd7b4d3b626d003eea526be18718 \
-    --hash=sha256:27e46cdd01d6c3a0dd8f728b6a938a6751f7bd324817501c15fb056307f918c6 \
-    --hash=sha256:27f25232e2dd0edfe1f019d6bfaaf11e86e657d9bdb7b0956db95f560cceb2b3 \
-    --hash=sha256:3042bfc9ca118712c9809201f55355479cfcdc17449f9f8db5e744e9625c6805 \
-    --hash=sha256:37e5349d1d5de2f4763d534ccb26809d1c24b180a477659a12c4bde9dd677d74 \
-    --hash=sha256:4fff9fdcce59dc61ec1b317bdb319f8f4e6b69ebbe61193ae0a60c5f9333dc49 \
-    --hash=sha256:542cd732351ba8235f20faa0fc7398946fe1a57f2cdb289e5497e1e7f48cfedb \
-    --hash=sha256:5dc2c11ae59003d4a26dda637222d9ae924387f96acae9492df663843aefad55 \
-    --hash=sha256:8831479695eadc8b5ffed06fdfb3e424adc37962a75925668deeb503f446c0a3 \
-    --hash=sha256:8cdf91b0c466a6c43f36c1964772918a2c04cfa83df8001ff32a89e357f8eb06 \
-    --hash=sha256:8e0b8528838ffd426fea8d18bde4c73bcb4167218998cc8b9ee0a0f2bfe678a6 \
-    --hash=sha256:8ef1d96ad05a291f5c36895d86d1375c0ee70595b90f6bb5f5fdbee749b146db \
-    --hash=sha256:9ad3b48cf2b487be140072fb86feff36801487d4abb7382bb1929aaac80638ea \
-    --hash=sha256:9cc9e1457e1feb06b075c8ef8aeb046a28ec351b1958b42c7c31c989c841403a \
-    --hash=sha256:9e237e74fd321a55c90eee9bc5d44be976979ad38a29bbd734148295c1ce7617 \
-    --hash=sha256:c9f1a27592fac87daa4e3f16538713d705599b0a27dfe25518b80b6b017f0a6d \
-    --hash=sha256:d64dabc6336ddc10373922a146fa2256043b3b43e61f28961caec2a5207c56d5 \
-    --hash=sha256:e20d196815eeffb3d76b75223e8ffed124e65ee62097e4e73afb5fec6b993e7a \
-    --hash=sha256:e34f9b9e61333ecb0f7d79c21c28aa5cd63bec15cb7e1310d7d3da6ce886bc9b \
-    --hash=sha256:ed44e81517364cb5ba367e4f68fca01fba42a7a4690d40c07886586ac267d9b9 \
-    --hash=sha256:ee852185964744987609b40aee1d2eb81502ae63ee8eef614558f96a56c1902d \
-    --hash=sha256:f60d9de0d087454c91b3999a296d0c4558c1666771e3460621875021bf899af9 \
-    --hash=sha256:f818c5b81966d4728fec14caa338e30a70dfc3da577984d38f97816c4b3071ec \
-    --hash=sha256:fd5df1313915dbd70eaaa88c19030b441742e8b05e6103c631c83b75e0435ccc
-    # via
-    #   black
-    #   mypy
-typing-extensions==4.2.0 \
-    --hash=sha256:6657594ee297170d19f67d55c05852a874e7eb634f4f753dbd667855e07c1708 \
-    --hash=sha256:f1c24655a0da0d1b67f07e17a5e6b2a105894e6824b92096378bb3668ef02376
-    # via
-    #   black
-    #   importlib-metadata
-    #   mypy
-zipp==3.8.0 \
-    --hash=sha256:56bf8aadb83c24db6c4b577e13de374ccfb67da2078beba1d037c17980bf43ad \
-    --hash=sha256:c4f6e5bbf48e74f7a38e7cc5b0480ff42b0ae5178957d564d18932525d5cf099
-    # via importlib-metadata
diff --git a/requirements.in b/requirements.in
deleted file mode 100644
index 7ee6a48dc..000000000
--- a/requirements.in
+++ /dev/null
@@ -1,27 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-black
-flake8
-isort
-maturin
-mypy
-numpy
-pyarrow
-pytest
-toml
-importlib_metadata; python_version < "3.8"
diff --git a/requirements.txt b/requirements.txt
deleted file mode 100644
index ce2404f39..000000000
--- a/requirements.txt
+++ /dev/null
@@ -1,284 +0,0 @@
-#
-# This file is autogenerated by pip-compile with python 3.10
-# To update, run:
-#
-#    pip-compile --generate-hashes
-#
-attrs==21.2.0 \
-    --hash=sha256:149e90d6d8ac20db7a955ad60cf0e6881a3f20d37096140088356da6c716b0b1 \
-    --hash=sha256:ef6aaac3ca6cd92904cdd0d83f629a15f18053ec84e6432106f7a4d04ae4f5fb
-    # via pytest
-black==21.9b0 \
-    --hash=sha256:380f1b5da05e5a1429225676655dddb96f5ae8c75bdf91e53d798871b902a115 \
-    --hash=sha256:7de4cfc7eb6b710de325712d40125689101d21d25283eed7e9998722cf10eb91
-    # via -r requirements.in
-click==8.0.3 \
-    --hash=sha256:353f466495adaeb40b6b5f592f9f91cb22372351c84caeb068132442a4518ef3 \
-    --hash=sha256:410e932b050f5eed773c4cda94de75971c89cdb3155a72a0831139a79e5ecb5b
-    # via black
-flake8==4.0.1 \
-    --hash=sha256:479b1304f72536a55948cb40a32dce8bb0ffe3501e26eaf292c7e60eb5e0428d \
-    --hash=sha256:806e034dda44114815e23c16ef92f95c91e4c71100ff52813adf7132a6ad870d
-    # via -r requirements.in
-iniconfig==1.1.1 \
-    --hash=sha256:011e24c64b7f47f6ebd835bb12a743f2fbe9a26d4cecaa7f53bc4f35ee9da8b3 \
-    --hash=sha256:bc3af051d7d14b2ee5ef9969666def0cd1a000e121eaea580d4a313df4b37f32
-    # via pytest
-isort==5.9.3 \
-    --hash=sha256:9c2ea1e62d871267b78307fe511c0838ba0da28698c5732d54e2790bf3ba9899 \
-    --hash=sha256:e17d6e2b81095c9db0a03a8025a957f334d6ea30b26f9ec70805411e5c7c81f2
-    # via -r requirements.in
-maturin==0.14.2 \
-    --hash=sha256:065a0b48259624af1330bbc2d9bd447615ff07603710ad4a839478aa8e9e98cd \
-    --hash=sha256:2966ed9b2e66760ffa5e476dab20c9563dd14efa93ed40b706cbe0a03907d824 \
-    --hash=sha256:50a7a15d02f0b407eb5cf4cbc072d27e302993d5734af71bb6d6c567da8c6396 \
-    --hash=sha256:539545c666506d34474c1133a11e90b4e6b4b6a7e590f5727ae18a49d3b647d2 \
-    --hash=sha256:9f843736fc1c065ffba2dcfc581811c2eb7032c7119ff23012ccde68607e549c \
-    --hash=sha256:ace60890f19a87e4a421fd9753e42e5fb46b11e770feacd8ff6749d3bf114764 \
-    --hash=sha256:ae3a3a754c3b935420eeb1ec34d98d1693251537331feb43277bae7892b7c51a \
-    --hash=sha256:bbaa0689a87124c99adaff99e93dcf415e36f7068d5442f311b49ede4bb7b6c3 \
-    --hash=sha256:c65b00f4a4773bc56ca690d93abd09c85cc59b161a313fba3d03aca1ffbba7ca \
-    --hash=sha256:daefa75e3f03e914924cb5913b40ada47ff646562c3b1874ddaf5b1e4b0f41ef \
-    --hash=sha256:e0b808d1a0b78532c1bcbeb2d01d90281585dc460a966f1949fd337a3fb614c0 \
-    --hash=sha256:ebc722e9661a40c3d36a06ecc0d1c637ae1af3335ea0ab69230f46a71e344088 \
-    --hash=sha256:fa01eeacfd1798cde3ba1c7a0b8d7a889d2ed0e207f4860beb819c5ddd351f43
-    # via -r requirements.in
-mccabe==0.6.1 \
-    --hash=sha256:ab8a6258860da4b6677da4bd2fe5dc2c659cff31b3ee4f7f5d64e79735b80d42 \
-    --hash=sha256:dd8d182285a0fe56bace7f45b5e7d1a6ebcbf524e8f3bd87eb0f125271b8831f
-    # via flake8
-mypy==0.910 \
-    --hash=sha256:088cd9c7904b4ad80bec811053272986611b84221835e079be5bcad029e79dd9 \
-    --hash=sha256:0aadfb2d3935988ec3815952e44058a3100499f5be5b28c34ac9d79f002a4a9a \
-    --hash=sha256:119bed3832d961f3a880787bf621634ba042cb8dc850a7429f643508eeac97b9 \
-    --hash=sha256:1a85e280d4d217150ce8cb1a6dddffd14e753a4e0c3cf90baabb32cefa41b59e \
-    --hash=sha256:3c4b8ca36877fc75339253721f69603a9c7fdb5d4d5a95a1a1b899d8b86a4de2 \
-    --hash=sha256:3e382b29f8e0ccf19a2df2b29a167591245df90c0b5a2542249873b5c1d78212 \
-    --hash=sha256:42c266ced41b65ed40a282c575705325fa7991af370036d3f134518336636f5b \
-    --hash=sha256:53fd2eb27a8ee2892614370896956af2ff61254c275aaee4c230ae771cadd885 \
-    --hash=sha256:704098302473cb31a218f1775a873b376b30b4c18229421e9e9dc8916fd16150 \
-    --hash=sha256:7df1ead20c81371ccd6091fa3e2878559b5c4d4caadaf1a484cf88d93ca06703 \
-    --hash=sha256:866c41f28cee548475f146aa4d39a51cf3b6a84246969f3759cb3e9c742fc072 \
-    --hash=sha256:a155d80ea6cee511a3694b108c4494a39f42de11ee4e61e72bc424c490e46457 \
-    --hash=sha256:adaeee09bfde366d2c13fe6093a7df5df83c9a2ba98638c7d76b010694db760e \
-    --hash=sha256:b6fb13123aeef4a3abbcfd7e71773ff3ff1526a7d3dc538f3929a49b42be03f0 \
-    --hash=sha256:b94e4b785e304a04ea0828759172a15add27088520dc7e49ceade7834275bedb \
-    --hash=sha256:c0df2d30ed496a08de5daed2a9ea807d07c21ae0ab23acf541ab88c24b26ab97 \
-    --hash=sha256:c6c2602dffb74867498f86e6129fd52a2770c48b7cd3ece77ada4fa38f94eba8 \
-    --hash=sha256:ceb6e0a6e27fb364fb3853389607cf7eb3a126ad335790fa1e14ed02fba50811 \
-    --hash=sha256:d9dd839eb0dc1bbe866a288ba3c1afc33a202015d2ad83b31e875b5905a079b6 \
-    --hash=sha256:e4dab234478e3bd3ce83bac4193b2ecd9cf94e720ddd95ce69840273bf44f6de \
-    --hash=sha256:ec4e0cd079db280b6bdabdc807047ff3e199f334050db5cbb91ba3e959a67504 \
-    --hash=sha256:ecd2c3fe726758037234c93df7e98deb257fd15c24c9180dacf1ef829da5f921 \
-    --hash=sha256:ef565033fa5a958e62796867b1df10c40263ea9ded87164d67572834e57a174d
-    # via -r requirements.in
-mypy-extensions==0.4.3 \
-    --hash=sha256:090fedd75945a69ae91ce1303b5824f428daf5a028d2f6ab8a299250a846f15d \
-    --hash=sha256:2d82818f5bb3e369420cb3c4060a7970edba416647068eb4c5343488a6c604a8
-    # via
-    #   black
-    #   mypy
-numpy==1.21.3 \
-    --hash=sha256:043e83bfc274649c82a6f09836943e4a4aebe5e33656271c7dbf9621dd58b8ec \
-    --hash=sha256:160ccc1bed3a8371bf0d760971f09bfe80a3e18646620e9ded0ad159d9749baa \
-    --hash=sha256:188031f833bbb623637e66006cf75e933e00e7231f67e2b45cf8189612bb5dc3 \
-    --hash=sha256:28f15209fb535dd4c504a7762d3bc440779b0e37d50ed810ced209e5cea60d96 \
-    --hash=sha256:29fb3dcd0468b7715f8ce2c0c2d9bbbaf5ae686334951343a41bd8d155c6ea27 \
-    --hash=sha256:2a6ee9620061b2a722749b391c0d80a0e2ae97290f1b32e28d5a362e21941ee4 \
-    --hash=sha256:300321e3985c968e3ae7fbda187237b225f3ffe6528395a5b7a5407f73cf093e \
-    --hash=sha256:32437f0b275c1d09d9c3add782516413e98cd7c09e6baf4715cbce781fc29912 \
-    --hash=sha256:3c09418a14471c7ae69ba682e2428cae5b4420a766659605566c0fa6987f6b7e \
-    --hash=sha256:49c6249260890e05b8111ebfc391ed58b3cb4b33e63197b2ec7f776e45330721 \
-    --hash=sha256:4cc9b512e9fb590797474f58b7f6d1f1b654b3a94f4fa8558b48ca8b3cfc97cf \
-    --hash=sha256:508b0b513fa1266875524ba8a9ecc27b02ad771fe1704a16314dc1a816a68737 \
-    --hash=sha256:50cd26b0cf6664cb3b3dd161ba0a09c9c1343db064e7c69f9f8b551f5104d654 \
-    --hash=sha256:5c4193f70f8069550a1788bd0cd3268ab7d3a2b70583dfe3b2e7f421e9aace06 \
-    --hash=sha256:5dfe9d6a4c39b8b6edd7990091fea4f852888e41919d0e6722fe78dd421db0eb \
-    --hash=sha256:63571bb7897a584ca3249c86dd01c10bcb5fe4296e3568b2e9c1a55356b6410e \
-    --hash=sha256:75621882d2230ab77fb6a03d4cbccd2038511491076e7964ef87306623aa5272 \
-    --hash=sha256:75eb7cadc8da49302f5b659d40ba4f6d94d5045fbd9569c9d058e77b0514c9e4 \
-    --hash=sha256:88a5d6b268e9ad18f3533e184744acdaa2e913b13148160b1152300c949bbb5f \
-    --hash=sha256:8a10968963640e75cc0193e1847616ab4c718e83b6938ae74dea44953950f6b7 \
-    --hash=sha256:90bec6a86b348b4559b6482e2b684db4a9a7eed1fa054b86115a48d58fbbf62a \
-    --hash=sha256:98339aa9911853f131de11010f6dd94c8cec254d3d1f7261528c3b3e3219f139 \
-    --hash=sha256:a99a6b067e5190ac6d12005a4d85aa6227c5606fa93211f86b1dafb16233e57d \
-    --hash=sha256:bffa2eee3b87376cc6b31eee36d05349571c236d1de1175b804b348dc0941e3f \
-    --hash=sha256:c6c2d535a7beb1f8790aaa98fd089ceab2e3dd7ca48aca0af7dc60e6ef93ffe1 \
-    --hash=sha256:cc14e7519fab2a4ed87d31f99c31a3796e4e1fe63a86ebdd1c5a1ea78ebd5896 \
-    --hash=sha256:dd0482f3fc547f1b1b5d6a8b8e08f63fdc250c58ce688dedd8851e6e26cff0f3 \
-    --hash=sha256:dde972a1e11bb7b702ed0e447953e7617723760f420decb97305e66fb4afc54f \
-    --hash=sha256:e54af82d68ef8255535a6cdb353f55d6b8cf418a83e2be3569243787a4f4866f \
-    --hash=sha256:e606e6316911471c8d9b4618e082635cfe98876007556e89ce03d52ff5e8fcf0 \
-    --hash=sha256:f41b018f126aac18583956c54544db437f25c7ee4794bcb23eb38bef8e5e192a \
-    --hash=sha256:f8f4625536926a155b80ad2bbff44f8cc59e9f2ad14cdda7acf4c135b4dc8ff2 \
-    --hash=sha256:fe52dbe47d9deb69b05084abd4b0df7abb39a3c51957c09f635520abd49b29dd
-    # via
-    #   -r requirements.in
-    #   pandas
-    #   pyarrow
-packaging==21.0 \
-    --hash=sha256:7dc96269f53a4ccec5c0670940a4281106dd0bb343f47b7471f779df49c2fbe7 \
-    --hash=sha256:c86254f9220d55e31cc94d69bade760f0847da8000def4dfe1c6b872fd14ff14
-    # via pytest
-pandas==1.3.4 \
-    --hash=sha256:003ba92db58b71a5f8add604a17a059f3068ef4e8c0c365b088468d0d64935fd \
-    --hash=sha256:10e10a2527db79af6e830c3d5842a4d60383b162885270f8cffc15abca4ba4a9 \
-    --hash=sha256:22808afb8f96e2269dcc5b846decacb2f526dd0b47baebc63d913bf847317c8f \
-    --hash=sha256:2d1dc09c0013d8faa7474574d61b575f9af6257ab95c93dcf33a14fd8d2c1bab \
-    --hash=sha256:35c77609acd2e4d517da41bae0c11c70d31c87aae8dd1aabd2670906c6d2c143 \
-    --hash=sha256:372d72a3d8a5f2dbaf566a5fa5fa7f230842ac80f29a931fb4b071502cf86b9a \
-    --hash=sha256:42493f8ae67918bf129869abea8204df899902287a7f5eaf596c8e54e0ac7ff4 \
-    --hash=sha256:5298a733e5bfbb761181fd4672c36d0c627320eb999c59c65156c6a90c7e1b4f \
-    --hash=sha256:5ba0aac1397e1d7b654fccf263a4798a9e84ef749866060d19e577e927d66e1b \
-    --hash=sha256:a2aa18d3f0b7d538e21932f637fbfe8518d085238b429e4790a35e1e44a96ffc \
-    --hash=sha256:a388960f979665b447f0847626e40f99af8cf191bce9dc571d716433130cb3a7 \
-    --hash=sha256:a51528192755f7429c5bcc9e80832c517340317c861318fea9cea081b57c9afd \
-    --hash=sha256:b528e126c13816a4374e56b7b18bfe91f7a7f6576d1aadba5dee6a87a7f479ae \
-    --hash=sha256:c1aa4de4919358c5ef119f6377bc5964b3a7023c23e845d9db7d9016fa0c5b1c \
-    --hash=sha256:c2646458e1dce44df9f71a01dc65f7e8fa4307f29e5c0f2f92c97f47a5bf22f5 \
-    --hash=sha256:d47750cf07dee6b55d8423471be70d627314277976ff2edd1381f02d52dbadf9 \
-    --hash=sha256:d99d2350adb7b6c3f7f8f0e5dfb7d34ff8dd4bc0a53e62c445b7e43e163fce63 \
-    --hash=sha256:dd324f8ee05925ee85de0ea3f0d66e1362e8c80799eb4eb04927d32335a3e44a \
-    --hash=sha256:eaca36a80acaacb8183930e2e5ad7f71539a66805d6204ea88736570b2876a7b \
-    --hash=sha256:f567e972dce3bbc3a8076e0b675273b4a9e8576ac629149cf8286ee13c259ae5 \
-    --hash=sha256:fe48e4925455c964db914b958f6e7032d285848b7538a5e1b19aeb26ffaea3ec
-    # via -r requirements.in
-pathspec==0.9.0 \
-    --hash=sha256:7d15c4ddb0b5c802d161efc417ec1a2558ea2653c2e8ad9c19098201dc1c993a \
-    --hash=sha256:e564499435a2673d586f6b2130bb5b95f04a3ba06f81b8f895b651a3c76aabb1
-    # via black
-platformdirs==2.4.0 \
-    --hash=sha256:367a5e80b3d04d2428ffa76d33f124cf11e8fff2acdaa9b43d545f5c7d661ef2 \
-    --hash=sha256:8868bbe3c3c80d42f20156f22e7131d2fb321f5bc86a2a345375c6481a67021d
-    # via black
-pluggy==1.0.0 \
-    --hash=sha256:4224373bacce55f955a878bf9cfa763c1e360858e330072059e10bad68531159 \
-    --hash=sha256:74134bbf457f031a36d68416e1509f34bd5ccc019f0bcc952c7b909d06b37bd3
-    # via pytest
-py==1.10.0 \
-    --hash=sha256:21b81bda15b66ef5e1a777a21c4dcd9c20ad3efd0b3f817e7a809035269e1bd3 \
-    --hash=sha256:3b80836aa6d1feeaa108e046da6423ab8f6ceda6468545ae8d02d9d58d18818a
-    # via pytest
-pyarrow==6.0.0 \
-    --hash=sha256:004185e0babc6f3c3fba6ba4f106e406a0113d0f82bb9ad9a8571a1978c45d04 \
-    --hash=sha256:0204e80777ab8f4e9abd3a765a8ec07ed1e3c4630bacda50d2ce212ef0f3826f \
-    --hash=sha256:072c1a0fca4509eefd7d018b78542fb7e5c63aaf5698f1c0a6e45628ae17ba44 \
-    --hash=sha256:15dc0d673d3f865ca63c877bd7a2eced70b0a08969fb733a28247134b8a1f18b \
-    --hash=sha256:1c38263ea438a1666b13372e7565450cfeec32dbcd1c2595749476a58465eaec \
-    --hash=sha256:281ce5fa03621d786a9beb514abb09846db7f0221b50eabf543caa24037eaacd \
-    --hash=sha256:2d2c681659396c745e4f1988d5dd41dcc3ad557bb8d4a8c2e44030edafc08a91 \
-    --hash=sha256:376c4b5f248ae63df21fe15c194e9013753164be2d38f4b3fb8bde63ac5a1958 \
-    --hash=sha256:465f87fa0be0b2928b2beeba22b5813a0203fb05d90fd8563eea48e08ecc030e \
-    --hash=sha256:477c746ef42c039348a288584800e299456c80c5691401bb9b19aa9c02a427b7 \
-    --hash=sha256:5144bd9db2920c7cb566c96462d62443cc239104f94771d110f74393f2fb42a2 \
-    --hash=sha256:5408fa8d623e66a0445f3fb0e4027fd219bf99bfb57422d543d7b7876e2c5b55 \
-    --hash=sha256:5be62679201c441356d3f2a739895dcc8d4d299f2a6eabcd2163bfb6a898abba \
-    --hash=sha256:5c666bc6a1cebf01206e2dc1ab05f25f39f35d3a499e0ef5cd635225e07306ca \
-    --hash=sha256:6163d82cca7541774b00503c295fe86a1722820eddb958b57f091bb6f5b0a6db \
-    --hash=sha256:6a1d9a2f4ee812ed0bd4182cabef99ea914ac297274f0de086f2488093d284ef \
-    --hash=sha256:7a683f71b848eb6310b4ec48c0def55dac839e9994c1ac874c9b2d3d5625def1 \
-    --hash=sha256:82fe80309e01acf29e3943a1f6d3c98ec109fe1d356bc1ac37d639bcaadcf684 \
-    --hash=sha256:8c23f8cdecd3d9e49f9b0f9a651ae5549d1d32fd4901fb1bdc2d327edfba844f \
-    --hash=sha256:8d41dfb09ba9236cca6245f33088eb42f3c54023da281139241e0f9f3b4b754e \
-    --hash=sha256:a19e58dfb04e451cd8b7bdec3ac8848373b95dfc53492c9a69789aa9074a3c1b \
-    --hash=sha256:a50d2f77b86af38ceabf45617208b9105d20e7a5eebc584e7c8c0acededd82ce \
-    --hash=sha256:a5bed4f948c032c40597302e9bdfa65f62295240306976ecbe43a54924c6f94f \
-    --hash=sha256:ac941a147d14993987cc8b605b721735a34b3e54d167302501fb4db1ad7382c7 \
-    --hash=sha256:b86d175262db1eb46afdceb36d459409eb6f8e532d3dec162f8bf572c7f57623 \
-    --hash=sha256:bf3400780c4d3c9cb43b1e8a1aaf2e1b7199a0572d0a645529d2784e4d0d8497 \
-    --hash=sha256:c7a6e7e0bf8779e9c3428ced85507541f3da9a0675e2f4781d4eb2c7042cbf81 \
-    --hash=sha256:cc1d4a70efd583befe92d4ea6f74ed2e0aa31ccdde767cd5cae8e77c65a1c2d4 \
-    --hash=sha256:d046dc78a9337baa6415be915c5a16222505233e238a1017f368243c89817eea \
-    --hash=sha256:da7860688c33ca88ac05f1a487d32d96d9caa091412496c35f3d1d832145675a \
-    --hash=sha256:ddf2e6e3b321adaaf716f2d5af8e92d205a9671e0cb7c0779710a567fd1dd580 \
-    --hash=sha256:e81508239a71943759cee272ce625ae208092dd36ef2c6713fccee30bbcf52bb \
-    --hash=sha256:ea64a48a85c631eb2a0ea13ccdec5143c85b5897836b16331ee4289d27a57247 \
-    --hash=sha256:ed0be080cf595ea15ff1c9ff4097bbf1fcc4b50847d98c0a3c0412fbc6ede7e9 \
-    --hash=sha256:fb701ec4a94b92102606d4e88f0b8eba34f09a5ad8e014eaa4af76f42b7f62ae \
-    --hash=sha256:fbda7595f24a639bcef3419ecfac17216efacb09f7b0f1b4c4c97f900d65ca0e
-    # via -r requirements.in
-pycodestyle==2.8.0 \
-    --hash=sha256:720f8b39dde8b293825e7ff02c475f3077124006db4f440dcbc9a20b76548a20 \
-    --hash=sha256:eddd5847ef438ea1c7870ca7eb78a9d47ce0cdb4851a5523949f2601d0cbbe7f
-    # via flake8
-pyflakes==2.4.0 \
-    --hash=sha256:05a85c2872edf37a4ed30b0cce2f6093e1d0581f8c19d7393122da7e25b2b24c \
-    --hash=sha256:3bb3a3f256f4b7968c9c788781e4ff07dce46bdf12339dcda61053375426ee2e
-    # via flake8
-pyparsing==3.0.3 \
-    --hash=sha256:9e3511118010f112a4b4b435ae50e1eaa610cda191acb9e421d60cf5fde83455 \
-    --hash=sha256:f8d3fe9fc404576c5164f0f0c4e382c96b85265e023c409c43d48f65da9d60d0
-    # via packaging
-pytest==6.2.5 \
-    --hash=sha256:131b36680866a76e6781d13f101efb86cf674ebb9762eb70d3082b6f29889e89 \
-    --hash=sha256:7310f8d27bc79ced999e760ca304d69f6ba6c6649c0b60fb0e04a4a77cacc134
-    # via -r requirements.in
-python-dateutil==2.8.2 \
-    --hash=sha256:0123cacc1627ae19ddf3c27a5de5bd67ee4586fbdd6440d9748f8abb483d3e86 \
-    --hash=sha256:961d03dc3453ebbc59dbdea9e4e11c5651520a876d0f4db161e8674aae935da9
-    # via pandas
-pytz==2021.3 \
-    --hash=sha256:3672058bc3453457b622aab7a1c3bfd5ab0bdae451512f6cf25f64ed37f5b87c \
-    --hash=sha256:acad2d8b20a1af07d4e4c9d2e9285c5ed9104354062f275f3fcd88dcef4f1326
-    # via pandas
-regex==2021.10.23 \
-    --hash=sha256:0c186691a7995ef1db61205e00545bf161fb7b59cdb8c1201c89b333141c438a \
-    --hash=sha256:0dcc0e71118be8c69252c207630faf13ca5e1b8583d57012aae191e7d6d28b84 \
-    --hash=sha256:0f7552429dd39f70057ac5d0e897e5bfe211629652399a21671e53f2a9693a4e \
-    --hash=sha256:129472cd06062fb13e7b4670a102951a3e655e9b91634432cfbdb7810af9d710 \
-    --hash=sha256:13ec99df95003f56edcd307db44f06fbeb708c4ccdcf940478067dd62353181e \
-    --hash=sha256:1f2b59c28afc53973d22e7bc18428721ee8ca6079becf1b36571c42627321c65 \
-    --hash=sha256:2b20f544cbbeffe171911f6ce90388ad36fe3fad26b7c7a35d4762817e9ea69c \
-    --hash=sha256:2fb698037c35109d3c2e30f2beb499e5ebae6e4bb8ff2e60c50b9a805a716f79 \
-    --hash=sha256:34d870f9f27f2161709054d73646fc9aca49480617a65533fc2b4611c518e455 \
-    --hash=sha256:391703a2abf8013d95bae39145d26b4e21531ab82e22f26cd3a181ee2644c234 \
-    --hash=sha256:450dc27483548214314640c89a0f275dbc557968ed088da40bde7ef8fb52829e \
-    --hash=sha256:45b65d6a275a478ac2cbd7fdbf7cc93c1982d613de4574b56fd6972ceadb8395 \
-    --hash=sha256:5095a411c8479e715784a0c9236568ae72509450ee2226b649083730f3fadfc6 \
-    --hash=sha256:530fc2bbb3dc1ebb17f70f7b234f90a1dd43b1b489ea38cea7be95fb21cdb5c7 \
-    --hash=sha256:56f0c81c44638dfd0e2367df1a331b4ddf2e771366c4b9c5d9a473de75e3e1c7 \
-    --hash=sha256:5e9c9e0ce92f27cef79e28e877c6b6988c48b16942258f3bc55d39b5f911df4f \
-    --hash=sha256:6d7722136c6ed75caf84e1788df36397efdc5dbadab95e59c2bba82d4d808a4c \
-    --hash=sha256:74d071dbe4b53c602edd87a7476ab23015a991374ddb228d941929ad7c8c922e \
-    --hash=sha256:7b568809dca44cb75c8ebb260844ea98252c8c88396f9d203f5094e50a70355f \
-    --hash=sha256:80bb5d2e92b2258188e7dcae5b188c7bf868eafdf800ea6edd0fbfc029984a88 \
-    --hash=sha256:8d1cdcda6bd16268316d5db1038965acf948f2a6f43acc2e0b1641ceab443623 \
-    --hash=sha256:9f665677e46c5a4d288ece12fdedf4f4204a422bb28ff05f0e6b08b7447796d1 \
-    --hash=sha256:a30513828180264294953cecd942202dfda64e85195ae36c265daf4052af0464 \
-    --hash=sha256:a7a986c45d1099a5de766a15de7bee3840b1e0e1a344430926af08e5297cf666 \
-    --hash=sha256:a940ca7e7189d23da2bfbb38973832813eab6bd83f3bf89a977668c2f813deae \
-    --hash=sha256:ab7c5684ff3538b67df3f93d66bd3369b749087871ae3786e70ef39e601345b0 \
-    --hash=sha256:be04739a27be55631069b348dda0c81d8ea9822b5da10b8019b789e42d1fe452 \
-    --hash=sha256:c0938ddd60cc04e8f1faf7a14a166ac939aac703745bfcd8e8f20322a7373019 \
-    --hash=sha256:cb46b542133999580ffb691baf67410306833ee1e4f58ed06b6a7aaf4e046952 \
-    --hash=sha256:d134757a37d8640f3c0abb41f5e68b7cf66c644f54ef1cb0573b7ea1c63e1509 \
-    --hash=sha256:de557502c3bec8e634246588a94e82f1ee1b9dfcfdc453267c4fb652ff531570 \
-    --hash=sha256:ded0c4a3eee56b57fcb2315e40812b173cafe79d2f992d50015f4387445737fa \
-    --hash=sha256:e1dae12321b31059a1a72aaa0e6ba30156fe7e633355e445451e4021b8e122b6 \
-    --hash=sha256:eb672217f7bd640411cfc69756ce721d00ae600814708d35c930930f18e8029f \
-    --hash=sha256:ee684f139c91e69fe09b8e83d18b4d63bf87d9440c1eb2eeb52ee851883b1b29 \
-    --hash=sha256:f3f9a91d3cc5e5b0ddf1043c0ae5fa4852f18a1c0050318baf5fc7930ecc1f9c
-    # via black
-six==1.16.0 \
-    --hash=sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926 \
-    --hash=sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254
-    # via python-dateutil
-toml==0.10.2 \
-    --hash=sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b \
-    --hash=sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f
-    # via
-    #   -r requirements.in
-    #   maturin
-    #   mypy
-    #   pytest
-tomli==1.2.2 \
-    --hash=sha256:c6ce0015eb38820eaf32b5db832dbc26deb3dd427bd5f6556cf0acac2c214fee \
-    --hash=sha256:f04066f68f5554911363063a30b108d2b5a5b1a010aa8b6132af78489fe3aade
-    # via black
-typing-extensions==3.10.0.2 \
-    --hash=sha256:49f75d16ff11f1cd258e1b988ccff82a3ca5570217d7ad8c5f48205dd99a677e \
-    --hash=sha256:d8226d10bc02a29bcc81df19a26e56a9647f8b0a6d4a83924139f4a8b01f17b7 \
-    --hash=sha256:f1d25edafde516b146ecd0613dabcc61409817af4766fbbcfb8d1ad4ec441a34
-    # via
-    #   black
-    #   mypy
diff --git a/docs/requirements.txt b/rustfmt.toml
similarity index 92%
rename from docs/requirements.txt
rename to rustfmt.toml
index 2af563587..d04700d69 100644
--- a/docs/requirements.txt
+++ b/rustfmt.toml
@@ -15,8 +15,5 @@
 # specific language governing permissions and limitations
 # under the License.
 
-sphinx
-pydata-sphinx-theme==0.8.0
-myst-parser
-maturin
-jinja2
\ No newline at end of file
+group_imports = "StdExternalCrate"
+imports_granularity = "Module"
diff --git a/src/array.rs b/src/array.rs
new file mode 100644
index 000000000..1ff08dfb2
--- /dev/null
+++ b/src/array.rs
@@ -0,0 +1,92 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::ptr::NonNull;
+use std::sync::Arc;
+
+use arrow::array::{Array, ArrayRef};
+use arrow::datatypes::{Field, FieldRef};
+use arrow::ffi::{FFI_ArrowArray, FFI_ArrowSchema};
+use arrow::pyarrow::ToPyArrow;
+use pyo3::ffi::c_str;
+use pyo3::prelude::{PyAnyMethods, PyCapsuleMethods};
+use pyo3::types::PyCapsule;
+use pyo3::{Bound, PyAny, PyResult, Python, pyclass, pymethods};
+
+use crate::errors::PyDataFusionResult;
+use crate::utils::validate_pycapsule;
+
+/// A Python object which implements the Arrow PyCapsule for importing
+/// into other libraries.
+#[pyclass(
+    from_py_object,
+    name = "ArrowArrayExportable",
+    module = "datafusion",
+    frozen
+)]
+#[derive(Clone)]
+pub struct PyArrowArrayExportable {
+    array: ArrayRef,
+    field: FieldRef,
+}
+
+#[pymethods]
+impl PyArrowArrayExportable {
+    #[pyo3(signature = (requested_schema=None))]
+    fn __arrow_c_array__<'py>(
+        &'py self,
+        py: Python<'py>,
+        requested_schema: Option<Bound<'py, PyCapsule>>,
+    ) -> PyDataFusionResult<(Bound<'py, PyCapsule>, Bound<'py, PyCapsule>)> {
+        let field = if let Some(schema_capsule) = requested_schema {
+            validate_pycapsule(&schema_capsule, "arrow_schema")?;
+
+            let data: NonNull<FFI_ArrowSchema> = schema_capsule
+                .pointer_checked(Some(c_str!("arrow_schema")))?
+                .cast();
+            let schema_ptr = unsafe { data.as_ref() };
+            let desired_field = Field::try_from(schema_ptr)?;
+
+            Arc::new(desired_field)
+        } else {
+            Arc::clone(&self.field)
+        };
+
+        let ffi_schema = FFI_ArrowSchema::try_from(&field)?;
+        let schema_capsule = PyCapsule::new(py, ffi_schema, Some(cr"arrow_schema".into()))?;
+
+        let ffi_array = FFI_ArrowArray::new(&self.array.to_data());
+        let array_capsule = PyCapsule::new(py, ffi_array, Some(cr"arrow_array".into()))?;
+
+        Ok((schema_capsule, array_capsule))
+    }
+}
+
+impl ToPyArrow for PyArrowArrayExportable {
+    fn to_pyarrow<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        let module = py.import("pyarrow")?;
+        let method = module.getattr("array")?;
+        let array = method.call((self.clone(),), None)?;
+        Ok(array)
+    }
+}
+
+impl PyArrowArrayExportable {
+    pub fn new(array: ArrayRef, field: FieldRef) -> Self {
+        Self { array, field }
+    }
+}
diff --git a/src/catalog.rs b/src/catalog.rs
index 76521e9af..43325c30d 100644
--- a/src/catalog.rs
+++ b/src/catalog.rs
@@ -15,131 +15,705 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::any::Any;
 use std::collections::HashSet;
+use std::ptr::NonNull;
 use std::sync::Arc;
 
+use async_trait::async_trait;
+use datafusion::catalog::{
+    CatalogProvider, CatalogProviderList, MemoryCatalogProvider, MemoryCatalogProviderList,
+    MemorySchemaProvider, SchemaProvider,
+};
+use datafusion::common::DataFusionError;
+use datafusion::datasource::TableProvider;
+use datafusion_ffi::catalog_provider::FFI_CatalogProvider;
+use datafusion_ffi::proto::logical_extension_codec::FFI_LogicalExtensionCodec;
+use datafusion_ffi::schema_provider::FFI_SchemaProvider;
+use pyo3::IntoPyObjectExt;
 use pyo3::exceptions::PyKeyError;
+use pyo3::ffi::c_str;
 use pyo3::prelude::*;
+use pyo3::types::PyCapsule;
 
-use crate::errors::DataFusionError;
-use crate::utils::wait_for_future;
-use datafusion::{
-    arrow::pyarrow::PyArrowConvert,
-    catalog::{catalog::CatalogProvider, schema::SchemaProvider},
-    datasource::{TableProvider, TableType},
+use crate::dataset::Dataset;
+use crate::errors::{PyDataFusionError, PyDataFusionResult, py_datafusion_err, to_datafusion_err};
+use crate::table::PyTable;
+use crate::utils::{
+    create_logical_extension_capsule, extract_logical_extension_codec, validate_pycapsule,
+    wait_for_future,
 };
 
-#[pyclass(name = "Catalog", module = "datafusion", subclass)]
-pub(crate) struct PyCatalog {
-    catalog: Arc<dyn CatalogProvider>,
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "RawCatalogList",
+    module = "datafusion.catalog",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyCatalogList {
+    pub catalog_list: Arc<dyn CatalogProviderList>,
+    codec: Arc<FFI_LogicalExtensionCodec>,
 }
 
-#[pyclass(name = "Database", module = "datafusion", subclass)]
-pub(crate) struct PyDatabase {
-    database: Arc<dyn SchemaProvider>,
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "RawCatalog",
+    module = "datafusion.catalog",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyCatalog {
+    pub catalog: Arc<dyn CatalogProvider>,
+    codec: Arc<FFI_LogicalExtensionCodec>,
 }
 
-#[pyclass(name = "Table", module = "datafusion", subclass)]
-pub struct PyTable {
-    table: Arc<dyn TableProvider>,
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "RawSchema",
+    module = "datafusion.catalog",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PySchema {
+    pub schema: Arc<dyn SchemaProvider>,
+    codec: Arc<FFI_LogicalExtensionCodec>,
 }
 
 impl PyCatalog {
-    pub fn new(catalog: Arc<dyn CatalogProvider>) -> Self {
-        Self { catalog }
+    pub(crate) fn new_from_parts(
+        catalog: Arc<dyn CatalogProvider>,
+        codec: Arc<FFI_LogicalExtensionCodec>,
+    ) -> Self {
+        Self { catalog, codec }
     }
 }
 
-impl PyDatabase {
-    pub fn new(database: Arc<dyn SchemaProvider>) -> Self {
-        Self { database }
+impl PySchema {
+    pub(crate) fn new_from_parts(
+        schema: Arc<dyn SchemaProvider>,
+        codec: Arc<FFI_LogicalExtensionCodec>,
+    ) -> Self {
+        Self { schema, codec }
     }
 }
 
-impl PyTable {
-    pub fn new(table: Arc<dyn TableProvider>) -> Self {
-        Self { table }
+#[pymethods]
+impl PyCatalogList {
+    #[new]
+    pub fn new(
+        py: Python,
+        catalog_list: Py<PyAny>,
+        session: Option<Bound<PyAny>>,
+    ) -> PyResult<Self> {
+        let codec = extract_logical_extension_codec(py, session)?;
+        let catalog_list = Arc::new(RustWrappedPyCatalogProviderList::new(
+            catalog_list,
+            codec.clone(),
+        )) as Arc<dyn CatalogProviderList>;
+        Ok(Self {
+            catalog_list,
+            codec,
+        })
     }
 
-    pub fn table(&self) -> Arc<dyn TableProvider> {
-        self.table.clone()
+    #[staticmethod]
+    pub fn memory_catalog_list(py: Python, session: Option<Bound<PyAny>>) -> PyResult<Self> {
+        let codec = extract_logical_extension_codec(py, session)?;
+        let catalog_list =
+            Arc::new(MemoryCatalogProviderList::default()) as Arc<dyn CatalogProviderList>;
+        Ok(Self {
+            catalog_list,
+            codec,
+        })
+    }
+
+    pub fn catalog_names(&self) -> HashSet<String> {
+        self.catalog_list.catalog_names().into_iter().collect()
+    }
+
+    #[pyo3(signature = (name="public"))]
+    pub fn catalog(&self, name: &str) -> PyResult<Py<PyAny>> {
+        let catalog = self
+            .catalog_list
+            .catalog(name)
+            .ok_or(PyKeyError::new_err(format!(
+                "Schema with name {name} doesn't exist."
+            )))?;
+
+        Python::attach(|py| {
+            match catalog
+                .as_any()
+                .downcast_ref::<RustWrappedPyCatalogProvider>()
+            {
+                Some(wrapped_catalog) => Ok(wrapped_catalog.catalog_provider.clone_ref(py)),
+                None => PyCatalog::new_from_parts(catalog, self.codec.clone()).into_py_any(py),
+            }
+        })
+    }
+
+    pub fn register_catalog(&self, name: &str, catalog_provider: Bound<'_, PyAny>) -> PyResult<()> {
+        let provider = extract_catalog_provider_from_pyobj(catalog_provider, self.codec.as_ref())?;
+
+        let _ = self
+            .catalog_list
+            .register_catalog(name.to_owned(), provider);
+
+        Ok(())
+    }
+
+    pub fn __repr__(&self) -> PyResult<String> {
+        let mut names: Vec<String> = self.catalog_names().into_iter().collect();
+        names.sort();
+        Ok(format!("CatalogList(catalog_names=[{}])", names.join(", ")))
     }
 }
 
 #[pymethods]
 impl PyCatalog {
-    fn names(&self) -> Vec<String> {
-        self.catalog.schema_names()
+    #[new]
+    pub fn new(py: Python, catalog: Py<PyAny>, session: Option<Bound<PyAny>>) -> PyResult<Self> {
+        let codec = extract_logical_extension_codec(py, session)?;
+        let catalog = Arc::new(RustWrappedPyCatalogProvider::new(catalog, codec.clone()))
+            as Arc<dyn CatalogProvider>;
+        Ok(Self { catalog, codec })
+    }
+
+    #[staticmethod]
+    pub fn memory_catalog(py: Python, session: Option<Bound<PyAny>>) -> PyResult<Self> {
+        let codec = extract_logical_extension_codec(py, session)?;
+        let catalog = Arc::new(MemoryCatalogProvider::default()) as Arc<dyn CatalogProvider>;
+        Ok(Self { catalog, codec })
+    }
+
+    pub fn schema_names(&self) -> HashSet<String> {
+        self.catalog.schema_names().into_iter().collect()
     }
 
     #[pyo3(signature = (name="public"))]
-    fn database(&self, name: &str) -> PyResult<PyDatabase> {
-        match self.catalog.schema(name) {
-            Some(database) => Ok(PyDatabase::new(database)),
-            None => Err(PyKeyError::new_err(format!(
-                "Database with name {name} doesn't exist."
-            ))),
-        }
+    pub fn schema(&self, name: &str) -> PyResult<Py<PyAny>> {
+        let schema = self
+            .catalog
+            .schema(name)
+            .ok_or(PyKeyError::new_err(format!(
+                "Schema with name {name} doesn't exist."
+            )))?;
+
+        Python::attach(|py| {
+            match schema
+                .as_any()
+                .downcast_ref::<RustWrappedPySchemaProvider>()
+            {
+                Some(wrapped_schema) => Ok(wrapped_schema.schema_provider.clone_ref(py)),
+                None => PySchema::new_from_parts(schema, self.codec.clone()).into_py_any(py),
+            }
+        })
     }
 
-    fn __repr__(&self) -> PyResult<String> {
-        Ok(format!(
-            "Catalog(schema_names=[{}])",
-            self.names().join(";")
-        ))
+    pub fn register_schema(&self, name: &str, schema_provider: Bound<'_, PyAny>) -> PyResult<()> {
+        let provider = extract_schema_provider_from_pyobj(schema_provider, self.codec.as_ref())?;
+
+        let _ = self
+            .catalog
+            .register_schema(name, provider)
+            .map_err(py_datafusion_err)?;
+
+        Ok(())
+    }
+
+    pub fn deregister_schema(&self, name: &str, cascade: bool) -> PyResult<()> {
+        let _ = self
+            .catalog
+            .deregister_schema(name, cascade)
+            .map_err(py_datafusion_err)?;
+
+        Ok(())
+    }
+
+    pub fn __repr__(&self) -> PyResult<String> {
+        let mut names: Vec<String> = self.schema_names().into_iter().collect();
+        names.sort();
+        Ok(format!("Catalog(schema_names=[{}])", names.join(", ")))
     }
 }
 
 #[pymethods]
-impl PyDatabase {
-    fn names(&self) -> HashSet<String> {
-        self.database.table_names().into_iter().collect()
+impl PySchema {
+    #[new]
+    pub fn new(
+        py: Python,
+        schema_provider: Py<PyAny>,
+        session: Option<Bound<PyAny>>,
+    ) -> PyResult<Self> {
+        let codec = extract_logical_extension_codec(py, session)?;
+        let schema =
+            Arc::new(RustWrappedPySchemaProvider::new(schema_provider)) as Arc<dyn SchemaProvider>;
+        Ok(Self { schema, codec })
+    }
+
+    #[staticmethod]
+    fn memory_schema(py: Python, session: Option<Bound<PyAny>>) -> PyResult<Self> {
+        let codec = extract_logical_extension_codec(py, session)?;
+        let schema = Arc::new(MemorySchemaProvider::default()) as Arc<dyn SchemaProvider>;
+        Ok(Self { schema, codec })
+    }
+
+    #[getter]
+    fn table_names(&self) -> HashSet<String> {
+        self.schema.table_names().into_iter().collect()
     }
 
-    fn table(&self, name: &str, py: Python) -> PyResult<PyTable> {
-        if let Some(table) = wait_for_future(py, self.database.table(name)) {
-            Ok(PyTable::new(table))
+    fn table(&self, name: &str, py: Python) -> PyDataFusionResult<PyTable> {
+        if let Some(table) = wait_for_future(py, self.schema.table(name))?? {
+            Ok(PyTable::from(table))
         } else {
-            Err(DataFusionError::Common(format!("Table not found: {name}")).into())
+            Err(PyDataFusionError::Common(format!(
+                "Table not found: {name}"
+            )))
         }
     }
 
     fn __repr__(&self) -> PyResult<String> {
-        Ok(format!(
-            "Database(table_names=[{}])",
-            Vec::from_iter(self.names()).join(";")
-        ))
+        let mut names: Vec<String> = self.table_names().into_iter().collect();
+        names.sort();
+        Ok(format!("Schema(table_names=[{}])", names.join(";")))
     }
 
-    // register_table
-    // deregister_table
+    fn register_table(&self, name: &str, table_provider: Bound<'_, PyAny>) -> PyResult<()> {
+        let py = table_provider.py();
+        let codec_capsule = create_logical_extension_capsule(py, self.codec.as_ref())?
+            .as_any()
+            .clone();
+
+        let table = PyTable::new(table_provider, Some(codec_capsule))?;
+
+        let _ = self
+            .schema
+            .register_table(name.to_string(), table.table)
+            .map_err(py_datafusion_err)?;
+
+        Ok(())
+    }
+
+    fn deregister_table(&self, name: &str) -> PyResult<()> {
+        let _ = self
+            .schema
+            .deregister_table(name)
+            .map_err(py_datafusion_err)?;
+
+        Ok(())
+    }
+
+    fn table_exist(&self, name: &str) -> bool {
+        self.schema.table_exist(name)
+    }
 }
 
-#[pymethods]
-impl PyTable {
-    /// Get a reference to the schema for this table
-    #[getter]
-    fn schema(&self, py: Python) -> PyResult<PyObject> {
-        self.table.schema().to_pyarrow(py)
+#[derive(Debug)]
+pub(crate) struct RustWrappedPySchemaProvider {
+    schema_provider: Py<PyAny>,
+    owner_name: Option<String>,
+}
+
+impl RustWrappedPySchemaProvider {
+    pub fn new(schema_provider: Py<PyAny>) -> Self {
+        let owner_name = Python::attach(|py| {
+            schema_provider
+                .bind(py)
+                .getattr("owner_name")
+                .ok()
+                .map(|name| name.to_string())
+        });
+
+        Self {
+            schema_provider,
+            owner_name,
+        }
     }
 
-    /// Get the type of this table for metadata/catalog purposes.
-    #[getter]
-    fn kind(&self) -> &str {
-        match self.table.table_type() {
-            TableType::Base => "physical",
-            TableType::View => "view",
-            TableType::Temporary => "temporary",
+    fn table_inner(&self, name: &str) -> PyResult<Option<Arc<dyn TableProvider>>> {
+        Python::attach(|py| {
+            let provider = self.schema_provider.bind(py);
+            let py_table_method = provider.getattr("table")?;
+
+            let py_table = py_table_method.call((name,), None)?;
+            if py_table.is_none() {
+                return Ok(None);
+            }
+
+            let table = PyTable::new(py_table, None)?;
+
+            Ok(Some(table.table))
+        })
+    }
+}
+
+#[async_trait]
+impl SchemaProvider for RustWrappedPySchemaProvider {
+    fn owner_name(&self) -> Option<&str> {
+        self.owner_name.as_deref()
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn table_names(&self) -> Vec<String> {
+        Python::attach(|py| {
+            let provider = self.schema_provider.bind(py);
+
+            provider
+                .getattr("table_names")
+                .and_then(|names| names.extract::<Vec<String>>())
+                .unwrap_or_else(|err| {
+                    log::error!("Unable to get table_names: {err}");
+                    Vec::default()
+                })
+        })
+    }
+
+    async fn table(
+        &self,
+        name: &str,
+    ) -> datafusion::common::Result<Option<Arc<dyn TableProvider>>, DataFusionError> {
+        self.table_inner(name)
+            .map_err(|e| DataFusionError::External(Box::new(e)))
+    }
+
+    fn register_table(
+        &self,
+        name: String,
+        table: Arc<dyn TableProvider>,
+    ) -> datafusion::common::Result<Option<Arc<dyn TableProvider>>> {
+        let py_table = PyTable::from(table);
+        Python::attach(|py| {
+            let provider = self.schema_provider.bind(py);
+            let _ = provider
+                .call_method1("register_table", (name, py_table))
+                .map_err(to_datafusion_err)?;
+            // Since the definition of `register_table` says that an error
+            // will be returned if the table already exists, there is no
+            // case where we want to return a table provider as output.
+            Ok(None)
+        })
+    }
+
+    fn deregister_table(
+        &self,
+        name: &str,
+    ) -> datafusion::common::Result<Option<Arc<dyn TableProvider>>> {
+        Python::attach(|py| {
+            let provider = self.schema_provider.bind(py);
+            let table = provider
+                .call_method1("deregister_table", (name,))
+                .map_err(to_datafusion_err)?;
+            if table.is_none() {
+                return Ok(None);
+            }
+
+            // If we can turn this table provider into a `Dataset`, return it.
+            // Otherwise, return None.
+            let dataset = match Dataset::new(&table, py) {
+                Ok(dataset) => Some(Arc::new(dataset) as Arc<dyn TableProvider>),
+                Err(_) => None,
+            };
+
+            Ok(dataset)
+        })
+    }
+
+    fn table_exist(&self, name: &str) -> bool {
+        Python::attach(|py| {
+            let provider = self.schema_provider.bind(py);
+            provider
+                .call_method1("table_exist", (name,))
+                .and_then(|pyobj| pyobj.extract())
+                .unwrap_or(false)
+        })
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct RustWrappedPyCatalogProvider {
+    pub(crate) catalog_provider: Py<PyAny>,
+    codec: Arc<FFI_LogicalExtensionCodec>,
+}
+
+impl RustWrappedPyCatalogProvider {
+    pub fn new(catalog_provider: Py<PyAny>, codec: Arc<FFI_LogicalExtensionCodec>) -> Self {
+        Self {
+            catalog_provider,
+            codec,
         }
     }
 
-    fn __repr__(&self) -> PyResult<String> {
-        let kind = self.kind();
-        Ok(format!("Table(kind={kind})"))
+    fn schema_inner(&self, name: &str) -> PyResult<Option<Arc<dyn SchemaProvider>>> {
+        Python::attach(|py| {
+            let provider = self.catalog_provider.bind(py);
+
+            let py_schema = provider.call_method1("schema", (name,))?;
+            if py_schema.is_none() {
+                return Ok(None);
+            }
+
+            extract_schema_provider_from_pyobj(py_schema, self.codec.as_ref()).map(Some)
+        })
+    }
+}
+
+#[async_trait]
+impl CatalogProvider for RustWrappedPyCatalogProvider {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn schema_names(&self) -> Vec<String> {
+        Python::attach(|py| {
+            let provider = self.catalog_provider.bind(py);
+            provider
+                .call_method0("schema_names")
+                .and_then(|names| names.extract::<HashSet<String>>())
+                .map(|names| names.into_iter().collect())
+                .unwrap_or_else(|err| {
+                    log::error!("Unable to get schema_names: {err}");
+                    Vec::default()
+                })
+        })
     }
 
-    // fn scan
-    // fn statistics
-    // fn has_exact_statistics
-    // fn supports_filter_pushdown
+    fn schema(&self, name: &str) -> Option<Arc<dyn SchemaProvider>> {
+        self.schema_inner(name).unwrap_or_else(|err| {
+            log::error!("CatalogProvider schema returned error: {err}");
+            None
+        })
+    }
+
+    fn register_schema(
+        &self,
+        name: &str,
+        schema: Arc<dyn SchemaProvider>,
+    ) -> datafusion::common::Result<Option<Arc<dyn SchemaProvider>>> {
+        Python::attach(|py| {
+            let py_schema = match schema
+                .as_any()
+                .downcast_ref::<RustWrappedPySchemaProvider>()
+            {
+                Some(wrapped_schema) => wrapped_schema.schema_provider.as_any(),
+                None => &PySchema::new_from_parts(schema, self.codec.clone())
+                    .into_py_any(py)
+                    .map_err(to_datafusion_err)?,
+            };
+
+            let provider = self.catalog_provider.bind(py);
+            let schema = provider
+                .call_method1("register_schema", (name, py_schema))
+                .map_err(to_datafusion_err)?;
+            if schema.is_none() {
+                return Ok(None);
+            }
+
+            let schema = Arc::new(RustWrappedPySchemaProvider::new(schema.into()))
+                as Arc<dyn SchemaProvider>;
+
+            Ok(Some(schema))
+        })
+    }
+
+    fn deregister_schema(
+        &self,
+        name: &str,
+        cascade: bool,
+    ) -> datafusion::common::Result<Option<Arc<dyn SchemaProvider>>> {
+        Python::attach(|py| {
+            let provider = self.catalog_provider.bind(py);
+            let schema = provider
+                .call_method1("deregister_schema", (name, cascade))
+                .map_err(to_datafusion_err)?;
+            if schema.is_none() {
+                return Ok(None);
+            }
+
+            let schema = Arc::new(RustWrappedPySchemaProvider::new(schema.into()))
+                as Arc<dyn SchemaProvider>;
+
+            Ok(Some(schema))
+        })
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct RustWrappedPyCatalogProviderList {
+    pub(crate) catalog_provider_list: Py<PyAny>,
+    codec: Arc<FFI_LogicalExtensionCodec>,
+}
+
+impl RustWrappedPyCatalogProviderList {
+    pub fn new(catalog_provider_list: Py<PyAny>, codec: Arc<FFI_LogicalExtensionCodec>) -> Self {
+        Self {
+            catalog_provider_list,
+            codec,
+        }
+    }
+
+    fn catalog_inner(&self, name: &str) -> PyResult<Option<Arc<dyn CatalogProvider>>> {
+        Python::attach(|py| {
+            let provider = self.catalog_provider_list.bind(py);
+
+            let py_schema = provider.call_method1("catalog", (name,))?;
+            if py_schema.is_none() {
+                return Ok(None);
+            }
+
+            extract_catalog_provider_from_pyobj(py_schema, self.codec.as_ref()).map(Some)
+        })
+    }
+}
+
+#[async_trait]
+impl CatalogProviderList for RustWrappedPyCatalogProviderList {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn catalog_names(&self) -> Vec<String> {
+        Python::attach(|py| {
+            let provider = self.catalog_provider_list.bind(py);
+            provider
+                .call_method0("catalog_names")
+                .and_then(|names| names.extract::<HashSet<String>>())
+                .map(|names| names.into_iter().collect())
+                .unwrap_or_else(|err| {
+                    log::error!("Unable to get catalog_names: {err}");
+                    Vec::default()
+                })
+        })
+    }
+
+    fn catalog(&self, name: &str) -> Option<Arc<dyn CatalogProvider>> {
+        self.catalog_inner(name).unwrap_or_else(|err| {
+            log::error!("CatalogProvider catalog returned error: {err}");
+            None
+        })
+    }
+
+    fn register_catalog(
+        &self,
+        name: String,
+        catalog: Arc<dyn CatalogProvider>,
+    ) -> Option<Arc<dyn CatalogProvider>> {
+        Python::attach(|py| {
+            let py_catalog = match catalog
+                .as_any()
+                .downcast_ref::<RustWrappedPyCatalogProvider>()
+            {
+                Some(wrapped_schema) => wrapped_schema.catalog_provider.as_any().clone_ref(py),
+                None => {
+                    match PyCatalog::new_from_parts(catalog, self.codec.clone()).into_py_any(py) {
+                        Ok(c) => c,
+                        Err(err) => {
+                            log::error!(
+                                "register_catalog returned error during conversion to PyAny: {err}"
+                            );
+                            return None;
+                        }
+                    }
+                }
+            };
+
+            let provider = self.catalog_provider_list.bind(py);
+            let catalog = match provider.call_method1("register_catalog", (name, py_catalog)) {
+                Ok(c) => c,
+                Err(err) => {
+                    log::error!("register_catalog returned error: {err}");
+                    return None;
+                }
+            };
+            if catalog.is_none() {
+                return None;
+            }
+
+            let catalog = Arc::new(RustWrappedPyCatalogProvider::new(
+                catalog.into(),
+                self.codec.clone(),
+            )) as Arc<dyn CatalogProvider>;
+
+            Some(catalog)
+        })
+    }
+}
+
+fn extract_catalog_provider_from_pyobj(
+    mut catalog_provider: Bound<PyAny>,
+    codec: &FFI_LogicalExtensionCodec,
+) -> PyResult<Arc<dyn CatalogProvider>> {
+    if catalog_provider.hasattr("__datafusion_catalog_provider__")? {
+        let py = catalog_provider.py();
+        let codec_capsule = create_logical_extension_capsule(py, codec)?;
+        catalog_provider = catalog_provider
+            .getattr("__datafusion_catalog_provider__")?
+            .call1((codec_capsule,))?;
+    }
+
+    let provider = if let Ok(capsule) = catalog_provider.cast::<PyCapsule>() {
+        validate_pycapsule(capsule, "datafusion_catalog_provider")?;
+        let data: NonNull<FFI_CatalogProvider> = capsule
+            .pointer_checked(Some(c_str!("datafusion_catalog_provider")))?
+            .cast();
+        let provider = unsafe { data.as_ref() };
+        let provider: Arc<dyn CatalogProvider + Send> = provider.into();
+        provider as Arc<dyn CatalogProvider>
+    } else {
+        match catalog_provider.extract::<PyCatalog>() {
+            Ok(py_catalog) => py_catalog.catalog,
+            Err(_) => Arc::new(RustWrappedPyCatalogProvider::new(
+                catalog_provider.into(),
+                Arc::new(codec.clone()),
+            )) as Arc<dyn CatalogProvider>,
+        }
+    };
+
+    Ok(provider)
+}
+
+fn extract_schema_provider_from_pyobj(
+    mut schema_provider: Bound<PyAny>,
+    codec: &FFI_LogicalExtensionCodec,
+) -> PyResult<Arc<dyn SchemaProvider>> {
+    if schema_provider.hasattr("__datafusion_schema_provider__")? {
+        let py = schema_provider.py();
+        let codec_capsule = create_logical_extension_capsule(py, codec)?;
+        schema_provider = schema_provider
+            .getattr("__datafusion_schema_provider__")?
+            .call1((codec_capsule,))?;
+    }
+
+    let provider = if let Ok(capsule) = schema_provider.cast::<PyCapsule>() {
+        validate_pycapsule(capsule, "datafusion_schema_provider")?;
+
+        let data: NonNull<FFI_SchemaProvider> = capsule
+            .pointer_checked(Some(c_str!("datafusion_schema_provider")))?
+            .cast();
+        let provider = unsafe { data.as_ref() };
+        let provider: Arc<dyn SchemaProvider + Send> = provider.into();
+        provider as Arc<dyn SchemaProvider>
+    } else {
+        match schema_provider.extract::<PySchema>() {
+            Ok(py_schema) => py_schema.schema,
+            Err(_) => Arc::new(RustWrappedPySchemaProvider::new(schema_provider.into()))
+                as Arc<dyn SchemaProvider>,
+        }
+    };
+
+    Ok(provider)
+}
+
+pub(crate) fn init_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_class::<PyCatalog>()?;
+    m.add_class::<PySchema>()?;
+    m.add_class::<PyTable>()?;
+
+    Ok(())
 }
diff --git a/src/common.rs b/src/common.rs
index 8a8e2adf5..88d2fdd5f 100644
--- a/src/common.rs
+++ b/src/common.rs
@@ -18,16 +18,26 @@
 use pyo3::prelude::*;
 
 pub mod data_type;
-pub mod df_field;
 pub mod df_schema;
+pub mod function;
+pub mod schema;
 
 /// Initializes the `common` module to match the pattern of `datafusion-common` https://docs.rs/datafusion-common/18.0.0/datafusion_common/index.html
-pub(crate) fn init_module(m: &PyModule) -> PyResult<()> {
+pub(crate) fn init_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<df_schema::PyDFSchema>()?;
-    m.add_class::<df_field::PyDFField>()?;
     m.add_class::<data_type::PyDataType>()?;
     m.add_class::<data_type::DataTypeMap>()?;
+    m.add_class::<data_type::RexType>()?;
     m.add_class::<data_type::PythonType>()?;
     m.add_class::<data_type::SqlType>()?;
+    m.add_class::<data_type::NullTreatment>()?;
+    m.add_class::<schema::SqlTable>()?;
+    m.add_class::<schema::SqlSchema>()?;
+    m.add_class::<schema::SqlView>()?;
+    m.add_class::<schema::SqlStatistics>()?;
+    m.add_class::<function::SqlFunction>()?;
+    m.add_class::<schema::PyTableType>()?;
+    m.add_class::<schema::PyTableSource>()?;
+    m.add_class::<schema::PyConstraints>()?;
     Ok(())
 }
diff --git a/src/common/data_type.rs b/src/common/data_type.rs
index e07805c52..af4179806 100644
--- a/src/common/data_type.rs
+++ b/src/common/data_type.rs
@@ -15,11 +15,49 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion::arrow::datatypes::DataType;
-use datafusion_common::DataFusionError;
+use std::sync::Arc;
+
+use datafusion::arrow::array::Array;
+use datafusion::arrow::datatypes::{DataType, IntervalUnit, TimeUnit};
+use datafusion::common::ScalarValue;
+use datafusion::logical_expr::expr::NullTreatment as DFNullTreatment;
+use pyo3::exceptions::{PyNotImplementedError, PyValueError};
 use pyo3::prelude::*;
 
-use crate::errors::py_datafusion_err;
+/// A [`ScalarValue`] wrapped in a Python object. This struct allows for conversion
+/// from a variety of Python objects into a [`ScalarValue`]. See
+/// ``FromPyArrow::from_pyarrow_bound`` conversion details.
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd)]
+pub struct PyScalarValue(pub ScalarValue);
+
+impl From<ScalarValue> for PyScalarValue {
+    fn from(value: ScalarValue) -> Self {
+        Self(value)
+    }
+}
+impl From<PyScalarValue> for ScalarValue {
+    fn from(value: PyScalarValue) -> Self {
+        value.0
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    eq,
+    eq_int,
+    name = "RexType",
+    module = "datafusion.common"
+)]
+pub enum RexType {
+    Alias,
+    Literal,
+    Call,
+    Reference,
+    ScalarSubquery,
+    Other,
+}
 
 /// These bindings are tying together several disparate systems.
 /// You have SQL types for the SQL strings and RDBMS systems itself.
@@ -27,18 +65,24 @@ use crate::errors::py_datafusion_err;
 /// Arrow types which represents the underlying arrow format
 /// Python types which represent the type in Python
 /// It is important to keep all of those types in a single
-/// and managable location. Therefore this structure exists
+/// and manageable location. Therefore this structure exists
 /// to map those types and provide a simple place for developers
 /// to map types from one system to another.
+// TODO: This looks like this needs pyo3 tracking so leaving unfrozen for now
 #[derive(Debug, Clone)]
-#[pyclass(name = "DataTypeMap", module = "datafusion.common", subclass)]
+#[pyclass(
+    from_py_object,
+    name = "DataTypeMap",
+    module = "datafusion.common",
+    subclass
+)]
 pub struct DataTypeMap {
-    #[allow(dead_code)]
-    arrow_type: PyDataType,
-    #[allow(dead_code)]
-    python_type: PythonType,
-    #[allow(dead_code)]
-    sql_type: SqlType,
+    #[pyo3(get, set)]
+    pub arrow_type: PyDataType,
+    #[pyo3(get, set)]
+    pub python_type: PythonType,
+    #[pyo3(get, set)]
+    pub sql_type: SqlType,
 }
 
 impl DataTypeMap {
@@ -119,9 +163,11 @@ impl DataTypeMap {
                 PythonType::Float,
                 SqlType::FLOAT,
             )),
-            DataType::Timestamp(_, _) => Err(py_datafusion_err(DataFusionError::NotImplemented(
-                format!("{:?}", arrow_type),
-            ))),
+            DataType::Timestamp(unit, tz) => Ok(DataTypeMap::new(
+                DataType::Timestamp(*unit, tz.clone()),
+                PythonType::Datetime,
+                SqlType::DATE,
+            )),
             DataType::Date32 => Ok(DataTypeMap::new(
                 DataType::Date32,
                 PythonType::Datetime,
@@ -132,26 +178,34 @@ impl DataTypeMap {
                 PythonType::Datetime,
                 SqlType::DATE,
             )),
-            DataType::Time32(_) => Err(py_datafusion_err(DataFusionError::NotImplemented(
-                format!("{:?}", arrow_type),
-            ))),
-            DataType::Time64(_) => Err(py_datafusion_err(DataFusionError::NotImplemented(
-                format!("{:?}", arrow_type),
-            ))),
-            DataType::Duration(_) => Err(py_datafusion_err(DataFusionError::NotImplemented(
-                format!("{:?}", arrow_type),
-            ))),
-            DataType::Interval(_) => Err(py_datafusion_err(DataFusionError::NotImplemented(
-                format!("{:?}", arrow_type),
-            ))),
+            DataType::Time32(unit) => Ok(DataTypeMap::new(
+                DataType::Time32(*unit),
+                PythonType::Datetime,
+                SqlType::DATE,
+            )),
+            DataType::Time64(unit) => Ok(DataTypeMap::new(
+                DataType::Time64(*unit),
+                PythonType::Datetime,
+                SqlType::DATE,
+            )),
+            DataType::Duration(_) => Err(PyNotImplementedError::new_err(format!("{arrow_type:?}"))),
+            DataType::Interval(interval_unit) => Ok(DataTypeMap::new(
+                DataType::Interval(*interval_unit),
+                PythonType::Datetime,
+                match interval_unit {
+                    IntervalUnit::DayTime => SqlType::INTERVAL_DAY,
+                    IntervalUnit::MonthDayNano => SqlType::INTERVAL_MONTH,
+                    IntervalUnit::YearMonth => SqlType::INTERVAL_YEAR_MONTH,
+                },
+            )),
             DataType::Binary => Ok(DataTypeMap::new(
                 DataType::Binary,
                 PythonType::Bytes,
                 SqlType::BINARY,
             )),
-            DataType::FixedSizeBinary(_) => Err(py_datafusion_err(
-                DataFusionError::NotImplemented(format!("{:?}", arrow_type)),
-            )),
+            DataType::FixedSizeBinary(_) => {
+                Err(PyNotImplementedError::new_err(format!("{arrow_type:?}")))
+            }
             DataType::LargeBinary => Ok(DataTypeMap::new(
                 DataType::LargeBinary,
                 PythonType::Bytes,
@@ -167,36 +221,149 @@ impl DataTypeMap {
                 PythonType::Str,
                 SqlType::VARCHAR,
             )),
-            DataType::List(_) => Err(py_datafusion_err(DataFusionError::NotImplemented(format!(
-                "{:?}",
-                arrow_type
-            )))),
-            DataType::FixedSizeList(_, _) => Err(py_datafusion_err(
-                DataFusionError::NotImplemented(format!("{:?}", arrow_type)),
+            DataType::List(_) => Err(PyNotImplementedError::new_err(format!("{arrow_type:?}"))),
+            DataType::FixedSizeList(_, _) => {
+                Err(PyNotImplementedError::new_err(format!("{arrow_type:?}")))
+            }
+            DataType::LargeList(_) => {
+                Err(PyNotImplementedError::new_err(format!("{arrow_type:?}")))
+            }
+            DataType::Struct(_) => Err(PyNotImplementedError::new_err(format!("{arrow_type:?}"))),
+            DataType::Union(_, _) => Err(PyNotImplementedError::new_err(format!("{arrow_type:?}"))),
+            DataType::Dictionary(_, _) => {
+                Err(PyNotImplementedError::new_err(format!("{arrow_type:?}")))
+            }
+            DataType::Decimal32(precision, scale) => Ok(DataTypeMap::new(
+                DataType::Decimal32(*precision, *scale),
+                PythonType::Float,
+                SqlType::DECIMAL,
             )),
-            DataType::LargeList(_) => Err(py_datafusion_err(DataFusionError::NotImplemented(
-                format!("{:?}", arrow_type),
-            ))),
-            DataType::Struct(_) => Err(py_datafusion_err(DataFusionError::NotImplemented(
-                format!("{:?}", arrow_type),
-            ))),
-            DataType::Union(_, _, _) => Err(py_datafusion_err(DataFusionError::NotImplemented(
-                format!("{:?}", arrow_type),
-            ))),
-            DataType::Dictionary(_, _) => Err(py_datafusion_err(DataFusionError::NotImplemented(
-                format!("{:?}", arrow_type),
-            ))),
-            DataType::Decimal128(_, _) => Err(py_datafusion_err(DataFusionError::NotImplemented(
-                format!("{:?}", arrow_type),
-            ))),
-            DataType::Decimal256(_, _) => Err(py_datafusion_err(DataFusionError::NotImplemented(
-                format!("{:?}", arrow_type),
-            ))),
-            DataType::Map(_, _) => Err(py_datafusion_err(DataFusionError::NotImplemented(
-                format!("{:?}", arrow_type),
-            ))),
-            DataType::RunEndEncoded(_, _) => Err(py_datafusion_err(
-                DataFusionError::NotImplemented(format!("{:?}", arrow_type)),
+            DataType::Decimal64(precision, scale) => Ok(DataTypeMap::new(
+                DataType::Decimal64(*precision, *scale),
+                PythonType::Float,
+                SqlType::DECIMAL,
+            )),
+            DataType::Decimal128(precision, scale) => Ok(DataTypeMap::new(
+                DataType::Decimal128(*precision, *scale),
+                PythonType::Float,
+                SqlType::DECIMAL,
+            )),
+            DataType::Decimal256(precision, scale) => Ok(DataTypeMap::new(
+                DataType::Decimal256(*precision, *scale),
+                PythonType::Float,
+                SqlType::DECIMAL,
+            )),
+            DataType::Map(_, _) => Err(PyNotImplementedError::new_err(format!("{arrow_type:?}"))),
+            DataType::RunEndEncoded(_, _) => {
+                Err(PyNotImplementedError::new_err(format!("{arrow_type:?}")))
+            }
+            DataType::BinaryView => Err(PyNotImplementedError::new_err(format!("{arrow_type:?}"))),
+            DataType::Utf8View => Err(PyNotImplementedError::new_err(format!("{arrow_type:?}"))),
+            DataType::ListView(_) => Err(PyNotImplementedError::new_err(format!("{arrow_type:?}"))),
+            DataType::LargeListView(_) => {
+                Err(PyNotImplementedError::new_err(format!("{arrow_type:?}")))
+            }
+        }
+    }
+
+    /// Generate the `DataTypeMap` from a `ScalarValue` instance
+    pub fn map_from_scalar_value(scalar_val: &ScalarValue) -> Result<DataTypeMap, PyErr> {
+        DataTypeMap::map_from_arrow_type(&DataTypeMap::map_from_scalar_to_arrow(scalar_val)?)
+    }
+
+    /// Maps a `ScalarValue` to an Arrow `DataType`
+    pub fn map_from_scalar_to_arrow(scalar_val: &ScalarValue) -> Result<DataType, PyErr> {
+        match scalar_val {
+            ScalarValue::Boolean(_) => Ok(DataType::Boolean),
+            ScalarValue::Float16(_) => Ok(DataType::Float16),
+            ScalarValue::Float32(_) => Ok(DataType::Float32),
+            ScalarValue::Float64(_) => Ok(DataType::Float64),
+            ScalarValue::Decimal32(_, precision, scale) => {
+                Ok(DataType::Decimal32(*precision, *scale))
+            }
+            ScalarValue::Decimal64(_, precision, scale) => {
+                Ok(DataType::Decimal64(*precision, *scale))
+            }
+            ScalarValue::Decimal128(_, precision, scale) => {
+                Ok(DataType::Decimal128(*precision, *scale))
+            }
+            ScalarValue::Decimal256(_, precision, scale) => {
+                Ok(DataType::Decimal256(*precision, *scale))
+            }
+            ScalarValue::Dictionary(data_type, scalar_type) => {
+                // Call this function again to map the dictionary scalar_value to an Arrow type
+                Ok(DataType::Dictionary(
+                    Box::new(*data_type.clone()),
+                    Box::new(DataTypeMap::map_from_scalar_to_arrow(scalar_type)?),
+                ))
+            }
+            ScalarValue::Int8(_) => Ok(DataType::Int8),
+            ScalarValue::Int16(_) => Ok(DataType::Int16),
+            ScalarValue::Int32(_) => Ok(DataType::Int32),
+            ScalarValue::Int64(_) => Ok(DataType::Int64),
+            ScalarValue::UInt8(_) => Ok(DataType::UInt8),
+            ScalarValue::UInt16(_) => Ok(DataType::UInt16),
+            ScalarValue::UInt32(_) => Ok(DataType::UInt32),
+            ScalarValue::UInt64(_) => Ok(DataType::UInt64),
+            ScalarValue::Utf8(_) => Ok(DataType::Utf8),
+            ScalarValue::LargeUtf8(_) => Ok(DataType::LargeUtf8),
+            ScalarValue::Binary(_) => Ok(DataType::Binary),
+            ScalarValue::LargeBinary(_) => Ok(DataType::LargeBinary),
+            ScalarValue::Date32(_) => Ok(DataType::Date32),
+            ScalarValue::Date64(_) => Ok(DataType::Date64),
+            ScalarValue::Time32Second(_) => Ok(DataType::Time32(TimeUnit::Second)),
+            ScalarValue::Time32Millisecond(_) => Ok(DataType::Time32(TimeUnit::Millisecond)),
+            ScalarValue::Time64Microsecond(_) => Ok(DataType::Time64(TimeUnit::Microsecond)),
+            ScalarValue::Time64Nanosecond(_) => Ok(DataType::Time64(TimeUnit::Nanosecond)),
+            ScalarValue::Null => Ok(DataType::Null),
+            ScalarValue::TimestampSecond(_, tz) => {
+                Ok(DataType::Timestamp(TimeUnit::Second, tz.to_owned()))
+            }
+            ScalarValue::TimestampMillisecond(_, tz) => {
+                Ok(DataType::Timestamp(TimeUnit::Millisecond, tz.to_owned()))
+            }
+            ScalarValue::TimestampMicrosecond(_, tz) => {
+                Ok(DataType::Timestamp(TimeUnit::Microsecond, tz.to_owned()))
+            }
+            ScalarValue::TimestampNanosecond(_, tz) => {
+                Ok(DataType::Timestamp(TimeUnit::Nanosecond, tz.to_owned()))
+            }
+            ScalarValue::IntervalYearMonth(..) => Ok(DataType::Interval(IntervalUnit::YearMonth)),
+            ScalarValue::IntervalDayTime(..) => Ok(DataType::Interval(IntervalUnit::DayTime)),
+            ScalarValue::IntervalMonthDayNano(..) => {
+                Ok(DataType::Interval(IntervalUnit::MonthDayNano))
+            }
+            ScalarValue::List(arr) => Ok(arr.data_type().to_owned()),
+            ScalarValue::Struct(_fields) => Err(PyNotImplementedError::new_err(
+                "ScalarValue::Struct".to_string(),
+            )),
+            ScalarValue::FixedSizeBinary(size, _) => Ok(DataType::FixedSizeBinary(*size)),
+            ScalarValue::FixedSizeList(_array_ref) => {
+                // The FieldRef was removed from ScalarValue::FixedSizeList in
+                // https://github.com/apache/arrow-datafusion/pull/8221, so we can no
+                // longer convert back to a DataType here
+                Err(PyNotImplementedError::new_err(
+                    "ScalarValue::FixedSizeList".to_string(),
+                ))
+            }
+            ScalarValue::LargeList(_) => Err(PyNotImplementedError::new_err(
+                "ScalarValue::LargeList".to_string(),
+            )),
+            ScalarValue::DurationSecond(_) => Ok(DataType::Duration(TimeUnit::Second)),
+            ScalarValue::DurationMillisecond(_) => Ok(DataType::Duration(TimeUnit::Millisecond)),
+            ScalarValue::DurationMicrosecond(_) => Ok(DataType::Duration(TimeUnit::Microsecond)),
+            ScalarValue::DurationNanosecond(_) => Ok(DataType::Duration(TimeUnit::Nanosecond)),
+            ScalarValue::Union(_, _, _) => Err(PyNotImplementedError::new_err(
+                "ScalarValue::LargeList".to_string(),
+            )),
+            ScalarValue::Utf8View(_) => Ok(DataType::Utf8View),
+            ScalarValue::BinaryView(_) => Ok(DataType::BinaryView),
+            ScalarValue::Map(_) => Err(PyNotImplementedError::new_err(
+                "ScalarValue::Map".to_string(),
+            )),
+            ScalarValue::RunEndEncoded(field1, field2, _) => Ok(DataType::RunEndEncoded(
+                Arc::clone(field1),
+                Arc::clone(field2),
             )),
         }
     }
@@ -213,24 +380,49 @@ impl DataTypeMap {
         }
     }
 
+    #[staticmethod]
+    #[pyo3(name = "from_parquet_type_str")]
+    /// When using pyarrow.parquet.read_metadata().schema.column(x).physical_type you are presented
+    /// with a String type for schema rather than an object type. Here we make a best effort
+    /// to convert that to a physical type.
+    pub fn py_map_from_parquet_type_str(parquet_str_type: String) -> PyResult<DataTypeMap> {
+        let arrow_dtype = match parquet_str_type.to_lowercase().as_str() {
+            "boolean" => Ok(DataType::Boolean),
+            "int32" => Ok(DataType::Int32),
+            "int64" => Ok(DataType::Int64),
+            "int96" => {
+                // Int96 is an old parquet datatype that is now deprecated. We convert to nanosecond timestamp
+                Ok(DataType::Timestamp(TimeUnit::Nanosecond, None))
+            }
+            "float" => Ok(DataType::Float32),
+            "double" => Ok(DataType::Float64),
+            "byte_array" => Ok(DataType::Utf8),
+            _ => Err(PyValueError::new_err(format!(
+                "Unable to determine Arrow Data Type from Parquet String type: {parquet_str_type:?}"
+            ))),
+        };
+        DataTypeMap::map_from_arrow_type(&arrow_dtype?)
+    }
+
     #[staticmethod]
     #[pyo3(name = "arrow")]
     pub fn py_map_from_arrow_type(arrow_type: &PyDataType) -> PyResult<DataTypeMap> {
         DataTypeMap::map_from_arrow_type(&arrow_type.data_type)
     }
 
+    #[staticmethod]
+    #[pyo3(name = "arrow_str")]
+    pub fn py_map_from_arrow_type_str(arrow_type_str: String) -> PyResult<DataTypeMap> {
+        let data_type = PyDataType::py_map_from_arrow_type_str(arrow_type_str);
+        DataTypeMap::map_from_arrow_type(&data_type?.data_type)
+    }
+
     #[staticmethod]
     #[pyo3(name = "sql")]
     pub fn py_map_from_sql_type(sql_type: &SqlType) -> PyResult<DataTypeMap> {
         match sql_type {
-            SqlType::ANY => Err(py_datafusion_err(DataFusionError::NotImplemented(format!(
-                "{:?}",
-                sql_type
-            )))),
-            SqlType::ARRAY => Err(py_datafusion_err(DataFusionError::NotImplemented(format!(
-                "{:?}",
-                sql_type
-            )))),
+            SqlType::ANY => Err(PyNotImplementedError::new_err(format!("{sql_type:?}"))),
+            SqlType::ARRAY => Err(PyNotImplementedError::new_err(format!("{sql_type:?}"))),
             SqlType::BIGINT => Ok(DataTypeMap::new(
                 DataType::Int64,
                 PythonType::Int,
@@ -251,13 +443,8 @@ impl DataTypeMap {
                 PythonType::Int,
                 SqlType::CHAR,
             )),
-            SqlType::COLUMN_LIST => Err(py_datafusion_err(DataFusionError::NotImplemented(
-                format!("{:?}", sql_type),
-            ))),
-            SqlType::CURSOR => Err(py_datafusion_err(DataFusionError::NotImplemented(format!(
-                "{:?}",
-                sql_type
-            )))),
+            SqlType::COLUMN_LIST => Err(PyNotImplementedError::new_err(format!("{sql_type:?}"))),
+            SqlType::CURSOR => Err(PyNotImplementedError::new_err(format!("{sql_type:?}"))),
             SqlType::DATE => Ok(DataTypeMap::new(
                 DataType::Date64,
                 PythonType::Datetime,
@@ -268,139 +455,88 @@ impl DataTypeMap {
                 PythonType::Float,
                 SqlType::DECIMAL,
             )),
-            SqlType::DISTINCT => Err(py_datafusion_err(DataFusionError::NotImplemented(format!(
-                "{:?}",
-                sql_type
-            )))),
+            SqlType::DISTINCT => Err(PyNotImplementedError::new_err(format!("{sql_type:?}"))),
             SqlType::DOUBLE => Ok(DataTypeMap::new(
                 DataType::Decimal256(1, 1),
                 PythonType::Float,
                 SqlType::DOUBLE,
             )),
-            SqlType::DYNAMIC_STAR => Err(py_datafusion_err(DataFusionError::NotImplemented(
-                format!("{:?}", sql_type),
-            ))),
+            SqlType::DYNAMIC_STAR => Err(PyNotImplementedError::new_err(format!("{sql_type:?}"))),
             SqlType::FLOAT => Ok(DataTypeMap::new(
                 DataType::Decimal128(1, 1),
                 PythonType::Float,
                 SqlType::FLOAT,
             )),
-            SqlType::GEOMETRY => Err(py_datafusion_err(DataFusionError::NotImplemented(format!(
-                "{:?}",
-                sql_type
-            )))),
+            SqlType::GEOMETRY => Err(PyNotImplementedError::new_err(format!("{sql_type:?}"))),
             SqlType::INTEGER => Ok(DataTypeMap::new(
                 DataType::Int8,
                 PythonType::Int,
                 SqlType::INTEGER,
             )),
-            SqlType::INTERVAL => Err(py_datafusion_err(DataFusionError::NotImplemented(format!(
-                "{:?}",
-                sql_type
-            )))),
-            SqlType::INTERVAL_DAY => Err(py_datafusion_err(DataFusionError::NotImplemented(
-                format!("{:?}", sql_type),
-            ))),
-            SqlType::INTERVAL_DAY_HOUR => Err(py_datafusion_err(DataFusionError::NotImplemented(
-                format!("{:?}", sql_type),
-            ))),
-            SqlType::INTERVAL_DAY_MINUTE => Err(py_datafusion_err(
-                DataFusionError::NotImplemented(format!("{:?}", sql_type)),
-            )),
-            SqlType::INTERVAL_DAY_SECOND => Err(py_datafusion_err(
-                DataFusionError::NotImplemented(format!("{:?}", sql_type)),
-            )),
-            SqlType::INTERVAL_HOUR => Err(py_datafusion_err(DataFusionError::NotImplemented(
-                format!("{:?}", sql_type),
-            ))),
-            SqlType::INTERVAL_HOUR_MINUTE => Err(py_datafusion_err(
-                DataFusionError::NotImplemented(format!("{:?}", sql_type)),
-            )),
-            SqlType::INTERVAL_HOUR_SECOND => Err(py_datafusion_err(
-                DataFusionError::NotImplemented(format!("{:?}", sql_type)),
-            )),
-            SqlType::INTERVAL_MINUTE => Err(py_datafusion_err(DataFusionError::NotImplemented(
-                format!("{:?}", sql_type),
-            ))),
-            SqlType::INTERVAL_MINUTE_SECOND => Err(py_datafusion_err(
-                DataFusionError::NotImplemented(format!("{:?}", sql_type)),
-            )),
-            SqlType::INTERVAL_MONTH => Err(py_datafusion_err(DataFusionError::NotImplemented(
-                format!("{:?}", sql_type),
-            ))),
-            SqlType::INTERVAL_SECOND => Err(py_datafusion_err(DataFusionError::NotImplemented(
-                format!("{:?}", sql_type),
-            ))),
-            SqlType::INTERVAL_YEAR => Err(py_datafusion_err(DataFusionError::NotImplemented(
-                format!("{:?}", sql_type),
-            ))),
-            SqlType::INTERVAL_YEAR_MONTH => Err(py_datafusion_err(
-                DataFusionError::NotImplemented(format!("{:?}", sql_type)),
-            )),
-            SqlType::MAP => Err(py_datafusion_err(DataFusionError::NotImplemented(format!(
-                "{:?}",
-                sql_type
-            )))),
-            SqlType::MULTISET => Err(py_datafusion_err(DataFusionError::NotImplemented(format!(
-                "{:?}",
-                sql_type
-            )))),
+            SqlType::INTERVAL => Err(PyNotImplementedError::new_err(format!("{sql_type:?}"))),
+            SqlType::INTERVAL_DAY => Err(PyNotImplementedError::new_err(format!("{sql_type:?}"))),
+            SqlType::INTERVAL_DAY_HOUR => {
+                Err(PyNotImplementedError::new_err(format!("{sql_type:?}")))
+            }
+            SqlType::INTERVAL_DAY_MINUTE => {
+                Err(PyNotImplementedError::new_err(format!("{sql_type:?}")))
+            }
+            SqlType::INTERVAL_DAY_SECOND => {
+                Err(PyNotImplementedError::new_err(format!("{sql_type:?}")))
+            }
+            SqlType::INTERVAL_HOUR => Err(PyNotImplementedError::new_err(format!("{sql_type:?}"))),
+            SqlType::INTERVAL_HOUR_MINUTE => {
+                Err(PyNotImplementedError::new_err(format!("{sql_type:?}")))
+            }
+            SqlType::INTERVAL_HOUR_SECOND => {
+                Err(PyNotImplementedError::new_err(format!("{sql_type:?}")))
+            }
+            SqlType::INTERVAL_MINUTE => {
+                Err(PyNotImplementedError::new_err(format!("{sql_type:?}")))
+            }
+            SqlType::INTERVAL_MINUTE_SECOND => {
+                Err(PyNotImplementedError::new_err(format!("{sql_type:?}")))
+            }
+            SqlType::INTERVAL_MONTH => Err(PyNotImplementedError::new_err(format!("{sql_type:?}"))),
+            SqlType::INTERVAL_SECOND => {
+                Err(PyNotImplementedError::new_err(format!("{sql_type:?}")))
+            }
+            SqlType::INTERVAL_YEAR => Err(PyNotImplementedError::new_err(format!("{sql_type:?}"))),
+            SqlType::INTERVAL_YEAR_MONTH => {
+                Err(PyNotImplementedError::new_err(format!("{sql_type:?}")))
+            }
+            SqlType::MAP => Err(PyNotImplementedError::new_err(format!("{sql_type:?}"))),
+            SqlType::MULTISET => Err(PyNotImplementedError::new_err(format!("{sql_type:?}"))),
             SqlType::NULL => Ok(DataTypeMap::new(
                 DataType::Null,
                 PythonType::None,
                 SqlType::NULL,
             )),
-            SqlType::OTHER => Err(py_datafusion_err(DataFusionError::NotImplemented(format!(
-                "{:?}",
-                sql_type
-            )))),
-            SqlType::REAL => Err(py_datafusion_err(DataFusionError::NotImplemented(format!(
-                "{:?}",
-                sql_type
-            )))),
-            SqlType::ROW => Err(py_datafusion_err(DataFusionError::NotImplemented(format!(
-                "{:?}",
-                sql_type
-            )))),
-            SqlType::SARG => Err(py_datafusion_err(DataFusionError::NotImplemented(format!(
-                "{:?}",
-                sql_type
-            )))),
+            SqlType::OTHER => Err(PyNotImplementedError::new_err(format!("{sql_type:?}"))),
+            SqlType::REAL => Err(PyNotImplementedError::new_err(format!("{sql_type:?}"))),
+            SqlType::ROW => Err(PyNotImplementedError::new_err(format!("{sql_type:?}"))),
+            SqlType::SARG => Err(PyNotImplementedError::new_err(format!("{sql_type:?}"))),
             SqlType::SMALLINT => Ok(DataTypeMap::new(
                 DataType::Int16,
                 PythonType::Int,
                 SqlType::SMALLINT,
             )),
-            SqlType::STRUCTURED => Err(py_datafusion_err(DataFusionError::NotImplemented(
-                format!("{:?}", sql_type),
-            ))),
-            SqlType::SYMBOL => Err(py_datafusion_err(DataFusionError::NotImplemented(format!(
-                "{:?}",
-                sql_type
-            )))),
-            SqlType::TIME => Err(py_datafusion_err(DataFusionError::NotImplemented(format!(
-                "{:?}",
-                sql_type
-            )))),
-            SqlType::TIME_WITH_LOCAL_TIME_ZONE => Err(py_datafusion_err(
-                DataFusionError::NotImplemented(format!("{:?}", sql_type)),
-            )),
-            SqlType::TIMESTAMP => Err(py_datafusion_err(DataFusionError::NotImplemented(format!(
-                "{:?}",
-                sql_type
-            )))),
-            SqlType::TIMESTAMP_WITH_LOCAL_TIME_ZONE => Err(py_datafusion_err(
-                DataFusionError::NotImplemented(format!("{:?}", sql_type)),
-            )),
+            SqlType::STRUCTURED => Err(PyNotImplementedError::new_err(format!("{sql_type:?}"))),
+            SqlType::SYMBOL => Err(PyNotImplementedError::new_err(format!("{sql_type:?}"))),
+            SqlType::TIME => Err(PyNotImplementedError::new_err(format!("{sql_type:?}"))),
+            SqlType::TIME_WITH_LOCAL_TIME_ZONE => {
+                Err(PyNotImplementedError::new_err(format!("{sql_type:?}")))
+            }
+            SqlType::TIMESTAMP => Err(PyNotImplementedError::new_err(format!("{sql_type:?}"))),
+            SqlType::TIMESTAMP_WITH_LOCAL_TIME_ZONE => {
+                Err(PyNotImplementedError::new_err(format!("{sql_type:?}")))
+            }
             SqlType::TINYINT => Ok(DataTypeMap::new(
                 DataType::Int8,
                 PythonType::Int,
                 SqlType::TINYINT,
             )),
-            SqlType::UNKNOWN => Err(py_datafusion_err(DataFusionError::NotImplemented(format!(
-                "{:?}",
-                sql_type
-            )))),
+            SqlType::UNKNOWN => Err(PyNotImplementedError::new_err(format!("{sql_type:?}"))),
             SqlType::VARBINARY => Ok(DataTypeMap::new(
                 DataType::LargeBinary,
                 PythonType::Bytes,
@@ -413,15 +549,109 @@ impl DataTypeMap {
             )),
         }
     }
+
+    /// Unfortunately PyO3 does not allow for us to expose the DataType as an enum since
+    /// we cannot directly annotate the Enum instance of dependency code. Therefore, here
+    /// we provide an enum to mimic it.
+    #[pyo3(name = "friendly_arrow_type_name")]
+    pub fn friendly_arrow_type_name(&self) -> PyResult<&str> {
+        Ok(match &self.arrow_type.data_type {
+            DataType::Null => "Null",
+            DataType::Boolean => "Boolean",
+            DataType::Int8 => "Int8",
+            DataType::Int16 => "Int16",
+            DataType::Int32 => "Int32",
+            DataType::Int64 => "Int64",
+            DataType::UInt8 => "UInt8",
+            DataType::UInt16 => "UInt16",
+            DataType::UInt32 => "UInt32",
+            DataType::UInt64 => "UInt64",
+            DataType::Float16 => "Float16",
+            DataType::Float32 => "Float32",
+            DataType::Float64 => "Float64",
+            DataType::Timestamp(_, _) => "Timestamp",
+            DataType::Date32 => "Date32",
+            DataType::Date64 => "Date64",
+            DataType::Time32(_) => "Time32",
+            DataType::Time64(_) => "Time64",
+            DataType::Duration(_) => "Duration",
+            DataType::Interval(_) => "Interval",
+            DataType::Binary => "Binary",
+            DataType::FixedSizeBinary(_) => "FixedSizeBinary",
+            DataType::LargeBinary => "LargeBinary",
+            DataType::Utf8 => "Utf8",
+            DataType::LargeUtf8 => "LargeUtf8",
+            DataType::List(_) => "List",
+            DataType::FixedSizeList(_, _) => "FixedSizeList",
+            DataType::LargeList(_) => "LargeList",
+            DataType::Struct(_) => "Struct",
+            DataType::Union(_, _) => "Union",
+            DataType::Dictionary(_, _) => "Dictionary",
+            DataType::Decimal32(_, _) => "Decimal32",
+            DataType::Decimal64(_, _) => "Decimal64",
+            DataType::Decimal128(_, _) => "Decimal128",
+            DataType::Decimal256(_, _) => "Decimal256",
+            DataType::Map(_, _) => "Map",
+            DataType::RunEndEncoded(_, _) => "RunEndEncoded",
+            DataType::BinaryView => "BinaryView",
+            DataType::Utf8View => "Utf8View",
+            DataType::ListView(_) => "ListView",
+            DataType::LargeListView(_) => "LargeListView",
+        })
+    }
 }
 
 /// PyO3 requires that objects passed between Rust and Python implement the trait `PyClass`
 /// Since `DataType` exists in another package we cannot make that happen here so we wrap
 /// `DataType` as `PyDataType` This exists solely to satisfy those constraints.
 #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-#[pyclass(name = "DataType", module = "datafusion.common")]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "DataType",
+    module = "datafusion.common"
+)]
 pub struct PyDataType {
-    data_type: DataType,
+    pub data_type: DataType,
+}
+
+impl PyDataType {
+    /// There are situations when obtaining dtypes on the Python side where the Arrow type
+    /// is presented as a String rather than an actual DataType. This function is used to
+    /// convert that String to a DataType for the Python side to use.
+    pub fn py_map_from_arrow_type_str(arrow_str_type: String) -> PyResult<PyDataType> {
+        // Certain string types contain "metadata" that should be trimmed here. Ex: "datetime64[ns, Europe/Berlin]"
+        let arrow_str_type = match arrow_str_type.find('[') {
+            Some(index) => arrow_str_type[0..index].to_string(),
+            None => arrow_str_type, // Return early if ',' is not found.
+        };
+
+        let arrow_dtype = match arrow_str_type.to_lowercase().as_str() {
+            "bool" => Ok(DataType::Boolean),
+            "boolean" => Ok(DataType::Boolean),
+            "uint8" => Ok(DataType::UInt8),
+            "uint16" => Ok(DataType::UInt16),
+            "uint32" => Ok(DataType::UInt32),
+            "uint64" => Ok(DataType::UInt64),
+            "int8" => Ok(DataType::Int8),
+            "int16" => Ok(DataType::Int16),
+            "int32" => Ok(DataType::Int32),
+            "int64" => Ok(DataType::Int64),
+            "float" => Ok(DataType::Float32),
+            "double" => Ok(DataType::Float64),
+            "float16" => Ok(DataType::Float16),
+            "float32" => Ok(DataType::Float32),
+            "float64" => Ok(DataType::Float64),
+            "datetime64" => Ok(DataType::Date64),
+            "object" => Ok(DataType::Utf8),
+            _ => Err(PyValueError::new_err(format!(
+                "Unable to determine Arrow Data Type from Arrow String type: {arrow_str_type:?}"
+            ))),
+        };
+        Ok(PyDataType {
+            data_type: arrow_dtype?,
+        })
+    }
 }
 
 impl From<PyDataType> for DataType {
@@ -438,7 +668,14 @@ impl From<DataType> for PyDataType {
 
 /// Represents the possible Python types that can be mapped to the SQL types
 #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-#[pyclass(name = "PythonType", module = "datafusion.common")]
+#[pyclass(
+    from_py_object,
+    frozen,
+    eq,
+    eq_int,
+    name = "PythonType",
+    module = "datafusion.common"
+)]
 pub enum PythonType {
     Array,
     Bool,
@@ -458,7 +695,14 @@ pub enum PythonType {
 #[allow(non_camel_case_types)]
 #[allow(clippy::upper_case_acronyms)]
 #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-#[pyclass(name = "SqlType", module = "datafusion.common")]
+#[pyclass(
+    from_py_object,
+    frozen,
+    eq,
+    eq_int,
+    name = "SqlType",
+    module = "datafusion.common"
+)]
 pub enum SqlType {
     ANY,
     ARRAY,
@@ -509,3 +753,40 @@ pub enum SqlType {
     VARBINARY,
     VARCHAR,
 }
+
+/// Specifies Ignore / Respect NULL within window functions.
+/// For example
+/// `FIRST_VALUE(column2) IGNORE NULLS OVER (PARTITION BY column1)`
+#[allow(non_camel_case_types)]
+#[allow(clippy::upper_case_acronyms)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    eq,
+    eq_int,
+    name = "NullTreatment",
+    module = "datafusion.common"
+)]
+pub enum NullTreatment {
+    IGNORE_NULLS,
+    RESPECT_NULLS,
+}
+
+impl From<NullTreatment> for DFNullTreatment {
+    fn from(null_treatment: NullTreatment) -> DFNullTreatment {
+        match null_treatment {
+            NullTreatment::IGNORE_NULLS => DFNullTreatment::IgnoreNulls,
+            NullTreatment::RESPECT_NULLS => DFNullTreatment::RespectNulls,
+        }
+    }
+}
+
+impl From<DFNullTreatment> for NullTreatment {
+    fn from(null_treatment: DFNullTreatment) -> NullTreatment {
+        match null_treatment {
+            DFNullTreatment::IgnoreNulls => NullTreatment::IGNORE_NULLS,
+            DFNullTreatment::RespectNulls => NullTreatment::RESPECT_NULLS,
+        }
+    }
+}
diff --git a/src/common/df_field.rs b/src/common/df_field.rs
deleted file mode 100644
index fa65e0495..000000000
--- a/src/common/df_field.rs
+++ /dev/null
@@ -1,106 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-use datafusion::arrow::datatypes::DataType;
-use datafusion_common::DFField;
-use pyo3::prelude::*;
-
-use super::data_type::PyDataType;
-
-/// PyDFField wraps an arrow-datafusion `DFField` struct type
-/// and also supplies convenience methods for interacting
-/// with the `DFField` instance in the context of Python
-#[pyclass(name = "DFField", module = "datafusion.common", subclass)]
-#[derive(Debug, Clone)]
-pub struct PyDFField {
-    field: DFField,
-}
-
-impl From<PyDFField> for DFField {
-    fn from(py_field: PyDFField) -> DFField {
-        py_field.field
-    }
-}
-
-impl From<DFField> for PyDFField {
-    fn from(field: DFField) -> PyDFField {
-        PyDFField { field }
-    }
-}
-
-#[pymethods]
-impl PyDFField {
-    #[new]
-    #[pyo3(signature = (qualifier=None, name="", data_type=DataType::Int64.into(), nullable=false))]
-    fn new(qualifier: Option<&str>, name: &str, data_type: PyDataType, nullable: bool) -> Self {
-        PyDFField {
-            field: DFField::new(qualifier, name, data_type.into(), nullable),
-        }
-    }
-
-    // TODO: Need bindings for Array `Field` first
-    // #[staticmethod]
-    // #[pyo3(name = "from")]
-    // fn py_from(field: Field) -> Self {}
-
-    // TODO: Need bindings for Array `Field` first
-    // #[staticmethod]
-    // #[pyo3(name = "from_qualified")]
-    // fn py_from_qualified(field: Field) -> Self {}
-
-    #[pyo3(name = "name")]
-    fn py_name(&self) -> PyResult<String> {
-        Ok(self.field.name().clone())
-    }
-
-    #[pyo3(name = "data_type")]
-    fn py_data_type(&self) -> PyResult<PyDataType> {
-        Ok(self.field.data_type().clone().into())
-    }
-
-    #[pyo3(name = "is_nullable")]
-    fn py_is_nullable(&self) -> PyResult<bool> {
-        Ok(self.field.is_nullable())
-    }
-
-    #[pyo3(name = "qualified_name")]
-    fn py_qualified_name(&self) -> PyResult<String> {
-        Ok(self.field.qualified_name())
-    }
-
-    // TODO: Need bindings for `Column` first
-    // #[pyo3(name = "qualified_column")]
-    // fn py_qualified_column(&self) -> PyResult<PyColumn> {}
-
-    // TODO: Need bindings for `Column` first
-    // #[pyo3(name = "unqualified_column")]
-    // fn py_unqualified_column(&self) -> PyResult<PyColumn> {}
-
-    #[pyo3(name = "qualifier")]
-    fn py_qualifier(&self) -> PyResult<Option<&String>> {
-        Ok(self.field.qualifier())
-    }
-
-    // TODO: Need bindings for Arrow `Field` first
-    // #[pyo3(name = "field")]
-    // fn py_field(&self) -> PyResult<Field> {}
-
-    #[pyo3(name = "strip_qualifier")]
-    fn py_strip_qualifier(&self) -> PyResult<Self> {
-        Ok(self.field.clone().strip_qualifier().into())
-    }
-}
diff --git a/src/common/df_schema.rs b/src/common/df_schema.rs
index c16b8eba0..9167e772e 100644
--- a/src/common/df_schema.rs
+++ b/src/common/df_schema.rs
@@ -17,11 +17,17 @@
 
 use std::sync::Arc;
 
-use datafusion_common::DFSchema;
+use datafusion::common::DFSchema;
 use pyo3::prelude::*;
 
 #[derive(Debug, Clone)]
-#[pyclass(name = "DFSchema", module = "datafusion.common", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "DFSchema",
+    module = "datafusion.common",
+    subclass
+)]
 pub struct PyDFSchema {
     schema: Arc<DFSchema>,
 }
diff --git a/src/common/function.rs b/src/common/function.rs
new file mode 100644
index 000000000..41cab515f
--- /dev/null
+++ b/src/common/function.rs
@@ -0,0 +1,61 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::collections::HashMap;
+
+use datafusion::arrow::datatypes::DataType;
+use pyo3::prelude::*;
+
+use super::data_type::PyDataType;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "SqlFunction",
+    module = "datafusion.common",
+    subclass
+)]
+#[derive(Debug, Clone)]
+pub struct SqlFunction {
+    pub name: String,
+    pub return_types: HashMap<Vec<DataType>, DataType>,
+    pub aggregation: bool,
+}
+
+impl SqlFunction {
+    pub fn new(
+        function_name: String,
+        input_types: Vec<PyDataType>,
+        return_type: PyDataType,
+        aggregation_bool: bool,
+    ) -> Self {
+        let mut func = Self {
+            name: function_name,
+            return_types: HashMap::new(),
+            aggregation: aggregation_bool,
+        };
+        func.add_type_mapping(input_types, return_type);
+        func
+    }
+
+    pub fn add_type_mapping(&mut self, input_types: Vec<PyDataType>, return_type: PyDataType) {
+        self.return_types.insert(
+            input_types.iter().map(|t| t.clone().into()).collect(),
+            return_type.into(),
+        );
+    }
+}
diff --git a/src/common/schema.rs b/src/common/schema.rs
new file mode 100644
index 000000000..29a27b204
--- /dev/null
+++ b/src/common/schema.rs
@@ -0,0 +1,389 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::any::Any;
+use std::borrow::Cow;
+use std::fmt::{self, Display, Formatter};
+use std::sync::Arc;
+
+use arrow::datatypes::Schema;
+use arrow::pyarrow::PyArrowType;
+use datafusion::arrow::datatypes::SchemaRef;
+use datafusion::common::Constraints;
+use datafusion::datasource::TableType;
+use datafusion::logical_expr::utils::split_conjunction;
+use datafusion::logical_expr::{Expr, TableProviderFilterPushDown, TableSource};
+use parking_lot::RwLock;
+use pyo3::prelude::*;
+
+use super::data_type::DataTypeMap;
+use super::function::SqlFunction;
+use crate::sql::logical::PyLogicalPlan;
+
+#[pyclass(
+    from_py_object,
+    name = "SqlSchema",
+    module = "datafusion.common",
+    subclass,
+    frozen
+)]
+#[derive(Debug, Clone)]
+pub struct SqlSchema {
+    name: Arc<RwLock<String>>,
+    tables: Arc<RwLock<Vec<SqlTable>>>,
+    views: Arc<RwLock<Vec<SqlView>>>,
+    functions: Arc<RwLock<Vec<SqlFunction>>>,
+}
+
+#[pyclass(
+    from_py_object,
+    name = "SqlTable",
+    module = "datafusion.common",
+    subclass
+)]
+#[derive(Debug, Clone)]
+pub struct SqlTable {
+    #[pyo3(get, set)]
+    pub name: String,
+    #[pyo3(get, set)]
+    pub columns: Vec<(String, DataTypeMap)>,
+    #[pyo3(get, set)]
+    pub primary_key: Option<String>,
+    #[pyo3(get, set)]
+    pub foreign_keys: Vec<String>,
+    #[pyo3(get, set)]
+    pub indexes: Vec<String>,
+    #[pyo3(get, set)]
+    pub constraints: Vec<String>,
+    #[pyo3(get, set)]
+    pub statistics: SqlStatistics,
+    #[pyo3(get, set)]
+    pub filepaths: Option<Vec<String>>,
+}
+
+#[pymethods]
+impl SqlTable {
+    #[new]
+    #[pyo3(signature = (table_name, columns, row_count, filepaths=None))]
+    pub fn new(
+        table_name: String,
+        columns: Vec<(String, DataTypeMap)>,
+        row_count: f64,
+        filepaths: Option<Vec<String>>,
+    ) -> Self {
+        Self {
+            name: table_name,
+            columns,
+            primary_key: None,
+            foreign_keys: Vec::new(),
+            indexes: Vec::new(),
+            constraints: Vec::new(),
+            statistics: SqlStatistics::new(row_count),
+            filepaths,
+        }
+    }
+}
+
+#[pyclass(
+    from_py_object,
+    name = "SqlView",
+    module = "datafusion.common",
+    subclass
+)]
+#[derive(Debug, Clone)]
+pub struct SqlView {
+    #[pyo3(get, set)]
+    pub name: String,
+    #[pyo3(get, set)]
+    pub definition: String, // SQL code that defines the view
+}
+
+#[pymethods]
+impl SqlSchema {
+    #[new]
+    pub fn new(schema_name: &str) -> Self {
+        Self {
+            name: Arc::new(RwLock::new(schema_name.to_owned())),
+            tables: Arc::new(RwLock::new(Vec::new())),
+            views: Arc::new(RwLock::new(Vec::new())),
+            functions: Arc::new(RwLock::new(Vec::new())),
+        }
+    }
+
+    #[getter]
+    fn name(&self) -> PyResult<String> {
+        Ok(self.name.read().clone())
+    }
+
+    #[setter]
+    fn set_name(&self, value: String) -> PyResult<()> {
+        *self.name.write() = value;
+        Ok(())
+    }
+
+    #[getter]
+    fn tables(&self) -> PyResult<Vec<SqlTable>> {
+        Ok(self.tables.read().clone())
+    }
+
+    #[setter]
+    fn set_tables(&self, tables: Vec<SqlTable>) -> PyResult<()> {
+        *self.tables.write() = tables;
+        Ok(())
+    }
+
+    #[getter]
+    fn views(&self) -> PyResult<Vec<SqlView>> {
+        Ok(self.views.read().clone())
+    }
+
+    #[setter]
+    fn set_views(&self, views: Vec<SqlView>) -> PyResult<()> {
+        *self.views.write() = views;
+        Ok(())
+    }
+
+    #[getter]
+    fn functions(&self) -> PyResult<Vec<SqlFunction>> {
+        Ok(self.functions.read().clone())
+    }
+
+    #[setter]
+    fn set_functions(&self, functions: Vec<SqlFunction>) -> PyResult<()> {
+        *self.functions.write() = functions;
+        Ok(())
+    }
+
+    pub fn table_by_name(&self, table_name: &str) -> Option<SqlTable> {
+        let tables = self.tables.read();
+        tables.iter().find(|tbl| tbl.name.eq(table_name)).cloned()
+    }
+
+    pub fn add_table(&self, table: SqlTable) {
+        let mut tables = self.tables.write();
+        tables.push(table);
+    }
+
+    pub fn drop_table(&self, table_name: String) {
+        let mut tables = self.tables.write();
+        tables.retain(|x| !x.name.eq(&table_name));
+    }
+}
+
+/// SqlTable wrapper that is compatible with DataFusion logical query plans
+pub struct SqlTableSource {
+    schema: SchemaRef,
+    statistics: Option<SqlStatistics>,
+    filepaths: Option<Vec<String>>,
+}
+
+impl SqlTableSource {
+    /// Initialize a new `EmptyTable` from a schema
+    pub fn new(
+        schema: SchemaRef,
+        statistics: Option<SqlStatistics>,
+        filepaths: Option<Vec<String>>,
+    ) -> Self {
+        Self {
+            schema,
+            statistics,
+            filepaths,
+        }
+    }
+
+    /// Access optional statistics associated with this table source
+    pub fn statistics(&self) -> Option<&SqlStatistics> {
+        self.statistics.as_ref()
+    }
+
+    /// Access optional filepath associated with this table source
+    #[allow(dead_code)]
+    pub fn filepaths(&self) -> Option<&Vec<String>> {
+        self.filepaths.as_ref()
+    }
+}
+
+/// Implement TableSource, used in the logical query plan and in logical query optimizations
+impl TableSource for SqlTableSource {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn schema(&self) -> SchemaRef {
+        self.schema.clone()
+    }
+
+    fn table_type(&self) -> datafusion::logical_expr::TableType {
+        datafusion::logical_expr::TableType::Base
+    }
+
+    fn supports_filters_pushdown(
+        &self,
+        filters: &[&Expr],
+    ) -> datafusion::common::Result<Vec<TableProviderFilterPushDown>> {
+        filters
+            .iter()
+            .map(|f| {
+                let filters = split_conjunction(f);
+                if filters.iter().all(|f| is_supported_push_down_expr(f)) {
+                    // Push down filters to the tablescan operation if all are supported
+                    Ok(TableProviderFilterPushDown::Exact)
+                } else if filters.iter().any(|f| is_supported_push_down_expr(f)) {
+                    // Partially apply the filter in the TableScan but retain
+                    // the Filter operator in the plan as well
+                    Ok(TableProviderFilterPushDown::Inexact)
+                } else {
+                    Ok(TableProviderFilterPushDown::Unsupported)
+                }
+            })
+            .collect()
+    }
+
+    fn get_logical_plan(&self) -> Option<Cow<'_, datafusion::logical_expr::LogicalPlan>> {
+        None
+    }
+}
+
+fn is_supported_push_down_expr(_expr: &Expr) -> bool {
+    // For now we support all kinds of expr's at this level
+    true
+}
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "SqlStatistics",
+    module = "datafusion.common",
+    subclass
+)]
+#[derive(Debug, Clone)]
+pub struct SqlStatistics {
+    row_count: f64,
+}
+
+#[pymethods]
+impl SqlStatistics {
+    #[new]
+    pub fn new(row_count: f64) -> Self {
+        Self { row_count }
+    }
+
+    #[pyo3(name = "getRowCount")]
+    pub fn get_row_count(&self) -> f64 {
+        self.row_count
+    }
+}
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Constraints",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyConstraints {
+    pub constraints: Constraints,
+}
+
+impl From<PyConstraints> for Constraints {
+    fn from(constraints: PyConstraints) -> Self {
+        constraints.constraints
+    }
+}
+
+impl From<Constraints> for PyConstraints {
+    fn from(constraints: Constraints) -> Self {
+        PyConstraints { constraints }
+    }
+}
+
+impl Display for PyConstraints {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "Constraints: {:?}", self.constraints)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    eq,
+    eq_int,
+    name = "TableType",
+    module = "datafusion.common"
+)]
+pub enum PyTableType {
+    Base,
+    View,
+    Temporary,
+}
+
+impl From<PyTableType> for datafusion::logical_expr::TableType {
+    fn from(table_type: PyTableType) -> Self {
+        match table_type {
+            PyTableType::Base => datafusion::logical_expr::TableType::Base,
+            PyTableType::View => datafusion::logical_expr::TableType::View,
+            PyTableType::Temporary => datafusion::logical_expr::TableType::Temporary,
+        }
+    }
+}
+
+impl From<TableType> for PyTableType {
+    fn from(table_type: TableType) -> Self {
+        match table_type {
+            datafusion::logical_expr::TableType::Base => PyTableType::Base,
+            datafusion::logical_expr::TableType::View => PyTableType::View,
+            datafusion::logical_expr::TableType::Temporary => PyTableType::Temporary,
+        }
+    }
+}
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "TableSource",
+    module = "datafusion.common",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyTableSource {
+    pub table_source: Arc<dyn TableSource>,
+}
+
+#[pymethods]
+impl PyTableSource {
+    pub fn schema(&self) -> PyArrowType<Schema> {
+        (*self.table_source.schema()).clone().into()
+    }
+
+    pub fn constraints(&self) -> Option<PyConstraints> {
+        self.table_source.constraints().map(|c| PyConstraints {
+            constraints: c.clone(),
+        })
+    }
+
+    pub fn table_type(&self) -> PyTableType {
+        self.table_source.table_type().into()
+    }
+
+    pub fn get_logical_plan(&self) -> Option<PyLogicalPlan> {
+        self.table_source
+            .get_logical_plan()
+            .map(|plan| PyLogicalPlan::new(plan.into_owned()))
+    }
+}
diff --git a/src/config.rs b/src/config.rs
index 228f95a0b..fdb693a12 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -15,16 +15,25 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use pyo3::prelude::*;
-use pyo3::types::*;
+use std::sync::Arc;
 
 use datafusion::config::ConfigOptions;
-use datafusion_common::ScalarValue;
+use parking_lot::RwLock;
+use pyo3::prelude::*;
+use pyo3::types::*;
 
-#[pyclass(name = "Config", module = "datafusion", subclass)]
+use crate::common::data_type::PyScalarValue;
+use crate::errors::PyDataFusionResult;
+#[pyclass(
+    from_py_object,
+    name = "Config",
+    module = "datafusion",
+    subclass,
+    frozen
+)]
 #[derive(Clone)]
 pub(crate) struct PyConfig {
-    config: ConfigOptions,
+    config: Arc<RwLock<ConfigOptions>>,
 }
 
 #[pymethods]
@@ -32,69 +41,64 @@ impl PyConfig {
     #[new]
     fn py_new() -> Self {
         Self {
-            config: ConfigOptions::new(),
+            config: Arc::new(RwLock::new(ConfigOptions::new())),
         }
     }
 
     /// Get configurations from environment variables
     #[staticmethod]
-    pub fn from_env() -> PyResult<Self> {
+    pub fn from_env() -> PyDataFusionResult<Self> {
         Ok(Self {
-            config: ConfigOptions::from_env()?,
+            config: Arc::new(RwLock::new(ConfigOptions::from_env()?)),
         })
     }
 
     /// Get a configuration option
-    pub fn get(&mut self, key: &str, py: Python) -> PyResult<PyObject> {
-        let options = self.config.to_owned();
-        for entry in options.entries() {
-            if entry.key == key {
-                return Ok(entry.value.into_py(py));
-            }
+    pub fn get<'py>(&self, key: &str, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        let value: Option<Option<String>> = {
+            let options = self.config.read();
+            options
+                .entries()
+                .into_iter()
+                .find_map(|entry| (entry.key == key).then_some(entry.value.clone()))
+        };
+
+        match value {
+            Some(value) => Ok(value.into_pyobject(py)?),
+            None => Ok(None::<String>.into_pyobject(py)?),
         }
-        Ok(None::<String>.into_py(py))
     }
 
     /// Set a configuration option
-    pub fn set(&mut self, key: &str, value: PyObject, py: Python) -> PyResult<()> {
-        let scalar_value = py_obj_to_scalar_value(py, value);
-        self.config
-            .set(key, scalar_value.to_string().as_str())
-            .map_err(|e| e.into())
+    pub fn set(&self, key: &str, value: Py<PyAny>, py: Python) -> PyDataFusionResult<()> {
+        let scalar_value: PyScalarValue = value.extract(py)?;
+        let mut options = self.config.write();
+        options.set(key, scalar_value.0.to_string().as_str())?;
+        Ok(())
     }
 
     /// Get all configuration options
-    pub fn get_all(&mut self, py: Python) -> PyResult<PyObject> {
+    pub fn get_all(&self, py: Python) -> PyResult<Py<PyAny>> {
+        let entries: Vec<(String, Option<String>)> = {
+            let options = self.config.read();
+            options
+                .entries()
+                .into_iter()
+                .map(|entry| (entry.key.clone(), entry.value.clone()))
+                .collect()
+        };
+
         let dict = PyDict::new(py);
-        let options = self.config.to_owned();
-        for entry in options.entries() {
-            dict.set_item(entry.key, entry.value.clone().into_py(py))?;
+        for (key, value) in entries {
+            dict.set_item(key, value.into_pyobject(py)?)?;
         }
         Ok(dict.into())
     }
 
-    fn __repr__(&mut self, py: Python) -> PyResult<String> {
-        let dict = self.get_all(py);
-        match dict {
+    fn __repr__(&self, py: Python) -> PyResult<String> {
+        match self.get_all(py) {
             Ok(result) => Ok(format!("Config({result})")),
             Err(err) => Ok(format!("Error: {:?}", err.to_string())),
         }
     }
 }
-
-/// Convert a python object to a ScalarValue
-fn py_obj_to_scalar_value(py: Python, obj: PyObject) -> ScalarValue {
-    if let Ok(value) = obj.extract::<bool>(py) {
-        ScalarValue::Boolean(Some(value))
-    } else if let Ok(value) = obj.extract::<i64>(py) {
-        ScalarValue::Int64(Some(value))
-    } else if let Ok(value) = obj.extract::<u64>(py) {
-        ScalarValue::UInt64(Some(value))
-    } else if let Ok(value) = obj.extract::<f64>(py) {
-        ScalarValue::Float64(Some(value))
-    } else if let Ok(value) = obj.extract::<String>(py) {
-        ScalarValue::Utf8(Some(value))
-    } else {
-        panic!("Unsupported value type")
-    }
-}
diff --git a/src/context.rs b/src/context.rs
index e2c509abe..2eaf5a737 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -17,48 +17,87 @@
 
 use std::collections::{HashMap, HashSet};
 use std::path::PathBuf;
+use std::ptr::NonNull;
+use std::str::FromStr;
 use std::sync::Arc;
 
+use arrow::array::RecordBatchReader;
+use arrow::ffi_stream::ArrowArrayStreamReader;
+use arrow::pyarrow::FromPyArrow;
+use datafusion::arrow::datatypes::{DataType, Schema, SchemaRef};
+use datafusion::arrow::pyarrow::PyArrowType;
+use datafusion::arrow::record_batch::RecordBatch;
+use datafusion::catalog::{CatalogProvider, CatalogProviderList};
+use datafusion::common::{ScalarValue, TableReference, exec_err};
+use datafusion::datasource::file_format::file_compression_type::FileCompressionType;
+use datafusion::datasource::file_format::parquet::ParquetFormat;
+use datafusion::datasource::listing::{
+    ListingOptions, ListingTable, ListingTableConfig, ListingTableUrl,
+};
+use datafusion::datasource::{MemTable, TableProvider};
+use datafusion::execution::TaskContextProvider;
+use datafusion::execution::context::{
+    DataFilePaths, SQLOptions, SessionConfig, SessionContext, TaskContext,
+};
+use datafusion::execution::disk_manager::DiskManagerMode;
+use datafusion::execution::memory_pool::{FairSpillPool, GreedyMemoryPool, UnboundedMemoryPool};
+use datafusion::execution::options::ReadOptions;
+use datafusion::execution::runtime_env::RuntimeEnvBuilder;
+use datafusion::execution::session_state::SessionStateBuilder;
+use datafusion::prelude::{
+    AvroReadOptions, CsvReadOptions, DataFrame, JsonReadOptions, ParquetReadOptions,
+};
+use datafusion_ffi::catalog_provider::FFI_CatalogProvider;
+use datafusion_ffi::catalog_provider_list::FFI_CatalogProviderList;
+use datafusion_ffi::execution::FFI_TaskContextProvider;
+use datafusion_ffi::proto::logical_extension_codec::FFI_LogicalExtensionCodec;
+use datafusion_proto::logical_plan::DefaultLogicalExtensionCodec;
 use object_store::ObjectStore;
-use uuid::Uuid;
-
+use pyo3::IntoPyObjectExt;
 use pyo3::exceptions::{PyKeyError, PyValueError};
+use pyo3::ffi::c_str;
 use pyo3::prelude::*;
+use pyo3::types::{PyCapsule, PyDict, PyList, PyTuple};
+use url::Url;
+use uuid::Uuid;
 
-use crate::catalog::{PyCatalog, PyTable};
+use crate::catalog::{
+    PyCatalog, PyCatalogList, RustWrappedPyCatalogProvider, RustWrappedPyCatalogProviderList,
+};
+use crate::common::data_type::PyScalarValue;
 use crate::dataframe::PyDataFrame;
 use crate::dataset::Dataset;
-use crate::errors::{py_datafusion_err, DataFusionError};
+use crate::errors::{
+    PyDataFusionError, PyDataFusionResult, from_datafusion_error, py_datafusion_err,
+};
+use crate::expr::sort_expr::PySortExpr;
+use crate::options::PyCsvReadOptions;
 use crate::physical_plan::PyExecutionPlan;
 use crate::record_batch::PyRecordBatchStream;
 use crate::sql::logical::PyLogicalPlan;
+use crate::sql::util::replace_placeholders_with_strings;
 use crate::store::StorageContexts;
+use crate::table::PyTable;
 use crate::udaf::PyAggregateUDF;
 use crate::udf::PyScalarUDF;
-use crate::utils::wait_for_future;
-use datafusion::arrow::datatypes::{DataType, Schema};
-use datafusion::arrow::pyarrow::PyArrowType;
-use datafusion::arrow::record_batch::RecordBatch;
-use datafusion::datasource::datasource::TableProvider;
-use datafusion::datasource::MemTable;
-use datafusion::execution::context::{SessionConfig, SessionContext, TaskContext};
-use datafusion::execution::disk_manager::DiskManagerConfig;
-use datafusion::execution::memory_pool::{FairSpillPool, GreedyMemoryPool, UnboundedMemoryPool};
-use datafusion::execution::runtime_env::{RuntimeConfig, RuntimeEnv};
-use datafusion::physical_plan::SendableRecordBatchStream;
-use datafusion::prelude::{
-    AvroReadOptions, CsvReadOptions, DataFrame, NdJsonReadOptions, ParquetReadOptions,
+use crate::udtf::PyTableFunction;
+use crate::udwf::PyWindowUDF;
+use crate::utils::{
+    create_logical_extension_capsule, extract_logical_extension_codec, get_global_ctx,
+    get_tokio_runtime, spawn_future, validate_pycapsule, wait_for_future,
 };
-use datafusion_common::config::Extensions;
-use datafusion_common::ScalarValue;
-use pyo3::types::PyTuple;
-use tokio::runtime::Runtime;
-use tokio::task::JoinHandle;
 
-#[pyclass(name = "SessionConfig", module = "datafusion", subclass, unsendable)]
+/// Configuration options for a SessionContext
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "SessionConfig",
+    module = "datafusion",
+    subclass
+)]
 #[derive(Clone, Default)]
-pub(crate) struct PySessionConfig {
-    pub(crate) config: SessionConfig,
+pub struct PySessionConfig {
+    pub config: SessionConfig,
 }
 
 impl From<SessionConfig> for PySessionConfig {
@@ -75,7 +114,7 @@ impl PySessionConfig {
         let mut config = SessionConfig::new();
         if let Some(hash_map) = config_options {
             for (k, v) in &hash_map {
-                config = config.set(k, ScalarValue::Utf8(Some(v.clone())));
+                config = config.set(k, &ScalarValue::Utf8(Some(v.clone())));
             }
         }
 
@@ -141,147 +180,344 @@ impl PySessionConfig {
     fn with_parquet_pruning(&self, enabled: bool) -> Self {
         Self::from(self.config.clone().with_parquet_pruning(enabled))
     }
+
+    fn set(&self, key: &str, value: &str) -> Self {
+        Self::from(self.config.clone().set_str(key, value))
+    }
 }
 
-#[pyclass(name = "RuntimeConfig", module = "datafusion", subclass, unsendable)]
+/// Runtime options for a SessionContext
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "RuntimeEnvBuilder",
+    module = "datafusion",
+    subclass
+)]
 #[derive(Clone)]
-pub(crate) struct PyRuntimeConfig {
-    pub(crate) config: RuntimeConfig,
+pub struct PyRuntimeEnvBuilder {
+    pub builder: RuntimeEnvBuilder,
 }
 
 #[pymethods]
-impl PyRuntimeConfig {
+impl PyRuntimeEnvBuilder {
     #[new]
     fn new() -> Self {
         Self {
-            config: RuntimeConfig::default(),
+            builder: RuntimeEnvBuilder::default(),
         }
     }
 
     fn with_disk_manager_disabled(&self) -> Self {
-        let config = self.config.clone();
-        let config = config.with_disk_manager(DiskManagerConfig::Disabled);
-        Self { config }
+        let mut runtime_builder = self.builder.clone();
+
+        let mut disk_mgr_builder = runtime_builder
+            .disk_manager_builder
+            .clone()
+            .unwrap_or_default();
+        disk_mgr_builder.set_mode(DiskManagerMode::Disabled);
+
+        runtime_builder = runtime_builder.with_disk_manager_builder(disk_mgr_builder);
+        Self {
+            builder: runtime_builder,
+        }
     }
 
     fn with_disk_manager_os(&self) -> Self {
-        let config = self.config.clone();
-        let config = config.with_disk_manager(DiskManagerConfig::NewOs);
-        Self { config }
+        let mut runtime_builder = self.builder.clone();
+
+        let mut disk_mgr_builder = runtime_builder
+            .disk_manager_builder
+            .clone()
+            .unwrap_or_default();
+        disk_mgr_builder.set_mode(DiskManagerMode::OsTmpDirectory);
+
+        runtime_builder = runtime_builder.with_disk_manager_builder(disk_mgr_builder);
+        Self {
+            builder: runtime_builder,
+        }
     }
 
     fn with_disk_manager_specified(&self, paths: Vec<String>) -> Self {
-        let config = self.config.clone();
         let paths = paths.iter().map(|s| s.into()).collect();
-        let config = config.with_disk_manager(DiskManagerConfig::NewSpecified(paths));
-        Self { config }
+        let mut runtime_builder = self.builder.clone();
+
+        let mut disk_mgr_builder = runtime_builder
+            .disk_manager_builder
+            .clone()
+            .unwrap_or_default();
+        disk_mgr_builder.set_mode(DiskManagerMode::Directories(paths));
+
+        runtime_builder = runtime_builder.with_disk_manager_builder(disk_mgr_builder);
+        Self {
+            builder: runtime_builder,
+        }
     }
 
     fn with_unbounded_memory_pool(&self) -> Self {
-        let config = self.config.clone();
-        let config = config.with_memory_pool(Arc::new(UnboundedMemoryPool::default()));
-        Self { config }
+        let builder = self.builder.clone();
+        let builder = builder.with_memory_pool(Arc::new(UnboundedMemoryPool::default()));
+        Self { builder }
     }
 
     fn with_fair_spill_pool(&self, size: usize) -> Self {
-        let config = self.config.clone();
-        let config = config.with_memory_pool(Arc::new(FairSpillPool::new(size)));
-        Self { config }
+        let builder = self.builder.clone();
+        let builder = builder.with_memory_pool(Arc::new(FairSpillPool::new(size)));
+        Self { builder }
     }
 
     fn with_greedy_memory_pool(&self, size: usize) -> Self {
-        let config = self.config.clone();
-        let config = config.with_memory_pool(Arc::new(GreedyMemoryPool::new(size)));
-        Self { config }
+        let builder = self.builder.clone();
+        let builder = builder.with_memory_pool(Arc::new(GreedyMemoryPool::new(size)));
+        Self { builder }
     }
 
     fn with_temp_file_path(&self, path: &str) -> Self {
-        let config = self.config.clone();
-        let config = config.with_temp_file_path(path);
-        Self { config }
+        let builder = self.builder.clone();
+        let builder = builder.with_temp_file_path(path);
+        Self { builder }
+    }
+}
+
+/// `PySQLOptions` allows you to specify options to the sql execution.
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "SQLOptions",
+    module = "datafusion",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PySQLOptions {
+    pub options: SQLOptions,
+}
+
+impl From<SQLOptions> for PySQLOptions {
+    fn from(options: SQLOptions) -> Self {
+        Self { options }
+    }
+}
+
+#[pymethods]
+impl PySQLOptions {
+    #[new]
+    fn new() -> Self {
+        let options = SQLOptions::new();
+        Self { options }
+    }
+
+    /// Should DDL data modification commands  (e.g. `CREATE TABLE`) be run? Defaults to `true`.
+    fn with_allow_ddl(&self, allow: bool) -> Self {
+        Self::from(self.options.with_allow_ddl(allow))
+    }
+
+    /// Should DML data modification commands (e.g. `INSERT and COPY`) be run? Defaults to `true`
+    pub fn with_allow_dml(&self, allow: bool) -> Self {
+        Self::from(self.options.with_allow_dml(allow))
+    }
+
+    /// Should Statements such as (e.g. `SET VARIABLE and `BEGIN TRANSACTION` ...`) be run?. Defaults to `true`
+    pub fn with_allow_statements(&self, allow: bool) -> Self {
+        Self::from(self.options.with_allow_statements(allow))
     }
 }
 
 /// `PySessionContext` is able to plan and execute DataFusion plans.
 /// It has a powerful optimizer, a physical planner for local execution, and a
 /// multi-threaded execution engine to perform the execution.
-#[pyclass(name = "SessionContext", module = "datafusion", subclass, unsendable)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "SessionContext",
+    module = "datafusion",
+    subclass
+)]
 #[derive(Clone)]
-pub(crate) struct PySessionContext {
-    pub(crate) ctx: SessionContext,
+pub struct PySessionContext {
+    pub ctx: Arc<SessionContext>,
+    logical_codec: Arc<FFI_LogicalExtensionCodec>,
 }
 
 #[pymethods]
 impl PySessionContext {
     #[pyo3(signature = (config=None, runtime=None))]
     #[new]
-    fn new(config: Option<PySessionConfig>, runtime: Option<PyRuntimeConfig>) -> PyResult<Self> {
+    pub fn new(
+        config: Option<PySessionConfig>,
+        runtime: Option<PyRuntimeEnvBuilder>,
+    ) -> PyDataFusionResult<Self> {
         let config = if let Some(c) = config {
             c.config
         } else {
-            SessionConfig::default()
+            SessionConfig::default().with_information_schema(true)
         };
-        let runtime_config = if let Some(c) = runtime {
-            c.config
+        let runtime_env_builder = if let Some(c) = runtime {
+            c.builder
         } else {
-            RuntimeConfig::default()
+            RuntimeEnvBuilder::default()
         };
-        let runtime = Arc::new(RuntimeEnv::new(runtime_config)?);
+        let runtime = Arc::new(runtime_env_builder.build()?);
+        let session_state = SessionStateBuilder::new()
+            .with_config(config)
+            .with_runtime_env(runtime)
+            .with_default_features()
+            .build();
+        let ctx = Arc::new(SessionContext::new_with_state(session_state));
+        let logical_codec = Self::default_logical_codec(&ctx);
+        Ok(PySessionContext { ctx, logical_codec })
+    }
+
+    pub fn enable_url_table(&self) -> PyResult<Self> {
         Ok(PySessionContext {
-            ctx: SessionContext::with_config_rt(config, runtime),
+            ctx: Arc::new(self.ctx.as_ref().clone().enable_url_table()),
+            logical_codec: Arc::clone(&self.logical_codec),
         })
     }
 
-    /// Register a an object store with the given name
-    fn register_object_store(
-        &mut self,
+    #[staticmethod]
+    #[pyo3(signature = ())]
+    pub fn global_ctx() -> PyResult<Self> {
+        let ctx = get_global_ctx().clone();
+        let logical_codec = Self::default_logical_codec(&ctx);
+        Ok(Self { ctx, logical_codec })
+    }
+
+    /// Register an object store with the given name
+    #[pyo3(signature = (scheme, store, host=None))]
+    pub fn register_object_store(
+        &self,
         scheme: &str,
-        store: &PyAny,
+        store: StorageContexts,
         host: Option<&str>,
     ) -> PyResult<()> {
-        let res: Result<(Arc<dyn ObjectStore>, String), PyErr> =
-            match StorageContexts::extract(store) {
-                Ok(store) => match store {
-                    StorageContexts::AmazonS3(s3) => Ok((s3.inner, s3.bucket_name)),
-                    StorageContexts::GoogleCloudStorage(gcs) => Ok((gcs.inner, gcs.bucket_name)),
-                    StorageContexts::MicrosoftAzure(azure) => {
-                        Ok((azure.inner, azure.container_name))
-                    }
-                    StorageContexts::LocalFileSystem(local) => Ok((local.inner, "".to_string())),
-                },
-                Err(_e) => Err(PyValueError::new_err("Invalid object store")),
-            };
-
         // for most stores the "host" is the bucket name and can be inferred from the store
-        let (store, upstream_host) = res?;
+        let (store, upstream_host): (Arc<dyn ObjectStore>, String) = match store {
+            StorageContexts::AmazonS3(s3) => (s3.inner, s3.bucket_name),
+            StorageContexts::GoogleCloudStorage(gcs) => (gcs.inner, gcs.bucket_name),
+            StorageContexts::MicrosoftAzure(azure) => (azure.inner, azure.container_name),
+            StorageContexts::LocalFileSystem(local) => (local.inner, "".to_string()),
+            StorageContexts::HTTP(http) => (http.store, http.url),
+        };
+
         // let users override the host to match the api signature from upstream
         let derived_host = if let Some(host) = host {
             host
         } else {
             &upstream_host
         };
+        let url_string = format!("{scheme}{derived_host}");
+        let url = Url::parse(&url_string).unwrap();
+        self.ctx.runtime_env().register_object_store(&url, store);
+        Ok(())
+    }
 
-        self.ctx
-            .runtime_env()
-            .register_object_store(scheme, derived_host, store);
+    #[allow(clippy::too_many_arguments)]
+    #[pyo3(signature = (name, path, table_partition_cols=vec![],
+    file_extension=".parquet",
+    schema=None,
+    file_sort_order=None))]
+    pub fn register_listing_table(
+        &self,
+        name: &str,
+        path: &str,
+        table_partition_cols: Vec<(String, PyArrowType<DataType>)>,
+        file_extension: &str,
+        schema: Option<PyArrowType<Schema>>,
+        file_sort_order: Option<Vec<Vec<PySortExpr>>>,
+        py: Python,
+    ) -> PyDataFusionResult<()> {
+        let options = ListingOptions::new(Arc::new(ParquetFormat::new()))
+            .with_file_extension(file_extension)
+            .with_table_partition_cols(
+                table_partition_cols
+                    .into_iter()
+                    .map(|(name, ty)| (name, ty.0))
+                    .collect::<Vec<(String, DataType)>>(),
+            )
+            .with_file_sort_order(
+                file_sort_order
+                    .unwrap_or_default()
+                    .into_iter()
+                    .map(|e| e.into_iter().map(|f| f.into()).collect())
+                    .collect(),
+            );
+        let table_path = ListingTableUrl::parse(path)?;
+        let resolved_schema: SchemaRef = match schema {
+            Some(s) => Arc::new(s.0),
+            None => {
+                let state = self.ctx.state();
+                let schema = options.infer_schema(&state, &table_path);
+                wait_for_future(py, schema)??
+            }
+        };
+        let config = ListingTableConfig::new(table_path)
+            .with_listing_options(options)
+            .with_schema(resolved_schema);
+        let table = ListingTable::try_new(config)?;
+        self.ctx.register_table(name, Arc::new(table))?;
         Ok(())
     }
 
-    /// Returns a PyDataFrame whose plan corresponds to the SQL statement.
-    fn sql(&mut self, query: &str, py: Python) -> PyResult<PyDataFrame> {
-        let result = self.ctx.sql(query);
-        let df = wait_for_future(py, result).map_err(DataFusionError::from)?;
+    pub fn register_udtf(&self, func: PyTableFunction) {
+        let name = func.name.clone();
+        let func = Arc::new(func);
+        self.ctx.register_udtf(&name, func);
+    }
+
+    #[pyo3(signature = (query, options=None, param_values=HashMap::default(), param_strings=HashMap::default()))]
+    pub fn sql_with_options(
+        &self,
+        py: Python,
+        mut query: String,
+        options: Option<PySQLOptions>,
+        param_values: HashMap<String, PyScalarValue>,
+        param_strings: HashMap<String, String>,
+    ) -> PyDataFusionResult<PyDataFrame> {
+        let options = if let Some(options) = options {
+            options.options
+        } else {
+            SQLOptions::new()
+        };
+
+        let param_values = param_values
+            .into_iter()
+            .map(|(name, value)| (name, ScalarValue::from(value)))
+            .collect::<HashMap<_, _>>();
+
+        let state = self.ctx.state();
+        let dialect = state.config().options().sql_parser.dialect.as_ref();
+
+        if !param_strings.is_empty() {
+            query = replace_placeholders_with_strings(&query, dialect, param_strings)?;
+        }
+
+        let mut df = wait_for_future(py, async {
+            self.ctx.sql_with_options(&query, options).await
+        })?
+        .map_err(from_datafusion_error)?;
+
+        if !param_values.is_empty() {
+            df = df.with_param_values(param_values)?;
+        }
+
         Ok(PyDataFrame::new(df))
     }
 
-    fn create_dataframe(
-        &mut self,
+    #[pyo3(signature = (partitions, name=None, schema=None))]
+    pub fn create_dataframe(
+        &self,
         partitions: PyArrowType<Vec<Vec<RecordBatch>>>,
         name: Option<&str>,
+        schema: Option<PyArrowType<Schema>>,
         py: Python,
-    ) -> PyResult<PyDataFrame> {
-        let schema = partitions.0[0][0].schema();
-        let table = MemTable::try_new(schema, partitions.0).map_err(DataFusionError::from)?;
+    ) -> PyDataFusionResult<PyDataFrame> {
+        let schema = if let Some(schema) = schema {
+            SchemaRef::from(schema.0)
+        } else {
+            partitions.0[0][0].schema()
+        };
+
+        let table = MemTable::try_new(schema, partitions.0)?;
 
         // generate a random (unique) name for this table if none is provided
         // table name cannot start with numeric digit
@@ -295,166 +531,296 @@ impl PySessionContext {
             }
         };
 
-        self.ctx
-            .register_table(&*table_name, Arc::new(table))
-            .map_err(DataFusionError::from)?;
+        self.ctx.register_table(&*table_name, Arc::new(table))?;
 
-        let table = wait_for_future(py, self._table(&table_name)).map_err(DataFusionError::from)?;
+        let table = wait_for_future(py, self._table(&table_name))??;
 
         let df = PyDataFrame::new(table);
         Ok(df)
     }
 
     /// Create a DataFrame from an existing logical plan
-    fn create_dataframe_from_logical_plan(&mut self, plan: PyLogicalPlan) -> PyDataFrame {
+    pub fn create_dataframe_from_logical_plan(&self, plan: PyLogicalPlan) -> PyDataFrame {
         PyDataFrame::new(DataFrame::new(self.ctx.state(), plan.plan.as_ref().clone()))
     }
 
     /// Construct datafusion dataframe from Python list
-    #[allow(clippy::wrong_self_convention)]
-    fn from_pylist(
-        &mut self,
-        data: PyObject,
+    #[pyo3(signature = (data, name=None))]
+    pub fn from_pylist(
+        &self,
+        data: Bound<'_, PyList>,
         name: Option<&str>,
-        _py: Python,
     ) -> PyResult<PyDataFrame> {
-        Python::with_gil(|py| {
-            // Instantiate pyarrow Table object & convert to Arrow Table
-            let table_class = py.import("pyarrow")?.getattr("Table")?;
-            let args = PyTuple::new(py, &[data]);
-            let table = table_class.call_method1("from_pylist", args)?.into();
-
-            // Convert Arrow Table to datafusion DataFrame
-            let df = self.from_arrow_table(table, name, py)?;
-            Ok(df)
-        })
+        // Acquire GIL Token
+        let py = data.py();
+
+        // Instantiate pyarrow Table object & convert to Arrow Table
+        let table_class = py.import("pyarrow")?.getattr("Table")?;
+        let args = PyTuple::new(py, &[data])?;
+        let table = table_class.call_method1("from_pylist", args)?;
+
+        // Convert Arrow Table to datafusion DataFrame
+        let df = self.from_arrow(table, name, py)?;
+        Ok(df)
     }
 
     /// Construct datafusion dataframe from Python dictionary
-    #[allow(clippy::wrong_self_convention)]
-    fn from_pydict(
-        &mut self,
-        data: PyObject,
+    #[pyo3(signature = (data, name=None))]
+    pub fn from_pydict(
+        &self,
+        data: Bound<'_, PyDict>,
         name: Option<&str>,
-        _py: Python,
     ) -> PyResult<PyDataFrame> {
-        Python::with_gil(|py| {
-            // Instantiate pyarrow Table object & convert to Arrow Table
-            let table_class = py.import("pyarrow")?.getattr("Table")?;
-            let args = PyTuple::new(py, &[data]);
-            let table = table_class.call_method1("from_pydict", args)?.into();
-
-            // Convert Arrow Table to datafusion DataFrame
-            let df = self.from_arrow_table(table, name, py)?;
-            Ok(df)
-        })
+        // Acquire GIL Token
+        let py = data.py();
+
+        // Instantiate pyarrow Table object & convert to Arrow Table
+        let table_class = py.import("pyarrow")?.getattr("Table")?;
+        let args = PyTuple::new(py, &[data])?;
+        let table = table_class.call_method1("from_pydict", args)?;
+
+        // Convert Arrow Table to datafusion DataFrame
+        let df = self.from_arrow(table, name, py)?;
+        Ok(df)
     }
 
     /// Construct datafusion dataframe from Arrow Table
-    #[allow(clippy::wrong_self_convention)]
-    fn from_arrow_table(
-        &mut self,
-        data: PyObject,
+    #[pyo3(signature = (data, name=None))]
+    pub fn from_arrow(
+        &self,
+        data: Bound<'_, PyAny>,
         name: Option<&str>,
-        _py: Python,
-    ) -> PyResult<PyDataFrame> {
-        Python::with_gil(|py| {
-            // Instantiate pyarrow Table object & convert to batches
-            let table = data.call_method0(py, "to_batches")?;
-
-            // Cast PyObject to RecordBatch type
-            // Because create_dataframe() expects a vector of vectors of record batches
-            // here we need to wrap the vector of record batches in an additional vector
-            let batches = table.extract::<PyArrowType<Vec<RecordBatch>>>(py)?;
-            let list_of_batches = PyArrowType::try_from(vec![batches.0])?;
-            self.create_dataframe(list_of_batches, name, py)
-        })
+        py: Python,
+    ) -> PyDataFusionResult<PyDataFrame> {
+        let (schema, batches) =
+            if let Ok(stream_reader) = ArrowArrayStreamReader::from_pyarrow_bound(&data) {
+                // Works for any object that implements __arrow_c_stream__ in pycapsule.
+
+                let schema = stream_reader.schema().as_ref().to_owned();
+                let batches = stream_reader
+                    .collect::<Result<Vec<RecordBatch>, arrow::error::ArrowError>>()?;
+
+                (schema, batches)
+            } else if let Ok(array) = RecordBatch::from_pyarrow_bound(&data) {
+                // While this says RecordBatch, it will work for any object that implements
+                // __arrow_c_array__ and returns a StructArray.
+
+                (array.schema().as_ref().to_owned(), vec![array])
+            } else {
+                return Err(PyDataFusionError::Common(
+                    "Expected either a Arrow Array or Arrow Stream in from_arrow().".to_string(),
+                ));
+            };
+
+        // Because create_dataframe() expects a vector of vectors of record batches
+        // here we need to wrap the vector of record batches in an additional vector
+        let list_of_batches = PyArrowType::from(vec![batches]);
+        self.create_dataframe(list_of_batches, name, Some(schema.into()), py)
     }
 
     /// Construct datafusion dataframe from pandas
     #[allow(clippy::wrong_self_convention)]
-    fn from_pandas(
-        &mut self,
-        data: PyObject,
-        name: Option<&str>,
-        _py: Python,
-    ) -> PyResult<PyDataFrame> {
-        Python::with_gil(|py| {
-            // Instantiate pyarrow Table object & convert to Arrow Table
-            let table_class = py.import("pyarrow")?.getattr("Table")?;
-            let args = PyTuple::new(py, &[data]);
-            let table = table_class.call_method1("from_pandas", args)?.into();
-
-            // Convert Arrow Table to datafusion DataFrame
-            let df = self.from_arrow_table(table, name, py)?;
-            Ok(df)
-        })
+    #[pyo3(signature = (data, name=None))]
+    pub fn from_pandas(&self, data: Bound<'_, PyAny>, name: Option<&str>) -> PyResult<PyDataFrame> {
+        // Obtain GIL token
+        let py = data.py();
+
+        // Instantiate pyarrow Table object & convert to Arrow Table
+        let table_class = py.import("pyarrow")?.getattr("Table")?;
+        let args = PyTuple::new(py, &[data])?;
+        let table = table_class.call_method1("from_pandas", args)?;
+
+        // Convert Arrow Table to datafusion DataFrame
+        let df = self.from_arrow(table, name, py)?;
+        Ok(df)
     }
 
     /// Construct datafusion dataframe from polars
-    #[allow(clippy::wrong_self_convention)]
-    fn from_polars(
-        &mut self,
-        data: PyObject,
-        name: Option<&str>,
-        _py: Python,
-    ) -> PyResult<PyDataFrame> {
-        Python::with_gil(|py| {
-            // Convert Polars dataframe to Arrow Table
-            let table = data.call_method0(py, "to_arrow")?;
+    #[pyo3(signature = (data, name=None))]
+    pub fn from_polars(&self, data: Bound<'_, PyAny>, name: Option<&str>) -> PyResult<PyDataFrame> {
+        // Convert Polars dataframe to Arrow Table
+        let table = data.call_method0("to_arrow")?;
 
-            // Convert Arrow Table to datafusion DataFrame
-            let df = self.from_arrow_table(table, name, py)?;
-            Ok(df)
-        })
+        // Convert Arrow Table to datafusion DataFrame
+        let df = self.from_arrow(table, name, data.py())?;
+        Ok(df)
     }
 
-    fn register_table(&mut self, name: &str, table: &PyTable) -> PyResult<()> {
-        self.ctx
-            .register_table(name, table.table())
-            .map_err(DataFusionError::from)?;
+    pub fn register_table(&self, name: &str, table: Bound<'_, PyAny>) -> PyDataFusionResult<()> {
+        let session = self.clone().into_bound_py_any(table.py())?;
+        let table = PyTable::new(table, Some(session))?;
+
+        self.ctx.register_table(name, table.table)?;
         Ok(())
     }
 
-    fn deregister_table(&mut self, name: &str) -> PyResult<()> {
-        self.ctx
-            .deregister_table(name)
-            .map_err(DataFusionError::from)?;
+    pub fn deregister_table(&self, name: &str) -> PyDataFusionResult<()> {
+        self.ctx.deregister_table(name)?;
         Ok(())
     }
 
-    fn register_record_batches(
-        &mut self,
+    pub fn register_catalog_provider_list(
+        &self,
+        mut provider: Bound<PyAny>,
+    ) -> PyDataFusionResult<()> {
+        if provider.hasattr("__datafusion_catalog_provider_list__")? {
+            let py = provider.py();
+            let codec_capsule = create_logical_extension_capsule(py, self.logical_codec.as_ref())?;
+            provider = provider
+                .getattr("__datafusion_catalog_provider_list__")?
+                .call1((codec_capsule,))?;
+        }
+
+        let provider = if let Ok(capsule) = provider.cast::<PyCapsule>().map_err(py_datafusion_err)
+        {
+            validate_pycapsule(capsule, "datafusion_catalog_provider_list")?;
+
+            let data: NonNull<FFI_CatalogProviderList> = capsule
+                .pointer_checked(Some(c_str!("datafusion_catalog_provider_list")))?
+                .cast();
+            let provider = unsafe { data.as_ref() };
+            let provider: Arc<dyn CatalogProviderList + Send> = provider.into();
+            provider as Arc<dyn CatalogProviderList>
+        } else {
+            match provider.extract::<PyCatalogList>() {
+                Ok(py_catalog_list) => py_catalog_list.catalog_list,
+                Err(_) => Arc::new(RustWrappedPyCatalogProviderList::new(
+                    provider.into(),
+                    Arc::clone(&self.logical_codec),
+                )) as Arc<dyn CatalogProviderList>,
+            }
+        };
+
+        self.ctx.register_catalog_list(provider);
+
+        Ok(())
+    }
+
+    pub fn register_catalog_provider(
+        &self,
+        name: &str,
+        mut provider: Bound<'_, PyAny>,
+    ) -> PyDataFusionResult<()> {
+        if provider.hasattr("__datafusion_catalog_provider__")? {
+            let py = provider.py();
+            let codec_capsule = create_logical_extension_capsule(py, self.logical_codec.as_ref())?;
+            provider = provider
+                .getattr("__datafusion_catalog_provider__")?
+                .call1((codec_capsule,))?;
+        }
+
+        let provider = if let Ok(capsule) = provider.cast::<PyCapsule>().map_err(py_datafusion_err)
+        {
+            validate_pycapsule(capsule, "datafusion_catalog_provider")?;
+
+            let data: NonNull<FFI_CatalogProvider> = capsule
+                .pointer_checked(Some(c_str!("datafusion_catalog_provider")))?
+                .cast();
+            let provider = unsafe { data.as_ref() };
+            let provider: Arc<dyn CatalogProvider + Send> = provider.into();
+            provider as Arc<dyn CatalogProvider>
+        } else {
+            match provider.extract::<PyCatalog>() {
+                Ok(py_catalog) => py_catalog.catalog,
+                Err(_) => Arc::new(RustWrappedPyCatalogProvider::new(
+                    provider.into(),
+                    Arc::clone(&self.logical_codec),
+                )) as Arc<dyn CatalogProvider>,
+            }
+        };
+
+        let _ = self.ctx.register_catalog(name, provider);
+
+        Ok(())
+    }
+
+    /// Construct datafusion dataframe from Arrow Table
+    pub fn register_table_provider(
+        &self,
+        name: &str,
+        provider: Bound<'_, PyAny>,
+    ) -> PyDataFusionResult<()> {
+        // Deprecated: use `register_table` instead
+        self.register_table(name, provider)
+    }
+
+    pub fn register_record_batches(
+        &self,
         name: &str,
         partitions: PyArrowType<Vec<Vec<RecordBatch>>>,
-    ) -> PyResult<()> {
+    ) -> PyDataFusionResult<()> {
         let schema = partitions.0[0][0].schema();
         let table = MemTable::try_new(schema, partitions.0)?;
-        self.ctx
-            .register_table(name, Arc::new(table))
-            .map_err(DataFusionError::from)?;
+        self.ctx.register_table(name, Arc::new(table))?;
         Ok(())
     }
 
     #[allow(clippy::too_many_arguments)]
     #[pyo3(signature = (name, path, table_partition_cols=vec![],
                         parquet_pruning=true,
-                        file_extension=".parquet"))]
-    fn register_parquet(
-        &mut self,
+                        file_extension=".parquet",
+                        skip_metadata=true,
+                        schema=None,
+                        file_sort_order=None))]
+    pub fn register_parquet(
+        &self,
         name: &str,
         path: &str,
-        table_partition_cols: Vec<(String, String)>,
+        table_partition_cols: Vec<(String, PyArrowType<DataType>)>,
         parquet_pruning: bool,
         file_extension: &str,
+        skip_metadata: bool,
+        schema: Option<PyArrowType<Schema>>,
+        file_sort_order: Option<Vec<Vec<PySortExpr>>>,
         py: Python,
-    ) -> PyResult<()> {
+    ) -> PyDataFusionResult<()> {
         let mut options = ParquetReadOptions::default()
-            .table_partition_cols(convert_table_partition_cols(table_partition_cols)?)
-            .parquet_pruning(parquet_pruning);
+            .table_partition_cols(
+                table_partition_cols
+                    .into_iter()
+                    .map(|(name, ty)| (name, ty.0))
+                    .collect::<Vec<(String, DataType)>>(),
+            )
+            .parquet_pruning(parquet_pruning)
+            .skip_metadata(skip_metadata);
         options.file_extension = file_extension;
+        options.schema = schema.as_ref().map(|x| &x.0);
+        options.file_sort_order = file_sort_order
+            .unwrap_or_default()
+            .into_iter()
+            .map(|e| e.into_iter().map(|f| f.into()).collect())
+            .collect();
+
         let result = self.ctx.register_parquet(name, path, options);
-        wait_for_future(py, result).map_err(DataFusionError::from)?;
+        wait_for_future(py, result)??;
+        Ok(())
+    }
+
+    #[pyo3(signature = (name,
+                        path,
+                        options=None))]
+    pub fn register_csv(
+        &self,
+        name: &str,
+        path: &Bound<'_, PyAny>,
+        options: Option<&PyCsvReadOptions>,
+        py: Python,
+    ) -> PyDataFusionResult<()> {
+        let options = options
+            .map(|opts| opts.try_into())
+            .transpose()?
+            .unwrap_or_default();
+
+        if path.is_instance_of::<PyList>() {
+            let paths = path.extract::<Vec<String>>()?;
+            let result = self.register_csv_from_multiple_paths(name, paths, options);
+            wait_for_future(py, result)??;
+        } else {
+            let path = path.extract::<String>()?;
+            let result = self.ctx.register_csv(name, &path, options);
+            wait_for_future(py, result)??;
+        }
+
         Ok(())
     }
 
@@ -462,173 +828,231 @@ impl PySessionContext {
     #[pyo3(signature = (name,
                         path,
                         schema=None,
-                        has_header=true,
-                        delimiter=",",
                         schema_infer_max_records=1000,
-                        file_extension=".csv"))]
-    fn register_csv(
-        &mut self,
+                        file_extension=".json",
+                        table_partition_cols=vec![],
+                        file_compression_type=None))]
+    pub fn register_json(
+        &self,
         name: &str,
         path: PathBuf,
         schema: Option<PyArrowType<Schema>>,
-        has_header: bool,
-        delimiter: &str,
         schema_infer_max_records: usize,
         file_extension: &str,
+        table_partition_cols: Vec<(String, PyArrowType<DataType>)>,
+        file_compression_type: Option<String>,
         py: Python,
-    ) -> PyResult<()> {
+    ) -> PyDataFusionResult<()> {
+        let path = path
+            .to_str()
+            .ok_or_else(|| PyValueError::new_err("Unable to convert path to a string"))?;
+
+        let mut options = JsonReadOptions::default()
+            .file_compression_type(parse_file_compression_type(file_compression_type)?)
+            .table_partition_cols(
+                table_partition_cols
+                    .into_iter()
+                    .map(|(name, ty)| (name, ty.0))
+                    .collect::<Vec<(String, DataType)>>(),
+            );
+        options.schema_infer_max_records = schema_infer_max_records;
+        options.file_extension = file_extension;
+        options.schema = schema.as_ref().map(|x| &x.0);
+
+        let result = self.ctx.register_json(name, path, options);
+        wait_for_future(py, result)??;
+
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    #[pyo3(signature = (name,
+                        path,
+                        schema=None,
+                        file_extension=".avro",
+                        table_partition_cols=vec![]))]
+    pub fn register_avro(
+        &self,
+        name: &str,
+        path: PathBuf,
+        schema: Option<PyArrowType<Schema>>,
+        file_extension: &str,
+        table_partition_cols: Vec<(String, PyArrowType<DataType>)>,
+        py: Python,
+    ) -> PyDataFusionResult<()> {
         let path = path
             .to_str()
             .ok_or_else(|| PyValueError::new_err("Unable to convert path to a string"))?;
-        let delimiter = delimiter.as_bytes();
-        if delimiter.len() != 1 {
-            return Err(PyValueError::new_err(
-                "Delimiter must be a single character",
-            ));
-        }
 
-        let mut options = CsvReadOptions::new()
-            .has_header(has_header)
-            .delimiter(delimiter[0])
-            .schema_infer_max_records(schema_infer_max_records)
-            .file_extension(file_extension);
+        let mut options = AvroReadOptions::default().table_partition_cols(
+            table_partition_cols
+                .into_iter()
+                .map(|(name, ty)| (name, ty.0))
+                .collect::<Vec<(String, DataType)>>(),
+        );
+        options.file_extension = file_extension;
         options.schema = schema.as_ref().map(|x| &x.0);
 
-        let result = self.ctx.register_csv(name, path, options);
-        wait_for_future(py, result).map_err(DataFusionError::from)?;
+        let result = self.ctx.register_avro(name, path, options);
+        wait_for_future(py, result)??;
 
         Ok(())
     }
 
     // Registers a PyArrow.Dataset
-    fn register_dataset(&self, name: &str, dataset: &PyAny, py: Python) -> PyResult<()> {
+    pub fn register_dataset(
+        &self,
+        name: &str,
+        dataset: &Bound<'_, PyAny>,
+        py: Python,
+    ) -> PyDataFusionResult<()> {
         let table: Arc<dyn TableProvider> = Arc::new(Dataset::new(dataset, py)?);
 
-        self.ctx
-            .register_table(name, table)
-            .map_err(DataFusionError::from)?;
+        self.ctx.register_table(name, table)?;
 
         Ok(())
     }
 
-    fn register_udf(&mut self, udf: PyScalarUDF) -> PyResult<()> {
+    pub fn register_udf(&self, udf: PyScalarUDF) -> PyResult<()> {
         self.ctx.register_udf(udf.function);
         Ok(())
     }
 
-    fn register_udaf(&mut self, udaf: PyAggregateUDF) -> PyResult<()> {
+    pub fn register_udaf(&self, udaf: PyAggregateUDF) -> PyResult<()> {
         self.ctx.register_udaf(udaf.function);
         Ok(())
     }
 
+    pub fn register_udwf(&self, udwf: PyWindowUDF) -> PyResult<()> {
+        self.ctx.register_udwf(udwf.function);
+        Ok(())
+    }
+
     #[pyo3(signature = (name="datafusion"))]
-    fn catalog(&self, name: &str) -> PyResult<PyCatalog> {
-        match self.ctx.catalog(name) {
-            Some(catalog) => Ok(PyCatalog::new(catalog)),
-            None => Err(PyKeyError::new_err(format!(
-                "Catalog with name {} doesn't exist.",
-                &name,
-            ))),
+    pub fn catalog(&self, py: Python, name: &str) -> PyResult<Py<PyAny>> {
+        let catalog = self.ctx.catalog(name).ok_or(PyKeyError::new_err(format!(
+            "Catalog with name {name} doesn't exist."
+        )))?;
+
+        match catalog
+            .as_any()
+            .downcast_ref::<RustWrappedPyCatalogProvider>()
+        {
+            Some(wrapped_schema) => Ok(wrapped_schema.catalog_provider.clone_ref(py)),
+            None => Ok(
+                PyCatalog::new_from_parts(catalog, Arc::clone(&self.logical_codec))
+                    .into_py_any(py)?,
+            ),
         }
     }
 
-    fn tables(&self) -> HashSet<String> {
-        #[allow(deprecated)]
-        self.ctx.tables().unwrap()
+    pub fn catalog_names(&self) -> HashSet<String> {
+        self.ctx.catalog_names().into_iter().collect()
     }
 
-    fn table(&self, name: &str, py: Python) -> PyResult<PyDataFrame> {
-        let x = wait_for_future(py, self.ctx.table(name)).map_err(DataFusionError::from)?;
-        Ok(PyDataFrame::new(x))
+    pub fn tables(&self) -> HashSet<String> {
+        self.ctx
+            .catalog_names()
+            .into_iter()
+            .filter_map(|name| self.ctx.catalog(&name))
+            .flat_map(move |catalog| {
+                catalog
+                    .schema_names()
+                    .into_iter()
+                    .filter_map(move |name| catalog.schema(&name))
+            })
+            .flat_map(|schema| schema.table_names())
+            .collect()
     }
 
-    fn table_exist(&self, name: &str) -> PyResult<bool> {
+    pub fn table(&self, name: &str, py: Python) -> PyResult<PyDataFrame> {
+        let res = wait_for_future(py, self.ctx.table(name))
+            .map_err(|e| PyKeyError::new_err(e.to_string()))?;
+        match res {
+            Ok(df) => Ok(PyDataFrame::new(df)),
+            Err(e) => {
+                if let datafusion::error::DataFusionError::Plan(msg) = &e
+                    && msg.contains("No table named")
+                {
+                    return Err(PyKeyError::new_err(msg.to_string()));
+                }
+                Err(py_datafusion_err(e))
+            }
+        }
+    }
+
+    pub fn table_exist(&self, name: &str) -> PyDataFusionResult<bool> {
         Ok(self.ctx.table_exist(name)?)
     }
 
-    fn empty_table(&self) -> PyResult<PyDataFrame> {
+    pub fn empty_table(&self) -> PyDataFusionResult<PyDataFrame> {
         Ok(PyDataFrame::new(self.ctx.read_empty()?))
     }
 
-    fn session_id(&self) -> PyResult<String> {
-        Ok(self.ctx.session_id())
+    pub fn session_id(&self) -> String {
+        self.ctx.session_id()
     }
 
     #[allow(clippy::too_many_arguments)]
-    #[pyo3(signature = (path, schema=None, schema_infer_max_records=1000, file_extension=".json", table_partition_cols=vec![]))]
-    fn read_json(
-        &mut self,
+    #[pyo3(signature = (path, schema=None, schema_infer_max_records=1000, file_extension=".json", table_partition_cols=vec![], file_compression_type=None))]
+    pub fn read_json(
+        &self,
         path: PathBuf,
         schema: Option<PyArrowType<Schema>>,
         schema_infer_max_records: usize,
         file_extension: &str,
-        table_partition_cols: Vec<(String, String)>,
+        table_partition_cols: Vec<(String, PyArrowType<DataType>)>,
+        file_compression_type: Option<String>,
         py: Python,
-    ) -> PyResult<PyDataFrame> {
+    ) -> PyDataFusionResult<PyDataFrame> {
         let path = path
             .to_str()
             .ok_or_else(|| PyValueError::new_err("Unable to convert path to a string"))?;
-        let mut options = NdJsonReadOptions::default()
-            .table_partition_cols(convert_table_partition_cols(table_partition_cols)?);
+        let mut options = JsonReadOptions::default()
+            .table_partition_cols(
+                table_partition_cols
+                    .into_iter()
+                    .map(|(name, ty)| (name, ty.0))
+                    .collect::<Vec<(String, DataType)>>(),
+            )
+            .file_compression_type(parse_file_compression_type(file_compression_type)?);
         options.schema_infer_max_records = schema_infer_max_records;
         options.file_extension = file_extension;
         let df = if let Some(schema) = schema {
             options.schema = Some(&schema.0);
             let result = self.ctx.read_json(path, options);
-            wait_for_future(py, result).map_err(DataFusionError::from)?
+            wait_for_future(py, result)??
         } else {
             let result = self.ctx.read_json(path, options);
-            wait_for_future(py, result).map_err(DataFusionError::from)?
+            wait_for_future(py, result)??
         };
         Ok(PyDataFrame::new(df))
     }
 
-    #[allow(clippy::too_many_arguments)]
     #[pyo3(signature = (
         path,
-        schema=None,
-        has_header=true,
-        delimiter=",",
-        schema_infer_max_records=1000,
-        file_extension=".csv",
-        table_partition_cols=vec![]))]
-    fn read_csv(
+        options=None))]
+    pub fn read_csv(
         &self,
-        path: PathBuf,
-        schema: Option<PyArrowType<Schema>>,
-        has_header: bool,
-        delimiter: &str,
-        schema_infer_max_records: usize,
-        file_extension: &str,
-        table_partition_cols: Vec<(String, String)>,
+        path: &Bound<'_, PyAny>,
+        options: Option<&PyCsvReadOptions>,
         py: Python,
-    ) -> PyResult<PyDataFrame> {
-        let path = path
-            .to_str()
-            .ok_or_else(|| PyValueError::new_err("Unable to convert path to a string"))?;
-
-        let delimiter = delimiter.as_bytes();
-        if delimiter.len() != 1 {
-            return Err(PyValueError::new_err(
-                "Delimiter must be a single character",
-            ));
-        };
-
-        let mut options = CsvReadOptions::new()
-            .has_header(has_header)
-            .delimiter(delimiter[0])
-            .schema_infer_max_records(schema_infer_max_records)
-            .file_extension(file_extension)
-            .table_partition_cols(convert_table_partition_cols(table_partition_cols)?);
-
-        if let Some(py_schema) = schema {
-            options.schema = Some(&py_schema.0);
-            let result = self.ctx.read_csv(path, options);
-            let df = PyDataFrame::new(wait_for_future(py, result).map_err(DataFusionError::from)?);
+    ) -> PyDataFusionResult<PyDataFrame> {
+        let options = options
+            .map(|opts| opts.try_into())
+            .transpose()?
+            .unwrap_or_default();
+
+        if path.is_instance_of::<PyList>() {
+            let paths = path.extract::<Vec<String>>()?;
+            let paths = paths.iter().map(|p| p as &str).collect::<Vec<&str>>();
+            let result = self.ctx.read_csv(paths, options);
+            let df = PyDataFrame::new(wait_for_future(py, result)??);
             Ok(df)
         } else {
+            let path = path.extract::<String>()?;
             let result = self.ctx.read_csv(path, options);
-            let df = PyDataFrame::new(wait_for_future(py, result).map_err(DataFusionError::from)?);
+            let df = PyDataFrame::new(wait_for_future(py, result)??);
             Ok(df)
         }
     }
@@ -639,57 +1063,92 @@ impl PySessionContext {
         table_partition_cols=vec![],
         parquet_pruning=true,
         file_extension=".parquet",
-        skip_metadata=true))]
-    fn read_parquet(
+        skip_metadata=true,
+        schema=None,
+        file_sort_order=None))]
+    pub fn read_parquet(
         &self,
         path: &str,
-        table_partition_cols: Vec<(String, String)>,
+        table_partition_cols: Vec<(String, PyArrowType<DataType>)>,
         parquet_pruning: bool,
         file_extension: &str,
         skip_metadata: bool,
+        schema: Option<PyArrowType<Schema>>,
+        file_sort_order: Option<Vec<Vec<PySortExpr>>>,
         py: Python,
-    ) -> PyResult<PyDataFrame> {
+    ) -> PyDataFusionResult<PyDataFrame> {
         let mut options = ParquetReadOptions::default()
-            .table_partition_cols(convert_table_partition_cols(table_partition_cols)?)
+            .table_partition_cols(
+                table_partition_cols
+                    .into_iter()
+                    .map(|(name, ty)| (name, ty.0))
+                    .collect::<Vec<(String, DataType)>>(),
+            )
             .parquet_pruning(parquet_pruning)
             .skip_metadata(skip_metadata);
         options.file_extension = file_extension;
+        options.schema = schema.as_ref().map(|x| &x.0);
+        options.file_sort_order = file_sort_order
+            .unwrap_or_default()
+            .into_iter()
+            .map(|e| e.into_iter().map(|f| f.into()).collect())
+            .collect();
 
         let result = self.ctx.read_parquet(path, options);
-        let df = PyDataFrame::new(wait_for_future(py, result).map_err(DataFusionError::from)?);
+        let df = PyDataFrame::new(wait_for_future(py, result)??);
         Ok(df)
     }
 
     #[allow(clippy::too_many_arguments)]
     #[pyo3(signature = (path, schema=None, table_partition_cols=vec![], file_extension=".avro"))]
-    fn read_avro(
+    pub fn read_avro(
         &self,
         path: &str,
         schema: Option<PyArrowType<Schema>>,
-        table_partition_cols: Vec<(String, String)>,
+        table_partition_cols: Vec<(String, PyArrowType<DataType>)>,
         file_extension: &str,
         py: Python,
-    ) -> PyResult<PyDataFrame> {
-        let mut options = AvroReadOptions::default()
-            .table_partition_cols(convert_table_partition_cols(table_partition_cols)?);
+    ) -> PyDataFusionResult<PyDataFrame> {
+        let mut options = AvroReadOptions::default().table_partition_cols(
+            table_partition_cols
+                .into_iter()
+                .map(|(name, ty)| (name, ty.0))
+                .collect::<Vec<(String, DataType)>>(),
+        );
         options.file_extension = file_extension;
         let df = if let Some(schema) = schema {
             options.schema = Some(&schema.0);
             let read_future = self.ctx.read_avro(path, options);
-            wait_for_future(py, read_future).map_err(DataFusionError::from)?
+            wait_for_future(py, read_future)??
         } else {
             let read_future = self.ctx.read_avro(path, options);
-            wait_for_future(py, read_future).map_err(DataFusionError::from)?
+            wait_for_future(py, read_future)??
         };
         Ok(PyDataFrame::new(df))
     }
 
+    pub fn read_table(&self, table: Bound<'_, PyAny>) -> PyDataFusionResult<PyDataFrame> {
+        let session = self.clone().into_bound_py_any(table.py())?;
+        let table = PyTable::new(table, Some(session))?;
+        let df = self.ctx.read_table(table.table())?;
+        Ok(PyDataFrame::new(df))
+    }
+
     fn __repr__(&self) -> PyResult<String> {
-        let id = self.session_id();
-        match id {
-            Ok(value) => Ok(format!("SessionContext(session_id={value})")),
-            Err(err) => Ok(format!("Error: {:?}", err.to_string())),
-        }
+        let config = self.ctx.copied_config();
+        let mut config_entries = config
+            .options()
+            .entries()
+            .iter()
+            .filter(|e| e.value.is_some())
+            .map(|e| format!("{} = {}", e.key, e.value.as_ref().unwrap()))
+            .collect::<Vec<_>>();
+        config_entries.sort();
+        Ok(format!(
+            "SessionContext: id={}; configs=[\n\t{}]",
+            self.session_id(),
+            config_entries.join("\n\t")
+        ))
     }
 
     /// Execute a partition of an execution plan and return a stream of record batches
@@ -698,54 +1157,125 @@ impl PySessionContext {
         plan: PyExecutionPlan,
         part: usize,
         py: Python,
-    ) -> PyResult<PyRecordBatchStream> {
-        let ctx = TaskContext::try_new(
-            "task_id".to_string(),
-            "session_id".to_string(),
-            HashMap::new(),
-            HashMap::new(),
-            HashMap::new(),
-            Arc::new(RuntimeEnv::default()),
-            Extensions::default(),
-        );
-        // create a Tokio runtime to run the async code
-        let rt = Runtime::new().unwrap();
+    ) -> PyDataFusionResult<PyRecordBatchStream> {
+        let ctx: TaskContext = TaskContext::from(&self.ctx.state());
         let plan = plan.plan.clone();
-        let fut: JoinHandle<datafusion_common::Result<SendableRecordBatchStream>> =
-            rt.spawn(async move { plan.execute(part, Arc::new(ctx?)) });
-        let stream = wait_for_future(py, fut).map_err(py_datafusion_err)?;
-        Ok(PyRecordBatchStream::new(stream?))
+        let stream = spawn_future(py, async move { plan.execute(part, Arc::new(ctx)) })?;
+        Ok(PyRecordBatchStream::new(stream))
+    }
+
+    pub fn __datafusion_task_context_provider__<'py>(
+        &self,
+        py: Python<'py>,
+    ) -> PyResult<Bound<'py, PyCapsule>> {
+        let name = cr"datafusion_task_context_provider".into();
+
+        let ctx_provider = Arc::clone(&self.ctx) as Arc<dyn TaskContextProvider>;
+        let ffi_ctx_provider = FFI_TaskContextProvider::from(&ctx_provider);
+
+        PyCapsule::new(py, ffi_ctx_provider, Some(name))
+    }
+
+    pub fn __datafusion_logical_extension_codec__<'py>(
+        &self,
+        py: Python<'py>,
+    ) -> PyResult<Bound<'py, PyCapsule>> {
+        create_logical_extension_capsule(py, self.logical_codec.as_ref())
+    }
+
+    pub fn with_logical_extension_codec<'py>(
+        &self,
+        codec: Bound<'py, PyAny>,
+    ) -> PyDataFusionResult<Self> {
+        let py = codec.py();
+        let logical_codec = extract_logical_extension_codec(py, Some(codec))?;
+
+        Ok({
+            Self {
+                ctx: Arc::clone(&self.ctx),
+                logical_codec,
+            }
+        })
     }
 }
 
 impl PySessionContext {
-    async fn _table(&self, name: &str) -> datafusion_common::Result<DataFrame> {
+    async fn _table(&self, name: &str) -> datafusion::common::Result<DataFrame> {
         self.ctx.table(name).await
     }
+
+    async fn register_csv_from_multiple_paths(
+        &self,
+        name: &str,
+        table_paths: Vec<String>,
+        options: CsvReadOptions<'_>,
+    ) -> datafusion::common::Result<()> {
+        let table_paths = table_paths.to_urls()?;
+        let session_config = self.ctx.copied_config();
+        let listing_options =
+            options.to_listing_options(&session_config, self.ctx.copied_table_options());
+
+        let option_extension = listing_options.file_extension.clone();
+
+        if table_paths.is_empty() {
+            return exec_err!("No table paths were provided");
+        }
+
+        // check if the file extension matches the expected extension
+        for path in &table_paths {
+            let file_path = path.as_str();
+            if !file_path.ends_with(option_extension.clone().as_str()) && !path.is_collection() {
+                return exec_err!(
+                    "File path '{file_path}' does not match the expected extension '{option_extension}'"
+                );
+            }
+        }
+
+        let resolved_schema = options
+            .get_resolved_schema(&session_config, self.ctx.state(), table_paths[0].clone())
+            .await?;
+
+        let config = ListingTableConfig::new_with_multi_paths(table_paths)
+            .with_listing_options(listing_options)
+            .with_schema(resolved_schema);
+        let table = ListingTable::try_new(config)?;
+        self.ctx
+            .register_table(TableReference::Bare { table: name.into() }, Arc::new(table))?;
+        Ok(())
+    }
+
+    fn default_logical_codec(ctx: &Arc<SessionContext>) -> Arc<FFI_LogicalExtensionCodec> {
+        let codec = Arc::new(DefaultLogicalExtensionCodec {});
+        let runtime = get_tokio_runtime().0.handle().clone();
+        let ctx_provider = Arc::clone(ctx) as Arc<dyn TaskContextProvider>;
+        Arc::new(FFI_LogicalExtensionCodec::new(
+            codec,
+            Some(runtime),
+            &ctx_provider,
+        ))
+    }
 }
 
-fn convert_table_partition_cols(
-    table_partition_cols: Vec<(String, String)>,
-) -> Result<Vec<(String, DataType)>, DataFusionError> {
-    table_partition_cols
-        .into_iter()
-        .map(|(name, ty)| match ty.as_str() {
-            "string" => Ok((name, DataType::Utf8)),
-            _ => Err(DataFusionError::Common(format!(
-                "Unsupported data type '{ty}' for partition column"
-            ))),
+pub fn parse_file_compression_type(
+    file_compression_type: Option<String>,
+) -> Result<FileCompressionType, PyErr> {
+    FileCompressionType::from_str(&*file_compression_type.unwrap_or("".to_string()).as_str())
+        .map_err(|_| {
+            PyValueError::new_err("file_compression_type must one of: gzip, bz2, xz, zstd")
         })
-        .collect::<Result<Vec<_>, _>>()
 }
 
 impl From<PySessionContext> for SessionContext {
     fn from(ctx: PySessionContext) -> SessionContext {
-        ctx.ctx
+        ctx.ctx.as_ref().clone()
     }
 }
 
 impl From<SessionContext> for PySessionContext {
     fn from(ctx: SessionContext) -> PySessionContext {
-        PySessionContext { ctx }
+        let ctx = Arc::new(ctx);
+        let logical_codec = Self::default_logical_codec(&ctx);
+
+        PySessionContext { ctx, logical_codec }
     }
 }
diff --git a/src/dataframe.rs b/src/dataframe.rs
index b21f56104..eb1fa4a81 100644
--- a/src/dataframe.rs
+++ b/src/dataframe.rs
@@ -15,98 +15,605 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::physical_plan::PyExecutionPlan;
-use crate::sql::logical::PyLogicalPlan;
-use crate::utils::wait_for_future;
-use crate::{errors::DataFusionError, expr::PyExpr};
-use datafusion::arrow::datatypes::Schema;
-use datafusion::arrow::pyarrow::{PyArrowConvert, PyArrowException, PyArrowType};
+use std::collections::HashMap;
+use std::ffi::{CStr, CString};
+use std::ptr::NonNull;
+use std::str::FromStr;
+use std::sync::Arc;
+
+use arrow::array::{Array, ArrayRef, RecordBatch, RecordBatchReader, new_null_array};
+use arrow::compute::can_cast_types;
+use arrow::error::ArrowError;
+use arrow::ffi::FFI_ArrowSchema;
+use arrow::ffi_stream::FFI_ArrowArrayStream;
+use arrow::pyarrow::FromPyArrow;
+use cstr::cstr;
+use datafusion::arrow::datatypes::{Schema, SchemaRef};
+use datafusion::arrow::pyarrow::{PyArrowType, ToPyArrow};
 use datafusion::arrow::util::pretty;
-use datafusion::dataframe::DataFrame;
+use datafusion::catalog::TableProvider;
+use datafusion::common::UnnestOptions;
+use datafusion::config::{CsvOptions, ParquetColumnOptions, ParquetOptions, TableParquetOptions};
+use datafusion::dataframe::{DataFrame, DataFrameWriteOptions};
+use datafusion::error::DataFusionError;
+use datafusion::execution::SendableRecordBatchStream;
+use datafusion::logical_expr::SortExpr;
+use datafusion::logical_expr::dml::InsertOp;
+use datafusion::parquet::basic::{BrotliLevel, Compression, GzipLevel, ZstdLevel};
 use datafusion::prelude::*;
-use pyo3::exceptions::PyTypeError;
+use futures::{StreamExt, TryStreamExt};
+use parking_lot::Mutex;
+use pyo3::PyErr;
+use pyo3::exceptions::PyValueError;
+use pyo3::ffi::c_str;
 use pyo3::prelude::*;
-use pyo3::types::PyTuple;
-use std::sync::Arc;
+use pyo3::pybacked::PyBackedStr;
+use pyo3::types::{PyCapsule, PyList, PyTuple, PyTupleMethods};
+
+use crate::common::data_type::PyScalarValue;
+use crate::errors::{PyDataFusionError, PyDataFusionResult, py_datafusion_err};
+use crate::expr::PyExpr;
+use crate::expr::sort_expr::{PySortExpr, to_sort_expressions};
+use crate::physical_plan::PyExecutionPlan;
+use crate::record_batch::{PyRecordBatchStream, poll_next_batch};
+use crate::sql::logical::PyLogicalPlan;
+use crate::table::{PyTable, TempViewTable};
+use crate::utils::{is_ipython_env, spawn_future, validate_pycapsule, wait_for_future};
+
+/// File-level static CStr for the Arrow array stream capsule name.
+static ARROW_ARRAY_STREAM_NAME: &CStr = cstr!("arrow_array_stream");
+
+// Type aliases to simplify very complex types used in this file and
+// avoid compiler complaints about deeply nested types in struct fields.
+type CachedBatches = Option<(Vec<RecordBatch>, bool)>;
+type SharedCachedBatches = Arc<Mutex<CachedBatches>>;
+
+/// Configuration for DataFrame display formatting
+#[derive(Debug, Clone)]
+pub struct FormatterConfig {
+    /// Maximum memory in bytes to use for display (default: 2MB)
+    pub max_bytes: usize,
+    /// Minimum number of rows to display (default: 10)
+    pub min_rows: usize,
+    /// Maximum number of rows to include in __repr__ output (default: 10)
+    pub max_rows: usize,
+}
+
+impl Default for FormatterConfig {
+    fn default() -> Self {
+        Self {
+            max_bytes: 2 * 1024 * 1024, // 2MB
+            min_rows: 10,
+            max_rows: 10,
+        }
+    }
+}
+
+impl FormatterConfig {
+    /// Validates that all configuration values are positive integers.
+    ///
+    /// # Returns
+    ///
+    /// `Ok(())` if all values are valid, or an `Err` with a descriptive error message.
+    pub fn validate(&self) -> Result<(), String> {
+        if self.max_bytes == 0 {
+            return Err("max_bytes must be a positive integer".to_string());
+        }
+
+        if self.min_rows == 0 {
+            return Err("min_rows must be a positive integer".to_string());
+        }
+
+        if self.max_rows == 0 {
+            return Err("max_rows must be a positive integer".to_string());
+        }
+
+        if self.min_rows > self.max_rows {
+            return Err("min_rows must be less than or equal to max_rows".to_string());
+        }
+
+        Ok(())
+    }
+}
+
+/// Holds the Python formatter and its configuration
+struct PythonFormatter<'py> {
+    /// The Python formatter object
+    formatter: Bound<'py, PyAny>,
+    /// The formatter configuration
+    config: FormatterConfig,
+}
+
+/// Get the Python formatter and its configuration
+fn get_python_formatter_with_config(py: Python) -> PyResult<PythonFormatter> {
+    let formatter = import_python_formatter(py)?;
+    let config = build_formatter_config_from_python(&formatter)?;
+    Ok(PythonFormatter { formatter, config })
+}
+
+/// Get the Python formatter from the datafusion.dataframe_formatter module
+fn import_python_formatter(py: Python<'_>) -> PyResult<Bound<'_, PyAny>> {
+    let formatter_module = py.import("datafusion.dataframe_formatter")?;
+    let get_formatter = formatter_module.getattr("get_formatter")?;
+    get_formatter.call0()
+}
+
+// Helper function to extract attributes with fallback to default
+fn get_attr<'a, T>(py_object: &'a Bound<'a, PyAny>, attr_name: &str, default_value: T) -> T
+where
+    T: for<'py> pyo3::FromPyObject<'py, 'py> + Clone,
+{
+    py_object
+        .getattr(attr_name)
+        .and_then(|v| v.extract::<T>().map_err(Into::<PyErr>::into))
+        .unwrap_or_else(|_| default_value.clone())
+}
+
+/// Helper function to create a FormatterConfig from a Python formatter object
+fn build_formatter_config_from_python(formatter: &Bound<'_, PyAny>) -> PyResult<FormatterConfig> {
+    let default_config = FormatterConfig::default();
+    let max_bytes = get_attr(formatter, "max_memory_bytes", default_config.max_bytes);
+    let min_rows = get_attr(formatter, "min_rows", default_config.min_rows);
+
+    // Backward compatibility: Try max_rows first (new name), fall back to repr_rows (deprecated),
+    // then use default. This ensures backward compatibility with custom formatter implementations
+    // during the deprecation period.
+    let max_rows = get_attr(formatter, "max_rows", 0usize);
+    let max_rows = if max_rows > 0 {
+        // max_rows attribute exists and has a value
+        max_rows
+    } else {
+        // Try the deprecated repr_rows attribute
+        let repr_rows = get_attr(formatter, "repr_rows", 0usize);
+        if repr_rows > 0 {
+            repr_rows
+        } else {
+            // Use default
+            default_config.max_rows
+        }
+    };
+
+    let config = FormatterConfig {
+        max_bytes,
+        min_rows,
+        max_rows,
+    };
+
+    // Return the validated config, converting String error to PyErr
+    config.validate().map_err(PyValueError::new_err)?;
+    Ok(config)
+}
+
+/// Python mapping of `ParquetOptions` (includes just the writer-related options).
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "ParquetWriterOptions",
+    module = "datafusion",
+    subclass
+)]
+#[derive(Clone, Default)]
+pub struct PyParquetWriterOptions {
+    options: ParquetOptions,
+}
+
+#[pymethods]
+impl PyParquetWriterOptions {
+    #[new]
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        data_pagesize_limit: usize,
+        write_batch_size: usize,
+        writer_version: &str,
+        skip_arrow_metadata: bool,
+        compression: Option<String>,
+        dictionary_enabled: Option<bool>,
+        dictionary_page_size_limit: usize,
+        statistics_enabled: Option<String>,
+        max_row_group_size: usize,
+        created_by: String,
+        column_index_truncate_length: Option<usize>,
+        statistics_truncate_length: Option<usize>,
+        data_page_row_count_limit: usize,
+        encoding: Option<String>,
+        bloom_filter_on_write: bool,
+        bloom_filter_fpp: Option<f64>,
+        bloom_filter_ndv: Option<u64>,
+        allow_single_file_parallelism: bool,
+        maximum_parallel_row_group_writers: usize,
+        maximum_buffered_record_batches_per_stream: usize,
+    ) -> PyResult<Self> {
+        let writer_version =
+            datafusion::common::parquet_config::DFParquetWriterVersion::from_str(writer_version)
+                .map_err(py_datafusion_err)?;
+        Ok(Self {
+            options: ParquetOptions {
+                data_pagesize_limit,
+                write_batch_size,
+                writer_version,
+                skip_arrow_metadata,
+                compression,
+                dictionary_enabled,
+                dictionary_page_size_limit,
+                statistics_enabled,
+                max_row_group_size,
+                created_by,
+                column_index_truncate_length,
+                statistics_truncate_length,
+                data_page_row_count_limit,
+                encoding,
+                bloom_filter_on_write,
+                bloom_filter_fpp,
+                bloom_filter_ndv,
+                allow_single_file_parallelism,
+                maximum_parallel_row_group_writers,
+                maximum_buffered_record_batches_per_stream,
+                ..Default::default()
+            },
+        })
+    }
+}
+
+/// Python mapping of `ParquetColumnOptions`.
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "ParquetColumnOptions",
+    module = "datafusion",
+    subclass
+)]
+#[derive(Clone, Default)]
+pub struct PyParquetColumnOptions {
+    options: ParquetColumnOptions,
+}
+
+#[pymethods]
+impl PyParquetColumnOptions {
+    #[new]
+    pub fn new(
+        bloom_filter_enabled: Option<bool>,
+        encoding: Option<String>,
+        dictionary_enabled: Option<bool>,
+        compression: Option<String>,
+        statistics_enabled: Option<String>,
+        bloom_filter_fpp: Option<f64>,
+        bloom_filter_ndv: Option<u64>,
+    ) -> Self {
+        Self {
+            options: ParquetColumnOptions {
+                bloom_filter_enabled,
+                encoding,
+                dictionary_enabled,
+                compression,
+                statistics_enabled,
+                bloom_filter_fpp,
+                bloom_filter_ndv,
+            },
+        }
+    }
+}
 
 /// A PyDataFrame is a representation of a logical plan and an API to compose statements.
 /// Use it to build a plan and `.collect()` to execute the plan and collect the result.
 /// The actual execution of a plan runs natively on Rust and Arrow on a multi-threaded environment.
-#[pyclass(name = "DataFrame", module = "datafusion", subclass)]
+#[pyclass(
+    from_py_object,
+    name = "DataFrame",
+    module = "datafusion",
+    subclass,
+    frozen
+)]
 #[derive(Clone)]
-pub(crate) struct PyDataFrame {
+pub struct PyDataFrame {
     df: Arc<DataFrame>,
+
+    // In IPython environment cache batches between __repr__ and _repr_html_ calls.
+    batches: SharedCachedBatches,
 }
 
 impl PyDataFrame {
     /// creates a new PyDataFrame
     pub fn new(df: DataFrame) -> Self {
-        Self { df: Arc::new(df) }
+        Self {
+            df: Arc::new(df),
+            batches: Arc::new(Mutex::new(None)),
+        }
+    }
+
+    /// Return a clone of the inner Arc<DataFrame> for crate-local callers.
+    pub(crate) fn inner_df(&self) -> Arc<DataFrame> {
+        Arc::clone(&self.df)
+    }
+
+    fn prepare_repr_string<'py>(
+        &self,
+        py: Python<'py>,
+        as_html: bool,
+    ) -> PyDataFusionResult<String> {
+        // Get the Python formatter and config
+        let PythonFormatter { formatter, config } = get_python_formatter_with_config(py)?;
+
+        let is_ipython = *is_ipython_env(py);
+
+        let (cached_batches, should_cache) = {
+            let mut cache = self.batches.lock();
+            let should_cache = is_ipython && cache.is_none();
+            let batches = cache.take();
+            (batches, should_cache)
+        };
+
+        let (batches, has_more) = match cached_batches {
+            Some(b) => b,
+            None => wait_for_future(
+                py,
+                collect_record_batches_to_display(self.df.as_ref().clone(), config),
+            )??,
+        };
+
+        if batches.is_empty() {
+            // This should not be reached, but do it for safety since we index into the vector below
+            return Ok("No data to display".to_string());
+        }
+
+        let table_uuid = uuid::Uuid::new_v4().to_string();
+
+        // Convert record batches to Py<PyAny> list
+        let py_batches = batches
+            .iter()
+            .map(|rb| rb.to_pyarrow(py))
+            .collect::<PyResult<Vec<Bound<'py, PyAny>>>>()?;
+
+        let py_schema = self.schema().into_pyobject(py)?;
+
+        let kwargs = pyo3::types::PyDict::new(py);
+        let py_batches_list = PyList::new(py, py_batches.as_slice())?;
+        kwargs.set_item("batches", py_batches_list)?;
+        kwargs.set_item("schema", py_schema)?;
+        kwargs.set_item("has_more", has_more)?;
+        kwargs.set_item("table_uuid", table_uuid)?;
+
+        let method_name = match as_html {
+            true => "format_html",
+            false => "format_str",
+        };
+
+        let html_result = formatter.call_method(method_name, (), Some(&kwargs))?;
+        let html_str: String = html_result.extract()?;
+
+        if should_cache {
+            let mut cache = self.batches.lock();
+            *cache = Some((batches.clone(), has_more));
+        }
+
+        Ok(html_str)
+    }
+
+    async fn collect_column_inner(&self, column: &str) -> Result<ArrayRef, DataFusionError> {
+        let batches = self
+            .df
+            .as_ref()
+            .clone()
+            .select_columns(&[column])?
+            .collect()
+            .await?;
+
+        let arrays = batches
+            .iter()
+            .map(|b| b.column(0).as_ref())
+            .collect::<Vec<_>>();
+
+        arrow_select::concat::concat(&arrays).map_err(Into::into)
+    }
+}
+
+/// Synchronous wrapper around partitioned [`SendableRecordBatchStream`]s used
+/// for the `__arrow_c_stream__` implementation.
+///
+/// It drains each partition's stream sequentially, yielding record batches in
+/// their original partition order. When a `projection` is set, each batch is
+/// converted via `record_batch_into_schema` to apply schema changes per batch.
+struct PartitionedDataFrameStreamReader {
+    streams: Vec<SendableRecordBatchStream>,
+    schema: SchemaRef,
+    projection: Option<SchemaRef>,
+    current: usize,
+}
+
+impl Iterator for PartitionedDataFrameStreamReader {
+    type Item = Result<RecordBatch, ArrowError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        while self.current < self.streams.len() {
+            let stream = &mut self.streams[self.current];
+            let fut = poll_next_batch(stream);
+            let result = Python::attach(|py| wait_for_future(py, fut));
+
+            match result {
+                Ok(Ok(Some(batch))) => {
+                    let batch = if let Some(ref schema) = self.projection {
+                        match record_batch_into_schema(batch, schema.as_ref()) {
+                            Ok(b) => b,
+                            Err(e) => return Some(Err(e)),
+                        }
+                    } else {
+                        batch
+                    };
+                    return Some(Ok(batch));
+                }
+                Ok(Ok(None)) => {
+                    self.current += 1;
+                    continue;
+                }
+                Ok(Err(e)) => {
+                    return Some(Err(ArrowError::ExternalError(Box::new(e))));
+                }
+                Err(e) => {
+                    return Some(Err(ArrowError::ExternalError(Box::new(e))));
+                }
+            }
+        }
+
+        None
+    }
+}
+
+impl RecordBatchReader for PartitionedDataFrameStreamReader {
+    fn schema(&self) -> SchemaRef {
+        self.schema.clone()
     }
 }
 
 #[pymethods]
 impl PyDataFrame {
-    fn __getitem__(&self, key: PyObject) -> PyResult<Self> {
-        Python::with_gil(|py| {
-            if let Ok(key) = key.extract::<&str>(py) {
-                self.select_columns(vec![key])
-            } else if let Ok(tuple) = key.extract::<&PyTuple>(py) {
-                let keys = tuple
-                    .iter()
-                    .map(|item| item.extract::<&str>())
-                    .collect::<PyResult<Vec<&str>>>()?;
-                self.select_columns(keys)
-            } else if let Ok(keys) = key.extract::<Vec<&str>>(py) {
-                self.select_columns(keys)
-            } else {
-                let message = "DataFrame can only be indexed by string index or indices";
-                Err(PyTypeError::new_err(message))
-            }
-        })
+    /// Enable selection for `df[col]`, `df[col1, col2, col3]`, and `df[[col1, col2, col3]]`
+    fn __getitem__(&self, key: Bound<'_, PyAny>) -> PyDataFusionResult<Self> {
+        if let Ok(key) = key.extract::<PyBackedStr>() {
+            // df[col]
+            self.select_columns(vec![key])
+        } else if let Ok(tuple) = key.cast::<PyTuple>() {
+            // df[col1, col2, col3]
+            let keys = tuple
+                .iter()
+                .map(|item| item.extract::<PyBackedStr>())
+                .collect::<PyResult<Vec<PyBackedStr>>>()?;
+            self.select_columns(keys)
+        } else if let Ok(keys) = key.extract::<Vec<PyBackedStr>>() {
+            // df[[col1, col2, col3]]
+            self.select_columns(keys)
+        } else {
+            let message = "DataFrame can only be indexed by string index or indices".to_string();
+            Err(PyDataFusionError::Common(message))
+        }
     }
 
-    fn __repr__(&self, py: Python) -> PyResult<String> {
-        let df = self.df.as_ref().clone().limit(0, Some(10))?;
-        let batches = wait_for_future(py, df.collect())?;
-        let batches_as_string = pretty::pretty_format_batches(&batches);
-        match batches_as_string {
-            Ok(batch) => Ok(format!("DataFrame()\n{batch}")),
-            Err(err) => Ok(format!("Error: {:?}", err.to_string())),
+    fn __repr__(&self, py: Python) -> PyDataFusionResult<String> {
+        self.prepare_repr_string(py, false)
+    }
+
+    #[staticmethod]
+    #[expect(unused_variables)]
+    fn default_str_repr<'py>(
+        batches: Vec<Bound<'py, PyAny>>,
+        schema: &Bound<'py, PyAny>,
+        has_more: bool,
+        table_uuid: &str,
+    ) -> PyResult<String> {
+        let batches = batches
+            .into_iter()
+            .map(|batch| RecordBatch::from_pyarrow_bound(&batch))
+            .collect::<PyResult<Vec<RecordBatch>>>()?
+            .into_iter()
+            .filter(|batch| batch.num_rows() > 0)
+            .collect::<Vec<_>>();
+
+        if batches.is_empty() {
+            return Ok("No data to display".to_owned());
         }
+
+        let batches_as_displ =
+            pretty::pretty_format_batches(&batches).map_err(py_datafusion_err)?;
+
+        let additional_str = match has_more {
+            true => "\nData truncated.",
+            false => "",
+        };
+
+        Ok(format!("DataFrame()\n{batches_as_displ}{additional_str}"))
+    }
+
+    fn _repr_html_(&self, py: Python) -> PyDataFusionResult<String> {
+        self.prepare_repr_string(py, true)
+    }
+
+    /// Calculate summary statistics for a DataFrame
+    fn describe(&self, py: Python) -> PyDataFusionResult<Self> {
+        let df = self.df.as_ref().clone();
+        let stat_df = wait_for_future(py, df.describe())??;
+        Ok(Self::new(stat_df))
     }
 
     /// Returns the schema from the logical plan
     fn schema(&self) -> PyArrowType<Schema> {
-        PyArrowType(self.df.schema().into())
+        PyArrowType(self.df.schema().as_arrow().clone())
+    }
+
+    /// Convert this DataFrame into a Table Provider that can be used in register_table
+    /// By convention, into_... methods consume self and return the new object.
+    /// Disabling the clippy lint, so we can use &self
+    /// because we're working with Python bindings
+    /// where objects are shared
+    #[allow(clippy::wrong_self_convention)]
+    pub fn into_view(&self, temporary: bool) -> PyDataFusionResult<PyTable> {
+        let table_provider = if temporary {
+            Arc::new(TempViewTable::new(Arc::clone(&self.df))) as Arc<dyn TableProvider>
+        } else {
+            // Call the underlying Rust DataFrame::into_view method.
+            // Note that the Rust method consumes self; here we clone the inner Arc<DataFrame>
+            // so that we don't invalidate this PyDataFrame.
+            self.df.as_ref().clone().into_view()
+        };
+        Ok(PyTable::from(table_provider))
     }
 
     #[pyo3(signature = (*args))]
-    fn select_columns(&self, args: Vec<&str>) -> PyResult<Self> {
+    fn select_columns(&self, args: Vec<PyBackedStr>) -> PyDataFusionResult<Self> {
+        let args = args.iter().map(|s| s.as_ref()).collect::<Vec<&str>>();
         let df = self.df.as_ref().clone().select_columns(&args)?;
         Ok(Self::new(df))
     }
 
     #[pyo3(signature = (*args))]
-    fn select(&self, args: Vec<PyExpr>) -> PyResult<Self> {
-        let expr = args.into_iter().map(|e| e.into()).collect();
+    fn select_exprs(&self, args: Vec<PyBackedStr>) -> PyDataFusionResult<Self> {
+        let args = args.iter().map(|s| s.as_ref()).collect::<Vec<&str>>();
+        let df = self.df.as_ref().clone().select_exprs(&args)?;
+        Ok(Self::new(df))
+    }
+
+    #[pyo3(signature = (*args))]
+    fn select(&self, args: Vec<PyExpr>) -> PyDataFusionResult<Self> {
+        let expr: Vec<Expr> = args.into_iter().map(|e| e.into()).collect();
         let df = self.df.as_ref().clone().select(expr)?;
         Ok(Self::new(df))
     }
 
-    fn filter(&self, predicate: PyExpr) -> PyResult<Self> {
+    #[pyo3(signature = (*args))]
+    fn drop(&self, args: Vec<PyBackedStr>) -> PyDataFusionResult<Self> {
+        let cols = args.iter().map(|s| s.as_ref()).collect::<Vec<&str>>();
+        let df = self.df.as_ref().clone().drop_columns(&cols)?;
+        Ok(Self::new(df))
+    }
+
+    fn filter(&self, predicate: PyExpr) -> PyDataFusionResult<Self> {
         let df = self.df.as_ref().clone().filter(predicate.into())?;
         Ok(Self::new(df))
     }
 
-    fn with_column(&self, name: &str, expr: PyExpr) -> PyResult<Self> {
+    fn parse_sql_expr(&self, expr: PyBackedStr) -> PyDataFusionResult<PyExpr> {
+        self.df
+            .as_ref()
+            .parse_sql_expr(&expr)
+            .map(PyExpr::from)
+            .map_err(PyDataFusionError::from)
+    }
+
+    fn with_column(&self, name: &str, expr: PyExpr) -> PyDataFusionResult<Self> {
         let df = self.df.as_ref().clone().with_column(name, expr.into())?;
         Ok(Self::new(df))
     }
 
+    fn with_columns(&self, exprs: Vec<PyExpr>) -> PyDataFusionResult<Self> {
+        let mut df = self.df.as_ref().clone();
+        for expr in exprs {
+            let expr: Expr = expr.into();
+            let name = format!("{}", expr.schema_name());
+            df = df.with_column(name.as_str(), expr)?
+        }
+        Ok(Self::new(df))
+    }
+
     /// Rename one column by applying a new projection. This is a no-op if the column to be
     /// renamed does not exist.
-    fn with_column_renamed(&self, old_name: &str, new_name: &str) -> PyResult<Self> {
+    fn with_column_renamed(&self, old_name: &str, new_name: &str) -> PyDataFusionResult<Self> {
         let df = self
             .df
             .as_ref()
@@ -115,7 +622,7 @@ impl PyDataFrame {
         Ok(Self::new(df))
     }
 
-    fn aggregate(&self, group_by: Vec<PyExpr>, aggs: Vec<PyExpr>) -> PyResult<Self> {
+    fn aggregate(&self, group_by: Vec<PyExpr>, aggs: Vec<PyExpr>) -> PyDataFusionResult<Self> {
         let group_by = group_by.into_iter().map(|e| e.into()).collect();
         let aggs = aggs.into_iter().map(|e| e.into()).collect();
         let df = self.df.as_ref().clone().aggregate(group_by, aggs)?;
@@ -123,37 +630,40 @@ impl PyDataFrame {
     }
 
     #[pyo3(signature = (*exprs))]
-    fn sort(&self, exprs: Vec<PyExpr>) -> PyResult<Self> {
-        let exprs = exprs.into_iter().map(|e| e.into()).collect();
+    fn sort(&self, exprs: Vec<PySortExpr>) -> PyDataFusionResult<Self> {
+        let exprs = to_sort_expressions(exprs);
         let df = self.df.as_ref().clone().sort(exprs)?;
         Ok(Self::new(df))
     }
 
-    fn limit(&self, count: usize) -> PyResult<Self> {
-        let df = self.df.as_ref().clone().limit(0, Some(count))?;
+    #[pyo3(signature = (count, offset=0))]
+    fn limit(&self, count: usize, offset: usize) -> PyDataFusionResult<Self> {
+        let df = self.df.as_ref().clone().limit(offset, Some(count))?;
         Ok(Self::new(df))
     }
 
     /// Executes the plan, returning a list of `RecordBatch`es.
     /// Unless some order is specified in the plan, there is no
     /// guarantee of the order of the result.
-    fn collect(&self, py: Python) -> PyResult<Vec<PyObject>> {
-        let batches = wait_for_future(py, self.df.as_ref().clone().collect())?;
+    fn collect<'py>(&self, py: Python<'py>) -> PyResult<Vec<Bound<'py, PyAny>>> {
+        let batches = wait_for_future(py, self.df.as_ref().clone().collect())?
+            .map_err(PyDataFusionError::from)?;
         // cannot use PyResult<Vec<RecordBatch>> return type due to
         // https://github.com/PyO3/pyo3/issues/1813
         batches.into_iter().map(|rb| rb.to_pyarrow(py)).collect()
     }
 
     /// Cache DataFrame.
-    fn cache(&self, py: Python) -> PyResult<Self> {
-        let df = wait_for_future(py, self.df.as_ref().clone().cache())?;
+    fn cache(&self, py: Python) -> PyDataFusionResult<Self> {
+        let df = wait_for_future(py, self.df.as_ref().clone().cache())??;
         Ok(Self::new(df))
     }
 
     /// Executes this DataFrame and collects all results into a vector of vector of RecordBatch
     /// maintaining the input partitioning.
-    fn collect_partitioned(&self, py: Python) -> PyResult<Vec<Vec<PyObject>>> {
-        let batches = wait_for_future(py, self.df.as_ref().clone().collect_partitioned())?;
+    fn collect_partitioned<'py>(&self, py: Python<'py>) -> PyResult<Vec<Vec<Bound<'py, PyAny>>>> {
+        let batches = wait_for_future(py, self.df.as_ref().clone().collect_partitioned())?
+            .map_err(PyDataFusionError::from)?;
 
         batches
             .into_iter()
@@ -161,16 +671,22 @@ impl PyDataFrame {
             .collect()
     }
 
+    fn collect_column<'py>(&self, py: Python<'py>, column: &str) -> PyResult<Bound<'py, PyAny>> {
+        wait_for_future(py, self.collect_column_inner(column))?
+            .map_err(PyDataFusionError::from)?
+            .to_data()
+            .to_pyarrow(py)
+    }
+
     /// Print the result, 20 lines by default
     #[pyo3(signature = (num=20))]
-    fn show(&self, py: Python, num: usize) -> PyResult<()> {
+    fn show(&self, py: Python, num: usize) -> PyDataFusionResult<()> {
         let df = self.df.as_ref().clone().limit(0, Some(num))?;
-        let batches = wait_for_future(py, df.collect())?;
-        pretty::print_batches(&batches).map_err(|err| PyArrowException::new_err(err.to_string()))
+        print_dataframe(py, df)
     }
 
     /// Filter out duplicate rows
-    fn distinct(&self) -> PyResult<Self> {
+    fn distinct(&self) -> PyDataFusionResult<Self> {
         let df = self.df.as_ref().clone().distinct()?;
         Ok(Self::new(df))
     }
@@ -178,9 +694,11 @@ impl PyDataFrame {
     fn join(
         &self,
         right: PyDataFrame,
-        join_keys: (Vec<&str>, Vec<&str>),
         how: &str,
-    ) -> PyResult<Self> {
+        left_on: Vec<PyBackedStr>,
+        right_on: Vec<PyBackedStr>,
+        coalesce_keys: bool,
+    ) -> PyDataFusionResult<Self> {
         let join_type = match how {
             "inner" => JoinType::Inner,
             "left" => JoinType::Left,
@@ -189,29 +707,108 @@ impl PyDataFrame {
             "semi" => JoinType::LeftSemi,
             "anti" => JoinType::LeftAnti,
             how => {
-                return Err(DataFusionError::Common(format!(
+                return Err(PyDataFusionError::Common(format!(
                     "The join type {how} does not exist or is not implemented"
-                ))
-                .into());
+                )));
             }
         };
 
-        let df = self.df.as_ref().clone().join(
+        let left_keys = left_on.iter().map(|s| s.as_ref()).collect::<Vec<&str>>();
+        let right_keys = right_on.iter().map(|s| s.as_ref()).collect::<Vec<&str>>();
+
+        let mut df = self.df.as_ref().clone().join(
             right.df.as_ref().clone(),
             join_type,
-            &join_keys.0,
-            &join_keys.1,
+            &left_keys,
+            &right_keys,
             None,
         )?;
+
+        if coalesce_keys {
+            let mutual_keys = left_keys
+                .iter()
+                .zip(right_keys.iter())
+                .filter(|(l, r)| l == r)
+                .map(|(key, _)| *key)
+                .collect::<Vec<_>>();
+
+            let fields_to_coalesce = mutual_keys
+                .iter()
+                .map(|name| {
+                    let qualified_fields = df
+                        .logical_plan()
+                        .schema()
+                        .qualified_fields_with_unqualified_name(name);
+                    (*name, qualified_fields)
+                })
+                .filter(|(_, fields)| fields.len() == 2)
+                .collect::<Vec<_>>();
+
+            let expr: Vec<Expr> = df
+                .logical_plan()
+                .schema()
+                .fields()
+                .into_iter()
+                .enumerate()
+                .map(|(idx, _)| df.logical_plan().schema().qualified_field(idx))
+                .filter_map(|(qualifier, field)| {
+                    if let Some((key_name, qualified_fields)) = fields_to_coalesce
+                        .iter()
+                        .find(|(_, qf)| qf.contains(&(qualifier, field)))
+                    {
+                        // Only add the coalesce expression once (when we encounter the first field)
+                        // Skip the second field (it's already included in to coalesce)
+                        if (qualifier, field) == qualified_fields[0] {
+                            let left_col = Expr::Column(Column::from(qualified_fields[0]));
+                            let right_col = Expr::Column(Column::from(qualified_fields[1]));
+                            return Some(coalesce(vec![left_col, right_col]).alias(*key_name));
+                        }
+                        None
+                    } else {
+                        Some(Expr::Column(Column::from((qualifier, field))))
+                    }
+                })
+                .collect();
+            df = df.select(expr)?;
+        }
+
+        Ok(Self::new(df))
+    }
+
+    fn join_on(
+        &self,
+        right: PyDataFrame,
+        on_exprs: Vec<PyExpr>,
+        how: &str,
+    ) -> PyDataFusionResult<Self> {
+        let join_type = match how {
+            "inner" => JoinType::Inner,
+            "left" => JoinType::Left,
+            "right" => JoinType::Right,
+            "full" => JoinType::Full,
+            "semi" => JoinType::LeftSemi,
+            "anti" => JoinType::LeftAnti,
+            how => {
+                return Err(PyDataFusionError::Common(format!(
+                    "The join type {how} does not exist or is not implemented"
+                )));
+            }
+        };
+        let exprs: Vec<Expr> = on_exprs.into_iter().map(|e| e.into()).collect();
+
+        let df = self
+            .df
+            .as_ref()
+            .clone()
+            .join_on(right.df.as_ref().clone(), join_type, exprs)?;
         Ok(Self::new(df))
     }
 
     /// Print the query plan
     #[pyo3(signature = (verbose=false, analyze=false))]
-    fn explain(&self, py: Python, verbose: bool, analyze: bool) -> PyResult<()> {
+    fn explain(&self, py: Python, verbose: bool, analyze: bool) -> PyDataFusionResult<()> {
         let df = self.df.as_ref().clone().explain(verbose, analyze)?;
-        let batches = wait_for_future(py, df.collect())?;
-        pretty::print_batches(&batches).map_err(|err| PyArrowException::new_err(err.to_string()))
+        print_dataframe(py, df)
     }
 
     /// Get the logical plan for this `DataFrame`
@@ -220,18 +817,18 @@ impl PyDataFrame {
     }
 
     /// Get the optimized logical plan for this `DataFrame`
-    fn optimized_logical_plan(&self) -> PyResult<PyLogicalPlan> {
+    fn optimized_logical_plan(&self) -> PyDataFusionResult<PyLogicalPlan> {
         Ok(self.df.as_ref().clone().into_optimized_plan()?.into())
     }
 
     /// Get the execution plan for this `DataFrame`
-    fn execution_plan(&self, py: Python) -> PyResult<PyExecutionPlan> {
-        let plan = wait_for_future(py, self.df.as_ref().clone().create_physical_plan())?;
+    fn execution_plan(&self, py: Python) -> PyDataFusionResult<PyExecutionPlan> {
+        let plan = wait_for_future(py, self.df.as_ref().clone().create_physical_plan())??;
         Ok(plan.into())
     }
 
     /// Repartition a `DataFrame` based on a logical partitioning scheme.
-    fn repartition(&self, num: usize) -> PyResult<Self> {
+    fn repartition(&self, num: usize) -> PyDataFusionResult<Self> {
         let new_df = self
             .df
             .as_ref()
@@ -242,7 +839,7 @@ impl PyDataFrame {
 
     /// Repartition a `DataFrame` based on a logical partitioning scheme.
     #[pyo3(signature = (*args, num))]
-    fn repartition_by_hash(&self, args: Vec<PyExpr>, num: usize) -> PyResult<Self> {
+    fn repartition_by_hash(&self, args: Vec<PyExpr>, num: usize) -> PyDataFusionResult<Self> {
         let expr = args.into_iter().map(|py_expr| py_expr.into()).collect();
         let new_df = self
             .df
@@ -255,7 +852,7 @@ impl PyDataFrame {
     /// Calculate the union of two `DataFrame`s, preserving duplicate rows.The
     /// two `DataFrame`s must have exactly the same schema
     #[pyo3(signature = (py_df, distinct=false))]
-    fn union(&self, py_df: PyDataFrame, distinct: bool) -> PyResult<Self> {
+    fn union(&self, py_df: PyDataFrame, distinct: bool) -> PyDataFusionResult<Self> {
         let new_df = if distinct {
             self.df
                 .as_ref()
@@ -270,7 +867,7 @@ impl PyDataFrame {
 
     /// Calculate the distinct union of two `DataFrame`s.  The
     /// two `DataFrame`s must have exactly the same schema
-    fn union_distinct(&self, py_df: PyDataFrame) -> PyResult<Self> {
+    fn union_distinct(&self, py_df: PyDataFrame) -> PyDataFusionResult<Self> {
         let new_df = self
             .df
             .as_ref()
@@ -279,8 +876,39 @@ impl PyDataFrame {
         Ok(Self::new(new_df))
     }
 
+    #[pyo3(signature = (column, preserve_nulls=true))]
+    fn unnest_column(&self, column: &str, preserve_nulls: bool) -> PyDataFusionResult<Self> {
+        // TODO: expose RecursionUnnestOptions
+        // REF: https://github.com/apache/datafusion/pull/11577
+        let unnest_options = UnnestOptions::default().with_preserve_nulls(preserve_nulls);
+        let df = self
+            .df
+            .as_ref()
+            .clone()
+            .unnest_columns_with_options(&[column], unnest_options)?;
+        Ok(Self::new(df))
+    }
+
+    #[pyo3(signature = (columns, preserve_nulls=true))]
+    fn unnest_columns(
+        &self,
+        columns: Vec<String>,
+        preserve_nulls: bool,
+    ) -> PyDataFusionResult<Self> {
+        // TODO: expose RecursionUnnestOptions
+        // REF: https://github.com/apache/datafusion/pull/11577
+        let unnest_options = UnnestOptions::default().with_preserve_nulls(preserve_nulls);
+        let cols = columns.iter().map(|s| s.as_ref()).collect::<Vec<&str>>();
+        let df = self
+            .df
+            .as_ref()
+            .clone()
+            .unnest_columns_with_options(&cols, unnest_options)?;
+        Ok(Self::new(df))
+    }
+
     /// Calculate the intersection of two `DataFrame`s.  The two `DataFrame`s must have exactly the same schema
-    fn intersect(&self, py_df: PyDataFrame) -> PyResult<Self> {
+    fn intersect(&self, py_df: PyDataFrame) -> PyDataFusionResult<Self> {
         let new_df = self
             .df
             .as_ref()
@@ -290,95 +918,555 @@ impl PyDataFrame {
     }
 
     /// Calculate the exception of two `DataFrame`s.  The two `DataFrame`s must have exactly the same schema
-    fn except_all(&self, py_df: PyDataFrame) -> PyResult<Self> {
+    fn except_all(&self, py_df: PyDataFrame) -> PyDataFusionResult<Self> {
         let new_df = self.df.as_ref().clone().except(py_df.df.as_ref().clone())?;
         Ok(Self::new(new_df))
     }
 
     /// Write a `DataFrame` to a CSV file.
-    fn write_csv(&self, path: &str, py: Python) -> PyResult<()> {
-        wait_for_future(py, self.df.as_ref().clone().write_csv(path))?;
+    fn write_csv(
+        &self,
+        py: Python,
+        path: &str,
+        with_header: bool,
+        write_options: Option<PyDataFrameWriteOptions>,
+    ) -> PyDataFusionResult<()> {
+        let csv_options = CsvOptions {
+            has_header: Some(with_header),
+            ..Default::default()
+        };
+        let write_options = write_options
+            .map(DataFrameWriteOptions::from)
+            .unwrap_or_default();
+
+        wait_for_future(
+            py,
+            self.df
+                .as_ref()
+                .clone()
+                .write_csv(path, write_options, Some(csv_options)),
+        )??;
         Ok(())
     }
 
     /// Write a `DataFrame` to a Parquet file.
-    fn write_parquet(&self, path: &str, py: Python) -> PyResult<()> {
-        wait_for_future(py, self.df.as_ref().clone().write_parquet(path, None))?;
+    #[pyo3(signature = (
+        path,
+        compression="zstd",
+        compression_level=None,
+        write_options=None,
+        ))]
+    fn write_parquet(
+        &self,
+        path: &str,
+        compression: &str,
+        compression_level: Option<u32>,
+        write_options: Option<PyDataFrameWriteOptions>,
+        py: Python,
+    ) -> PyDataFusionResult<()> {
+        fn verify_compression_level(cl: Option<u32>) -> Result<u32, PyErr> {
+            cl.ok_or(PyValueError::new_err("compression_level is not defined"))
+        }
+
+        let _validated = match compression.to_lowercase().as_str() {
+            "snappy" => Compression::SNAPPY,
+            "gzip" => Compression::GZIP(
+                GzipLevel::try_new(compression_level.unwrap_or(6))
+                    .map_err(|e| PyValueError::new_err(format!("{e}")))?,
+            ),
+            "brotli" => Compression::BROTLI(
+                BrotliLevel::try_new(verify_compression_level(compression_level)?)
+                    .map_err(|e| PyValueError::new_err(format!("{e}")))?,
+            ),
+            "zstd" => Compression::ZSTD(
+                ZstdLevel::try_new(verify_compression_level(compression_level)? as i32)
+                    .map_err(|e| PyValueError::new_err(format!("{e}")))?,
+            ),
+            "lzo" => Compression::LZO,
+            "lz4" => Compression::LZ4,
+            "lz4_raw" => Compression::LZ4_RAW,
+            "uncompressed" => Compression::UNCOMPRESSED,
+            _ => {
+                return Err(PyDataFusionError::Common(format!(
+                    "Unrecognized compression type {compression}"
+                )));
+            }
+        };
+
+        let mut compression_string = compression.to_string();
+        if let Some(level) = compression_level {
+            compression_string.push_str(&format!("({level})"));
+        }
+
+        let mut options = TableParquetOptions::default();
+        options.global.compression = Some(compression_string);
+        let write_options = write_options
+            .map(DataFrameWriteOptions::from)
+            .unwrap_or_default();
+
+        wait_for_future(
+            py,
+            self.df
+                .as_ref()
+                .clone()
+                .write_parquet(path, write_options, Option::from(options)),
+        )??;
+        Ok(())
+    }
+
+    /// Write a `DataFrame` to a Parquet file, using advanced options.
+    fn write_parquet_with_options(
+        &self,
+        path: &str,
+        options: PyParquetWriterOptions,
+        column_specific_options: HashMap<String, PyParquetColumnOptions>,
+        write_options: Option<PyDataFrameWriteOptions>,
+        py: Python,
+    ) -> PyDataFusionResult<()> {
+        let table_options = TableParquetOptions {
+            global: options.options,
+            column_specific_options: column_specific_options
+                .into_iter()
+                .map(|(k, v)| (k, v.options))
+                .collect(),
+            ..Default::default()
+        };
+        let write_options = write_options
+            .map(DataFrameWriteOptions::from)
+            .unwrap_or_default();
+        wait_for_future(
+            py,
+            self.df.as_ref().clone().write_parquet(
+                path,
+                write_options,
+                Option::from(table_options),
+            ),
+        )??;
         Ok(())
     }
 
     /// Executes a query and writes the results to a partitioned JSON file.
-    fn write_json(&self, path: &str, py: Python) -> PyResult<()> {
-        wait_for_future(py, self.df.as_ref().clone().write_json(path))?;
+    fn write_json(
+        &self,
+        path: &str,
+        py: Python,
+        write_options: Option<PyDataFrameWriteOptions>,
+    ) -> PyDataFusionResult<()> {
+        let write_options = write_options
+            .map(DataFrameWriteOptions::from)
+            .unwrap_or_default();
+        wait_for_future(
+            py,
+            self.df
+                .as_ref()
+                .clone()
+                .write_json(path, write_options, None),
+        )??;
+        Ok(())
+    }
+
+    fn write_table(
+        &self,
+        py: Python,
+        table_name: &str,
+        write_options: Option<PyDataFrameWriteOptions>,
+    ) -> PyDataFusionResult<()> {
+        let write_options = write_options
+            .map(DataFrameWriteOptions::from)
+            .unwrap_or_default();
+        wait_for_future(
+            py,
+            self.df
+                .as_ref()
+                .clone()
+                .write_table(table_name, write_options),
+        )??;
         Ok(())
     }
 
     /// Convert to Arrow Table
     /// Collect the batches and pass to Arrow Table
-    fn to_arrow_table(&self, py: Python) -> PyResult<PyObject> {
-        let batches = self.collect(py)?.to_object(py);
-        let schema: PyObject = self.schema().into_py(py);
-
-        Python::with_gil(|py| {
-            // Instantiate pyarrow Table object and use its from_batches method
-            let table_class = py.import("pyarrow")?.getattr("Table")?;
-            let args = PyTuple::new(py, &[batches, schema]);
-            let table: PyObject = table_class.call_method1("from_batches", args)?.into();
-            Ok(table)
-        })
+    fn to_arrow_table(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
+        let batches = self.collect(py)?.into_pyobject(py)?;
+
+        // only use the DataFrame's schema if there are no batches, otherwise let the schema be
+        // determined from the batches (avoids some inconsistencies with nullable columns)
+        let args = if batches.len()? == 0 {
+            let schema = self.schema().into_pyobject(py)?;
+            PyTuple::new(py, &[batches, schema])?
+        } else {
+            PyTuple::new(py, &[batches])?
+        };
+
+        // Instantiate pyarrow Table object and use its from_batches method
+        let table_class = py.import("pyarrow")?.getattr("Table")?;
+        let table: Py<PyAny> = table_class.call_method1("from_batches", args)?.into();
+        Ok(table)
+    }
+
+    #[pyo3(signature = (requested_schema=None))]
+    fn __arrow_c_stream__<'py>(
+        &'py self,
+        py: Python<'py>,
+        requested_schema: Option<Bound<'py, PyCapsule>>,
+    ) -> PyDataFusionResult<Bound<'py, PyCapsule>> {
+        let df = self.df.as_ref().clone();
+        let streams = spawn_future(py, async move { df.execute_stream_partitioned().await })?;
+
+        let mut schema: Schema = self.df.schema().to_owned().as_arrow().clone();
+        let mut projection: Option<SchemaRef> = None;
+
+        if let Some(schema_capsule) = requested_schema {
+            validate_pycapsule(&schema_capsule, "arrow_schema")?;
+
+            let data: NonNull<FFI_ArrowSchema> = schema_capsule
+                .pointer_checked(Some(c_str!("arrow_schema")))?
+                .cast();
+            let schema_ptr = unsafe { data.as_ref() };
+            let desired_schema = Schema::try_from(schema_ptr)?;
+
+            schema = project_schema(schema, desired_schema)?;
+            projection = Some(Arc::new(schema.clone()));
+        }
+
+        let schema_ref = Arc::new(schema.clone());
+
+        let reader = PartitionedDataFrameStreamReader {
+            streams,
+            schema: schema_ref,
+            projection,
+            current: 0,
+        };
+        let reader: Box<dyn RecordBatchReader + Send> = Box::new(reader);
+
+        // Create the Arrow stream and wrap it in a PyCapsule. The default
+        // destructor provided by PyO3 will drop the stream unless ownership is
+        // transferred to PyArrow during import.
+        let stream = FFI_ArrowArrayStream::new(reader);
+        let name = CString::new(ARROW_ARRAY_STREAM_NAME.to_bytes()).unwrap();
+        let capsule = PyCapsule::new(py, stream, Some(name))?;
+        Ok(capsule)
+    }
+
+    fn execute_stream(&self, py: Python) -> PyDataFusionResult<PyRecordBatchStream> {
+        let df = self.df.as_ref().clone();
+        let stream = spawn_future(py, async move { df.execute_stream().await })?;
+        Ok(PyRecordBatchStream::new(stream))
+    }
+
+    fn execute_stream_partitioned(&self, py: Python) -> PyResult<Vec<PyRecordBatchStream>> {
+        let df = self.df.as_ref().clone();
+        let streams = spawn_future(py, async move { df.execute_stream_partitioned().await })?;
+        Ok(streams.into_iter().map(PyRecordBatchStream::new).collect())
     }
 
     /// Convert to pandas dataframe with pyarrow
     /// Collect the batches, pass to Arrow Table & then convert to Pandas DataFrame
-    fn to_pandas(&self, py: Python) -> PyResult<PyObject> {
+    fn to_pandas(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
         let table = self.to_arrow_table(py)?;
 
-        Python::with_gil(|py| {
-            // See also: https://arrow.apache.org/docs/python/generated/pyarrow.Table.html#pyarrow.Table.to_pandas
-            let result = table.call_method0(py, "to_pandas")?;
-            Ok(result)
-        })
+        // See also: https://arrow.apache.org/docs/python/generated/pyarrow.Table.html#pyarrow.Table.to_pandas
+        let result = table.call_method0(py, "to_pandas")?;
+        Ok(result)
     }
 
     /// Convert to Python list using pyarrow
     /// Each list item represents one row encoded as dictionary
-    fn to_pylist(&self, py: Python) -> PyResult<PyObject> {
+    fn to_pylist(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
         let table = self.to_arrow_table(py)?;
 
-        Python::with_gil(|py| {
-            // See also: https://arrow.apache.org/docs/python/generated/pyarrow.Table.html#pyarrow.Table.to_pylist
-            let result = table.call_method0(py, "to_pylist")?;
-            Ok(result)
-        })
+        // See also: https://arrow.apache.org/docs/python/generated/pyarrow.Table.html#pyarrow.Table.to_pylist
+        let result = table.call_method0(py, "to_pylist")?;
+        Ok(result)
     }
 
     /// Convert to Python dictionary using pyarrow
     /// Each dictionary key is a column and the dictionary value represents the column values
-    fn to_pydict(&self, py: Python) -> PyResult<PyObject> {
+    fn to_pydict(&self, py: Python) -> PyResult<Py<PyAny>> {
         let table = self.to_arrow_table(py)?;
 
-        Python::with_gil(|py| {
-            // See also: https://arrow.apache.org/docs/python/generated/pyarrow.Table.html#pyarrow.Table.to_pydict
-            let result = table.call_method0(py, "to_pydict")?;
-            Ok(result)
-        })
+        // See also: https://arrow.apache.org/docs/python/generated/pyarrow.Table.html#pyarrow.Table.to_pydict
+        let result = table.call_method0(py, "to_pydict")?;
+        Ok(result)
     }
 
     /// Convert to polars dataframe with pyarrow
     /// Collect the batches, pass to Arrow Table & then convert to polars DataFrame
-    fn to_polars(&self, py: Python) -> PyResult<PyObject> {
+    fn to_polars(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
         let table = self.to_arrow_table(py)?;
-
-        Python::with_gil(|py| {
-            let dataframe = py.import("polars")?.getattr("DataFrame")?;
-            let args = PyTuple::new(py, &[table]);
-            let result: PyObject = dataframe.call1(args)?.into();
-            Ok(result)
-        })
+        let dataframe = py.import("polars")?.getattr("DataFrame")?;
+        let args = PyTuple::new(py, &[table])?;
+        let result: Py<PyAny> = dataframe.call1(args)?.into();
+        Ok(result)
     }
 
     // Executes this DataFrame to get the total number of rows.
-    fn count(&self, py: Python) -> PyResult<usize> {
-        Ok(wait_for_future(py, self.df.as_ref().clone().count())?)
+    fn count(&self, py: Python) -> PyDataFusionResult<usize> {
+        Ok(wait_for_future(py, self.df.as_ref().clone().count())??)
+    }
+
+    /// Fill null values with a specified value for specific columns
+    #[pyo3(signature = (value, columns=None))]
+    fn fill_null(
+        &self,
+        value: Py<PyAny>,
+        columns: Option<Vec<PyBackedStr>>,
+        py: Python,
+    ) -> PyDataFusionResult<Self> {
+        let scalar_value: PyScalarValue = value.extract(py)?;
+
+        let cols = match columns {
+            Some(col_names) => col_names.iter().map(|c| c.to_string()).collect(),
+            None => Vec::new(), // Empty vector means fill null for all columns
+        };
+
+        let df = self.df.as_ref().clone().fill_null(scalar_value.0, cols)?;
+        Ok(Self::new(df))
     }
 }
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    eq,
+    eq_int,
+    name = "InsertOp",
+    module = "datafusion"
+)]
+pub enum PyInsertOp {
+    APPEND,
+    REPLACE,
+    OVERWRITE,
+}
+
+impl From<PyInsertOp> for InsertOp {
+    fn from(value: PyInsertOp) -> Self {
+        match value {
+            PyInsertOp::APPEND => InsertOp::Append,
+            PyInsertOp::REPLACE => InsertOp::Replace,
+            PyInsertOp::OVERWRITE => InsertOp::Overwrite,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "DataFrameWriteOptions",
+    module = "datafusion"
+)]
+pub struct PyDataFrameWriteOptions {
+    insert_operation: InsertOp,
+    single_file_output: bool,
+    partition_by: Vec<String>,
+    sort_by: Vec<SortExpr>,
+}
+
+impl From<PyDataFrameWriteOptions> for DataFrameWriteOptions {
+    fn from(value: PyDataFrameWriteOptions) -> Self {
+        DataFrameWriteOptions::new()
+            .with_insert_operation(value.insert_operation)
+            .with_single_file_output(value.single_file_output)
+            .with_partition_by(value.partition_by)
+            .with_sort_by(value.sort_by)
+    }
+}
+
+#[pymethods]
+impl PyDataFrameWriteOptions {
+    #[new]
+    fn new(
+        insert_operation: Option<PyInsertOp>,
+        single_file_output: bool,
+        partition_by: Option<Vec<String>>,
+        sort_by: Option<Vec<PySortExpr>>,
+    ) -> Self {
+        let insert_operation = insert_operation.map(Into::into).unwrap_or(InsertOp::Append);
+        let sort_by = sort_by
+            .unwrap_or_default()
+            .into_iter()
+            .map(Into::into)
+            .collect();
+        Self {
+            insert_operation,
+            single_file_output,
+            partition_by: partition_by.unwrap_or_default(),
+            sort_by,
+        }
+    }
+}
+
+/// Print DataFrame
+fn print_dataframe(py: Python, df: DataFrame) -> PyDataFusionResult<()> {
+    // Get string representation of record batches
+    let batches = wait_for_future(py, df.collect())??;
+    let result = if batches.is_empty() {
+        "DataFrame has no rows".to_string()
+    } else {
+        match pretty::pretty_format_batches(&batches) {
+            Ok(batch) => format!("DataFrame()\n{batch}"),
+            Err(err) => format!("Error: {:?}", err.to_string()),
+        }
+    };
+
+    // Import the Python 'builtins' module to access the print function
+    // Note that println! does not print to the Python debug console and is not visible in notebooks for instance
+    let print = py.import("builtins")?.getattr("print")?;
+    print.call1((result,))?;
+    Ok(())
+}
+
+fn project_schema(from_schema: Schema, to_schema: Schema) -> Result<Schema, ArrowError> {
+    let merged_schema = Schema::try_merge(vec![from_schema, to_schema.clone()])?;
+
+    let project_indices: Vec<usize> = to_schema
+        .fields
+        .iter()
+        .map(|field| field.name())
+        .filter_map(|field_name| merged_schema.index_of(field_name).ok())
+        .collect();
+
+    merged_schema.project(&project_indices)
+}
+// NOTE: `arrow::compute::cast` in combination with `RecordBatch::try_select` or
+// DataFusion's `schema::cast_record_batch` do not fully cover the required
+// transformations here. They will not create missing columns and may insert
+// nulls for non-nullable fields without erroring. To maintain current behavior
+// we perform the casting and null checks manually.
+fn record_batch_into_schema(
+    record_batch: RecordBatch,
+    schema: &Schema,
+) -> Result<RecordBatch, ArrowError> {
+    let schema = Arc::new(schema.clone());
+    let base_schema = record_batch.schema();
+    if base_schema.fields().is_empty() {
+        // Nothing to project
+        return Ok(RecordBatch::new_empty(schema));
+    }
+
+    let array_size = record_batch.column(0).len();
+    let mut data_arrays = Vec::with_capacity(schema.fields().len());
+
+    for field in schema.fields() {
+        let desired_data_type = field.data_type();
+        if let Some(original_data) = record_batch.column_by_name(field.name()) {
+            let original_data_type = original_data.data_type();
+
+            if can_cast_types(original_data_type, desired_data_type) {
+                data_arrays.push(arrow::compute::kernels::cast(
+                    original_data,
+                    desired_data_type,
+                )?);
+            } else if field.is_nullable() {
+                data_arrays.push(new_null_array(desired_data_type, array_size));
+            } else {
+                return Err(ArrowError::CastError(format!(
+                    "Attempting to cast to non-nullable and non-castable field {} during schema projection.",
+                    field.name()
+                )));
+            }
+        } else {
+            if !field.is_nullable() {
+                return Err(ArrowError::CastError(format!(
+                    "Attempting to set null to non-nullable field {} during schema projection.",
+                    field.name()
+                )));
+            }
+            data_arrays.push(new_null_array(desired_data_type, array_size));
+        }
+    }
+
+    RecordBatch::try_new(schema, data_arrays)
+}
+
+/// This is a helper function to return the first non-empty record batch from executing a DataFrame.
+/// It additionally returns a bool, which indicates if there are more record batches available.
+/// We do this so we can determine if we should indicate to the user that the data has been
+/// truncated. This collects until we have archived both of these two conditions
+///
+/// - We have collected our minimum number of rows
+/// - We have reached our limit, either data size or maximum number of rows
+///
+/// Otherwise it will return when the stream has exhausted. If you want a specific number of
+/// rows, set min_rows == max_rows.
+async fn collect_record_batches_to_display(
+    df: DataFrame,
+    config: FormatterConfig,
+) -> Result<(Vec<RecordBatch>, bool), DataFusionError> {
+    let FormatterConfig {
+        max_bytes,
+        min_rows,
+        max_rows,
+    } = config;
+
+    let partitioned_stream = df.execute_stream_partitioned().await?;
+    let mut stream = futures::stream::iter(partitioned_stream).flatten();
+    let mut size_estimate_so_far = 0;
+    let mut rows_so_far = 0;
+    let mut record_batches = Vec::default();
+    let mut has_more = false;
+
+    // Collect rows until we hit a limit (memory or max_rows) OR reach the guaranteed minimum.
+    // The minimum rows constraint overrides both memory and row limits to ensure a baseline
+    // of data is always displayed, even if it temporarily exceeds those limits.
+    // This provides better UX by guaranteeing users see at least min_rows rows.
+    while (size_estimate_so_far < max_bytes && rows_so_far < max_rows) || rows_so_far < min_rows {
+        let mut rb = match stream.next().await {
+            None => {
+                break;
+            }
+            Some(Ok(r)) => r,
+            Some(Err(e)) => return Err(e),
+        };
+
+        let mut rows_in_rb = rb.num_rows();
+        if rows_in_rb > 0 {
+            size_estimate_so_far += rb.get_array_memory_size();
+
+            // When memory limit is exceeded, scale back row count proportionally to stay within budget
+            if size_estimate_so_far > max_bytes {
+                let ratio = max_bytes as f32 / size_estimate_so_far as f32;
+                let total_rows = rows_in_rb + rows_so_far;
+
+                // Calculate reduced rows maintaining the memory/data proportion
+                let mut reduced_row_num = (total_rows as f32 * ratio).round() as usize;
+                // Ensure we always respect the minimum rows guarantee
+                if reduced_row_num < min_rows {
+                    reduced_row_num = min_rows.min(total_rows);
+                }
+
+                let limited_rows_this_rb = reduced_row_num - rows_so_far;
+                if limited_rows_this_rb < rows_in_rb {
+                    rows_in_rb = limited_rows_this_rb;
+                    rb = rb.slice(0, limited_rows_this_rb);
+                    has_more = true;
+                }
+            }
+
+            if rows_in_rb + rows_so_far > max_rows {
+                rb = rb.slice(0, max_rows - rows_so_far);
+                has_more = true;
+            }
+
+            rows_so_far += rb.num_rows();
+            record_batches.push(rb);
+        }
+    }
+
+    if record_batches.is_empty() {
+        return Ok((Vec::default(), false));
+    }
+
+    if !has_more {
+        // Data was not already truncated, so check to see if more record batches remain
+        has_more = match stream.try_next().await {
+            Ok(None) => false, // reached end
+            Ok(Some(_)) => true,
+            Err(_) => false, // Stream disconnected
+        };
+    }
+
+    Ok((record_batches, has_more))
+}
diff --git a/src/dataset.rs b/src/dataset.rs
index 0a2c7f50f..dbeafcd9f 100644
--- a/src/dataset.rs
+++ b/src/dataset.rs
@@ -15,44 +15,42 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use pyo3::exceptions::PyValueError;
-/// Implements a Datafusion TableProvider that delegates to a PyArrow Dataset
-/// This allows us to use PyArrow Datasets as Datafusion tables while pushing down projections and filters
-use pyo3::prelude::*;
-use pyo3::types::PyType;
-
 use std::any::Any;
 use std::sync::Arc;
 
 use async_trait::async_trait;
-
 use datafusion::arrow::datatypes::SchemaRef;
 use datafusion::arrow::pyarrow::PyArrowType;
-use datafusion::datasource::datasource::TableProviderFilterPushDown;
+use datafusion::catalog::Session;
 use datafusion::datasource::{TableProvider, TableType};
 use datafusion::error::{DataFusionError, Result as DFResult};
-use datafusion::execution::context::SessionState;
+use datafusion::logical_expr::{Expr, TableProviderFilterPushDown};
 use datafusion::physical_plan::ExecutionPlan;
-use datafusion_expr::Expr;
+use pyo3::exceptions::PyValueError;
+/// Implements a Datafusion TableProvider that delegates to a PyArrow Dataset
+/// This allows us to use PyArrow Datasets as Datafusion tables while pushing down projections and filters
+use pyo3::prelude::*;
+use pyo3::types::PyType;
 
 use crate::dataset_exec::DatasetExec;
 use crate::pyarrow_filter_expression::PyArrowFilterExpression;
 
 // Wraps a pyarrow.dataset.Dataset class and implements a Datafusion TableProvider around it
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub(crate) struct Dataset {
-    dataset: PyObject,
+    dataset: Py<PyAny>,
 }
 
 impl Dataset {
     // Creates a Python PyArrow.Dataset
-    pub fn new(dataset: &PyAny, py: Python) -> PyResult<Self> {
+    pub fn new(dataset: &Bound<'_, PyAny>, py: Python) -> PyResult<Self> {
         // Ensure that we were passed an instance of pyarrow.dataset.Dataset
         let ds = PyModule::import(py, "pyarrow.dataset")?;
-        let ds_type: &PyType = ds.getattr("Dataset")?.downcast()?;
+        let ds_attr = ds.getattr("Dataset")?;
+        let ds_type = ds_attr.cast::<PyType>()?;
         if dataset.is_instance(ds_type)? {
             Ok(Dataset {
-                dataset: dataset.into(),
+                dataset: dataset.clone().unbind(),
             })
         } else {
             Err(PyValueError::new_err(
@@ -72,8 +70,8 @@ impl TableProvider for Dataset {
 
     /// Get a reference to the schema for this table
     fn schema(&self) -> SchemaRef {
-        Python::with_gil(|py| {
-            let dataset = self.dataset.as_ref(py);
+        Python::attach(|py| {
+            let dataset = self.dataset.bind(py);
             // This can panic but since we checked that self.dataset is a pyarrow.dataset.Dataset it should never
             Arc::new(
                 dataset
@@ -97,7 +95,7 @@ impl TableProvider for Dataset {
     /// parallelized or distributed.
     async fn scan(
         &self,
-        _ctx: &SessionState,
+        _ctx: &dyn Session,
         projection: Option<&Vec<usize>>,
         filters: &[Expr],
         // limit can be used to reduce the amount scanned
@@ -106,9 +104,9 @@ impl TableProvider for Dataset {
         // The datasource should return *at least* this number of rows if available.
         _limit: Option<usize>,
     ) -> DFResult<Arc<dyn ExecutionPlan>> {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let plan: Arc<dyn ExecutionPlan> = Arc::new(
-                DatasetExec::new(py, self.dataset.as_ref(py), projection.cloned(), filters)
+                DatasetExec::new(py, self.dataset.bind(py), projection.cloned(), filters)
                     .map_err(|err| DataFusionError::External(Box::new(err)))?,
             );
             Ok(plan)
@@ -117,10 +115,16 @@ impl TableProvider for Dataset {
 
     /// Tests whether the table provider can make use of a filter expression
     /// to optimise data retrieval.
-    fn supports_filter_pushdown(&self, filter: &Expr) -> DFResult<TableProviderFilterPushDown> {
-        match PyArrowFilterExpression::try_from(filter) {
-            Ok(_) => Ok(TableProviderFilterPushDown::Exact),
-            _ => Ok(TableProviderFilterPushDown::Unsupported),
-        }
+    fn supports_filters_pushdown(
+        &self,
+        filter: &[&Expr],
+    ) -> DFResult<Vec<TableProviderFilterPushDown>> {
+        filter
+            .iter()
+            .map(|&f| match PyArrowFilterExpression::try_from(f) {
+                Ok(_) => Ok(TableProviderFilterPushDown::Exact),
+                _ => Ok(TableProviderFilterPushDown::Unsupported),
+            })
+            .collect()
     }
 }
diff --git a/src/dataset_exec.rs b/src/dataset_exec.rs
index 859678856..e3c058c07 100644
--- a/src/dataset_exec.rs
+++ b/src/dataset_exec.rs
@@ -15,32 +15,31 @@
 // specific language governing permissions and limitations
 // under the License.
 
-/// Implements a Datafusion physical ExecutionPlan that delegates to a PyArrow Dataset
-/// This actually performs the projection, filtering and scanning of a Dataset
-use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyIterator, PyList};
-
 use std::any::Any;
 use std::sync::Arc;
 
-use futures::{stream, TryStreamExt};
-
 use datafusion::arrow::datatypes::SchemaRef;
-use datafusion::arrow::error::ArrowError;
-use datafusion::arrow::error::Result as ArrowResult;
+use datafusion::arrow::error::{ArrowError, Result as ArrowResult};
 use datafusion::arrow::pyarrow::PyArrowType;
 use datafusion::arrow::record_batch::RecordBatch;
 use datafusion::error::{DataFusionError as InnerDataFusionError, Result as DFResult};
 use datafusion::execution::context::TaskContext;
-use datafusion::physical_expr::PhysicalSortExpr;
+use datafusion::logical_expr::Expr;
+use datafusion::logical_expr::utils::conjunction;
+use datafusion::physical_expr::{EquivalenceProperties, LexOrdering};
+use datafusion::physical_plan::execution_plan::{Boundedness, EmissionType};
 use datafusion::physical_plan::stream::RecordBatchStreamAdapter;
 use datafusion::physical_plan::{
-    DisplayFormatType, ExecutionPlan, Partitioning, SendableRecordBatchStream, Statistics,
+    DisplayAs, DisplayFormatType, ExecutionPlan, ExecutionPlanProperties, Partitioning,
+    PlanProperties, SendableRecordBatchStream, Statistics,
 };
-use datafusion_expr::Expr;
-use datafusion_optimizer::utils::conjunction;
+use futures::{TryStreamExt, stream};
+/// Implements a Datafusion physical ExecutionPlan that delegates to a PyArrow Dataset
+/// This actually performs the projection, filtering and scanning of a Dataset
+use pyo3::prelude::*;
+use pyo3::types::{PyDict, PyIterator, PyList};
 
-use crate::errors::DataFusionError;
+use crate::errors::PyDataFusionResult;
 use crate::pyarrow_filter_expression::PyArrowFilterExpression;
 
 struct PyArrowBatchesAdapter {
@@ -51,8 +50,8 @@ impl Iterator for PyArrowBatchesAdapter {
     type Item = ArrowResult<RecordBatch>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        Python::with_gil(|py| {
-            let mut batches: &PyIterator = self.batches.as_ref(py);
+        Python::attach(|py| {
+            let mut batches = self.batches.clone_ref(py).into_bound(py);
             Some(
                 batches
                     .next()?
@@ -64,24 +63,25 @@ impl Iterator for PyArrowBatchesAdapter {
 }
 
 // Wraps a pyarrow.dataset.Dataset class and implements a Datafusion ExecutionPlan around it
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub(crate) struct DatasetExec {
-    dataset: PyObject,
+    dataset: Py<PyAny>,
     schema: SchemaRef,
     fragments: Py<PyList>,
     columns: Option<Vec<String>>,
-    filter_expr: Option<PyObject>,
+    filter_expr: Option<Py<PyAny>>,
     projected_statistics: Statistics,
+    plan_properties: Arc<PlanProperties>,
 }
 
 impl DatasetExec {
     pub fn new(
         py: Python,
-        dataset: &PyAny,
+        dataset: &Bound<'_, PyAny>,
         projection: Option<Vec<usize>>,
         filters: &[Expr],
-    ) -> Result<Self, DataFusionError> {
-        let columns: Option<Result<Vec<String>, DataFusionError>> = projection.map(|p| {
+    ) -> PyDataFusionResult<Self> {
+        let columns: Option<PyDataFusionResult<Vec<String>>> = projection.map(|p| {
             p.iter()
                 .map(|index| {
                     let name: String = dataset
@@ -94,7 +94,7 @@ impl DatasetExec {
                 .collect()
         });
         let columns: Option<Vec<String>> = columns.transpose()?;
-        let filter_expr: Option<PyObject> = conjunction(filters.to_owned())
+        let filter_expr: Option<Py<PyAny>> = conjunction(filters.to_owned())
             .map(|filters| {
                 PyArrowFilterExpression::try_from(&filters)
                     .map(|filter_expr| filter_expr.inner().clone_ref(py))
@@ -109,7 +109,7 @@ impl DatasetExec {
             filter_expr.as_ref().map(|expr| expr.clone_ref(py)),
         )?;
 
-        let scanner = dataset.call_method("scanner", (), Some(kwargs))?;
+        let scanner = dataset.call_method("scanner", (), Some(&kwargs))?;
 
         let schema = Arc::new(
             scanner
@@ -122,28 +122,40 @@ impl DatasetExec {
         let pylist = builtins.getattr("list")?;
 
         // Get the fragments or partitions of the dataset
-        let fragments_iterator: &PyAny = dataset.call_method1(
+        let fragments_iterator: Bound<'_, PyAny> = dataset.call_method1(
             "get_fragments",
             (filter_expr.as_ref().map(|expr| expr.clone_ref(py)),),
         )?;
 
-        let fragments: &PyList = pylist
-            .call1((fragments_iterator,))?
-            .downcast()
-            .map_err(PyErr::from)?;
+        let fragments_iter = pylist.call1((fragments_iterator,))?;
+        let fragments = fragments_iter.cast::<PyList>().map_err(PyErr::from)?;
+
+        let projected_statistics = Statistics::new_unknown(&schema);
+        let plan_properties = Arc::new(PlanProperties::new(
+            EquivalenceProperties::new(schema.clone()),
+            Partitioning::UnknownPartitioning(fragments.len()),
+            EmissionType::Final,
+            Boundedness::Bounded,
+        ));
 
         Ok(DatasetExec {
-            dataset: dataset.into(),
+            dataset: dataset.clone().unbind(),
             schema,
-            fragments: fragments.into(),
+            fragments: fragments.clone().unbind(),
             columns,
             filter_expr,
-            projected_statistics: Default::default(),
+            projected_statistics,
+            plan_properties,
         })
     }
 }
 
 impl ExecutionPlan for DatasetExec {
+    fn name(&self) -> &str {
+        // [ExecutionPlan::name] docs recommends forwarding to `static_name`
+        Self::static_name()
+    }
+
     /// Return a reference to Any that can be used for downcasting
     fn as_any(&self) -> &dyn Any {
         self
@@ -154,19 +166,7 @@ impl ExecutionPlan for DatasetExec {
         self.schema.clone()
     }
 
-    /// Get the output partitioning of this plan
-    fn output_partitioning(&self) -> Partitioning {
-        Python::with_gil(|py| {
-            let fragments = self.fragments.as_ref(py);
-            Partitioning::UnknownPartitioning(fragments.len())
-        })
-    }
-
-    fn output_ordering(&self) -> Option<&[PhysicalSortExpr]> {
-        None
-    }
-
-    fn children(&self) -> Vec<Arc<dyn ExecutionPlan>> {
+    fn children(&self) -> Vec<&Arc<dyn ExecutionPlan>> {
         // this is a leaf node and has no children
         vec![]
     }
@@ -184,9 +184,9 @@ impl ExecutionPlan for DatasetExec {
         context: Arc<TaskContext>,
     ) -> DFResult<SendableRecordBatchStream> {
         let batch_size = context.session_config().batch_size();
-        Python::with_gil(|py| {
-            let dataset = self.dataset.as_ref(py);
-            let fragments = self.fragments.as_ref(py);
+        Python::attach(|py| {
+            let dataset = self.dataset.bind(py);
+            let fragments = self.fragments.bind(py);
             let fragment = fragments
                 .get_item(partition)
                 .map_err(|err| InnerDataFusionError::External(Box::new(err)))?;
@@ -209,7 +209,7 @@ impl ExecutionPlan for DatasetExec {
                 .set_item("batch_size", batch_size)
                 .map_err(|err| InnerDataFusionError::External(Box::new(err)))?;
             let scanner = fragment
-                .call_method("scanner", (dataset_schema,), Some(kwargs))
+                .call_method("scanner", (dataset_schema,), Some(&kwargs))
                 .map_err(|err| InnerDataFusionError::External(Box::new(err)))?;
             let schema: SchemaRef = Arc::new(
                 scanner
@@ -217,10 +217,10 @@ impl ExecutionPlan for DatasetExec {
                     .and_then(|schema| Ok(schema.extract::<PyArrowType<_>>()?.0))
                     .map_err(|err| InnerDataFusionError::External(Box::new(err)))?,
             );
-            let record_batches: &PyIterator = scanner
+            let record_batches: Bound<'_, PyIterator> = scanner
                 .call_method0("to_batches")
                 .map_err(|err| InnerDataFusionError::External(Box::new(err)))?
-                .iter()
+                .try_iter()
                 .map_err(|err| InnerDataFusionError::External(Box::new(err)))?;
 
             let record_batches = PyArrowBatchesAdapter {
@@ -235,11 +235,46 @@ impl ExecutionPlan for DatasetExec {
         })
     }
 
+    fn partition_statistics(&self, _partition: Option<usize>) -> DFResult<Statistics> {
+        Ok(self.projected_statistics.clone())
+    }
+
+    fn properties(&self) -> &Arc<PlanProperties> {
+        &self.plan_properties
+    }
+}
+
+impl ExecutionPlanProperties for DatasetExec {
+    /// Get the output partitioning of this plan
+    fn output_partitioning(&self) -> &Partitioning {
+        self.plan_properties.output_partitioning()
+    }
+
+    fn output_ordering(&self) -> Option<&LexOrdering> {
+        None
+    }
+
+    fn boundedness(&self) -> Boundedness {
+        self.plan_properties.boundedness
+    }
+
+    fn pipeline_behavior(&self) -> EmissionType {
+        self.plan_properties.emission_type
+    }
+
+    fn equivalence_properties(&self) -> &datafusion::physical_expr::EquivalenceProperties {
+        &self.plan_properties.eq_properties
+    }
+}
+
+impl DisplayAs for DatasetExec {
     fn fmt_as(&self, t: DisplayFormatType, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        Python::with_gil(|py| {
-            let number_of_fragments = self.fragments.as_ref(py).len();
+        Python::attach(|py| {
+            let number_of_fragments = self.fragments.bind(py).len();
             match t {
-                DisplayFormatType::Default => {
+                DisplayFormatType::Default
+                | DisplayFormatType::Verbose
+                | DisplayFormatType::TreeRender => {
                     let projected_columns: Vec<String> = self
                         .schema
                         .fields()
@@ -247,7 +282,7 @@ impl ExecutionPlan for DatasetExec {
                         .map(|x| x.name().to_owned())
                         .collect();
                     if let Some(filter_expr) = &self.filter_expr {
-                        let filter_expr = filter_expr.as_ref(py).str().or(Err(std::fmt::Error))?;
+                        let filter_expr = filter_expr.bind(py).str().or(Err(std::fmt::Error))?;
                         write!(
                             f,
                             "DatasetExec: number_of_fragments={}, filter_expr={}, projection=[{}]",
@@ -267,8 +302,4 @@ impl ExecutionPlan for DatasetExec {
             }
         })
     }
-
-    fn statistics(&self) -> Statistics {
-        self.projected_statistics.clone()
-    }
 }
diff --git a/src/errors.rs b/src/errors.rs
index ce6b3c28a..0d25c8847 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -21,57 +21,61 @@ use std::fmt::Debug;
 
 use datafusion::arrow::error::ArrowError;
 use datafusion::error::DataFusionError as InnerDataFusionError;
-use pyo3::{exceptions::PyException, PyErr};
+use prost::EncodeError;
+use pyo3::PyErr;
+use pyo3::exceptions::{PyException, PyValueError};
 
-pub type Result<T> = std::result::Result<T, DataFusionError>;
+pub type PyDataFusionResult<T> = std::result::Result<T, PyDataFusionError>;
 
 #[derive(Debug)]
-pub enum DataFusionError {
-    ExecutionError(InnerDataFusionError),
+pub enum PyDataFusionError {
+    ExecutionError(Box<InnerDataFusionError>),
     ArrowError(ArrowError),
     Common(String),
     PythonError(PyErr),
+    EncodeError(EncodeError),
 }
 
-impl fmt::Display for DataFusionError {
+impl fmt::Display for PyDataFusionError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            DataFusionError::ExecutionError(e) => write!(f, "DataFusion error: {e:?}"),
-            DataFusionError::ArrowError(e) => write!(f, "Arrow error: {e:?}"),
-            DataFusionError::PythonError(e) => write!(f, "Python error {e:?}"),
-            DataFusionError::Common(e) => write!(f, "{e}"),
+            PyDataFusionError::ExecutionError(e) => write!(f, "DataFusion error: {e}"),
+            PyDataFusionError::ArrowError(e) => write!(f, "Arrow error: {e:?}"),
+            PyDataFusionError::PythonError(e) => write!(f, "Python error {e:?}"),
+            PyDataFusionError::Common(e) => write!(f, "{e}"),
+            PyDataFusionError::EncodeError(e) => write!(f, "Failed to encode substrait plan: {e}"),
         }
     }
 }
 
-impl From<ArrowError> for DataFusionError {
-    fn from(err: ArrowError) -> DataFusionError {
-        DataFusionError::ArrowError(err)
+impl From<ArrowError> for PyDataFusionError {
+    fn from(err: ArrowError) -> PyDataFusionError {
+        PyDataFusionError::ArrowError(err)
     }
 }
 
-impl From<InnerDataFusionError> for DataFusionError {
-    fn from(err: InnerDataFusionError) -> DataFusionError {
-        DataFusionError::ExecutionError(err)
+impl From<InnerDataFusionError> for PyDataFusionError {
+    fn from(err: InnerDataFusionError) -> PyDataFusionError {
+        PyDataFusionError::ExecutionError(Box::new(err))
     }
 }
 
-impl From<PyErr> for DataFusionError {
-    fn from(err: PyErr) -> DataFusionError {
-        DataFusionError::PythonError(err)
+impl From<PyErr> for PyDataFusionError {
+    fn from(err: PyErr) -> PyDataFusionError {
+        PyDataFusionError::PythonError(err)
     }
 }
 
-impl From<DataFusionError> for PyErr {
-    fn from(err: DataFusionError) -> PyErr {
+impl From<PyDataFusionError> for PyErr {
+    fn from(err: PyDataFusionError) -> PyErr {
         match err {
-            DataFusionError::PythonError(py_err) => py_err,
+            PyDataFusionError::PythonError(py_err) => py_err,
             _ => PyException::new_err(err.to_string()),
         }
     }
 }
 
-impl Error for DataFusionError {}
+impl Error for PyDataFusionError {}
 
 pub fn py_type_err(e: impl Debug) -> PyErr {
     PyErr::new::<pyo3::exceptions::PyTypeError, _>(format!("{e:?}"))
@@ -88,3 +92,17 @@ pub fn py_datafusion_err(e: impl Debug) -> PyErr {
 pub fn py_unsupported_variant_err(e: impl Debug) -> PyErr {
     PyErr::new::<pyo3::exceptions::PyValueError, _>(format!("{e:?}"))
 }
+
+pub fn to_datafusion_err(e: impl Debug) -> InnerDataFusionError {
+    InnerDataFusionError::Execution(format!("{e:?}"))
+}
+
+pub fn from_datafusion_error(err: InnerDataFusionError) -> PyErr {
+    match err {
+        InnerDataFusionError::External(boxed) => match boxed.downcast::<PyErr>() {
+            Ok(py_err) => *py_err,
+            Err(original_boxed) => PyValueError::new_err(format!("{original_boxed}")),
+        },
+        _ => PyValueError::new_err(format!("{err}")),
+    }
+}
diff --git a/src/expr.rs b/src/expr.rs
index 7c80d0d82..c4f2a12da 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -15,19 +15,26 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use pyo3::{basic::CompareOp, prelude::*};
+use std::collections::HashMap;
 use std::convert::{From, Into};
+use std::sync::Arc;
 
-use datafusion::arrow::datatypes::DataType;
+use datafusion::arrow::datatypes::{DataType, Field};
 use datafusion::arrow::pyarrow::PyArrowType;
-use datafusion_expr::{col, lit, Cast, Expr, GetIndexedField};
-
-use crate::errors::py_runtime_err;
-use crate::expr::aggregate_expr::PyAggregateFunction;
-use crate::expr::binary_expr::PyBinaryExpr;
-use crate::expr::column::PyColumn;
-use crate::expr::literal::PyLiteral;
-use datafusion::scalar::ScalarValue;
+use datafusion::functions::core::expr_ext::FieldAccessor;
+use datafusion::logical_expr::expr::{
+    AggregateFunction, AggregateFunctionParams, FieldMetadata, InList, InSubquery, ScalarFunction,
+    SetComparison, WindowFunction,
+};
+use datafusion::logical_expr::utils::exprlist_to_fields;
+use datafusion::logical_expr::{
+    Between, BinaryExpr, Case, Cast, Expr, ExprFuncBuilder, ExprFunctionExt, Like, LogicalPlan,
+    Operator, TryCast, WindowFunctionDefinition, col, lit, lit_with_metadata,
+};
+use pyo3::IntoPyObjectExt;
+use pyo3::basic::CompareOp;
+use pyo3::prelude::*;
+use window::PyWindowFrame;
 
 use self::alias::PyAlias;
 use self::bool_expr::{
@@ -36,6 +43,15 @@ use self::bool_expr::{
 };
 use self::like::{PyILike, PyLike, PySimilarTo};
 use self::scalar_variable::PyScalarVariable;
+use crate::common::data_type::{DataTypeMap, NullTreatment, PyScalarValue, RexType};
+use crate::errors::{PyDataFusionResult, py_runtime_err, py_type_err, py_unsupported_variant_err};
+use crate::expr::aggregate_expr::PyAggregateFunction;
+use crate::expr::binary_expr::PyBinaryExpr;
+use crate::expr::column::PyColumn;
+use crate::expr::literal::PyLiteral;
+use crate::functions::add_builder_fns_to_window;
+use crate::pyarrow_util::scalar_to_pyarrow;
+use crate::sql::logical::PyLogicalPlan;
 
 pub mod aggregate;
 pub mod aggregate_expr;
@@ -47,11 +63,22 @@ pub mod bool_expr;
 pub mod case;
 pub mod cast;
 pub mod column;
+pub mod conditional_expr;
+pub mod copy_to;
+pub mod create_catalog;
+pub mod create_catalog_schema;
+pub mod create_external_table;
+pub mod create_function;
+pub mod create_index;
 pub mod create_memory_table;
 pub mod create_view;
-pub mod cross_join;
+pub mod describe_table;
 pub mod distinct;
+pub mod dml;
+pub mod drop_catalog_schema;
+pub mod drop_function;
 pub mod drop_table;
+pub mod drop_view;
 pub mod empty_relation;
 pub mod exists;
 pub mod explain;
@@ -60,7 +87,6 @@ pub mod filter;
 pub mod grouping_set;
 pub mod in_list;
 pub mod in_subquery;
-pub mod indexed_field;
 pub mod join;
 pub mod like;
 pub mod limit;
@@ -68,22 +94,37 @@ pub mod literal;
 pub mod logical_node;
 pub mod placeholder;
 pub mod projection;
+pub mod recursive_query;
 pub mod repartition;
-pub mod scalar_function;
 pub mod scalar_subquery;
 pub mod scalar_variable;
+pub mod set_comparison;
 pub mod signature;
 pub mod sort;
+pub mod sort_expr;
+pub mod statement;
 pub mod subquery;
 pub mod subquery_alias;
 pub mod table_scan;
 pub mod union;
+pub mod unnest;
+pub mod unnest_expr;
+pub mod values;
+pub mod window;
+
+use sort_expr::{PySortExpr, to_sort_expressions};
 
 /// A PyExpr that can be used on a DataFrame
-#[pyclass(name = "Expr", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "RawExpr",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Debug, Clone)]
 pub struct PyExpr {
-    pub(crate) expr: Expr,
+    pub expr: Expr,
 }
 
 impl From<PyExpr> for Expr {
@@ -98,47 +139,105 @@ impl From<Expr> for PyExpr {
     }
 }
 
+/// Convert a list of DataFusion Expr to PyExpr
+pub fn py_expr_list(expr: &[Expr]) -> PyResult<Vec<PyExpr>> {
+    Ok(expr.iter().map(|e| PyExpr::from(e.clone())).collect())
+}
+
 #[pymethods]
 impl PyExpr {
     /// Return the specific expression
-    fn to_variant(&self, py: Python) -> PyResult<PyObject> {
-        Python::with_gil(|_| match &self.expr {
-            Expr::Alias(alias, name) => Ok(PyAlias::new(alias, name).into_py(py)),
-            Expr::Column(col) => Ok(PyColumn::from(col.clone()).into_py(py)),
-            Expr::ScalarVariable(data_type, variables) => {
-                Ok(PyScalarVariable::new(data_type, variables).into_py(py))
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        Python::attach(|_| match &self.expr {
+            Expr::Alias(alias) => Ok(PyAlias::from(alias.clone()).into_bound_py_any(py)?),
+            Expr::Column(col) => Ok(PyColumn::from(col.clone()).into_bound_py_any(py)?),
+            Expr::ScalarVariable(field, variables) => {
+                Ok(PyScalarVariable::new(field, variables).into_bound_py_any(py)?)
             }
-            Expr::Literal(value) => Ok(PyLiteral::from(value.clone()).into_py(py)),
-            Expr::BinaryExpr(expr) => Ok(PyBinaryExpr::from(expr.clone()).into_py(py)),
-            Expr::Not(expr) => Ok(PyNot::new(*expr.clone()).into_py(py)),
-            Expr::IsNotNull(expr) => Ok(PyIsNotNull::new(*expr.clone()).into_py(py)),
-            Expr::IsNull(expr) => Ok(PyIsNull::new(*expr.clone()).into_py(py)),
-            Expr::IsTrue(expr) => Ok(PyIsTrue::new(*expr.clone()).into_py(py)),
-            Expr::IsFalse(expr) => Ok(PyIsFalse::new(*expr.clone()).into_py(py)),
-            Expr::IsUnknown(expr) => Ok(PyIsUnknown::new(*expr.clone()).into_py(py)),
-            Expr::IsNotTrue(expr) => Ok(PyIsNotTrue::new(*expr.clone()).into_py(py)),
-            Expr::IsNotFalse(expr) => Ok(PyIsNotFalse::new(*expr.clone()).into_py(py)),
-            Expr::IsNotUnknown(expr) => Ok(PyIsNotUnknown::new(*expr.clone()).into_py(py)),
-            Expr::Negative(expr) => Ok(PyNegative::new(*expr.clone()).into_py(py)),
+            Expr::Like(value) => Ok(PyLike::from(value.clone()).into_bound_py_any(py)?),
+            Expr::Literal(value, metadata) => Ok(PyLiteral::new_with_metadata(
+                value.clone(),
+                metadata.clone(),
+            )
+            .into_bound_py_any(py)?),
+            Expr::BinaryExpr(expr) => Ok(PyBinaryExpr::from(expr.clone()).into_bound_py_any(py)?),
+            Expr::Not(expr) => Ok(PyNot::new(*expr.clone()).into_bound_py_any(py)?),
+            Expr::IsNotNull(expr) => Ok(PyIsNotNull::new(*expr.clone()).into_bound_py_any(py)?),
+            Expr::IsNull(expr) => Ok(PyIsNull::new(*expr.clone()).into_bound_py_any(py)?),
+            Expr::IsTrue(expr) => Ok(PyIsTrue::new(*expr.clone()).into_bound_py_any(py)?),
+            Expr::IsFalse(expr) => Ok(PyIsFalse::new(*expr.clone()).into_bound_py_any(py)?),
+            Expr::IsUnknown(expr) => Ok(PyIsUnknown::new(*expr.clone()).into_bound_py_any(py)?),
+            Expr::IsNotTrue(expr) => Ok(PyIsNotTrue::new(*expr.clone()).into_bound_py_any(py)?),
+            Expr::IsNotFalse(expr) => Ok(PyIsNotFalse::new(*expr.clone()).into_bound_py_any(py)?),
+            Expr::IsNotUnknown(expr) => {
+                Ok(PyIsNotUnknown::new(*expr.clone()).into_bound_py_any(py)?)
+            }
+            Expr::Negative(expr) => Ok(PyNegative::new(*expr.clone()).into_bound_py_any(py)?),
             Expr::AggregateFunction(expr) => {
-                Ok(PyAggregateFunction::from(expr.clone()).into_py(py))
+                Ok(PyAggregateFunction::from(expr.clone()).into_bound_py_any(py)?)
+            }
+            Expr::SimilarTo(value) => Ok(PySimilarTo::from(value.clone()).into_bound_py_any(py)?),
+            Expr::Between(value) => {
+                Ok(between::PyBetween::from(value.clone()).into_bound_py_any(py)?)
             }
-            other => Err(py_runtime_err(format!(
-                "Cannot convert this Expr to a Python object: {:?}",
-                other
+            Expr::Case(value) => Ok(case::PyCase::from(value.clone()).into_bound_py_any(py)?),
+            Expr::Cast(value) => Ok(cast::PyCast::from(value.clone()).into_bound_py_any(py)?),
+            Expr::TryCast(value) => Ok(cast::PyTryCast::from(value.clone()).into_bound_py_any(py)?),
+            Expr::ScalarFunction(value) => Err(py_unsupported_variant_err(format!(
+                "Converting Expr::ScalarFunction to a Python object is not implemented: {value:?}"
             ))),
+            Expr::WindowFunction(value) => Err(py_unsupported_variant_err(format!(
+                "Converting Expr::WindowFunction to a Python object is not implemented: {value:?}"
+            ))),
+            Expr::InList(value) => {
+                Ok(in_list::PyInList::from(value.clone()).into_bound_py_any(py)?)
+            }
+            Expr::Exists(value) => Ok(exists::PyExists::from(value.clone()).into_bound_py_any(py)?),
+            Expr::InSubquery(value) => {
+                Ok(in_subquery::PyInSubquery::from(value.clone()).into_bound_py_any(py)?)
+            }
+            Expr::ScalarSubquery(value) => {
+                Ok(scalar_subquery::PyScalarSubquery::from(value.clone()).into_bound_py_any(py)?)
+            }
+            #[allow(deprecated)]
+            Expr::Wildcard { qualifier, options } => Err(py_unsupported_variant_err(format!(
+                "Converting Expr::Wildcard to a Python object is not implemented : {qualifier:?} {options:?}"
+            ))),
+            Expr::GroupingSet(value) => {
+                Ok(grouping_set::PyGroupingSet::from(value.clone()).into_bound_py_any(py)?)
+            }
+            Expr::Placeholder(value) => {
+                Ok(placeholder::PyPlaceholder::from(value.clone()).into_bound_py_any(py)?)
+            }
+            Expr::OuterReferenceColumn(data_type, column) => {
+                Err(py_unsupported_variant_err(format!(
+                    "Converting Expr::OuterReferenceColumn to a Python object is not implemented: {data_type:?} - {column:?}"
+                )))
+            }
+            Expr::Unnest(value) => {
+                Ok(unnest_expr::PyUnnestExpr::from(value.clone()).into_bound_py_any(py)?)
+            }
+            Expr::SetComparison(value) => {
+                Ok(set_comparison::PySetComparison::from(value.clone()).into_bound_py_any(py)?)
+            }
         })
     }
 
     /// Returns the name of this expression as it should appear in a schema. This name
     /// will not include any CAST expressions.
-    fn display_name(&self) -> PyResult<String> {
-        Ok(self.expr.display_name()?)
+    fn schema_name(&self) -> PyResult<String> {
+        Ok(format!("{}", self.expr.schema_name()))
     }
 
     /// Returns a full and complete string representation of this expression.
     fn canonical_name(&self) -> PyResult<String> {
-        Ok(self.expr.canonical_name())
+        Ok(format!("{}", self.expr))
+    }
+
+    /// Returns the name of the Expr variant.
+    /// Ex: 'IsNotNull', 'Literal', 'BinaryExpr', etc
+    fn variant_name(&self) -> PyResult<&str> {
+        Ok(self.expr.variant_name())
     }
 
     fn __richcmp__(&self, other: PyExpr, op: CompareOp) -> PyExpr {
@@ -174,7 +273,8 @@ impl PyExpr {
     }
 
     fn __mod__(&self, rhs: PyExpr) -> PyResult<PyExpr> {
-        Ok(self.expr.clone().modulus(rhs.expr).into())
+        let expr = self.expr.clone() % rhs.expr;
+        Ok(expr.into())
     }
 
     fn __and__(&self, rhs: PyExpr) -> PyResult<PyExpr> {
@@ -186,20 +286,26 @@ impl PyExpr {
     }
 
     fn __invert__(&self) -> PyResult<PyExpr> {
-        Ok(self.expr.clone().not().into())
+        let expr = !self.expr.clone();
+        Ok(expr.into())
     }
 
     fn __getitem__(&self, key: &str) -> PyResult<PyExpr> {
-        Ok(Expr::GetIndexedField(GetIndexedField::new(
-            Box::new(self.expr.clone()),
-            ScalarValue::Utf8(Some(key.to_string())),
-        ))
-        .into())
+        Ok(self.expr.clone().field(key).into())
+    }
+
+    #[staticmethod]
+    pub fn literal(value: PyScalarValue) -> PyExpr {
+        lit(value.0).into()
     }
 
     #[staticmethod]
-    pub fn literal(value: ScalarValue) -> PyExpr {
-        lit(value).into()
+    pub fn literal_with_metadata(
+        value: PyScalarValue,
+        metadata: HashMap<String, String>,
+    ) -> PyExpr {
+        let metadata = FieldMetadata::new(metadata.into_iter().collect());
+        lit_with_metadata(value.0, Some(metadata)).into()
     }
 
     #[staticmethod]
@@ -208,13 +314,15 @@ impl PyExpr {
     }
 
     /// assign a name to the PyExpr
-    pub fn alias(&self, name: &str) -> PyExpr {
-        self.expr.clone().alias(name).into()
+    #[pyo3(signature = (name, metadata=None))]
+    pub fn alias(&self, name: &str, metadata: Option<HashMap<String, String>>) -> PyExpr {
+        let metadata = metadata.map(|m| FieldMetadata::new(m.into_iter().collect()));
+        self.expr.clone().alias_with_metadata(name, metadata).into()
     }
 
     /// Create a sort PyExpr from an existing PyExpr.
     #[pyo3(signature = (ascending=true, nulls_first=true))]
-    pub fn sort(&self, ascending: bool, nulls_first: bool) -> PyExpr {
+    pub fn sort(&self, ascending: bool, nulls_first: bool) -> PySortExpr {
         self.expr.clone().sort(ascending, nulls_first).into()
     }
 
@@ -222,17 +330,469 @@ impl PyExpr {
         self.expr.clone().is_null().into()
     }
 
+    pub fn is_not_null(&self) -> PyExpr {
+        self.expr.clone().is_not_null().into()
+    }
+
     pub fn cast(&self, to: PyArrowType<DataType>) -> PyExpr {
         // self.expr.cast_to() requires DFSchema to validate that the cast
         // is supported, omit that for now
         let expr = Expr::Cast(Cast::new(Box::new(self.expr.clone()), to.0));
         expr.into()
     }
+
+    #[pyo3(signature = (low, high, negated=false))]
+    pub fn between(&self, low: PyExpr, high: PyExpr, negated: bool) -> PyExpr {
+        let expr = Expr::Between(Between::new(
+            Box::new(self.expr.clone()),
+            negated,
+            Box::new(low.into()),
+            Box::new(high.into()),
+        ));
+        expr.into()
+    }
+
+    /// A Rex (Row Expression) specifies a single row of data. That specification
+    /// could include user defined functions or types. RexType identifies the row
+    /// as one of the possible valid `RexTypes`.
+    pub fn rex_type(&self) -> PyResult<RexType> {
+        Ok(match self.expr {
+            Expr::Alias(..) => RexType::Alias,
+            Expr::Column(..) => RexType::Reference,
+            Expr::ScalarVariable(..) | Expr::Literal(..) => RexType::Literal,
+            Expr::BinaryExpr { .. }
+            | Expr::Not(..)
+            | Expr::IsNotNull(..)
+            | Expr::Negative(..)
+            | Expr::IsNull(..)
+            | Expr::Like { .. }
+            | Expr::SimilarTo { .. }
+            | Expr::Between { .. }
+            | Expr::Case { .. }
+            | Expr::Cast { .. }
+            | Expr::TryCast { .. }
+            | Expr::ScalarFunction { .. }
+            | Expr::AggregateFunction { .. }
+            | Expr::WindowFunction { .. }
+            | Expr::InList { .. }
+            | Expr::Exists { .. }
+            | Expr::InSubquery { .. }
+            | Expr::GroupingSet(..)
+            | Expr::IsTrue(..)
+            | Expr::IsFalse(..)
+            | Expr::IsUnknown(_)
+            | Expr::IsNotTrue(..)
+            | Expr::IsNotFalse(..)
+            | Expr::Placeholder { .. }
+            | Expr::OuterReferenceColumn(_, _)
+            | Expr::Unnest(_)
+            | Expr::IsNotUnknown(_)
+            | Expr::SetComparison(_) => RexType::Call,
+            Expr::ScalarSubquery(..) => RexType::ScalarSubquery,
+            #[allow(deprecated)]
+            Expr::Wildcard { .. } => {
+                return Err(py_unsupported_variant_err("Expr::Wildcard is unsupported"));
+            }
+        })
+    }
+
+    /// Given the current `Expr` return the DataTypeMap which represents the
+    /// PythonType, Arrow DataType, and SqlType Enum which represents
+    pub fn types(&self) -> PyResult<DataTypeMap> {
+        Self::_types(&self.expr)
+    }
+
+    /// Extracts the Expr value into a Py<PyAny> that can be shared with Python
+    pub fn python_value<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        match &self.expr {
+            Expr::Literal(scalar_value, _) => scalar_to_pyarrow(scalar_value, py),
+            _ => Err(py_type_err(format!(
+                "Non Expr::Literal encountered in types: {:?}",
+                &self.expr
+            ))),
+        }
+    }
+
+    /// Row expressions, Rex(s), operate on the concept of operands. Different variants of Expressions, Expr(s),
+    /// store those operands in different datastructures. This function examines the Expr variant and returns
+    /// the operands to the calling logic as a Vec of PyExpr instances.
+    pub fn rex_call_operands(&self) -> PyResult<Vec<PyExpr>> {
+        match &self.expr {
+            // Expr variants that are themselves the operand to return
+            Expr::Column(..) | Expr::ScalarVariable(..) | Expr::Literal(..) => {
+                Ok(vec![PyExpr::from(self.expr.clone())])
+            }
+
+            Expr::Alias(alias) => Ok(vec![PyExpr::from(*alias.expr.clone())]),
+
+            // Expr(s) that house the Expr instance to return in their bounded params
+            Expr::Not(expr)
+            | Expr::IsNull(expr)
+            | Expr::IsNotNull(expr)
+            | Expr::IsTrue(expr)
+            | Expr::IsFalse(expr)
+            | Expr::IsUnknown(expr)
+            | Expr::IsNotTrue(expr)
+            | Expr::IsNotFalse(expr)
+            | Expr::IsNotUnknown(expr)
+            | Expr::Negative(expr)
+            | Expr::Cast(Cast { expr, .. })
+            | Expr::TryCast(TryCast { expr, .. })
+            | Expr::InSubquery(InSubquery { expr, .. })
+            | Expr::SetComparison(SetComparison { expr, .. }) => {
+                Ok(vec![PyExpr::from(*expr.clone())])
+            }
+
+            // Expr variants containing a collection of Expr(s) for operands
+            Expr::AggregateFunction(AggregateFunction {
+                params: AggregateFunctionParams { args, .. },
+                ..
+            })
+            | Expr::ScalarFunction(ScalarFunction { args, .. }) => {
+                Ok(args.iter().map(|arg| PyExpr::from(arg.clone())).collect())
+            }
+            Expr::WindowFunction(boxed_window_fn) => {
+                let args = &boxed_window_fn.params.args;
+                Ok(args.iter().map(|arg| PyExpr::from(arg.clone())).collect())
+            }
+
+            // Expr(s) that require more specific processing
+            Expr::Case(Case {
+                expr,
+                when_then_expr,
+                else_expr,
+            }) => {
+                let mut operands: Vec<PyExpr> = Vec::new();
+
+                if let Some(e) = expr {
+                    for (when, then) in when_then_expr {
+                        operands.push(PyExpr::from(Expr::BinaryExpr(BinaryExpr::new(
+                            Box::new(*e.clone()),
+                            Operator::Eq,
+                            Box::new(*when.clone()),
+                        ))));
+                        operands.push(PyExpr::from(*then.clone()));
+                    }
+                } else {
+                    for (when, then) in when_then_expr {
+                        operands.push(PyExpr::from(*when.clone()));
+                        operands.push(PyExpr::from(*then.clone()));
+                    }
+                };
+
+                if let Some(e) = else_expr {
+                    operands.push(PyExpr::from(*e.clone()));
+                };
+
+                Ok(operands)
+            }
+            Expr::InList(InList { expr, list, .. }) => {
+                let mut operands: Vec<PyExpr> = vec![PyExpr::from(*expr.clone())];
+                for list_elem in list {
+                    operands.push(PyExpr::from(list_elem.clone()));
+                }
+
+                Ok(operands)
+            }
+            Expr::BinaryExpr(BinaryExpr { left, right, .. }) => Ok(vec![
+                PyExpr::from(*left.clone()),
+                PyExpr::from(*right.clone()),
+            ]),
+            Expr::Like(Like { expr, pattern, .. }) => Ok(vec![
+                PyExpr::from(*expr.clone()),
+                PyExpr::from(*pattern.clone()),
+            ]),
+            Expr::SimilarTo(Like { expr, pattern, .. }) => Ok(vec![
+                PyExpr::from(*expr.clone()),
+                PyExpr::from(*pattern.clone()),
+            ]),
+            Expr::Between(Between {
+                expr,
+                negated: _,
+                low,
+                high,
+            }) => Ok(vec![
+                PyExpr::from(*expr.clone()),
+                PyExpr::from(*low.clone()),
+                PyExpr::from(*high.clone()),
+            ]),
+
+            // Currently un-support/implemented Expr types for Rex Call operations
+            Expr::GroupingSet(..)
+            | Expr::Unnest(_)
+            | Expr::OuterReferenceColumn(_, _)
+            | Expr::ScalarSubquery(..)
+            | Expr::Placeholder { .. }
+            | Expr::Exists { .. } => Err(py_runtime_err(format!(
+                "Unimplemented Expr type: {}",
+                self.expr
+            ))),
+
+            #[allow(deprecated)]
+            Expr::Wildcard { .. } => {
+                Err(py_unsupported_variant_err("Expr::Wildcard is unsupported"))
+            }
+        }
+    }
+
+    /// Extracts the operator associated with a RexType::Call
+    pub fn rex_call_operator(&self) -> PyResult<String> {
+        Ok(match &self.expr {
+            Expr::BinaryExpr(BinaryExpr {
+                left: _,
+                op,
+                right: _,
+            }) => format!("{op}"),
+            Expr::ScalarFunction(ScalarFunction { func, args: _ }) => func.name().to_string(),
+            Expr::Cast { .. } => "cast".to_string(),
+            Expr::Between { .. } => "between".to_string(),
+            Expr::Case { .. } => "case".to_string(),
+            Expr::IsNull(..) => "is null".to_string(),
+            Expr::IsNotNull(..) => "is not null".to_string(),
+            Expr::IsTrue(_) => "is true".to_string(),
+            Expr::IsFalse(_) => "is false".to_string(),
+            Expr::IsUnknown(_) => "is unknown".to_string(),
+            Expr::IsNotTrue(_) => "is not true".to_string(),
+            Expr::IsNotFalse(_) => "is not false".to_string(),
+            Expr::IsNotUnknown(_) => "is not unknown".to_string(),
+            Expr::InList { .. } => "in list".to_string(),
+            Expr::Negative(..) => "negative".to_string(),
+            Expr::Not(..) => "not".to_string(),
+            Expr::Like(Like {
+                negated,
+                case_insensitive,
+                ..
+            }) => {
+                let name = if *case_insensitive { "ilike" } else { "like" };
+                if *negated {
+                    format!("not {name}")
+                } else {
+                    name.to_string()
+                }
+            }
+            Expr::SimilarTo(Like { negated, .. }) => {
+                if *negated {
+                    "not similar to".to_string()
+                } else {
+                    "similar to".to_string()
+                }
+            }
+            _ => {
+                return Err(py_type_err(format!(
+                    "Catch all triggered in get_operator_name: {:?}",
+                    &self.expr
+                )));
+            }
+        })
+    }
+
+    pub fn column_name(&self, plan: PyLogicalPlan) -> PyResult<String> {
+        self._column_name(&plan.plan()).map_err(py_runtime_err)
+    }
+
+    // Expression Function Builder functions
+
+    pub fn order_by(&self, order_by: Vec<PySortExpr>) -> PyExprFuncBuilder {
+        self.expr
+            .clone()
+            .order_by(to_sort_expressions(order_by))
+            .into()
+    }
+
+    pub fn filter(&self, filter: PyExpr) -> PyExprFuncBuilder {
+        self.expr.clone().filter(filter.expr.clone()).into()
+    }
+
+    pub fn distinct(&self) -> PyExprFuncBuilder {
+        self.expr.clone().distinct().into()
+    }
+
+    pub fn null_treatment(&self, null_treatment: NullTreatment) -> PyExprFuncBuilder {
+        self.expr
+            .clone()
+            .null_treatment(Some(null_treatment.into()))
+            .into()
+    }
+
+    pub fn partition_by(&self, partition_by: Vec<PyExpr>) -> PyExprFuncBuilder {
+        let partition_by = partition_by.iter().map(|e| e.expr.clone()).collect();
+        self.expr.clone().partition_by(partition_by).into()
+    }
+
+    pub fn window_frame(&self, window_frame: PyWindowFrame) -> PyExprFuncBuilder {
+        self.expr.clone().window_frame(window_frame.into()).into()
+    }
+
+    #[pyo3(signature = (partition_by=None, window_frame=None, order_by=None, null_treatment=None))]
+    pub fn over(
+        &self,
+        partition_by: Option<Vec<PyExpr>>,
+        window_frame: Option<PyWindowFrame>,
+        order_by: Option<Vec<PySortExpr>>,
+        null_treatment: Option<NullTreatment>,
+    ) -> PyDataFusionResult<PyExpr> {
+        match &self.expr {
+            Expr::AggregateFunction(agg_fn) => {
+                let window_fn = Expr::WindowFunction(Box::new(WindowFunction::new(
+                    WindowFunctionDefinition::AggregateUDF(agg_fn.func.clone()),
+                    agg_fn.params.args.clone(),
+                )));
+
+                add_builder_fns_to_window(
+                    window_fn,
+                    partition_by,
+                    window_frame,
+                    order_by,
+                    null_treatment,
+                )
+            }
+            Expr::WindowFunction(_) => add_builder_fns_to_window(
+                self.expr.clone(),
+                partition_by,
+                window_frame,
+                order_by,
+                null_treatment,
+            ),
+            _ => Err(datafusion::error::DataFusionError::Plan(format!(
+                "Using {} with `over` is not allowed. Must use an aggregate or window function.",
+                self.expr.variant_name()
+            ))
+            .into()),
+        }
+    }
+}
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "ExprFuncBuilder",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Debug, Clone)]
+pub struct PyExprFuncBuilder {
+    pub builder: ExprFuncBuilder,
+}
+
+impl From<ExprFuncBuilder> for PyExprFuncBuilder {
+    fn from(builder: ExprFuncBuilder) -> Self {
+        Self { builder }
+    }
+}
+
+#[pymethods]
+impl PyExprFuncBuilder {
+    pub fn order_by(&self, order_by: Vec<PySortExpr>) -> PyExprFuncBuilder {
+        self.builder
+            .clone()
+            .order_by(to_sort_expressions(order_by))
+            .into()
+    }
+
+    pub fn filter(&self, filter: PyExpr) -> PyExprFuncBuilder {
+        self.builder.clone().filter(filter.expr.clone()).into()
+    }
+
+    pub fn distinct(&self) -> PyExprFuncBuilder {
+        self.builder.clone().distinct().into()
+    }
+
+    pub fn null_treatment(&self, null_treatment: NullTreatment) -> PyExprFuncBuilder {
+        self.builder
+            .clone()
+            .null_treatment(Some(null_treatment.into()))
+            .into()
+    }
+
+    pub fn partition_by(&self, partition_by: Vec<PyExpr>) -> PyExprFuncBuilder {
+        let partition_by = partition_by.iter().map(|e| e.expr.clone()).collect();
+        self.builder.clone().partition_by(partition_by).into()
+    }
+
+    pub fn window_frame(&self, window_frame: PyWindowFrame) -> PyExprFuncBuilder {
+        self.builder
+            .clone()
+            .window_frame(window_frame.into())
+            .into()
+    }
+
+    pub fn build(&self) -> PyDataFusionResult<PyExpr> {
+        Ok(self.builder.clone().build().map(|expr| expr.into())?)
+    }
+}
+
+impl PyExpr {
+    pub fn _column_name(&self, plan: &LogicalPlan) -> PyDataFusionResult<String> {
+        let field = Self::expr_to_field(&self.expr, plan)?;
+        Ok(field.name().to_owned())
+    }
+
+    /// Create a [Field] representing an [Expr], given an input [LogicalPlan] to resolve against
+    pub fn expr_to_field(expr: &Expr, input_plan: &LogicalPlan) -> PyDataFusionResult<Arc<Field>> {
+        let fields = exprlist_to_fields(std::slice::from_ref(expr), input_plan)?;
+        Ok(fields[0].1.clone())
+    }
+    fn _types(expr: &Expr) -> PyResult<DataTypeMap> {
+        match expr {
+            Expr::BinaryExpr(BinaryExpr {
+                left: _,
+                op,
+                right: _,
+            }) => match op {
+                Operator::Eq
+                | Operator::NotEq
+                | Operator::Lt
+                | Operator::LtEq
+                | Operator::Gt
+                | Operator::GtEq
+                | Operator::And
+                | Operator::Or
+                | Operator::IsDistinctFrom
+                | Operator::IsNotDistinctFrom
+                | Operator::RegexMatch
+                | Operator::RegexIMatch
+                | Operator::RegexNotMatch
+                | Operator::RegexNotIMatch
+                | Operator::LikeMatch
+                | Operator::ILikeMatch
+                | Operator::NotLikeMatch
+                | Operator::NotILikeMatch => DataTypeMap::map_from_arrow_type(&DataType::Boolean),
+                Operator::Plus | Operator::Minus | Operator::Multiply | Operator::Modulo => {
+                    DataTypeMap::map_from_arrow_type(&DataType::Int64)
+                }
+                Operator::Divide => DataTypeMap::map_from_arrow_type(&DataType::Float64),
+                Operator::StringConcat => DataTypeMap::map_from_arrow_type(&DataType::Utf8),
+                Operator::BitwiseShiftLeft
+                | Operator::BitwiseShiftRight
+                | Operator::BitwiseXor
+                | Operator::BitwiseAnd
+                | Operator::BitwiseOr => DataTypeMap::map_from_arrow_type(&DataType::Binary),
+                Operator::AtArrow
+                | Operator::ArrowAt
+                | Operator::Arrow
+                | Operator::LongArrow
+                | Operator::HashArrow
+                | Operator::HashLongArrow
+                | Operator::AtAt
+                | Operator::IntegerDivide
+                | Operator::HashMinus
+                | Operator::AtQuestion
+                | Operator::Question
+                | Operator::QuestionAnd
+                | Operator::QuestionPipe
+                | Operator::Colon => Err(py_type_err(format!("Unsupported expr: ${op}"))),
+            },
+            Expr::Cast(Cast { expr: _, data_type }) => DataTypeMap::map_from_arrow_type(data_type),
+            Expr::Literal(scalar_value, _) => DataTypeMap::map_from_scalar_value(scalar_value),
+            _ => Err(py_type_err(format!(
+                "Non Expr::Literal encountered in types: {expr:?}"
+            ))),
+        }
+    }
 }
 
 /// Initializes the `expr` module to match the pattern of `datafusion-expr` https://docs.rs/datafusion-expr/latest/datafusion_expr/
-pub(crate) fn init_module(m: &PyModule) -> PyResult<()> {
-    // expressions
+pub(crate) fn init_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<PyExpr>()?;
     m.add_class::<PyColumn>()?;
     m.add_class::<PyLiteral>()?;
@@ -254,8 +814,6 @@ pub(crate) fn init_module(m: &PyModule) -> PyResult<()> {
     m.add_class::<PySimilarTo>()?;
     m.add_class::<PyScalarVariable>()?;
     m.add_class::<alias::PyAlias>()?;
-    m.add_class::<scalar_function::PyScalarFunction>()?;
-    m.add_class::<scalar_function::PyBuiltinScalarFunction>()?;
     m.add_class::<in_list::PyInList>()?;
     m.add_class::<exists::PyExists>()?;
     m.add_class::<subquery::PySubquery>()?;
@@ -264,10 +822,10 @@ pub(crate) fn init_module(m: &PyModule) -> PyResult<()> {
     m.add_class::<placeholder::PyPlaceholder>()?;
     m.add_class::<grouping_set::PyGroupingSet>()?;
     m.add_class::<case::PyCase>()?;
+    m.add_class::<conditional_expr::PyCaseBuilder>()?;
     m.add_class::<cast::PyCast>()?;
     m.add_class::<cast::PyTryCast>()?;
     m.add_class::<between::PyBetween>()?;
-    m.add_class::<indexed_field::PyGetIndexedField>()?;
     m.add_class::<explain::PyExplain>()?;
     m.add_class::<limit::PyLimit>()?;
     m.add_class::<aggregate::PyAggregate>()?;
@@ -277,8 +835,9 @@ pub(crate) fn init_module(m: &PyModule) -> PyResult<()> {
     m.add_class::<join::PyJoin>()?;
     m.add_class::<join::PyJoinType>()?;
     m.add_class::<join::PyJoinConstraint>()?;
-    m.add_class::<cross_join::PyCrossJoin>()?;
     m.add_class::<union::PyUnion>()?;
+    m.add_class::<unnest::PyUnnest>()?;
+    m.add_class::<unnest_expr::PyUnnestExpr>()?;
     m.add_class::<extension::PyExtension>()?;
     m.add_class::<filter::PyFilter>()?;
     m.add_class::<projection::PyProjection>()?;
@@ -286,9 +845,40 @@ pub(crate) fn init_module(m: &PyModule) -> PyResult<()> {
     m.add_class::<create_memory_table::PyCreateMemoryTable>()?;
     m.add_class::<create_view::PyCreateView>()?;
     m.add_class::<distinct::PyDistinct>()?;
+    m.add_class::<sort_expr::PySortExpr>()?;
     m.add_class::<subquery_alias::PySubqueryAlias>()?;
     m.add_class::<drop_table::PyDropTable>()?;
     m.add_class::<repartition::PyPartitioning>()?;
     m.add_class::<repartition::PyRepartition>()?;
+    m.add_class::<window::PyWindowExpr>()?;
+    m.add_class::<window::PyWindowFrame>()?;
+    m.add_class::<window::PyWindowFrameBound>()?;
+    m.add_class::<copy_to::PyCopyTo>()?;
+    m.add_class::<copy_to::PyFileType>()?;
+    m.add_class::<create_catalog::PyCreateCatalog>()?;
+    m.add_class::<create_catalog_schema::PyCreateCatalogSchema>()?;
+    m.add_class::<create_external_table::PyCreateExternalTable>()?;
+    m.add_class::<create_function::PyCreateFunction>()?;
+    m.add_class::<create_function::PyOperateFunctionArg>()?;
+    m.add_class::<create_function::PyCreateFunctionBody>()?;
+    m.add_class::<create_index::PyCreateIndex>()?;
+    m.add_class::<describe_table::PyDescribeTable>()?;
+    m.add_class::<dml::PyDmlStatement>()?;
+    m.add_class::<drop_catalog_schema::PyDropCatalogSchema>()?;
+    m.add_class::<drop_function::PyDropFunction>()?;
+    m.add_class::<drop_view::PyDropView>()?;
+    m.add_class::<recursive_query::PyRecursiveQuery>()?;
+
+    m.add_class::<statement::PyTransactionStart>()?;
+    m.add_class::<statement::PyTransactionEnd>()?;
+    m.add_class::<statement::PySetVariable>()?;
+    m.add_class::<statement::PyPrepare>()?;
+    m.add_class::<statement::PyExecute>()?;
+    m.add_class::<statement::PyDeallocate>()?;
+    m.add_class::<values::PyValues>()?;
+    m.add_class::<statement::PyTransactionAccessMode>()?;
+    m.add_class::<statement::PyTransactionConclusion>()?;
+    m.add_class::<statement::PyTransactionIsolationLevel>()?;
+
     Ok(())
 }
diff --git a/src/expr/aggregate.rs b/src/expr/aggregate.rs
index c3de9673a..5a6a771a7 100644
--- a/src/expr/aggregate.rs
+++ b/src/expr/aggregate.rs
@@ -15,17 +15,28 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion_common::DataFusionError;
-use datafusion_expr::logical_plan::Aggregate;
-use pyo3::prelude::*;
 use std::fmt::{self, Display, Formatter};
 
+use datafusion::common::DataFusionError;
+use datafusion::logical_expr::Expr;
+use datafusion::logical_expr::expr::{AggregateFunction, AggregateFunctionParams, Alias};
+use datafusion::logical_expr::logical_plan::Aggregate;
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
 use super::logical_node::LogicalNode;
 use crate::common::df_schema::PyDFSchema;
+use crate::errors::py_type_err;
 use crate::expr::PyExpr;
 use crate::sql::logical::PyLogicalPlan;
 
-#[pyclass(name = "Aggregate", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Aggregate",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyAggregate {
     aggregate: Aggregate,
@@ -84,6 +95,24 @@ impl PyAggregate {
             .collect())
     }
 
+    /// Returns the inner Aggregate Expr(s)
+    pub fn agg_expressions(&self) -> PyResult<Vec<PyExpr>> {
+        Ok(self
+            .aggregate
+            .aggr_expr
+            .iter()
+            .map(|e| PyExpr::from(e.clone()))
+            .collect())
+    }
+
+    pub fn agg_func_name(&self, expr: PyExpr) -> PyResult<String> {
+        Self::_agg_func_name(&expr.expr)
+    }
+
+    pub fn aggregation_arguments(&self, expr: PyExpr) -> PyResult<Vec<PyExpr>> {
+        self._aggregation_arguments(&expr.expr)
+    }
+
     // Retrieves the input `LogicalPlan` to this `Aggregate` node
     fn input(&self) -> PyResult<Vec<PyLogicalPlan>> {
         Ok(Self::inputs(self))
@@ -95,7 +124,35 @@ impl PyAggregate {
     }
 
     fn __repr__(&self) -> PyResult<String> {
-        Ok(format!("Aggregate({})", self))
+        Ok(format!("Aggregate({self})"))
+    }
+}
+
+impl PyAggregate {
+    #[allow(clippy::only_used_in_recursion)]
+    fn _aggregation_arguments(&self, expr: &Expr) -> PyResult<Vec<PyExpr>> {
+        match expr {
+            // TODO: This Alias logic seems to be returning some strange results that we should investigate
+            Expr::Alias(Alias { expr, .. }) => self._aggregation_arguments(expr.as_ref()),
+            Expr::AggregateFunction(AggregateFunction {
+                func: _,
+                params: AggregateFunctionParams { args, .. },
+                ..
+            }) => Ok(args.iter().map(|e| PyExpr::from(e.clone())).collect()),
+            _ => Err(py_type_err(
+                "Encountered a non Aggregate type in aggregation_arguments",
+            )),
+        }
+    }
+
+    fn _agg_func_name(expr: &Expr) -> PyResult<String> {
+        match expr {
+            Expr::Alias(Alias { expr, .. }) => Self::_agg_func_name(expr.as_ref()),
+            Expr::AggregateFunction(AggregateFunction { func, .. }) => Ok(func.name().to_owned()),
+            _ => Err(py_type_err(
+                "Encountered a non Aggregate type in agg_func_name",
+            )),
+        }
     }
 }
 
@@ -104,7 +161,7 @@ impl LogicalNode for PyAggregate {
         vec![PyLogicalPlan::from((*self.aggregate.input).clone())]
     }
 
-    fn to_variant(&self, py: Python) -> PyResult<PyObject> {
-        Ok(self.clone().into_py(py))
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
     }
 }
diff --git a/src/expr/aggregate_expr.rs b/src/expr/aggregate_expr.rs
index 180105180..88e47999f 100644
--- a/src/expr/aggregate_expr.rs
+++ b/src/expr/aggregate_expr.rs
@@ -15,12 +15,20 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::expr::PyExpr;
-use datafusion_expr::expr::AggregateFunction;
-use pyo3::prelude::*;
 use std::fmt::{Display, Formatter};
 
-#[pyclass(name = "AggregateFunction", module = "datafusion.expr", subclass)]
+use datafusion::logical_expr::expr::AggregateFunction;
+use pyo3::prelude::*;
+
+use crate::expr::PyExpr;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "AggregateFunction",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyAggregateFunction {
     aggr: AggregateFunction,
@@ -40,8 +48,14 @@ impl From<AggregateFunction> for PyAggregateFunction {
 
 impl Display for PyAggregateFunction {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
-        let args: Vec<String> = self.aggr.args.iter().map(|expr| expr.to_string()).collect();
-        write!(f, "{}({})", self.aggr.fun, args.join(", "))
+        let args: Vec<String> = self
+            .aggr
+            .params
+            .args
+            .iter()
+            .map(|expr| expr.to_string())
+            .collect();
+        write!(f, "{}({})", self.aggr.func.name(), args.join(", "))
     }
 }
 
@@ -49,17 +63,18 @@ impl Display for PyAggregateFunction {
 impl PyAggregateFunction {
     /// Get the aggregate type, such as "MIN", or "MAX"
     fn aggregate_type(&self) -> String {
-        format!("{}", self.aggr.fun)
+        self.aggr.func.name().to_string()
     }
 
     /// is this a distinct aggregate such as `COUNT(DISTINCT expr)`
     fn is_distinct(&self) -> bool {
-        self.aggr.distinct
+        self.aggr.params.distinct
     }
 
     /// Get the arguments to the aggregate function
     fn args(&self) -> Vec<PyExpr> {
         self.aggr
+            .params
             .args
             .iter()
             .map(|expr| PyExpr::from(expr.clone()))
@@ -68,6 +83,6 @@ impl PyAggregateFunction {
 
     /// Get a String representation of this column
     fn __repr__(&self) -> String {
-        format!("{}", self)
+        format!("{self}")
     }
 }
diff --git a/src/expr/alias.rs b/src/expr/alias.rs
index 2ce656342..b76e82e22 100644
--- a/src/expr/alias.rs
+++ b/src/expr/alias.rs
@@ -15,17 +15,35 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::expr::PyExpr;
-use pyo3::prelude::*;
 use std::fmt::{self, Display, Formatter};
 
-use datafusion_expr::Expr;
+use datafusion::logical_expr::expr::Alias;
+use pyo3::prelude::*;
+
+use crate::expr::PyExpr;
 
-#[pyclass(name = "Alias", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Alias",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyAlias {
-    expr: PyExpr,
-    alias_name: String,
+    alias: Alias,
+}
+
+impl From<Alias> for PyAlias {
+    fn from(alias: Alias) -> Self {
+        Self { alias }
+    }
+}
+
+impl From<PyAlias> for Alias {
+    fn from(py_alias: PyAlias) -> Self {
+        py_alias.alias
+    }
 }
 
 impl Display for PyAlias {
@@ -35,33 +53,24 @@ impl Display for PyAlias {
             "Alias
             \nExpr: `{:?}`
             \nAlias Name: `{}`",
-            &self.expr, &self.alias_name
+            &self.alias.expr, &self.alias.name
         )
     }
 }
 
-impl PyAlias {
-    pub fn new(expr: &Expr, alias_name: &String) -> Self {
-        Self {
-            expr: expr.clone().into(),
-            alias_name: alias_name.to_owned(),
-        }
-    }
-}
-
 #[pymethods]
 impl PyAlias {
     /// Retrieve the "name" of the alias
     fn alias(&self) -> PyResult<String> {
-        Ok(self.alias_name.clone())
+        Ok(self.alias.name.clone())
     }
 
     fn expr(&self) -> PyResult<PyExpr> {
-        Ok(self.expr.clone())
+        Ok((*self.alias.expr.clone()).into())
     }
 
     /// Get a String representation of this column
     fn __repr__(&self) -> String {
-        format!("{}", self)
+        format!("{self}")
     }
 }
diff --git a/src/expr/analyze.rs b/src/expr/analyze.rs
index bbec3a808..137765fe1 100644
--- a/src/expr/analyze.rs
+++ b/src/expr/analyze.rs
@@ -15,15 +15,23 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion_expr::logical_plan::Analyze;
-use pyo3::prelude::*;
 use std::fmt::{self, Display, Formatter};
 
+use datafusion::logical_expr::logical_plan::Analyze;
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
 use super::logical_node::LogicalNode;
 use crate::common::df_schema::PyDFSchema;
 use crate::sql::logical::PyLogicalPlan;
 
-#[pyclass(name = "Analyze", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Analyze",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyAnalyze {
     analyze: Analyze,
@@ -69,7 +77,7 @@ impl PyAnalyze {
     }
 
     fn __repr__(&self) -> PyResult<String> {
-        Ok(format!("Analyze({})", self))
+        Ok(format!("Analyze({self})"))
     }
 }
 
@@ -78,7 +86,7 @@ impl LogicalNode for PyAnalyze {
         vec![PyLogicalPlan::from((*self.analyze.input).clone())]
     }
 
-    fn to_variant(&self, py: Python) -> PyResult<PyObject> {
-        Ok(self.clone().into_py(py))
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
     }
 }
diff --git a/src/expr/between.rs b/src/expr/between.rs
index 9b78b9eeb..6943b6c3b 100644
--- a/src/expr/between.rs
+++ b/src/expr/between.rs
@@ -15,12 +15,20 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::expr::PyExpr;
-use datafusion_expr::expr::Between;
-use pyo3::prelude::*;
 use std::fmt::{self, Display, Formatter};
 
-#[pyclass(name = "Between", module = "datafusion.expr", subclass)]
+use datafusion::logical_expr::expr::Between;
+use pyo3::prelude::*;
+
+use crate::expr::PyExpr;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Between",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyBetween {
     between: Between,
@@ -71,6 +79,6 @@ impl PyBetween {
     }
 
     fn __repr__(&self) -> String {
-        format!("{}", self)
+        format!("{self}")
     }
 }
diff --git a/src/expr/binary_expr.rs b/src/expr/binary_expr.rs
index 5f382b770..2326ba705 100644
--- a/src/expr/binary_expr.rs
+++ b/src/expr/binary_expr.rs
@@ -15,11 +15,18 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::expr::PyExpr;
-use datafusion_expr::BinaryExpr;
+use datafusion::logical_expr::BinaryExpr;
 use pyo3::prelude::*;
 
-#[pyclass(name = "BinaryExpr", module = "datafusion.expr", subclass)]
+use crate::expr::PyExpr;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "BinaryExpr",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyBinaryExpr {
     expr: BinaryExpr,
diff --git a/src/expr/bool_expr.rs b/src/expr/bool_expr.rs
index d1502a4eb..9e374c7e2 100644
--- a/src/expr/bool_expr.rs
+++ b/src/expr/bool_expr.rs
@@ -15,13 +15,20 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion_expr::Expr;
-use pyo3::prelude::*;
 use std::fmt::{self, Display, Formatter};
 
+use datafusion::logical_expr::Expr;
+use pyo3::prelude::*;
+
 use super::PyExpr;
 
-#[pyclass(name = "Not", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Not",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone, Debug)]
 pub struct PyNot {
     expr: Expr,
@@ -51,7 +58,13 @@ impl PyNot {
     }
 }
 
-#[pyclass(name = "IsNotNull", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "IsNotNull",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone, Debug)]
 pub struct PyIsNotNull {
     expr: Expr,
@@ -81,7 +94,13 @@ impl PyIsNotNull {
     }
 }
 
-#[pyclass(name = "IsNull", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "IsNull",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone, Debug)]
 pub struct PyIsNull {
     expr: Expr,
@@ -111,7 +130,13 @@ impl PyIsNull {
     }
 }
 
-#[pyclass(name = "IsTrue", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "IsTrue",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone, Debug)]
 pub struct PyIsTrue {
     expr: Expr,
@@ -141,7 +166,13 @@ impl PyIsTrue {
     }
 }
 
-#[pyclass(name = "IsFalse", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "IsFalse",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone, Debug)]
 pub struct PyIsFalse {
     expr: Expr,
@@ -171,7 +202,13 @@ impl PyIsFalse {
     }
 }
 
-#[pyclass(name = "IsUnknown", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "IsUnknown",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone, Debug)]
 pub struct PyIsUnknown {
     expr: Expr,
@@ -201,7 +238,13 @@ impl PyIsUnknown {
     }
 }
 
-#[pyclass(name = "IsNotTrue", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "IsNotTrue",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone, Debug)]
 pub struct PyIsNotTrue {
     expr: Expr,
@@ -231,7 +274,13 @@ impl PyIsNotTrue {
     }
 }
 
-#[pyclass(name = "IsNotFalse", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "IsNotFalse",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone, Debug)]
 pub struct PyIsNotFalse {
     expr: Expr,
@@ -261,7 +310,13 @@ impl PyIsNotFalse {
     }
 }
 
-#[pyclass(name = "IsNotUnknown", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "IsNotUnknown",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone, Debug)]
 pub struct PyIsNotUnknown {
     expr: Expr,
@@ -291,7 +346,13 @@ impl PyIsNotUnknown {
     }
 }
 
-#[pyclass(name = "Negative", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Negative",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone, Debug)]
 pub struct PyNegative {
     expr: Expr,
diff --git a/src/expr/case.rs b/src/expr/case.rs
index 605275376..4f00449d8 100644
--- a/src/expr/case.rs
+++ b/src/expr/case.rs
@@ -15,11 +15,18 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::expr::PyExpr;
-use datafusion_expr::Case;
+use datafusion::logical_expr::Case;
 use pyo3::prelude::*;
 
-#[pyclass(name = "Case", module = "datafusion.expr", subclass)]
+use crate::expr::PyExpr;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Case",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyCase {
     case: Case,
diff --git a/src/expr/cast.rs b/src/expr/cast.rs
index a72199876..37d603538 100644
--- a/src/expr/cast.rs
+++ b/src/expr/cast.rs
@@ -15,11 +15,19 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::{common::data_type::PyDataType, expr::PyExpr};
-use datafusion_expr::{Cast, TryCast};
+use datafusion::logical_expr::{Cast, TryCast};
 use pyo3::prelude::*;
 
-#[pyclass(name = "Cast", module = "datafusion.expr", subclass)]
+use crate::common::data_type::PyDataType;
+use crate::expr::PyExpr;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Cast",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyCast {
     cast: Cast,
@@ -48,7 +56,7 @@ impl PyCast {
     }
 }
 
-#[pyclass(name = "TryCast", module = "datafusion.expr", subclass)]
+#[pyclass(from_py_object, name = "TryCast", module = "datafusion.expr", subclass)]
 #[derive(Clone)]
 pub struct PyTryCast {
     try_cast: TryCast,
diff --git a/src/expr/column.rs b/src/expr/column.rs
index 16b8bce3c..c1238f98a 100644
--- a/src/expr/column.rs
+++ b/src/expr/column.rs
@@ -15,10 +15,16 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion_common::Column;
+use datafusion::common::Column;
 use pyo3::prelude::*;
 
-#[pyclass(name = "Column", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Column",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyColumn {
     pub col: Column,
@@ -45,7 +51,7 @@ impl PyColumn {
 
     /// Get the column relation
     fn relation(&self) -> Option<String> {
-        self.col.relation.clone()
+        self.col.relation.as_ref().map(|r| format!("{r}"))
     }
 
     /// Get the fully-qualified column name
diff --git a/src/expr/conditional_expr.rs b/src/expr/conditional_expr.rs
new file mode 100644
index 000000000..ea21fdb20
--- /dev/null
+++ b/src/expr/conditional_expr.rs
@@ -0,0 +1,84 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use datafusion::logical_expr::conditional_expressions::CaseBuilder;
+use datafusion::prelude::Expr;
+use pyo3::prelude::*;
+
+use crate::errors::PyDataFusionResult;
+use crate::expr::PyExpr;
+
+// TODO(tsaucer) replace this all with CaseBuilder after it implements Clone
+#[derive(Clone, Debug)]
+#[pyclass(
+    from_py_object,
+    name = "CaseBuilder",
+    module = "datafusion.expr",
+    subclass,
+    frozen
+)]
+pub struct PyCaseBuilder {
+    expr: Option<Expr>,
+    when: Vec<Expr>,
+    then: Vec<Expr>,
+}
+
+#[pymethods]
+impl PyCaseBuilder {
+    #[new]
+    pub fn new(expr: Option<PyExpr>) -> Self {
+        Self {
+            expr: expr.map(Into::into),
+            when: vec![],
+            then: vec![],
+        }
+    }
+
+    pub fn when(&self, when: PyExpr, then: PyExpr) -> PyCaseBuilder {
+        let mut case_builder = self.clone();
+        case_builder.when.push(when.into());
+        case_builder.then.push(then.into());
+
+        case_builder
+    }
+
+    fn otherwise(&self, else_expr: PyExpr) -> PyDataFusionResult<PyExpr> {
+        let case_builder = CaseBuilder::new(
+            self.expr.clone().map(Box::new),
+            self.when.clone(),
+            self.then.clone(),
+            Some(Box::new(else_expr.into())),
+        );
+
+        let expr = case_builder.end()?;
+
+        Ok(expr.into())
+    }
+
+    fn end(&self) -> PyDataFusionResult<PyExpr> {
+        let case_builder = CaseBuilder::new(
+            self.expr.clone().map(Box::new),
+            self.when.clone(),
+            self.then.clone(),
+            None,
+        );
+
+        let expr = case_builder.end()?;
+
+        Ok(expr.into())
+    }
+}
diff --git a/src/expr/copy_to.rs b/src/expr/copy_to.rs
new file mode 100644
index 000000000..78e53cdff
--- /dev/null
+++ b/src/expr/copy_to.rs
@@ -0,0 +1,149 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::collections::HashMap;
+use std::fmt::{self, Display, Formatter};
+use std::sync::Arc;
+
+use datafusion::common::file_options::file_type::FileType;
+use datafusion::logical_expr::dml::CopyTo;
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
+use super::logical_node::LogicalNode;
+use crate::sql::logical::PyLogicalPlan;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "CopyTo",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyCopyTo {
+    copy: CopyTo,
+}
+
+impl From<PyCopyTo> for CopyTo {
+    fn from(copy: PyCopyTo) -> Self {
+        copy.copy
+    }
+}
+
+impl From<CopyTo> for PyCopyTo {
+    fn from(copy: CopyTo) -> PyCopyTo {
+        PyCopyTo { copy }
+    }
+}
+
+impl Display for PyCopyTo {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "CopyTo: {:?}", self.copy.output_url)
+    }
+}
+
+impl LogicalNode for PyCopyTo {
+    fn inputs(&self) -> Vec<PyLogicalPlan> {
+        vec![PyLogicalPlan::from((*self.copy.input).clone())]
+    }
+
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
+
+#[pymethods]
+impl PyCopyTo {
+    #[new]
+    pub fn new(
+        input: PyLogicalPlan,
+        output_url: String,
+        partition_by: Vec<String>,
+        file_type: PyFileType,
+        options: HashMap<String, String>,
+    ) -> Self {
+        PyCopyTo {
+            copy: CopyTo::new(
+                input.plan(),
+                output_url,
+                partition_by,
+                file_type.file_type,
+                options,
+            ),
+        }
+    }
+
+    fn input(&self) -> PyLogicalPlan {
+        PyLogicalPlan::from((*self.copy.input).clone())
+    }
+
+    fn output_url(&self) -> String {
+        self.copy.output_url.clone()
+    }
+
+    fn partition_by(&self) -> Vec<String> {
+        self.copy.partition_by.clone()
+    }
+
+    fn file_type(&self) -> PyFileType {
+        PyFileType {
+            file_type: self.copy.file_type.clone(),
+        }
+    }
+
+    fn options(&self) -> HashMap<String, String> {
+        self.copy.options.clone()
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("CopyTo({self})"))
+    }
+
+    fn __name__(&self) -> PyResult<String> {
+        Ok("CopyTo".to_string())
+    }
+}
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "FileType",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyFileType {
+    file_type: Arc<dyn FileType>,
+}
+
+impl Display for PyFileType {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "FileType: {}", self.file_type)
+    }
+}
+
+#[pymethods]
+impl PyFileType {
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("FileType({self})"))
+    }
+
+    fn __name__(&self) -> PyResult<String> {
+        Ok("FileType".to_string())
+    }
+}
diff --git a/src/expr/create_catalog.rs b/src/expr/create_catalog.rs
new file mode 100644
index 000000000..fa95980c0
--- /dev/null
+++ b/src/expr/create_catalog.rs
@@ -0,0 +1,105 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::fmt::{self, Display, Formatter};
+use std::sync::Arc;
+
+use datafusion::logical_expr::CreateCatalog;
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
+use super::logical_node::LogicalNode;
+use crate::common::df_schema::PyDFSchema;
+use crate::sql::logical::PyLogicalPlan;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "CreateCatalog",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyCreateCatalog {
+    create: CreateCatalog,
+}
+
+impl From<PyCreateCatalog> for CreateCatalog {
+    fn from(create: PyCreateCatalog) -> Self {
+        create.create
+    }
+}
+
+impl From<CreateCatalog> for PyCreateCatalog {
+    fn from(create: CreateCatalog) -> PyCreateCatalog {
+        PyCreateCatalog { create }
+    }
+}
+
+impl Display for PyCreateCatalog {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "CreateCatalog: {:?}", self.create.catalog_name)
+    }
+}
+
+#[pymethods]
+impl PyCreateCatalog {
+    #[new]
+    pub fn new(
+        catalog_name: String,
+        if_not_exists: bool,
+        schema: PyDFSchema,
+    ) -> PyResult<PyCreateCatalog> {
+        Ok(PyCreateCatalog {
+            create: CreateCatalog {
+                catalog_name,
+                if_not_exists,
+                schema: Arc::new(schema.into()),
+            },
+        })
+    }
+
+    pub fn catalog_name(&self) -> String {
+        self.create.catalog_name.clone()
+    }
+
+    pub fn if_not_exists(&self) -> bool {
+        self.create.if_not_exists
+    }
+
+    pub fn schema(&self) -> PyDFSchema {
+        (*self.create.schema).clone().into()
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("CreateCatalog({self})"))
+    }
+
+    fn __name__(&self) -> PyResult<String> {
+        Ok("CreateCatalog".to_string())
+    }
+}
+
+impl LogicalNode for PyCreateCatalog {
+    fn inputs(&self) -> Vec<PyLogicalPlan> {
+        vec![]
+    }
+
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
diff --git a/src/expr/create_catalog_schema.rs b/src/expr/create_catalog_schema.rs
new file mode 100644
index 000000000..d836284a0
--- /dev/null
+++ b/src/expr/create_catalog_schema.rs
@@ -0,0 +1,105 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::fmt::{self, Display, Formatter};
+use std::sync::Arc;
+
+use datafusion::logical_expr::CreateCatalogSchema;
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
+use super::logical_node::LogicalNode;
+use crate::common::df_schema::PyDFSchema;
+use crate::sql::logical::PyLogicalPlan;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "CreateCatalogSchema",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyCreateCatalogSchema {
+    create: CreateCatalogSchema,
+}
+
+impl From<PyCreateCatalogSchema> for CreateCatalogSchema {
+    fn from(create: PyCreateCatalogSchema) -> Self {
+        create.create
+    }
+}
+
+impl From<CreateCatalogSchema> for PyCreateCatalogSchema {
+    fn from(create: CreateCatalogSchema) -> PyCreateCatalogSchema {
+        PyCreateCatalogSchema { create }
+    }
+}
+
+impl Display for PyCreateCatalogSchema {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "CreateCatalogSchema: {:?}", self.create.schema_name)
+    }
+}
+
+#[pymethods]
+impl PyCreateCatalogSchema {
+    #[new]
+    pub fn new(
+        schema_name: String,
+        if_not_exists: bool,
+        schema: PyDFSchema,
+    ) -> PyResult<PyCreateCatalogSchema> {
+        Ok(PyCreateCatalogSchema {
+            create: CreateCatalogSchema {
+                schema_name,
+                if_not_exists,
+                schema: Arc::new(schema.into()),
+            },
+        })
+    }
+
+    pub fn schema_name(&self) -> String {
+        self.create.schema_name.clone()
+    }
+
+    pub fn if_not_exists(&self) -> bool {
+        self.create.if_not_exists
+    }
+
+    pub fn schema(&self) -> PyDFSchema {
+        (*self.create.schema).clone().into()
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("CreateCatalogSchema({self})"))
+    }
+
+    fn __name__(&self) -> PyResult<String> {
+        Ok("CreateCatalogSchema".to_string())
+    }
+}
+
+impl LogicalNode for PyCreateCatalogSchema {
+    fn inputs(&self) -> Vec<PyLogicalPlan> {
+        vec![]
+    }
+
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
diff --git a/src/expr/create_external_table.rs b/src/expr/create_external_table.rs
new file mode 100644
index 000000000..980eea131
--- /dev/null
+++ b/src/expr/create_external_table.rs
@@ -0,0 +1,192 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::collections::HashMap;
+use std::fmt::{self, Display, Formatter};
+use std::sync::Arc;
+
+use datafusion::logical_expr::CreateExternalTable;
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
+use super::logical_node::LogicalNode;
+use super::sort_expr::PySortExpr;
+use crate::common::df_schema::PyDFSchema;
+use crate::common::schema::PyConstraints;
+use crate::expr::PyExpr;
+use crate::sql::logical::PyLogicalPlan;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "CreateExternalTable",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyCreateExternalTable {
+    create: CreateExternalTable,
+}
+
+impl From<PyCreateExternalTable> for CreateExternalTable {
+    fn from(create: PyCreateExternalTable) -> Self {
+        create.create
+    }
+}
+
+impl From<CreateExternalTable> for PyCreateExternalTable {
+    fn from(create: CreateExternalTable) -> PyCreateExternalTable {
+        PyCreateExternalTable { create }
+    }
+}
+
+impl Display for PyCreateExternalTable {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(
+            f,
+            "CreateExternalTable: {:?}{}",
+            self.create.name, self.create.constraints
+        )
+    }
+}
+
+#[pymethods]
+impl PyCreateExternalTable {
+    #[allow(clippy::too_many_arguments)]
+    #[new]
+    #[pyo3(signature = (schema, name, location, file_type, table_partition_cols, if_not_exists, or_replace, temporary, order_exprs, unbounded, options, constraints, column_defaults, definition=None))]
+    pub fn new(
+        schema: PyDFSchema,
+        name: String,
+        location: String,
+        file_type: String,
+        table_partition_cols: Vec<String>,
+        if_not_exists: bool,
+        or_replace: bool,
+        temporary: bool,
+        order_exprs: Vec<Vec<PySortExpr>>,
+        unbounded: bool,
+        options: HashMap<String, String>,
+        constraints: PyConstraints,
+        column_defaults: HashMap<String, PyExpr>,
+        definition: Option<String>,
+    ) -> Self {
+        let create = CreateExternalTable {
+            schema: Arc::new(schema.into()),
+            name: name.into(),
+            location,
+            file_type,
+            table_partition_cols,
+            if_not_exists,
+            or_replace,
+            temporary,
+            definition,
+            order_exprs: order_exprs
+                .into_iter()
+                .map(|vec| vec.into_iter().map(|s| s.into()).collect::<Vec<_>>())
+                .collect::<Vec<_>>(),
+            unbounded,
+            options,
+            constraints: constraints.constraints,
+            column_defaults: column_defaults
+                .into_iter()
+                .map(|(k, v)| (k, v.into()))
+                .collect(),
+        };
+        PyCreateExternalTable { create }
+    }
+
+    pub fn schema(&self) -> PyDFSchema {
+        (*self.create.schema).clone().into()
+    }
+
+    pub fn name(&self) -> PyResult<String> {
+        Ok(self.create.name.to_string())
+    }
+
+    pub fn location(&self) -> String {
+        self.create.location.clone()
+    }
+
+    pub fn file_type(&self) -> String {
+        self.create.file_type.clone()
+    }
+
+    pub fn table_partition_cols(&self) -> Vec<String> {
+        self.create.table_partition_cols.clone()
+    }
+
+    pub fn if_not_exists(&self) -> bool {
+        self.create.if_not_exists
+    }
+
+    pub fn temporary(&self) -> bool {
+        self.create.temporary
+    }
+
+    pub fn definition(&self) -> Option<String> {
+        self.create.definition.clone()
+    }
+
+    pub fn order_exprs(&self) -> Vec<Vec<PySortExpr>> {
+        self.create
+            .order_exprs
+            .iter()
+            .map(|vec| vec.iter().map(|s| s.clone().into()).collect())
+            .collect()
+    }
+
+    pub fn unbounded(&self) -> bool {
+        self.create.unbounded
+    }
+
+    pub fn options(&self) -> HashMap<String, String> {
+        self.create.options.clone()
+    }
+
+    pub fn constraints(&self) -> PyConstraints {
+        PyConstraints {
+            constraints: self.create.constraints.clone(),
+        }
+    }
+
+    pub fn column_defaults(&self) -> HashMap<String, PyExpr> {
+        self.create
+            .column_defaults
+            .iter()
+            .map(|(k, v)| (k.clone(), v.clone().into()))
+            .collect()
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("CreateExternalTable({self})"))
+    }
+
+    fn __name__(&self) -> PyResult<String> {
+        Ok("CreateExternalTable".to_string())
+    }
+}
+
+impl LogicalNode for PyCreateExternalTable {
+    fn inputs(&self) -> Vec<PyLogicalPlan> {
+        vec![]
+    }
+
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
diff --git a/src/expr/create_function.rs b/src/expr/create_function.rs
new file mode 100644
index 000000000..622858913
--- /dev/null
+++ b/src/expr/create_function.rs
@@ -0,0 +1,207 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::fmt::{self, Display, Formatter};
+use std::sync::Arc;
+
+use datafusion::logical_expr::{
+    CreateFunction, CreateFunctionBody, OperateFunctionArg, Volatility,
+};
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
+use super::PyExpr;
+use super::logical_node::LogicalNode;
+use crate::common::data_type::PyDataType;
+use crate::common::df_schema::PyDFSchema;
+use crate::sql::logical::PyLogicalPlan;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "CreateFunction",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyCreateFunction {
+    create: CreateFunction,
+}
+
+impl From<PyCreateFunction> for CreateFunction {
+    fn from(create: PyCreateFunction) -> Self {
+        create.create
+    }
+}
+
+impl From<CreateFunction> for PyCreateFunction {
+    fn from(create: CreateFunction) -> PyCreateFunction {
+        PyCreateFunction { create }
+    }
+}
+
+impl Display for PyCreateFunction {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "CreateFunction: name {:?}", self.create.name)
+    }
+}
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "OperateFunctionArg",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyOperateFunctionArg {
+    arg: OperateFunctionArg,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    eq,
+    eq_int,
+    name = "Volatility",
+    module = "datafusion.expr"
+)]
+pub enum PyVolatility {
+    Immutable,
+    Stable,
+    Volatile,
+}
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "CreateFunctionBody",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyCreateFunctionBody {
+    body: CreateFunctionBody,
+}
+
+#[pymethods]
+impl PyCreateFunctionBody {
+    pub fn language(&self) -> Option<String> {
+        self.body
+            .language
+            .as_ref()
+            .map(|language| language.to_string())
+    }
+
+    pub fn behavior(&self) -> Option<PyVolatility> {
+        self.body.behavior.as_ref().map(|behavior| match behavior {
+            Volatility::Immutable => PyVolatility::Immutable,
+            Volatility::Stable => PyVolatility::Stable,
+            Volatility::Volatile => PyVolatility::Volatile,
+        })
+    }
+
+    pub fn function_body(&self) -> Option<PyExpr> {
+        self.body
+            .function_body
+            .as_ref()
+            .map(|function_body| function_body.clone().into())
+    }
+}
+
+#[pymethods]
+impl PyCreateFunction {
+    #[new]
+    #[pyo3(signature = (or_replace, temporary, name, params, schema, return_type=None, args=None))]
+    pub fn new(
+        or_replace: bool,
+        temporary: bool,
+        name: String,
+        params: PyCreateFunctionBody,
+        schema: PyDFSchema,
+        return_type: Option<PyDataType>,
+        args: Option<Vec<PyOperateFunctionArg>>,
+    ) -> Self {
+        PyCreateFunction {
+            create: CreateFunction {
+                or_replace,
+                temporary,
+                name,
+                args: args.map(|args| args.into_iter().map(|arg| arg.arg).collect()),
+                return_type: return_type.map(|return_type| return_type.data_type),
+                params: params.body,
+                schema: Arc::new(schema.into()),
+            },
+        }
+    }
+
+    pub fn or_replace(&self) -> bool {
+        self.create.or_replace
+    }
+
+    pub fn temporary(&self) -> bool {
+        self.create.temporary
+    }
+
+    pub fn name(&self) -> String {
+        self.create.name.clone()
+    }
+
+    pub fn params(&self) -> PyCreateFunctionBody {
+        PyCreateFunctionBody {
+            body: self.create.params.clone(),
+        }
+    }
+
+    pub fn schema(&self) -> PyDFSchema {
+        (*self.create.schema).clone().into()
+    }
+
+    pub fn return_type(&self) -> Option<PyDataType> {
+        self.create
+            .return_type
+            .as_ref()
+            .map(|return_type| return_type.clone().into())
+    }
+
+    pub fn args(&self) -> Option<Vec<PyOperateFunctionArg>> {
+        self.create.args.as_ref().map(|args| {
+            args.iter()
+                .map(|arg| PyOperateFunctionArg { arg: arg.clone() })
+                .collect()
+        })
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("CreateFunction({self})"))
+    }
+
+    fn __name__(&self) -> PyResult<String> {
+        Ok("CreateFunction".to_string())
+    }
+}
+
+impl LogicalNode for PyCreateFunction {
+    fn inputs(&self) -> Vec<PyLogicalPlan> {
+        vec![]
+    }
+
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
diff --git a/src/expr/create_index.rs b/src/expr/create_index.rs
new file mode 100644
index 000000000..5f9bd11e8
--- /dev/null
+++ b/src/expr/create_index.rs
@@ -0,0 +1,135 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::fmt::{self, Display, Formatter};
+use std::sync::Arc;
+
+use datafusion::logical_expr::CreateIndex;
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
+use super::logical_node::LogicalNode;
+use super::sort_expr::PySortExpr;
+use crate::common::df_schema::PyDFSchema;
+use crate::sql::logical::PyLogicalPlan;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "CreateIndex",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyCreateIndex {
+    create: CreateIndex,
+}
+
+impl From<PyCreateIndex> for CreateIndex {
+    fn from(create: PyCreateIndex) -> Self {
+        create.create
+    }
+}
+
+impl From<CreateIndex> for PyCreateIndex {
+    fn from(create: CreateIndex) -> PyCreateIndex {
+        PyCreateIndex { create }
+    }
+}
+
+impl Display for PyCreateIndex {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "CreateIndex: {:?}", self.create.name)
+    }
+}
+
+#[pymethods]
+impl PyCreateIndex {
+    #[new]
+    #[pyo3(signature = (table, columns, unique, if_not_exists, schema, name=None, using=None))]
+    pub fn new(
+        table: String,
+        columns: Vec<PySortExpr>,
+        unique: bool,
+        if_not_exists: bool,
+        schema: PyDFSchema,
+        name: Option<String>,
+        using: Option<String>,
+    ) -> PyResult<Self> {
+        Ok(PyCreateIndex {
+            create: CreateIndex {
+                name,
+                table: table.into(),
+                using,
+                columns: columns.iter().map(|c| c.clone().into()).collect(),
+                unique,
+                if_not_exists,
+                schema: Arc::new(schema.into()),
+            },
+        })
+    }
+
+    pub fn name(&self) -> Option<String> {
+        self.create.name.clone()
+    }
+
+    pub fn table(&self) -> PyResult<String> {
+        Ok(self.create.table.to_string())
+    }
+
+    pub fn using(&self) -> Option<String> {
+        self.create.using.clone()
+    }
+
+    pub fn columns(&self) -> Vec<PySortExpr> {
+        self.create
+            .columns
+            .iter()
+            .map(|c| c.clone().into())
+            .collect()
+    }
+
+    pub fn unique(&self) -> bool {
+        self.create.unique
+    }
+
+    pub fn if_not_exists(&self) -> bool {
+        self.create.if_not_exists
+    }
+
+    pub fn schema(&self) -> PyDFSchema {
+        (*self.create.schema).clone().into()
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("CreateIndex({self})"))
+    }
+
+    fn __name__(&self) -> PyResult<String> {
+        Ok("CreateIndex".to_string())
+    }
+}
+
+impl LogicalNode for PyCreateIndex {
+    fn inputs(&self) -> Vec<PyLogicalPlan> {
+        vec![]
+    }
+
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
diff --git a/src/expr/create_memory_table.rs b/src/expr/create_memory_table.rs
index 509bf2168..3214dab0e 100644
--- a/src/expr/create_memory_table.rs
+++ b/src/expr/create_memory_table.rs
@@ -17,14 +17,20 @@
 
 use std::fmt::{self, Display, Formatter};
 
-use datafusion_expr::CreateMemoryTable;
+use datafusion::logical_expr::CreateMemoryTable;
+use pyo3::IntoPyObjectExt;
 use pyo3::prelude::*;
 
-use crate::sql::logical::PyLogicalPlan;
-
 use super::logical_node::LogicalNode;
+use crate::sql::logical::PyLogicalPlan;
 
-#[pyclass(name = "CreateMemoryTable", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "CreateMemoryTable",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyCreateMemoryTable {
     create: CreateMemoryTable,
@@ -78,7 +84,7 @@ impl PyCreateMemoryTable {
     }
 
     fn __repr__(&self) -> PyResult<String> {
-        Ok(format!("CreateMemoryTable({})", self))
+        Ok(format!("CreateMemoryTable({self})"))
     }
 
     fn __name__(&self) -> PyResult<String> {
@@ -91,7 +97,7 @@ impl LogicalNode for PyCreateMemoryTable {
         vec![PyLogicalPlan::from((*self.create.input).clone())]
     }
 
-    fn to_variant(&self, py: Python) -> PyResult<PyObject> {
-        Ok(self.clone().into_py(py))
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
     }
 }
diff --git a/src/expr/create_view.rs b/src/expr/create_view.rs
index 9d06239ea..6941ef769 100644
--- a/src/expr/create_view.rs
+++ b/src/expr/create_view.rs
@@ -17,14 +17,21 @@
 
 use std::fmt::{self, Display, Formatter};
 
-use datafusion_expr::CreateView;
+use datafusion::logical_expr::{CreateView, DdlStatement, LogicalPlan};
+use pyo3::IntoPyObjectExt;
 use pyo3::prelude::*;
 
-use crate::sql::logical::PyLogicalPlan;
-
 use super::logical_node::LogicalNode;
+use crate::errors::py_type_err;
+use crate::sql::logical::PyLogicalPlan;
 
-#[pyclass(name = "CreateView", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "CreateView",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyCreateView {
     create: CreateView,
@@ -75,7 +82,7 @@ impl PyCreateView {
     }
 
     fn __repr__(&self) -> PyResult<String> {
-        Ok(format!("CreateView({})", self))
+        Ok(format!("CreateView({self})"))
     }
 
     fn __name__(&self) -> PyResult<String> {
@@ -88,7 +95,18 @@ impl LogicalNode for PyCreateView {
         vec![PyLogicalPlan::from((*self.create.input).clone())]
     }
 
-    fn to_variant(&self, py: Python) -> PyResult<PyObject> {
-        Ok(self.clone().into_py(py))
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
+
+impl TryFrom<LogicalPlan> for PyCreateView {
+    type Error = PyErr;
+
+    fn try_from(logical_plan: LogicalPlan) -> Result<Self, Self::Error> {
+        match logical_plan {
+            LogicalPlan::Ddl(DdlStatement::CreateView(create)) => Ok(PyCreateView { create }),
+            _ => Err(py_type_err("unexpected plan")),
+        }
     }
 }
diff --git a/src/expr/cross_join.rs b/src/expr/cross_join.rs
deleted file mode 100644
index 68793f249..000000000
--- a/src/expr/cross_join.rs
+++ /dev/null
@@ -1,94 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-use datafusion_expr::logical_plan::CrossJoin;
-use pyo3::prelude::*;
-use std::fmt::{self, Display, Formatter};
-
-use super::logical_node::LogicalNode;
-use crate::common::df_schema::PyDFSchema;
-use crate::sql::logical::PyLogicalPlan;
-
-#[pyclass(name = "CrossJoin", module = "datafusion.expr", subclass)]
-#[derive(Clone)]
-pub struct PyCrossJoin {
-    cross_join: CrossJoin,
-}
-
-impl From<CrossJoin> for PyCrossJoin {
-    fn from(cross_join: CrossJoin) -> PyCrossJoin {
-        PyCrossJoin { cross_join }
-    }
-}
-
-impl From<PyCrossJoin> for CrossJoin {
-    fn from(cross_join: PyCrossJoin) -> Self {
-        cross_join.cross_join
-    }
-}
-
-impl Display for PyCrossJoin {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(
-            f,
-            "CrossJoin
-            \nLeft: {:?}
-            \nRight: {:?}
-            \nSchema: {:?}",
-            &self.cross_join.left, &self.cross_join.right, &self.cross_join.schema
-        )
-    }
-}
-
-#[pymethods]
-impl PyCrossJoin {
-    /// Retrieves the left input `LogicalPlan` to this `CrossJoin` node
-    fn left(&self) -> PyResult<PyLogicalPlan> {
-        Ok(self.cross_join.left.as_ref().clone().into())
-    }
-
-    /// Retrieves the right input `LogicalPlan` to this `CrossJoin` node
-    fn right(&self) -> PyResult<PyLogicalPlan> {
-        Ok(self.cross_join.right.as_ref().clone().into())
-    }
-
-    /// Resulting Schema for this `CrossJoin` node instance
-    fn schema(&self) -> PyResult<PyDFSchema> {
-        Ok(self.cross_join.schema.as_ref().clone().into())
-    }
-
-    fn __repr__(&self) -> PyResult<String> {
-        Ok(format!("CrossJoin({})", self))
-    }
-
-    fn __name__(&self) -> PyResult<String> {
-        Ok("CrossJoin".to_string())
-    }
-}
-
-impl LogicalNode for PyCrossJoin {
-    fn inputs(&self) -> Vec<PyLogicalPlan> {
-        vec![
-            PyLogicalPlan::from((*self.cross_join.left).clone()),
-            PyLogicalPlan::from((*self.cross_join.right).clone()),
-        ]
-    }
-
-    fn to_variant(&self, py: Python) -> PyResult<PyObject> {
-        Ok(self.clone().into_py(py))
-    }
-}
diff --git a/src/expr/describe_table.rs b/src/expr/describe_table.rs
new file mode 100644
index 000000000..73955bb34
--- /dev/null
+++ b/src/expr/describe_table.rs
@@ -0,0 +1,98 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::fmt::{self, Display, Formatter};
+use std::sync::Arc;
+
+use arrow::datatypes::Schema;
+use arrow::pyarrow::PyArrowType;
+use datafusion::logical_expr::DescribeTable;
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
+use super::logical_node::LogicalNode;
+use crate::common::df_schema::PyDFSchema;
+use crate::sql::logical::PyLogicalPlan;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "DescribeTable",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyDescribeTable {
+    describe: DescribeTable,
+}
+
+impl Display for PyDescribeTable {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "DescribeTable")
+    }
+}
+
+#[pymethods]
+impl PyDescribeTable {
+    #[new]
+    fn new(schema: PyArrowType<Schema>, output_schema: PyDFSchema) -> Self {
+        Self {
+            describe: DescribeTable {
+                schema: Arc::new(schema.0),
+                output_schema: Arc::new(output_schema.into()),
+            },
+        }
+    }
+
+    pub fn schema(&self) -> PyArrowType<Schema> {
+        (*self.describe.schema).clone().into()
+    }
+
+    pub fn output_schema(&self) -> PyDFSchema {
+        (*self.describe.output_schema).clone().into()
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("DescribeTable({self})"))
+    }
+
+    fn __name__(&self) -> PyResult<String> {
+        Ok("DescribeTable".to_string())
+    }
+}
+
+impl From<PyDescribeTable> for DescribeTable {
+    fn from(describe: PyDescribeTable) -> Self {
+        describe.describe
+    }
+}
+
+impl From<DescribeTable> for PyDescribeTable {
+    fn from(describe: DescribeTable) -> PyDescribeTable {
+        PyDescribeTable { describe }
+    }
+}
+
+impl LogicalNode for PyDescribeTable {
+    fn inputs(&self) -> Vec<PyLogicalPlan> {
+        vec![]
+    }
+
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
diff --git a/src/expr/distinct.rs b/src/expr/distinct.rs
index 681ae953b..68c2a17fe 100644
--- a/src/expr/distinct.rs
+++ b/src/expr/distinct.rs
@@ -17,14 +17,20 @@
 
 use std::fmt::{self, Display, Formatter};
 
-use datafusion_expr::Distinct;
+use datafusion::logical_expr::Distinct;
+use pyo3::IntoPyObjectExt;
 use pyo3::prelude::*;
 
-use crate::sql::logical::PyLogicalPlan;
-
 use super::logical_node::LogicalNode;
+use crate::sql::logical::PyLogicalPlan;
 
-#[pyclass(name = "Distinct", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Distinct",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyDistinct {
     distinct: Distinct,
@@ -44,12 +50,21 @@ impl From<Distinct> for PyDistinct {
 
 impl Display for PyDistinct {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(
-            f,
-            "Distinct
+        match &self.distinct {
+            Distinct::All(input) => write!(
+                f,
+                "Distinct ALL
+            \nInput: {input:?}",
+            ),
+            Distinct::On(distinct_on) => {
+                write!(
+                    f,
+                    "Distinct ON
             \nInput: {:?}",
-            self.distinct.input,
-        )
+                    distinct_on.input,
+                )
+            }
+        }
     }
 }
 
@@ -61,7 +76,7 @@ impl PyDistinct {
     }
 
     fn __repr__(&self) -> PyResult<String> {
-        Ok(format!("Distinct({})", self))
+        Ok(format!("Distinct({self})"))
     }
 
     fn __name__(&self) -> PyResult<String> {
@@ -71,10 +86,15 @@ impl PyDistinct {
 
 impl LogicalNode for PyDistinct {
     fn inputs(&self) -> Vec<PyLogicalPlan> {
-        vec![PyLogicalPlan::from((*self.distinct.input).clone())]
+        match &self.distinct {
+            Distinct::All(input) => vec![PyLogicalPlan::from(input.as_ref().clone())],
+            Distinct::On(distinct_on) => {
+                vec![PyLogicalPlan::from(distinct_on.input.as_ref().clone())]
+            }
+        }
     }
 
-    fn to_variant(&self, py: Python) -> PyResult<PyObject> {
-        Ok(self.clone().into_py(py))
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
     }
 }
diff --git a/src/expr/dml.rs b/src/expr/dml.rs
new file mode 100644
index 000000000..26f975820
--- /dev/null
+++ b/src/expr/dml.rs
@@ -0,0 +1,149 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use datafusion::logical_expr::dml::InsertOp;
+use datafusion::logical_expr::{DmlStatement, WriteOp};
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
+use super::logical_node::LogicalNode;
+use crate::common::df_schema::PyDFSchema;
+use crate::common::schema::PyTableSource;
+use crate::sql::logical::PyLogicalPlan;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "DmlStatement",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyDmlStatement {
+    dml: DmlStatement,
+}
+
+impl From<PyDmlStatement> for DmlStatement {
+    fn from(dml: PyDmlStatement) -> Self {
+        dml.dml
+    }
+}
+
+impl From<DmlStatement> for PyDmlStatement {
+    fn from(dml: DmlStatement) -> PyDmlStatement {
+        PyDmlStatement { dml }
+    }
+}
+
+impl LogicalNode for PyDmlStatement {
+    fn inputs(&self) -> Vec<PyLogicalPlan> {
+        vec![PyLogicalPlan::from((*self.dml.input).clone())]
+    }
+
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
+
+#[pymethods]
+impl PyDmlStatement {
+    pub fn table_name(&self) -> PyResult<String> {
+        Ok(self.dml.table_name.to_string())
+    }
+
+    pub fn target(&self) -> PyResult<PyTableSource> {
+        Ok(PyTableSource {
+            table_source: self.dml.target.clone(),
+        })
+    }
+
+    pub fn op(&self) -> PyWriteOp {
+        self.dml.op.clone().into()
+    }
+
+    pub fn input(&self) -> PyLogicalPlan {
+        PyLogicalPlan {
+            plan: self.dml.input.clone(),
+        }
+    }
+
+    pub fn output_schema(&self) -> PyDFSchema {
+        (*self.dml.output_schema).clone().into()
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok("DmlStatement".to_string())
+    }
+
+    fn __name__(&self) -> PyResult<String> {
+        Ok("DmlStatement".to_string())
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[pyclass(
+    from_py_object,
+    eq,
+    eq_int,
+    name = "WriteOp",
+    module = "datafusion.expr"
+)]
+pub enum PyWriteOp {
+    Append,
+    Overwrite,
+    Replace,
+    Update,
+    Delete,
+    Ctas,
+    Truncate,
+}
+
+impl From<WriteOp> for PyWriteOp {
+    fn from(write_op: WriteOp) -> Self {
+        match write_op {
+            WriteOp::Insert(InsertOp::Append) => PyWriteOp::Append,
+            WriteOp::Insert(InsertOp::Overwrite) => PyWriteOp::Overwrite,
+            WriteOp::Insert(InsertOp::Replace) => PyWriteOp::Replace,
+            WriteOp::Update => PyWriteOp::Update,
+            WriteOp::Delete => PyWriteOp::Delete,
+            WriteOp::Ctas => PyWriteOp::Ctas,
+            WriteOp::Truncate => PyWriteOp::Truncate,
+        }
+    }
+}
+
+impl From<PyWriteOp> for WriteOp {
+    fn from(py: PyWriteOp) -> Self {
+        match py {
+            PyWriteOp::Append => WriteOp::Insert(InsertOp::Append),
+            PyWriteOp::Overwrite => WriteOp::Insert(InsertOp::Overwrite),
+            PyWriteOp::Replace => WriteOp::Insert(InsertOp::Replace),
+            PyWriteOp::Update => WriteOp::Update,
+            PyWriteOp::Delete => WriteOp::Delete,
+            PyWriteOp::Ctas => WriteOp::Ctas,
+            PyWriteOp::Truncate => WriteOp::Truncate,
+        }
+    }
+}
+
+#[pymethods]
+impl PyWriteOp {
+    fn name(&self) -> String {
+        let write_op: WriteOp = self.clone().into();
+        write_op.name().to_string()
+    }
+}
diff --git a/src/expr/drop_catalog_schema.rs b/src/expr/drop_catalog_schema.rs
new file mode 100644
index 000000000..fd5105332
--- /dev/null
+++ b/src/expr/drop_catalog_schema.rs
@@ -0,0 +1,123 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::fmt::{self, Display, Formatter};
+use std::sync::Arc;
+
+use datafusion::common::SchemaReference;
+use datafusion::logical_expr::DropCatalogSchema;
+use datafusion::sql::TableReference;
+use pyo3::IntoPyObjectExt;
+use pyo3::exceptions::PyValueError;
+use pyo3::prelude::*;
+
+use super::logical_node::LogicalNode;
+use crate::common::df_schema::PyDFSchema;
+use crate::sql::logical::PyLogicalPlan;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "DropCatalogSchema",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyDropCatalogSchema {
+    drop: DropCatalogSchema,
+}
+
+impl From<PyDropCatalogSchema> for DropCatalogSchema {
+    fn from(drop: PyDropCatalogSchema) -> Self {
+        drop.drop
+    }
+}
+
+impl From<DropCatalogSchema> for PyDropCatalogSchema {
+    fn from(drop: DropCatalogSchema) -> PyDropCatalogSchema {
+        PyDropCatalogSchema { drop }
+    }
+}
+
+impl Display for PyDropCatalogSchema {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "DropCatalogSchema")
+    }
+}
+
+fn parse_schema_reference(name: String) -> PyResult<SchemaReference> {
+    match name.into() {
+        TableReference::Bare { table } => Ok(SchemaReference::Bare { schema: table }),
+        TableReference::Partial { schema, table } => Ok(SchemaReference::Full {
+            schema: table,
+            catalog: schema,
+        }),
+        TableReference::Full {
+            catalog: _,
+            schema: _,
+            table: _,
+        } => Err(PyErr::new::<PyValueError, String>(
+            "Invalid schema specifier (has 3 parts)".to_string(),
+        )),
+    }
+}
+
+#[pymethods]
+impl PyDropCatalogSchema {
+    #[new]
+    fn new(name: String, schema: PyDFSchema, if_exists: bool, cascade: bool) -> PyResult<Self> {
+        let name = parse_schema_reference(name)?;
+        Ok(PyDropCatalogSchema {
+            drop: DropCatalogSchema {
+                name,
+                schema: Arc::new(schema.into()),
+                if_exists,
+                cascade,
+            },
+        })
+    }
+
+    fn name(&self) -> PyResult<String> {
+        Ok(self.drop.name.to_string())
+    }
+
+    fn schema(&self) -> PyDFSchema {
+        (*self.drop.schema).clone().into()
+    }
+
+    fn if_exists(&self) -> PyResult<bool> {
+        Ok(self.drop.if_exists)
+    }
+
+    fn cascade(&self) -> PyResult<bool> {
+        Ok(self.drop.cascade)
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("DropCatalogSchema({self})"))
+    }
+}
+
+impl LogicalNode for PyDropCatalogSchema {
+    fn inputs(&self) -> Vec<PyLogicalPlan> {
+        vec![]
+    }
+
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
diff --git a/src/expr/drop_function.rs b/src/expr/drop_function.rs
new file mode 100644
index 000000000..0599dd49e
--- /dev/null
+++ b/src/expr/drop_function.rs
@@ -0,0 +1,100 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::fmt::{self, Display, Formatter};
+use std::sync::Arc;
+
+use datafusion::logical_expr::DropFunction;
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
+use super::logical_node::LogicalNode;
+use crate::common::df_schema::PyDFSchema;
+use crate::sql::logical::PyLogicalPlan;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "DropFunction",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyDropFunction {
+    drop: DropFunction,
+}
+
+impl From<PyDropFunction> for DropFunction {
+    fn from(drop: PyDropFunction) -> Self {
+        drop.drop
+    }
+}
+
+impl From<DropFunction> for PyDropFunction {
+    fn from(drop: DropFunction) -> PyDropFunction {
+        PyDropFunction { drop }
+    }
+}
+
+impl Display for PyDropFunction {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "DropFunction")
+    }
+}
+
+#[pymethods]
+impl PyDropFunction {
+    #[new]
+    fn new(name: String, schema: PyDFSchema, if_exists: bool) -> PyResult<Self> {
+        Ok(PyDropFunction {
+            drop: DropFunction {
+                name,
+                schema: Arc::new(schema.into()),
+                if_exists,
+            },
+        })
+    }
+    fn name(&self) -> PyResult<String> {
+        Ok(self.drop.name.clone())
+    }
+
+    fn schema(&self) -> PyDFSchema {
+        (*self.drop.schema).clone().into()
+    }
+
+    fn if_exists(&self) -> PyResult<bool> {
+        Ok(self.drop.if_exists)
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("DropFunction({self})"))
+    }
+
+    fn __name__(&self) -> PyResult<String> {
+        Ok("DropFunction".to_string())
+    }
+}
+
+impl LogicalNode for PyDropFunction {
+    fn inputs(&self) -> Vec<PyLogicalPlan> {
+        vec![]
+    }
+
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
diff --git a/src/expr/drop_table.rs b/src/expr/drop_table.rs
index 2a8836db5..46fe67465 100644
--- a/src/expr/drop_table.rs
+++ b/src/expr/drop_table.rs
@@ -17,14 +17,20 @@
 
 use std::fmt::{self, Display, Formatter};
 
-use datafusion_expr::logical_plan::DropTable;
+use datafusion::logical_expr::logical_plan::DropTable;
+use pyo3::IntoPyObjectExt;
 use pyo3::prelude::*;
 
-use crate::sql::logical::PyLogicalPlan;
-
 use super::logical_node::LogicalNode;
+use crate::sql::logical::PyLogicalPlan;
 
-#[pyclass(name = "DropTable", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "DropTable",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyDropTable {
     drop: DropTable,
@@ -70,7 +76,7 @@ impl PyDropTable {
     }
 
     fn __repr__(&self) -> PyResult<String> {
-        Ok(format!("DropTable({})", self))
+        Ok(format!("DropTable({self})"))
     }
 
     fn __name__(&self) -> PyResult<String> {
@@ -83,7 +89,7 @@ impl LogicalNode for PyDropTable {
         vec![]
     }
 
-    fn to_variant(&self, py: Python) -> PyResult<PyObject> {
-        Ok(self.clone().into_py(py))
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
     }
 }
diff --git a/src/expr/drop_view.rs b/src/expr/drop_view.rs
new file mode 100644
index 000000000..0d0c51f13
--- /dev/null
+++ b/src/expr/drop_view.rs
@@ -0,0 +1,106 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::fmt::{self, Display, Formatter};
+use std::sync::Arc;
+
+use datafusion::logical_expr::DropView;
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
+use super::logical_node::LogicalNode;
+use crate::common::df_schema::PyDFSchema;
+use crate::sql::logical::PyLogicalPlan;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "DropView",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyDropView {
+    drop: DropView,
+}
+
+impl From<PyDropView> for DropView {
+    fn from(drop: PyDropView) -> Self {
+        drop.drop
+    }
+}
+
+impl From<DropView> for PyDropView {
+    fn from(drop: DropView) -> PyDropView {
+        PyDropView { drop }
+    }
+}
+
+impl Display for PyDropView {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(
+            f,
+            "DropView: {name:?} if not exist:={if_exists}",
+            name = self.drop.name,
+            if_exists = self.drop.if_exists
+        )
+    }
+}
+
+#[pymethods]
+impl PyDropView {
+    #[new]
+    fn new(name: String, schema: PyDFSchema, if_exists: bool) -> PyResult<Self> {
+        Ok(PyDropView {
+            drop: DropView {
+                name: name.into(),
+                schema: Arc::new(schema.into()),
+                if_exists,
+            },
+        })
+    }
+
+    fn name(&self) -> PyResult<String> {
+        Ok(self.drop.name.to_string())
+    }
+
+    fn schema(&self) -> PyDFSchema {
+        (*self.drop.schema).clone().into()
+    }
+
+    fn if_exists(&self) -> PyResult<bool> {
+        Ok(self.drop.if_exists)
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("DropView({self})"))
+    }
+
+    fn __name__(&self) -> PyResult<String> {
+        Ok("DropView".to_string())
+    }
+}
+
+impl LogicalNode for PyDropView {
+    fn inputs(&self) -> Vec<PyLogicalPlan> {
+        vec![]
+    }
+
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
diff --git a/src/expr/empty_relation.rs b/src/expr/empty_relation.rs
index 0bc222e59..f3c237731 100644
--- a/src/expr/empty_relation.rs
+++ b/src/expr/empty_relation.rs
@@ -15,14 +15,23 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::{common::df_schema::PyDFSchema, sql::logical::PyLogicalPlan};
-use datafusion_expr::EmptyRelation;
-use pyo3::prelude::*;
 use std::fmt::{self, Display, Formatter};
 
+use datafusion::logical_expr::EmptyRelation;
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
 use super::logical_node::LogicalNode;
+use crate::common::df_schema::PyDFSchema;
+use crate::sql::logical::PyLogicalPlan;
 
-#[pyclass(name = "EmptyRelation", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "EmptyRelation",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyEmptyRelation {
     empty: EmptyRelation,
@@ -65,7 +74,7 @@ impl PyEmptyRelation {
 
     /// Get a String representation of this column
     fn __repr__(&self) -> String {
-        format!("{}", self)
+        format!("{self}")
     }
 
     fn __name__(&self) -> PyResult<String> {
@@ -79,7 +88,7 @@ impl LogicalNode for PyEmptyRelation {
         vec![]
     }
 
-    fn to_variant(&self, py: Python) -> PyResult<PyObject> {
-        Ok(self.clone().into_py(py))
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
     }
 }
diff --git a/src/expr/exists.rs b/src/expr/exists.rs
index 7df9a6e81..d2e816127 100644
--- a/src/expr/exists.rs
+++ b/src/expr/exists.rs
@@ -15,31 +15,36 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion_expr::Subquery;
+use datafusion::logical_expr::expr::Exists;
 use pyo3::prelude::*;
 
 use super::subquery::PySubquery;
 
-#[pyclass(name = "Exists", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Exists",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyExists {
-    subquery: Subquery,
-    negated: bool,
+    exists: Exists,
 }
 
-impl PyExists {
-    pub fn new(subquery: Subquery, negated: bool) -> Self {
-        Self { subquery, negated }
+impl From<Exists> for PyExists {
+    fn from(exists: Exists) -> Self {
+        PyExists { exists }
     }
 }
 
 #[pymethods]
 impl PyExists {
     fn subquery(&self) -> PySubquery {
-        self.subquery.clone().into()
+        self.exists.subquery.clone().into()
     }
 
     fn negated(&self) -> bool {
-        self.negated
+        self.exists.negated
     }
 }
diff --git a/src/expr/explain.rs b/src/expr/explain.rs
index d5d6a7bbd..6259951de 100644
--- a/src/expr/explain.rs
+++ b/src/expr/explain.rs
@@ -17,14 +17,23 @@
 
 use std::fmt::{self, Display, Formatter};
 
-use datafusion_expr::{logical_plan::Explain, LogicalPlan};
+use datafusion::logical_expr::LogicalPlan;
+use datafusion::logical_expr::logical_plan::Explain;
+use pyo3::IntoPyObjectExt;
 use pyo3::prelude::*;
 
-use crate::{common::df_schema::PyDFSchema, errors::py_type_err, sql::logical::PyLogicalPlan};
-
 use super::logical_node::LogicalNode;
-
-#[pyclass(name = "Explain", module = "datafusion.expr", subclass)]
+use crate::common::df_schema::PyDFSchema;
+use crate::errors::py_type_err;
+use crate::sql::logical::PyLogicalPlan;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Explain",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyExplain {
     explain: Explain,
@@ -104,7 +113,7 @@ impl LogicalNode for PyExplain {
         vec![]
     }
 
-    fn to_variant(&self, py: Python) -> PyResult<PyObject> {
-        Ok(self.clone().into_py(py))
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
     }
 }
diff --git a/src/expr/extension.rs b/src/expr/extension.rs
index 81a435c23..a0b617565 100644
--- a/src/expr/extension.rs
+++ b/src/expr/extension.rs
@@ -15,14 +15,20 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion_expr::Extension;
+use datafusion::logical_expr::Extension;
+use pyo3::IntoPyObjectExt;
 use pyo3::prelude::*;
 
-use crate::sql::logical::PyLogicalPlan;
-
 use super::logical_node::LogicalNode;
+use crate::sql::logical::PyLogicalPlan;
 
-#[pyclass(name = "Extension", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Extension",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyExtension {
     pub node: Extension,
@@ -46,7 +52,7 @@ impl LogicalNode for PyExtension {
         vec![]
     }
 
-    fn to_variant(&self, py: Python) -> PyResult<PyObject> {
-        Ok(self.clone().into_py(py))
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
     }
 }
diff --git a/src/expr/filter.rs b/src/expr/filter.rs
index 2def2f7d6..67426806d 100644
--- a/src/expr/filter.rs
+++ b/src/expr/filter.rs
@@ -15,16 +15,24 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion_expr::logical_plan::Filter;
-use pyo3::prelude::*;
 use std::fmt::{self, Display, Formatter};
 
+use datafusion::logical_expr::logical_plan::Filter;
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
 use crate::common::df_schema::PyDFSchema;
-use crate::expr::logical_node::LogicalNode;
 use crate::expr::PyExpr;
+use crate::expr::logical_node::LogicalNode;
 use crate::sql::logical::PyLogicalPlan;
 
-#[pyclass(name = "Filter", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Filter",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyFilter {
     filter: Filter,
@@ -72,7 +80,7 @@ impl PyFilter {
     }
 
     fn __repr__(&self) -> String {
-        format!("Filter({})", self)
+        format!("Filter({self})")
     }
 }
 
@@ -81,7 +89,7 @@ impl LogicalNode for PyFilter {
         vec![PyLogicalPlan::from((*self.filter.input).clone())]
     }
 
-    fn to_variant(&self, py: Python) -> PyResult<PyObject> {
-        Ok(self.clone().into_py(py))
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
     }
 }
diff --git a/src/expr/grouping_set.rs b/src/expr/grouping_set.rs
index b73932863..549a866ed 100644
--- a/src/expr/grouping_set.rs
+++ b/src/expr/grouping_set.rs
@@ -15,10 +15,16 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion_expr::GroupingSet;
+use datafusion::logical_expr::GroupingSet;
 use pyo3::prelude::*;
 
-#[pyclass(name = "GroupingSet", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "GroupingSet",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyGroupingSet {
     grouping_set: GroupingSet,
diff --git a/src/expr/in_list.rs b/src/expr/in_list.rs
index 840eee2ce..0612cc21e 100644
--- a/src/expr/in_list.rs
+++ b/src/expr/in_list.rs
@@ -15,39 +15,40 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::expr::PyExpr;
-use datafusion_expr::Expr;
+use datafusion::logical_expr::expr::InList;
 use pyo3::prelude::*;
 
-#[pyclass(name = "InList", module = "datafusion.expr", subclass)]
+use crate::expr::PyExpr;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "InList",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyInList {
-    expr: Box<Expr>,
-    list: Vec<Expr>,
-    negated: bool,
+    in_list: InList,
 }
 
-impl PyInList {
-    pub fn new(expr: Box<Expr>, list: Vec<Expr>, negated: bool) -> Self {
-        Self {
-            expr,
-            list,
-            negated,
-        }
+impl From<InList> for PyInList {
+    fn from(in_list: InList) -> Self {
+        PyInList { in_list }
     }
 }
 
 #[pymethods]
 impl PyInList {
     fn expr(&self) -> PyExpr {
-        (*self.expr).clone().into()
+        (*self.in_list.expr).clone().into()
     }
 
     fn list(&self) -> Vec<PyExpr> {
-        self.list.iter().map(|e| e.clone().into()).collect()
+        self.in_list.list.iter().map(|e| e.clone().into()).collect()
     }
 
     fn negated(&self) -> bool {
-        self.negated
+        self.in_list.negated
     }
 }
diff --git a/src/expr/in_subquery.rs b/src/expr/in_subquery.rs
index 6cee4a1f0..81a2c5794 100644
--- a/src/expr/in_subquery.rs
+++ b/src/expr/in_subquery.rs
@@ -15,40 +15,41 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion_expr::{Expr, Subquery};
+use datafusion::logical_expr::expr::InSubquery;
 use pyo3::prelude::*;
 
-use super::{subquery::PySubquery, PyExpr};
+use super::PyExpr;
+use super::subquery::PySubquery;
 
-#[pyclass(name = "InSubquery", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "InSubquery",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyInSubquery {
-    expr: Box<Expr>,
-    subquery: Subquery,
-    negated: bool,
+    in_subquery: InSubquery,
 }
 
-impl PyInSubquery {
-    pub fn new(expr: Box<Expr>, subquery: Subquery, negated: bool) -> Self {
-        Self {
-            expr,
-            subquery,
-            negated,
-        }
+impl From<InSubquery> for PyInSubquery {
+    fn from(in_subquery: InSubquery) -> Self {
+        PyInSubquery { in_subquery }
     }
 }
 
 #[pymethods]
 impl PyInSubquery {
     fn expr(&self) -> PyExpr {
-        (*self.expr).clone().into()
+        (*self.in_subquery.expr).clone().into()
     }
 
     fn subquery(&self) -> PySubquery {
-        self.subquery.clone().into()
+        self.in_subquery.subquery.clone().into()
     }
 
     fn negated(&self) -> bool {
-        self.negated
+        self.in_subquery.negated
     }
 }
diff --git a/src/expr/indexed_field.rs b/src/expr/indexed_field.rs
index c98607712..98a90d8d4 100644
--- a/src/expr/indexed_field.rs
+++ b/src/expr/indexed_field.rs
@@ -15,14 +15,21 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::expr::PyExpr;
-use datafusion_expr::expr::GetIndexedField;
-use pyo3::prelude::*;
 use std::fmt::{Display, Formatter};
 
+use datafusion::logical_expr::expr::{GetFieldAccess, GetIndexedField};
+use pyo3::prelude::*;
+
 use super::literal::PyLiteral;
+use crate::expr::PyExpr;
 
-#[pyclass(name = "GetIndexedField", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "GetIndexedField",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyGetIndexedField {
     indexed_field: GetIndexedField,
@@ -47,7 +54,7 @@ impl Display for PyGetIndexedField {
             "GetIndexedField
             Expr: {:?}
             Key: {:?}",
-            &self.indexed_field.expr, &self.indexed_field.key
+            &self.indexed_field.expr, &self.indexed_field.field
         )
     }
 }
@@ -59,7 +66,10 @@ impl PyGetIndexedField {
     }
 
     fn key(&self) -> PyResult<PyLiteral> {
-        Ok(self.indexed_field.key.clone().into())
+        match &self.indexed_field.field {
+            GetFieldAccess::NamedStructField { name, .. } => Ok(name.clone().into()),
+            _ => todo!(),
+        }
     }
 
     /// Get a String representation of this column
diff --git a/src/expr/join.rs b/src/expr/join.rs
index 801662962..b90f2f57d 100644
--- a/src/expr/join.rs
+++ b/src/expr/join.rs
@@ -15,16 +15,20 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion_expr::logical_plan::{Join, JoinConstraint, JoinType};
-use pyo3::prelude::*;
 use std::fmt::{self, Display, Formatter};
 
+use datafusion::common::NullEquality;
+use datafusion::logical_expr::logical_plan::{Join, JoinConstraint, JoinType};
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
 use crate::common::df_schema::PyDFSchema;
-use crate::expr::{logical_node::LogicalNode, PyExpr};
+use crate::expr::PyExpr;
+use crate::expr::logical_node::LogicalNode;
 use crate::sql::logical::PyLogicalPlan;
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[pyclass(name = "JoinType", module = "datafusion.expr")]
+#[pyclass(from_py_object, frozen, name = "JoinType", module = "datafusion.expr")]
 pub struct PyJoinType {
     join_type: JoinType,
 }
@@ -46,6 +50,10 @@ impl PyJoinType {
     pub fn is_outer(&self) -> bool {
         self.join_type.is_outer()
     }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("{}", self.join_type))
+    }
 }
 
 impl Display for PyJoinType {
@@ -55,7 +63,12 @@ impl Display for PyJoinType {
 }
 
 #[derive(Debug, Clone, Copy)]
-#[pyclass(name = "JoinConstraint", module = "datafusion.expr")]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "JoinConstraint",
+    module = "datafusion.expr"
+)]
 pub struct PyJoinConstraint {
     join_constraint: JoinConstraint,
 }
@@ -72,7 +85,23 @@ impl From<PyJoinConstraint> for JoinConstraint {
     }
 }
 
-#[pyclass(name = "Join", module = "datafusion.expr", subclass)]
+#[pymethods]
+impl PyJoinConstraint {
+    fn __repr__(&self) -> PyResult<String> {
+        match self.join_constraint {
+            JoinConstraint::On => Ok("On".to_string()),
+            JoinConstraint::Using => Ok("Using".to_string()),
+        }
+    }
+}
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Join",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyJoin {
     join: Join,
@@ -102,7 +131,7 @@ impl Display for PyJoin {
             JoinType: {:?}
             JoinConstraint: {:?}
             Schema: {:?}
-            NullEqualsNull: {:?}",
+            NullEquality: {:?}",
             &self.join.left,
             &self.join.right,
             &self.join.on,
@@ -110,7 +139,7 @@ impl Display for PyJoin {
             &self.join.join_type,
             &self.join.join_constraint,
             &self.join.schema,
-            &self.join.null_equals_null,
+            &self.join.null_equality,
         )
     }
 }
@@ -159,11 +188,14 @@ impl PyJoin {
 
     /// If null_equals_null is true, null == null else null != null
     fn null_equals_null(&self) -> PyResult<bool> {
-        Ok(self.join.null_equals_null)
+        match self.join.null_equality {
+            NullEquality::NullEqualsNothing => Ok(false),
+            NullEquality::NullEqualsNull => Ok(true),
+        }
     }
 
     fn __repr__(&self) -> PyResult<String> {
-        Ok(format!("Join({})", self))
+        Ok(format!("Join({self})"))
     }
 
     fn __name__(&self) -> PyResult<String> {
@@ -179,7 +211,7 @@ impl LogicalNode for PyJoin {
         ]
     }
 
-    fn to_variant(&self, py: Python) -> PyResult<PyObject> {
-        Ok(self.clone().into_py(py))
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
     }
 }
diff --git a/src/expr/like.rs b/src/expr/like.rs
index 6ed3c2467..417dc9182 100644
--- a/src/expr/like.rs
+++ b/src/expr/like.rs
@@ -15,13 +15,20 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion_expr::expr::Like;
-use pyo3::prelude::*;
 use std::fmt::{self, Display, Formatter};
 
+use datafusion::logical_expr::expr::Like;
+use pyo3::prelude::*;
+
 use crate::expr::PyExpr;
 
-#[pyclass(name = "Like", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Like",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyLike {
     like: Like,
@@ -75,11 +82,17 @@ impl PyLike {
     }
 
     fn __repr__(&self) -> String {
-        format!("Like({})", self)
+        format!("Like({self})")
     }
 }
 
-#[pyclass(name = "ILike", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "ILike",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyILike {
     like: Like,
@@ -133,11 +146,17 @@ impl PyILike {
     }
 
     fn __repr__(&self) -> String {
-        format!("Like({})", self)
+        format!("Like({self})")
     }
 }
 
-#[pyclass(name = "SimilarTo", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "SimilarTo",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PySimilarTo {
     like: Like,
@@ -191,6 +210,6 @@ impl PySimilarTo {
     }
 
     fn __repr__(&self) -> String {
-        format!("Like({})", self)
+        format!("Like({self})")
     }
 }
diff --git a/src/expr/limit.rs b/src/expr/limit.rs
index d7b3f4ca5..c04b8bfa8 100644
--- a/src/expr/limit.rs
+++ b/src/expr/limit.rs
@@ -15,15 +15,23 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion_expr::logical_plan::Limit;
-use pyo3::prelude::*;
 use std::fmt::{self, Display, Formatter};
 
+use datafusion::logical_expr::logical_plan::Limit;
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
 use crate::common::df_schema::PyDFSchema;
 use crate::expr::logical_node::LogicalNode;
 use crate::sql::logical::PyLogicalPlan;
 
-#[pyclass(name = "Limit", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Limit",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyLimit {
     limit: Limit,
@@ -46,7 +54,7 @@ impl Display for PyLimit {
         write!(
             f,
             "Limit
-            Skip: {}
+            Skip: {:?}
             Fetch: {:?}
             Input: {:?}",
             &self.limit.skip, &self.limit.fetch, &self.limit.input
@@ -56,15 +64,19 @@ impl Display for PyLimit {
 
 #[pymethods]
 impl PyLimit {
-    /// Retrieves the skip value for this `Limit`
-    fn skip(&self) -> usize {
-        self.limit.skip
-    }
+    // NOTE: Upstream now has expressions for skip and fetch
+    // TODO: Do we still want to expose these?
+    // REF: https://github.com/apache/datafusion/pull/12836
 
-    /// Retrieves the fetch value for this `Limit`
-    fn fetch(&self) -> Option<usize> {
-        self.limit.fetch
-    }
+    // /// Retrieves the skip value for this `Limit`
+    // fn skip(&self) -> usize {
+    //     self.limit.skip
+    // }
+
+    // /// Retrieves the fetch value for this `Limit`
+    // fn fetch(&self) -> Option<usize> {
+    //     self.limit.fetch
+    // }
 
     /// Retrieves the input `LogicalPlan` to this `Limit` node
     fn input(&self) -> PyResult<Vec<PyLogicalPlan>> {
@@ -77,7 +89,7 @@ impl PyLimit {
     }
 
     fn __repr__(&self) -> PyResult<String> {
-        Ok(format!("Limit({})", self))
+        Ok(format!("Limit({self})"))
     }
 }
 
@@ -86,7 +98,7 @@ impl LogicalNode for PyLimit {
         vec![PyLogicalPlan::from((*self.limit.input).clone())]
     }
 
-    fn to_variant(&self, py: Python) -> PyResult<PyObject> {
-        Ok(self.clone().into_py(py))
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
     }
 }
diff --git a/src/expr/literal.rs b/src/expr/literal.rs
index b29497e64..9db0f594b 100644
--- a/src/expr/literal.rs
+++ b/src/expr/literal.rs
@@ -15,14 +15,30 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::errors::{py_runtime_err, DataFusionError};
-use datafusion_common::ScalarValue;
+use datafusion::common::ScalarValue;
+use datafusion::logical_expr::expr::FieldMetadata;
+use pyo3::IntoPyObjectExt;
 use pyo3::prelude::*;
 
-#[pyclass(name = "Literal", module = "datafusion.expr", subclass)]
+use crate::errors::PyDataFusionError;
+
+#[pyclass(
+    from_py_object,
+    name = "Literal",
+    module = "datafusion.expr",
+    subclass,
+    frozen
+)]
 #[derive(Clone)]
 pub struct PyLiteral {
     pub value: ScalarValue,
+    pub metadata: Option<FieldMetadata>,
+}
+
+impl PyLiteral {
+    pub fn new_with_metadata(value: ScalarValue, metadata: Option<FieldMetadata>) -> PyLiteral {
+        Self { value, metadata }
+    }
 }
 
 impl From<PyLiteral> for ScalarValue {
@@ -33,7 +49,10 @@ impl From<PyLiteral> for ScalarValue {
 
 impl From<ScalarValue> for PyLiteral {
     fn from(value: ScalarValue) -> PyLiteral {
-        PyLiteral { value }
+        PyLiteral {
+            value,
+            metadata: None,
+        }
     }
 }
 
@@ -50,7 +69,7 @@ macro_rules! extract_scalar_value {
 impl PyLiteral {
     /// Get the data type of this literal value
     fn data_type(&self) -> String {
-        format!("{}", self.value.get_datatype())
+        format!("{}", self.value.data_type())
     }
 
     pub fn value_f32(&self) -> PyResult<Option<f32>> {
@@ -61,7 +80,7 @@ impl PyLiteral {
         extract_scalar_value!(self, Float64)
     }
 
-    pub fn value_decimal128(&mut self) -> PyResult<(Option<i128>, u8, i8)> {
+    pub fn value_decimal128(&self) -> PyResult<(Option<i128>, u8, i8)> {
         match &self.value {
             ScalarValue::Decimal128(value, precision, scale) => Ok((*value, *precision, *scale)),
             other => Err(unexpected_literal_value(other)),
@@ -112,12 +131,14 @@ impl PyLiteral {
         extract_scalar_value!(self, Time64Nanosecond)
     }
 
-    pub fn value_timestamp(&mut self) -> PyResult<(Option<i64>, Option<String>)> {
+    pub fn value_timestamp(&self) -> PyResult<(Option<i64>, Option<String>)> {
         match &self.value {
             ScalarValue::TimestampNanosecond(iv, tz)
             | ScalarValue::TimestampMicrosecond(iv, tz)
             | ScalarValue::TimestampMillisecond(iv, tz)
-            | ScalarValue::TimestampSecond(iv, tz) => Ok((*iv, tz.clone())),
+            | ScalarValue::TimestampSecond(iv, tz) => {
+                Ok((*iv, tz.as_ref().map(|s| s.as_ref().to_string())))
+            }
             other => Err(unexpected_literal_value(other)),
         }
     }
@@ -135,20 +156,15 @@ impl PyLiteral {
 
     pub fn value_interval_day_time(&self) -> PyResult<Option<(i32, i32)>> {
         match &self.value {
-            ScalarValue::IntervalDayTime(Some(iv)) => {
-                let interval = *iv as u64;
-                let days = (interval >> 32) as i32;
-                let ms = interval as i32;
-                Ok(Some((days, ms)))
-            }
+            ScalarValue::IntervalDayTime(Some(iv)) => Ok(Some((iv.days, iv.milliseconds))),
             ScalarValue::IntervalDayTime(None) => Ok(None),
             other => Err(unexpected_literal_value(other)),
         }
     }
 
     #[allow(clippy::wrong_self_convention)]
-    fn into_type(&self, py: Python) -> PyResult<PyObject> {
-        Ok(self.clone().into_py(py))
+    fn into_type<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
     }
 
     fn __repr__(&self) -> PyResult<String> {
@@ -157,5 +173,5 @@ impl PyLiteral {
 }
 
 fn unexpected_literal_value(value: &ScalarValue) -> PyErr {
-    DataFusionError::Common(format!("getValue<T>() - Unexpected value: {value}")).into()
+    PyDataFusionError::Common(format!("getValue<T>() - Unexpected value: {value}")).into()
 }
diff --git a/src/expr/logical_node.rs b/src/expr/logical_node.rs
index 757e4f94b..5aff70059 100644
--- a/src/expr/logical_node.rs
+++ b/src/expr/logical_node.rs
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use pyo3::{PyObject, PyResult, Python};
+use pyo3::{Bound, PyAny, PyResult, Python};
 
 use crate::sql::logical::PyLogicalPlan;
 
@@ -25,5 +25,5 @@ pub trait LogicalNode {
     /// The input plan to the current logical node instance.
     fn inputs(&self) -> Vec<PyLogicalPlan>;
 
-    fn to_variant(&self, py: Python) -> PyResult<PyObject>;
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>>;
 }
diff --git a/src/expr/placeholder.rs b/src/expr/placeholder.rs
index e37c8b561..6bd88321c 100644
--- a/src/expr/placeholder.rs
+++ b/src/expr/placeholder.rs
@@ -15,34 +15,48 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion::arrow::datatypes::DataType;
+use arrow::datatypes::Field;
+use arrow::pyarrow::PyArrowType;
+use datafusion::logical_expr::expr::Placeholder;
 use pyo3::prelude::*;
 
 use crate::common::data_type::PyDataType;
 
-#[pyclass(name = "Placeholder", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Placeholder",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyPlaceholder {
-    id: String,
-    data_type: Option<DataType>,
+    placeholder: Placeholder,
 }
 
-impl PyPlaceholder {
-    pub fn new(id: String, data_type: DataType) -> Self {
-        Self {
-            id,
-            data_type: Some(data_type),
-        }
+impl From<Placeholder> for PyPlaceholder {
+    fn from(placeholder: Placeholder) -> Self {
+        PyPlaceholder { placeholder }
     }
 }
 
 #[pymethods]
 impl PyPlaceholder {
     fn id(&self) -> String {
-        self.id.clone()
+        self.placeholder.id.clone()
     }
 
     fn data_type(&self) -> Option<PyDataType> {
-        self.data_type.as_ref().map(|e| e.clone().into())
+        self.placeholder
+            .field
+            .as_ref()
+            .map(|f| f.data_type().clone().into())
+    }
+
+    fn field(&self) -> Option<PyArrowType<Field>> {
+        self.placeholder
+            .field
+            .as_ref()
+            .map(|f| f.as_ref().clone().into())
     }
 }
diff --git a/src/expr/projection.rs b/src/expr/projection.rs
index f5ba12db2..456e06412 100644
--- a/src/expr/projection.rs
+++ b/src/expr/projection.rs
@@ -15,19 +15,28 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion_expr::logical_plan::Projection;
-use pyo3::prelude::*;
 use std::fmt::{self, Display, Formatter};
 
+use datafusion::logical_expr::Expr;
+use datafusion::logical_expr::logical_plan::Projection;
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
 use crate::common::df_schema::PyDFSchema;
-use crate::expr::logical_node::LogicalNode;
 use crate::expr::PyExpr;
+use crate::expr::logical_node::LogicalNode;
 use crate::sql::logical::PyLogicalPlan;
 
-#[pyclass(name = "Projection", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Projection",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyProjection {
-    projection: Projection,
+    pub projection: Projection,
 }
 
 impl PyProjection {
@@ -84,7 +93,7 @@ impl PyProjection {
     }
 
     fn __repr__(&self) -> PyResult<String> {
-        Ok(format!("Projection({})", self))
+        Ok(format!("Projection({self})"))
     }
 
     fn __name__(&self) -> PyResult<String> {
@@ -92,12 +101,27 @@ impl PyProjection {
     }
 }
 
+impl PyProjection {
+    /// Projection: Gets the names of the fields that should be projected
+    pub fn projected_expressions(local_expr: &PyExpr) -> Vec<PyExpr> {
+        let mut projs: Vec<PyExpr> = Vec::new();
+        match &local_expr.expr {
+            Expr::Alias(alias) => {
+                let py_expr: PyExpr = PyExpr::from(*alias.expr.clone());
+                projs.extend_from_slice(Self::projected_expressions(&py_expr).as_slice());
+            }
+            _ => projs.push(local_expr.clone()),
+        }
+        projs
+    }
+}
+
 impl LogicalNode for PyProjection {
     fn inputs(&self) -> Vec<PyLogicalPlan> {
         vec![PyLogicalPlan::from((*self.projection.input).clone())]
     }
 
-    fn to_variant(&self, py: Python) -> PyResult<PyObject> {
-        Ok(self.clone().into_py(py))
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
     }
 }
diff --git a/src/expr/recursive_query.rs b/src/expr/recursive_query.rs
new file mode 100644
index 000000000..e03137b80
--- /dev/null
+++ b/src/expr/recursive_query.rs
@@ -0,0 +1,117 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::fmt::{self, Display, Formatter};
+
+use datafusion::logical_expr::RecursiveQuery;
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
+use super::logical_node::LogicalNode;
+use crate::sql::logical::PyLogicalPlan;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "RecursiveQuery",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyRecursiveQuery {
+    query: RecursiveQuery,
+}
+
+impl From<PyRecursiveQuery> for RecursiveQuery {
+    fn from(query: PyRecursiveQuery) -> Self {
+        query.query
+    }
+}
+
+impl From<RecursiveQuery> for PyRecursiveQuery {
+    fn from(query: RecursiveQuery) -> PyRecursiveQuery {
+        PyRecursiveQuery { query }
+    }
+}
+
+impl Display for PyRecursiveQuery {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(
+            f,
+            "RecursiveQuery {name:?} is_distinct:={is_distinct}",
+            name = self.query.name,
+            is_distinct = self.query.is_distinct
+        )
+    }
+}
+
+#[pymethods]
+impl PyRecursiveQuery {
+    #[new]
+    fn new(
+        name: String,
+        static_term: PyLogicalPlan,
+        recursive_term: PyLogicalPlan,
+        is_distinct: bool,
+    ) -> Self {
+        Self {
+            query: RecursiveQuery {
+                name,
+                static_term: static_term.plan(),
+                recursive_term: recursive_term.plan(),
+                is_distinct,
+            },
+        }
+    }
+
+    fn name(&self) -> PyResult<String> {
+        Ok(self.query.name.clone())
+    }
+
+    fn static_term(&self) -> PyLogicalPlan {
+        PyLogicalPlan::from((*self.query.static_term).clone())
+    }
+
+    fn recursive_term(&self) -> PyLogicalPlan {
+        PyLogicalPlan::from((*self.query.recursive_term).clone())
+    }
+
+    fn is_distinct(&self) -> PyResult<bool> {
+        Ok(self.query.is_distinct)
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("RecursiveQuery({self})"))
+    }
+
+    fn __name__(&self) -> PyResult<String> {
+        Ok("RecursiveQuery".to_string())
+    }
+}
+
+impl LogicalNode for PyRecursiveQuery {
+    fn inputs(&self) -> Vec<PyLogicalPlan> {
+        vec![
+            PyLogicalPlan::from((*self.query.static_term).clone()),
+            PyLogicalPlan::from((*self.query.recursive_term).clone()),
+        ]
+    }
+
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
diff --git a/src/expr/repartition.rs b/src/expr/repartition.rs
index e3e14f878..be39b9978 100644
--- a/src/expr/repartition.rs
+++ b/src/expr/repartition.rs
@@ -17,20 +17,35 @@
 
 use std::fmt::{self, Display, Formatter};
 
-use datafusion_expr::{logical_plan::Repartition, Expr, Partitioning};
+use datafusion::logical_expr::logical_plan::Repartition;
+use datafusion::logical_expr::{Expr, Partitioning};
+use pyo3::IntoPyObjectExt;
 use pyo3::prelude::*;
 
-use crate::{errors::py_type_err, sql::logical::PyLogicalPlan};
-
-use super::{logical_node::LogicalNode, PyExpr};
-
-#[pyclass(name = "Repartition", module = "datafusion.expr", subclass)]
+use super::PyExpr;
+use super::logical_node::LogicalNode;
+use crate::errors::py_type_err;
+use crate::sql::logical::PyLogicalPlan;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Repartition",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyRepartition {
     repartition: Repartition,
 }
 
-#[pyclass(name = "Partitioning", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Partitioning",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyPartitioning {
     partitioning: Partitioning,
@@ -108,7 +123,7 @@ impl PyRepartition {
     }
 
     fn __repr__(&self) -> PyResult<String> {
-        Ok(format!("Repartition({})", self))
+        Ok(format!("Repartition({self})"))
     }
 
     fn __name__(&self) -> PyResult<String> {
@@ -121,7 +136,7 @@ impl LogicalNode for PyRepartition {
         vec![PyLogicalPlan::from((*self.repartition.input).clone())]
     }
 
-    fn to_variant(&self, py: Python) -> PyResult<PyObject> {
-        Ok(self.clone().into_py(py))
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
     }
 }
diff --git a/src/expr/scalar_function.rs b/src/expr/scalar_function.rs
deleted file mode 100644
index 1a71d5692..000000000
--- a/src/expr/scalar_function.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-use crate::expr::PyExpr;
-use datafusion_expr::{BuiltinScalarFunction, Expr};
-use pyo3::prelude::*;
-
-#[pyclass(name = "ScalarFunction", module = "datafusion.expr", subclass)]
-#[derive(Clone)]
-pub struct PyScalarFunction {
-    scalar_function: BuiltinScalarFunction,
-    args: Vec<Expr>,
-}
-
-impl PyScalarFunction {
-    pub fn new(scalar_function: BuiltinScalarFunction, args: Vec<Expr>) -> Self {
-        Self {
-            scalar_function,
-            args,
-        }
-    }
-}
-
-#[pyclass(name = "BuiltinScalarFunction", module = "datafusion.expr", subclass)]
-#[derive(Clone)]
-pub struct PyBuiltinScalarFunction {
-    scalar_function: BuiltinScalarFunction,
-}
-
-impl From<BuiltinScalarFunction> for PyBuiltinScalarFunction {
-    fn from(scalar_function: BuiltinScalarFunction) -> PyBuiltinScalarFunction {
-        PyBuiltinScalarFunction { scalar_function }
-    }
-}
-
-impl From<PyBuiltinScalarFunction> for BuiltinScalarFunction {
-    fn from(scalar_function: PyBuiltinScalarFunction) -> Self {
-        scalar_function.scalar_function
-    }
-}
-
-#[pymethods]
-impl PyScalarFunction {
-    fn fun(&self) -> PyResult<PyBuiltinScalarFunction> {
-        Ok(self.scalar_function.clone().into())
-    }
-
-    fn args(&self) -> PyResult<Vec<PyExpr>> {
-        Ok(self.args.iter().map(|e| e.clone().into()).collect())
-    }
-}
diff --git a/src/expr/scalar_subquery.rs b/src/expr/scalar_subquery.rs
index c71bb9905..c7852a4c4 100644
--- a/src/expr/scalar_subquery.rs
+++ b/src/expr/scalar_subquery.rs
@@ -15,12 +15,18 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion_expr::Subquery;
+use datafusion::logical_expr::Subquery;
 use pyo3::prelude::*;
 
 use super::subquery::PySubquery;
 
-#[pyclass(name = "ScalarSubquery", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "ScalarSubquery",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyScalarSubquery {
     subquery: Subquery,
diff --git a/src/expr/scalar_variable.rs b/src/expr/scalar_variable.rs
index 7b50ba241..2d3bc4b76 100644
--- a/src/expr/scalar_variable.rs
+++ b/src/expr/scalar_variable.rs
@@ -15,22 +15,28 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion::arrow::datatypes::DataType;
+use arrow::datatypes::FieldRef;
 use pyo3::prelude::*;
 
 use crate::common::data_type::PyDataType;
 
-#[pyclass(name = "ScalarVariable", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "ScalarVariable",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyScalarVariable {
-    data_type: DataType,
+    field: FieldRef,
     variables: Vec<String>,
 }
 
 impl PyScalarVariable {
-    pub fn new(data_type: &DataType, variables: &[String]) -> Self {
+    pub fn new(field: &FieldRef, variables: &[String]) -> Self {
         Self {
-            data_type: data_type.to_owned(),
+            field: field.to_owned(),
             variables: variables.to_vec(),
         }
     }
@@ -40,7 +46,7 @@ impl PyScalarVariable {
 impl PyScalarVariable {
     /// Get the data type
     fn data_type(&self) -> PyResult<PyDataType> {
-        Ok(self.data_type.clone().into())
+        Ok(self.field.data_type().clone().into())
     }
 
     fn variables(&self) -> PyResult<Vec<String>> {
@@ -48,6 +54,6 @@ impl PyScalarVariable {
     }
 
     fn __repr__(&self) -> PyResult<String> {
-        Ok(format!("{}{:?}", self.data_type, self.variables))
+        Ok(format!("{}{:?}", self.field.data_type(), self.variables))
     }
 }
diff --git a/src/expr/set_comparison.rs b/src/expr/set_comparison.rs
new file mode 100644
index 000000000..9f0c077e1
--- /dev/null
+++ b/src/expr/set_comparison.rs
@@ -0,0 +1,59 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use datafusion::logical_expr::expr::SetComparison;
+use pyo3::prelude::*;
+
+use super::subquery::PySubquery;
+use crate::expr::PyExpr;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "SetComparison",
+    module = "datafusion.set_comparison",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PySetComparison {
+    set_comparison: SetComparison,
+}
+
+impl From<SetComparison> for PySetComparison {
+    fn from(set_comparison: SetComparison) -> Self {
+        PySetComparison { set_comparison }
+    }
+}
+
+#[pymethods]
+impl PySetComparison {
+    fn expr(&self) -> PyExpr {
+        (*self.set_comparison.expr).clone().into()
+    }
+
+    fn subquery(&self) -> PySubquery {
+        self.set_comparison.subquery.clone().into()
+    }
+
+    fn op(&self) -> String {
+        format!("{}", self.set_comparison.op)
+    }
+
+    fn quantifier(&self) -> String {
+        format!("{}", self.set_comparison.quantifier)
+    }
+}
diff --git a/src/expr/signature.rs b/src/expr/signature.rs
index 2f194982e..35268e3a9 100644
--- a/src/expr/signature.rs
+++ b/src/expr/signature.rs
@@ -15,12 +15,17 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion_expr::{TypeSignature, Volatility};
+use datafusion::logical_expr::{TypeSignature, Volatility};
 use pyo3::prelude::*;
 
 #[allow(dead_code)]
-#[pyclass(name = "Signature", module = "datafusion.expr", subclass)]
-#[allow(dead_code)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Signature",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PySignature {
     type_signature: TypeSignature,
diff --git a/src/expr/sort.rs b/src/expr/sort.rs
index 8843c638d..7c1e654c5 100644
--- a/src/expr/sort.rs
+++ b/src/expr/sort.rs
@@ -15,17 +15,25 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion_common::DataFusionError;
-use datafusion_expr::logical_plan::Sort;
-use pyo3::prelude::*;
 use std::fmt::{self, Display, Formatter};
 
+use datafusion::common::DataFusionError;
+use datafusion::logical_expr::logical_plan::Sort;
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
 use crate::common::df_schema::PyDFSchema;
 use crate::expr::logical_node::LogicalNode;
-use crate::expr::PyExpr;
+use crate::expr::sort_expr::PySortExpr;
 use crate::sql::logical::PyLogicalPlan;
 
-#[pyclass(name = "Sort", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Sort",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PySort {
     sort: Sort,
@@ -63,15 +71,19 @@ impl Display for PySort {
 #[pymethods]
 impl PySort {
     /// Retrieves the sort expressions for this `Sort`
-    fn sort_exprs(&self) -> PyResult<Vec<PyExpr>> {
+    fn sort_exprs(&self) -> PyResult<Vec<PySortExpr>> {
         Ok(self
             .sort
             .expr
             .iter()
-            .map(|e| PyExpr::from(e.clone()))
+            .map(|e| PySortExpr::from(e.clone()))
             .collect())
     }
 
+    fn get_fetch_val(&self) -> PyResult<Option<usize>> {
+        Ok(self.sort.fetch)
+    }
+
     /// Retrieves the input `LogicalPlan` to this `Sort` node
     fn input(&self) -> PyResult<Vec<PyLogicalPlan>> {
         Ok(Self::inputs(self))
@@ -83,7 +95,7 @@ impl PySort {
     }
 
     fn __repr__(&self) -> PyResult<String> {
-        Ok(format!("Sort({})", self))
+        Ok(format!("Sort({self})"))
     }
 }
 
@@ -92,7 +104,7 @@ impl LogicalNode for PySort {
         vec![PyLogicalPlan::from((*self.sort.input).clone())]
     }
 
-    fn to_variant(&self, py: Python) -> PyResult<PyObject> {
-        Ok(self.clone().into_py(py))
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
     }
 }
diff --git a/src/expr/sort_expr.rs b/src/expr/sort_expr.rs
new file mode 100644
index 000000000..3c3c86bc1
--- /dev/null
+++ b/src/expr/sort_expr.rs
@@ -0,0 +1,98 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::fmt::{self, Display, Formatter};
+
+use datafusion::logical_expr::SortExpr;
+use pyo3::prelude::*;
+
+use crate::expr::PyExpr;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "SortExpr",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PySortExpr {
+    pub(crate) sort: SortExpr,
+}
+
+impl From<PySortExpr> for SortExpr {
+    fn from(sort: PySortExpr) -> Self {
+        sort.sort
+    }
+}
+
+impl From<SortExpr> for PySortExpr {
+    fn from(sort: SortExpr) -> PySortExpr {
+        PySortExpr { sort }
+    }
+}
+
+impl Display for PySortExpr {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(
+            f,
+            "Sort
+            Expr: {:?}
+            Asc: {:?}
+            NullsFirst: {:?}",
+            &self.sort.expr, &self.sort.asc, &self.sort.nulls_first
+        )
+    }
+}
+
+pub fn to_sort_expressions(order_by: Vec<PySortExpr>) -> Vec<SortExpr> {
+    order_by.iter().map(|e| e.sort.clone()).collect()
+}
+
+pub fn py_sort_expr_list(expr: &[SortExpr]) -> PyResult<Vec<PySortExpr>> {
+    Ok(expr.iter().map(|e| PySortExpr::from(e.clone())).collect())
+}
+
+#[pymethods]
+impl PySortExpr {
+    #[new]
+    fn new(expr: PyExpr, asc: bool, nulls_first: bool) -> Self {
+        Self {
+            sort: SortExpr {
+                expr: expr.into(),
+                asc,
+                nulls_first,
+            },
+        }
+    }
+
+    fn expr(&self) -> PyResult<PyExpr> {
+        Ok(self.sort.expr.clone().into())
+    }
+
+    fn ascending(&self) -> PyResult<bool> {
+        Ok(self.sort.asc)
+    }
+
+    fn nulls_first(&self) -> PyResult<bool> {
+        Ok(self.sort.nulls_first)
+    }
+
+    fn __repr__(&self) -> String {
+        format!("{self}")
+    }
+}
diff --git a/src/expr/statement.rs b/src/expr/statement.rs
new file mode 100644
index 000000000..5aa1e4e9c
--- /dev/null
+++ b/src/expr/statement.rs
@@ -0,0 +1,558 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::sync::Arc;
+
+use arrow::datatypes::Field;
+use arrow::pyarrow::PyArrowType;
+use datafusion::logical_expr::{
+    Deallocate, Execute, Prepare, ResetVariable, SetVariable, TransactionAccessMode,
+    TransactionConclusion, TransactionEnd, TransactionIsolationLevel, TransactionStart,
+};
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
+use super::PyExpr;
+use super::logical_node::LogicalNode;
+use crate::sql::logical::PyLogicalPlan;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "TransactionStart",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyTransactionStart {
+    transaction_start: TransactionStart,
+}
+
+impl From<TransactionStart> for PyTransactionStart {
+    fn from(transaction_start: TransactionStart) -> PyTransactionStart {
+        PyTransactionStart { transaction_start }
+    }
+}
+
+impl TryFrom<PyTransactionStart> for TransactionStart {
+    type Error = PyErr;
+
+    fn try_from(py: PyTransactionStart) -> Result<Self, Self::Error> {
+        Ok(py.transaction_start)
+    }
+}
+
+impl LogicalNode for PyTransactionStart {
+    fn inputs(&self) -> Vec<PyLogicalPlan> {
+        vec![]
+    }
+
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    eq,
+    eq_int,
+    name = "TransactionAccessMode",
+    module = "datafusion.expr"
+)]
+pub enum PyTransactionAccessMode {
+    ReadOnly,
+    ReadWrite,
+}
+
+impl From<TransactionAccessMode> for PyTransactionAccessMode {
+    fn from(access_mode: TransactionAccessMode) -> PyTransactionAccessMode {
+        match access_mode {
+            TransactionAccessMode::ReadOnly => PyTransactionAccessMode::ReadOnly,
+            TransactionAccessMode::ReadWrite => PyTransactionAccessMode::ReadWrite,
+        }
+    }
+}
+
+impl TryFrom<PyTransactionAccessMode> for TransactionAccessMode {
+    type Error = PyErr;
+
+    fn try_from(py: PyTransactionAccessMode) -> Result<Self, Self::Error> {
+        match py {
+            PyTransactionAccessMode::ReadOnly => Ok(TransactionAccessMode::ReadOnly),
+            PyTransactionAccessMode::ReadWrite => Ok(TransactionAccessMode::ReadWrite),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    eq,
+    eq_int,
+    name = "TransactionIsolationLevel",
+    module = "datafusion.expr"
+)]
+pub enum PyTransactionIsolationLevel {
+    ReadUncommitted,
+    ReadCommitted,
+    RepeatableRead,
+    Serializable,
+    Snapshot,
+}
+
+impl From<TransactionIsolationLevel> for PyTransactionIsolationLevel {
+    fn from(isolation_level: TransactionIsolationLevel) -> PyTransactionIsolationLevel {
+        match isolation_level {
+            TransactionIsolationLevel::ReadUncommitted => {
+                PyTransactionIsolationLevel::ReadUncommitted
+            }
+            TransactionIsolationLevel::ReadCommitted => PyTransactionIsolationLevel::ReadCommitted,
+            TransactionIsolationLevel::RepeatableRead => {
+                PyTransactionIsolationLevel::RepeatableRead
+            }
+            TransactionIsolationLevel::Serializable => PyTransactionIsolationLevel::Serializable,
+            TransactionIsolationLevel::Snapshot => PyTransactionIsolationLevel::Snapshot,
+        }
+    }
+}
+
+impl TryFrom<PyTransactionIsolationLevel> for TransactionIsolationLevel {
+    type Error = PyErr;
+
+    fn try_from(value: PyTransactionIsolationLevel) -> Result<Self, Self::Error> {
+        match value {
+            PyTransactionIsolationLevel::ReadUncommitted => {
+                Ok(TransactionIsolationLevel::ReadUncommitted)
+            }
+            PyTransactionIsolationLevel::ReadCommitted => {
+                Ok(TransactionIsolationLevel::ReadCommitted)
+            }
+            PyTransactionIsolationLevel::RepeatableRead => {
+                Ok(TransactionIsolationLevel::RepeatableRead)
+            }
+            PyTransactionIsolationLevel::Serializable => {
+                Ok(TransactionIsolationLevel::Serializable)
+            }
+            PyTransactionIsolationLevel::Snapshot => Ok(TransactionIsolationLevel::Snapshot),
+        }
+    }
+}
+
+#[pymethods]
+impl PyTransactionStart {
+    #[new]
+    pub fn new(
+        access_mode: PyTransactionAccessMode,
+        isolation_level: PyTransactionIsolationLevel,
+    ) -> PyResult<Self> {
+        let access_mode = access_mode.try_into()?;
+        let isolation_level = isolation_level.try_into()?;
+        Ok(PyTransactionStart {
+            transaction_start: TransactionStart {
+                access_mode,
+                isolation_level,
+            },
+        })
+    }
+
+    pub fn access_mode(&self) -> PyResult<PyTransactionAccessMode> {
+        Ok(self.transaction_start.access_mode.clone().into())
+    }
+
+    pub fn isolation_level(&self) -> PyResult<PyTransactionIsolationLevel> {
+        Ok(self.transaction_start.isolation_level.clone().into())
+    }
+}
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "TransactionEnd",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyTransactionEnd {
+    transaction_end: TransactionEnd,
+}
+
+impl From<TransactionEnd> for PyTransactionEnd {
+    fn from(transaction_end: TransactionEnd) -> PyTransactionEnd {
+        PyTransactionEnd { transaction_end }
+    }
+}
+
+impl TryFrom<PyTransactionEnd> for TransactionEnd {
+    type Error = PyErr;
+
+    fn try_from(py: PyTransactionEnd) -> Result<Self, Self::Error> {
+        Ok(py.transaction_end)
+    }
+}
+
+impl LogicalNode for PyTransactionEnd {
+    fn inputs(&self) -> Vec<PyLogicalPlan> {
+        vec![]
+    }
+
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    eq,
+    eq_int,
+    name = "TransactionConclusion",
+    module = "datafusion.expr"
+)]
+pub enum PyTransactionConclusion {
+    Commit,
+    Rollback,
+}
+
+impl From<TransactionConclusion> for PyTransactionConclusion {
+    fn from(value: TransactionConclusion) -> Self {
+        match value {
+            TransactionConclusion::Commit => PyTransactionConclusion::Commit,
+            TransactionConclusion::Rollback => PyTransactionConclusion::Rollback,
+        }
+    }
+}
+
+impl TryFrom<PyTransactionConclusion> for TransactionConclusion {
+    type Error = PyErr;
+
+    fn try_from(value: PyTransactionConclusion) -> Result<Self, Self::Error> {
+        match value {
+            PyTransactionConclusion::Commit => Ok(TransactionConclusion::Commit),
+            PyTransactionConclusion::Rollback => Ok(TransactionConclusion::Rollback),
+        }
+    }
+}
+#[pymethods]
+impl PyTransactionEnd {
+    #[new]
+    pub fn new(conclusion: PyTransactionConclusion, chain: bool) -> PyResult<Self> {
+        let conclusion = conclusion.try_into()?;
+        Ok(PyTransactionEnd {
+            transaction_end: TransactionEnd { conclusion, chain },
+        })
+    }
+
+    pub fn conclusion(&self) -> PyResult<PyTransactionConclusion> {
+        Ok(self.transaction_end.conclusion.clone().into())
+    }
+
+    pub fn chain(&self) -> bool {
+        self.transaction_end.chain
+    }
+}
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "ResetVariable",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyResetVariable {
+    reset_variable: ResetVariable,
+}
+
+impl From<ResetVariable> for PyResetVariable {
+    fn from(reset_variable: ResetVariable) -> PyResetVariable {
+        PyResetVariable { reset_variable }
+    }
+}
+
+impl TryFrom<PyResetVariable> for ResetVariable {
+    type Error = PyErr;
+
+    fn try_from(py: PyResetVariable) -> Result<Self, Self::Error> {
+        Ok(py.reset_variable)
+    }
+}
+
+impl LogicalNode for PyResetVariable {
+    fn inputs(&self) -> Vec<PyLogicalPlan> {
+        vec![]
+    }
+
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
+
+#[pymethods]
+impl PyResetVariable {
+    #[new]
+    pub fn new(variable: String) -> Self {
+        PyResetVariable {
+            reset_variable: ResetVariable { variable },
+        }
+    }
+
+    pub fn variable(&self) -> String {
+        self.reset_variable.variable.clone()
+    }
+}
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "SetVariable",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PySetVariable {
+    set_variable: SetVariable,
+}
+
+impl From<SetVariable> for PySetVariable {
+    fn from(set_variable: SetVariable) -> PySetVariable {
+        PySetVariable { set_variable }
+    }
+}
+
+impl TryFrom<PySetVariable> for SetVariable {
+    type Error = PyErr;
+
+    fn try_from(py: PySetVariable) -> Result<Self, Self::Error> {
+        Ok(py.set_variable)
+    }
+}
+
+impl LogicalNode for PySetVariable {
+    fn inputs(&self) -> Vec<PyLogicalPlan> {
+        vec![]
+    }
+
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
+
+#[pymethods]
+impl PySetVariable {
+    #[new]
+    pub fn new(variable: String, value: String) -> Self {
+        PySetVariable {
+            set_variable: SetVariable { variable, value },
+        }
+    }
+
+    pub fn variable(&self) -> String {
+        self.set_variable.variable.clone()
+    }
+
+    pub fn value(&self) -> String {
+        self.set_variable.value.clone()
+    }
+}
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Prepare",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyPrepare {
+    prepare: Prepare,
+}
+
+impl From<Prepare> for PyPrepare {
+    fn from(prepare: Prepare) -> PyPrepare {
+        PyPrepare { prepare }
+    }
+}
+
+impl TryFrom<PyPrepare> for Prepare {
+    type Error = PyErr;
+
+    fn try_from(py: PyPrepare) -> Result<Self, Self::Error> {
+        Ok(py.prepare)
+    }
+}
+
+impl LogicalNode for PyPrepare {
+    fn inputs(&self) -> Vec<PyLogicalPlan> {
+        vec![PyLogicalPlan::from((*self.prepare.input).clone())]
+    }
+
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
+
+#[pymethods]
+impl PyPrepare {
+    #[new]
+    pub fn new(name: String, fields: Vec<PyArrowType<Field>>, input: PyLogicalPlan) -> Self {
+        let input = input.plan().clone();
+        let fields = fields.into_iter().map(|field| Arc::new(field.0)).collect();
+        PyPrepare {
+            prepare: Prepare {
+                name,
+                fields,
+                input,
+            },
+        }
+    }
+
+    pub fn name(&self) -> String {
+        self.prepare.name.clone()
+    }
+
+    pub fn fields(&self) -> Vec<PyArrowType<Field>> {
+        self.prepare
+            .fields
+            .clone()
+            .into_iter()
+            .map(|f| f.as_ref().clone().into())
+            .collect()
+    }
+
+    pub fn input(&self) -> PyLogicalPlan {
+        PyLogicalPlan {
+            plan: self.prepare.input.clone(),
+        }
+    }
+}
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Execute",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyExecute {
+    execute: Execute,
+}
+
+impl From<Execute> for PyExecute {
+    fn from(execute: Execute) -> PyExecute {
+        PyExecute { execute }
+    }
+}
+
+impl TryFrom<PyExecute> for Execute {
+    type Error = PyErr;
+
+    fn try_from(py: PyExecute) -> Result<Self, Self::Error> {
+        Ok(py.execute)
+    }
+}
+
+impl LogicalNode for PyExecute {
+    fn inputs(&self) -> Vec<PyLogicalPlan> {
+        vec![]
+    }
+
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
+
+#[pymethods]
+impl PyExecute {
+    #[new]
+    pub fn new(name: String, parameters: Vec<PyExpr>) -> Self {
+        let parameters = parameters
+            .into_iter()
+            .map(|parameter| parameter.into())
+            .collect();
+        PyExecute {
+            execute: Execute { name, parameters },
+        }
+    }
+
+    pub fn name(&self) -> String {
+        self.execute.name.clone()
+    }
+
+    pub fn parameters(&self) -> Vec<PyExpr> {
+        self.execute
+            .parameters
+            .clone()
+            .into_iter()
+            .map(|t| t.into())
+            .collect()
+    }
+}
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Deallocate",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyDeallocate {
+    deallocate: Deallocate,
+}
+
+impl From<Deallocate> for PyDeallocate {
+    fn from(deallocate: Deallocate) -> PyDeallocate {
+        PyDeallocate { deallocate }
+    }
+}
+
+impl TryFrom<PyDeallocate> for Deallocate {
+    type Error = PyErr;
+
+    fn try_from(py: PyDeallocate) -> Result<Self, Self::Error> {
+        Ok(py.deallocate)
+    }
+}
+
+impl LogicalNode for PyDeallocate {
+    fn inputs(&self) -> Vec<PyLogicalPlan> {
+        vec![]
+    }
+
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
+
+#[pymethods]
+impl PyDeallocate {
+    #[new]
+    pub fn new(name: String) -> Self {
+        PyDeallocate {
+            deallocate: Deallocate { name },
+        }
+    }
+
+    pub fn name(&self) -> String {
+        self.deallocate.name.clone()
+    }
+}
diff --git a/src/expr/subquery.rs b/src/expr/subquery.rs
index 93ff244f6..c6fa83db8 100644
--- a/src/expr/subquery.rs
+++ b/src/expr/subquery.rs
@@ -15,10 +15,22 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion_expr::Subquery;
+use std::fmt::{self, Display, Formatter};
+
+use datafusion::logical_expr::Subquery;
+use pyo3::IntoPyObjectExt;
 use pyo3::prelude::*;
 
-#[pyclass(name = "Subquery", module = "datafusion.expr", subclass)]
+use super::logical_node::LogicalNode;
+use crate::sql::logical::PyLogicalPlan;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Subquery",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PySubquery {
     subquery: Subquery,
@@ -35,3 +47,41 @@ impl From<Subquery> for PySubquery {
         PySubquery { subquery }
     }
 }
+
+impl Display for PySubquery {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(
+            f,
+            "Subquery
+            Subquery: {:?}
+            outer_ref_columns: {:?}",
+            self.subquery.subquery, self.subquery.outer_ref_columns,
+        )
+    }
+}
+
+#[pymethods]
+impl PySubquery {
+    /// Retrieves the input `LogicalPlan` to this `Projection` node
+    fn input(&self) -> PyResult<Vec<PyLogicalPlan>> {
+        Ok(Self::inputs(self))
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("Subquery({self})"))
+    }
+
+    fn __name__(&self) -> PyResult<String> {
+        Ok("Subquery".to_string())
+    }
+}
+
+impl LogicalNode for PySubquery {
+    fn inputs(&self) -> Vec<PyLogicalPlan> {
+        vec![]
+    }
+
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
diff --git a/src/expr/subquery_alias.rs b/src/expr/subquery_alias.rs
index 5360bbbc4..a6b09e842 100644
--- a/src/expr/subquery_alias.rs
+++ b/src/expr/subquery_alias.rs
@@ -17,14 +17,21 @@
 
 use std::fmt::{self, Display, Formatter};
 
-use datafusion_expr::SubqueryAlias;
+use datafusion::logical_expr::SubqueryAlias;
+use pyo3::IntoPyObjectExt;
 use pyo3::prelude::*;
 
-use crate::{common::df_schema::PyDFSchema, sql::logical::PyLogicalPlan};
-
 use super::logical_node::LogicalNode;
+use crate::common::df_schema::PyDFSchema;
+use crate::sql::logical::PyLogicalPlan;
 
-#[pyclass(name = "SubqueryAlias", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "SubqueryAlias",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PySubqueryAlias {
     subquery_alias: SubqueryAlias,
@@ -68,11 +75,11 @@ impl PySubqueryAlias {
     }
 
     fn alias(&self) -> PyResult<String> {
-        Ok(self.subquery_alias.alias.clone())
+        Ok(self.subquery_alias.alias.to_string())
     }
 
     fn __repr__(&self) -> PyResult<String> {
-        Ok(format!("SubqueryAlias({})", self))
+        Ok(format!("SubqueryAlias({self})"))
     }
 
     fn __name__(&self) -> PyResult<String> {
@@ -85,7 +92,7 @@ impl LogicalNode for PySubqueryAlias {
         vec![PyLogicalPlan::from((*self.subquery_alias.input).clone())]
     }
 
-    fn to_variant(&self, py: Python) -> PyResult<PyObject> {
-        Ok(self.clone().into_py(py))
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
     }
 }
diff --git a/src/expr/table_scan.rs b/src/expr/table_scan.rs
index 63684fe7f..8ba7e4a69 100644
--- a/src/expr/table_scan.rs
+++ b/src/expr/table_scan.rs
@@ -15,15 +15,25 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion_expr::logical_plan::TableScan;
-use pyo3::prelude::*;
 use std::fmt::{self, Display, Formatter};
 
+use datafusion::common::TableReference;
+use datafusion::logical_expr::logical_plan::TableScan;
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
+use crate::common::df_schema::PyDFSchema;
+use crate::expr::PyExpr;
 use crate::expr::logical_node::LogicalNode;
 use crate::sql::logical::PyLogicalPlan;
-use crate::{common::df_schema::PyDFSchema, expr::PyExpr};
 
-#[pyclass(name = "TableScan", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "TableScan",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyTableScan {
     table_scan: TableScan,
@@ -67,20 +77,33 @@ impl Display for PyTableScan {
 impl PyTableScan {
     /// Retrieves the name of the table represented by this `TableScan` instance
     #[pyo3(name = "table_name")]
-    fn py_table_name(&self) -> PyResult<&str> {
-        Ok(&self.table_scan.table_name)
+    fn py_table_name(&self) -> PyResult<String> {
+        Ok(format!("{}", self.table_scan.table_name))
     }
 
-    /// TODO: Bindings for `TableSource` need to exist first. Left as a
-    /// placeholder to display intention to add when able to.
-    // #[pyo3(name = "source")]
-    // fn py_source(&self) -> PyResult<Arc<dyn TableSource>> {
-    //     Ok(self.table_scan.source)
-    // }
+    #[pyo3(name = "fqn")]
+    fn fqn(&self) -> PyResult<(Option<String>, Option<String>, String)> {
+        let table_ref: TableReference = self.table_scan.table_name.clone();
+        Ok(match table_ref {
+            TableReference::Bare { table } => (None, None, table.to_string()),
+            TableReference::Partial { schema, table } => {
+                (None, Some(schema.to_string()), table.to_string())
+            }
+            TableReference::Full {
+                catalog,
+                schema,
+                table,
+            } => (
+                Some(catalog.to_string()),
+                Some(schema.to_string()),
+                table.to_string(),
+            ),
+        })
+    }
 
     /// The column indexes that should be. Note if this is empty then
     /// all columns should be read by the `TableProvider`. This function
-    /// provides a Tuple of the (index, column_name) to make things simplier
+    /// provides a Tuple of the (index, column_name) to make things simpler
     /// for the calling code since often times the name is preferred to
     /// the index which is a lower level abstraction.
     #[pyo3(name = "projection")]
@@ -122,7 +145,7 @@ impl PyTableScan {
     }
 
     fn __repr__(&self) -> PyResult<String> {
-        Ok(format!("TableScan({})", self))
+        Ok(format!("TableScan({self})"))
     }
 }
 
@@ -132,7 +155,7 @@ impl LogicalNode for PyTableScan {
         vec![]
     }
 
-    fn to_variant(&self, py: Python) -> PyResult<PyObject> {
-        Ok(self.clone().into_py(py))
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
     }
 }
diff --git a/src/expr/union.rs b/src/expr/union.rs
index 98e8eaae6..a3b9efe91 100644
--- a/src/expr/union.rs
+++ b/src/expr/union.rs
@@ -15,15 +15,23 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion_expr::logical_plan::Union;
-use pyo3::prelude::*;
 use std::fmt::{self, Display, Formatter};
 
+use datafusion::logical_expr::logical_plan::Union;
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
 use crate::common::df_schema::PyDFSchema;
 use crate::expr::logical_node::LogicalNode;
 use crate::sql::logical::PyLogicalPlan;
 
-#[pyclass(name = "Union", module = "datafusion.expr", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Union",
+    module = "datafusion.expr",
+    subclass
+)]
 #[derive(Clone)]
 pub struct PyUnion {
     union_: Union,
@@ -66,7 +74,7 @@ impl PyUnion {
     }
 
     fn __repr__(&self) -> PyResult<String> {
-        Ok(format!("Union({})", self))
+        Ok(format!("Union({self})"))
     }
 
     fn __name__(&self) -> PyResult<String> {
@@ -83,7 +91,7 @@ impl LogicalNode for PyUnion {
             .collect()
     }
 
-    fn to_variant(&self, py: Python) -> PyResult<PyObject> {
-        Ok(self.clone().into_py(py))
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
     }
 }
diff --git a/src/expr/unnest.rs b/src/expr/unnest.rs
new file mode 100644
index 000000000..880d0a279
--- /dev/null
+++ b/src/expr/unnest.rs
@@ -0,0 +1,93 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::fmt::{self, Display, Formatter};
+
+use datafusion::logical_expr::logical_plan::Unnest;
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
+use crate::common::df_schema::PyDFSchema;
+use crate::expr::logical_node::LogicalNode;
+use crate::sql::logical::PyLogicalPlan;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Unnest",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyUnnest {
+    unnest_: Unnest,
+}
+
+impl From<Unnest> for PyUnnest {
+    fn from(unnest_: Unnest) -> PyUnnest {
+        PyUnnest { unnest_ }
+    }
+}
+
+impl From<PyUnnest> for Unnest {
+    fn from(unnest_: PyUnnest) -> Self {
+        unnest_.unnest_
+    }
+}
+
+impl Display for PyUnnest {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(
+            f,
+            "Unnest
+            Inputs: {:?}
+            Schema: {:?}",
+            &self.unnest_.input, &self.unnest_.schema,
+        )
+    }
+}
+
+#[pymethods]
+impl PyUnnest {
+    /// Retrieves the input `LogicalPlan` to this `Unnest` node
+    fn input(&self) -> PyResult<Vec<PyLogicalPlan>> {
+        Ok(Self::inputs(self))
+    }
+
+    /// Resulting Schema for this `Unnest` node instance
+    fn schema(&self) -> PyResult<PyDFSchema> {
+        Ok(self.unnest_.schema.as_ref().clone().into())
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("Unnest({self})"))
+    }
+
+    fn __name__(&self) -> PyResult<String> {
+        Ok("Unnest".to_string())
+    }
+}
+
+impl LogicalNode for PyUnnest {
+    fn inputs(&self) -> Vec<PyLogicalPlan> {
+        vec![PyLogicalPlan::from((*self.unnest_.input).clone())]
+    }
+
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
diff --git a/src/expr/unnest_expr.rs b/src/expr/unnest_expr.rs
new file mode 100644
index 000000000..97feef1d1
--- /dev/null
+++ b/src/expr/unnest_expr.rs
@@ -0,0 +1,74 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::fmt::{self, Display, Formatter};
+
+use datafusion::logical_expr::expr::Unnest;
+use pyo3::prelude::*;
+
+use super::PyExpr;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "UnnestExpr",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyUnnestExpr {
+    unnest: Unnest,
+}
+
+impl From<Unnest> for PyUnnestExpr {
+    fn from(unnest: Unnest) -> PyUnnestExpr {
+        PyUnnestExpr { unnest }
+    }
+}
+
+impl From<PyUnnestExpr> for Unnest {
+    fn from(unnest: PyUnnestExpr) -> Self {
+        unnest.unnest
+    }
+}
+
+impl Display for PyUnnestExpr {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(
+            f,
+            "Unnest
+            Expr: {:?}",
+            &self.unnest.expr,
+        )
+    }
+}
+
+#[pymethods]
+impl PyUnnestExpr {
+    /// Retrieves the expression that is being unnested
+    fn expr(&self) -> PyResult<PyExpr> {
+        Ok((*self.unnest.expr).clone().into())
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("UnnestExpr({self})"))
+    }
+
+    fn __name__(&self) -> PyResult<String> {
+        Ok("UnnestExpr".to_string())
+    }
+}
diff --git a/src/expr/values.rs b/src/expr/values.rs
new file mode 100644
index 000000000..d40b0e7cf
--- /dev/null
+++ b/src/expr/values.rs
@@ -0,0 +1,93 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::sync::Arc;
+
+use datafusion::logical_expr::Values;
+use pyo3::prelude::*;
+use pyo3::{IntoPyObjectExt, PyErr, PyResult, Python, pyclass};
+
+use super::PyExpr;
+use super::logical_node::LogicalNode;
+use crate::common::df_schema::PyDFSchema;
+use crate::sql::logical::PyLogicalPlan;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Values",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyValues {
+    values: Values,
+}
+
+impl From<Values> for PyValues {
+    fn from(values: Values) -> PyValues {
+        PyValues { values }
+    }
+}
+
+impl TryFrom<PyValues> for Values {
+    type Error = PyErr;
+
+    fn try_from(py: PyValues) -> Result<Self, Self::Error> {
+        Ok(py.values)
+    }
+}
+
+impl LogicalNode for PyValues {
+    fn inputs(&self) -> Vec<PyLogicalPlan> {
+        vec![]
+    }
+
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
+
+#[pymethods]
+impl PyValues {
+    #[new]
+    pub fn new(schema: PyDFSchema, values: Vec<Vec<PyExpr>>) -> PyResult<Self> {
+        let values = values
+            .into_iter()
+            .map(|row| row.into_iter().map(|expr| expr.into()).collect())
+            .collect();
+        Ok(PyValues {
+            values: Values {
+                schema: Arc::new(schema.into()),
+                values,
+            },
+        })
+    }
+
+    pub fn schema(&self) -> PyResult<PyDFSchema> {
+        Ok((*self.values.schema).clone().into())
+    }
+
+    pub fn values(&self) -> Vec<Vec<PyExpr>> {
+        self.values
+            .values
+            .clone()
+            .into_iter()
+            .map(|row| row.into_iter().map(|expr| expr.into()).collect())
+            .collect()
+    }
+}
diff --git a/src/expr/window.rs b/src/expr/window.rs
new file mode 100644
index 000000000..92d909bfc
--- /dev/null
+++ b/src/expr/window.rs
@@ -0,0 +1,307 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::fmt::{self, Display, Formatter};
+
+use datafusion::common::{DataFusionError, ScalarValue};
+use datafusion::logical_expr::{Expr, Window, WindowFrame, WindowFrameBound, WindowFrameUnits};
+use pyo3::IntoPyObjectExt;
+use pyo3::exceptions::PyNotImplementedError;
+use pyo3::prelude::*;
+
+use super::py_expr_list;
+use crate::common::data_type::PyScalarValue;
+use crate::common::df_schema::PyDFSchema;
+use crate::errors::{PyDataFusionResult, py_type_err};
+use crate::expr::PyExpr;
+use crate::expr::logical_node::LogicalNode;
+use crate::expr::sort_expr::{PySortExpr, py_sort_expr_list};
+use crate::sql::logical::PyLogicalPlan;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "WindowExpr",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyWindowExpr {
+    window: Window,
+}
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "WindowFrame",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyWindowFrame {
+    window_frame: WindowFrame,
+}
+
+impl From<PyWindowFrame> for WindowFrame {
+    fn from(window_frame: PyWindowFrame) -> Self {
+        window_frame.window_frame
+    }
+}
+
+impl From<WindowFrame> for PyWindowFrame {
+    fn from(window_frame: WindowFrame) -> PyWindowFrame {
+        PyWindowFrame { window_frame }
+    }
+}
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "WindowFrameBound",
+    module = "datafusion.expr",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyWindowFrameBound {
+    frame_bound: WindowFrameBound,
+}
+
+impl From<PyWindowExpr> for Window {
+    fn from(window: PyWindowExpr) -> Window {
+        window.window
+    }
+}
+
+impl From<Window> for PyWindowExpr {
+    fn from(window: Window) -> PyWindowExpr {
+        PyWindowExpr { window }
+    }
+}
+
+impl From<WindowFrameBound> for PyWindowFrameBound {
+    fn from(frame_bound: WindowFrameBound) -> Self {
+        PyWindowFrameBound { frame_bound }
+    }
+}
+
+impl Display for PyWindowExpr {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(
+            f,
+            "Over\n
+            Window Expr: {:?}
+            Schema: {:?}",
+            &self.window.window_expr, &self.window.schema
+        )
+    }
+}
+
+impl Display for PyWindowFrame {
+    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
+        write!(
+            f,
+            "OVER ({} BETWEEN {} AND {})",
+            self.window_frame.units, self.window_frame.start_bound, self.window_frame.end_bound
+        )
+    }
+}
+
+#[pymethods]
+impl PyWindowExpr {
+    /// Returns the schema of the Window
+    pub fn schema(&self) -> PyResult<PyDFSchema> {
+        Ok(self.window.schema.as_ref().clone().into())
+    }
+
+    /// Returns window expressions
+    pub fn get_window_expr(&self) -> PyResult<Vec<PyExpr>> {
+        py_expr_list(&self.window.window_expr)
+    }
+
+    /// Returns order by columns in a window function expression
+    pub fn get_sort_exprs(&self, expr: PyExpr) -> PyResult<Vec<PySortExpr>> {
+        match expr.expr.unalias() {
+            Expr::WindowFunction(boxed_window_fn) => {
+                py_sort_expr_list(&boxed_window_fn.params.order_by)
+            }
+            other => Err(not_window_function_err(other)),
+        }
+    }
+
+    /// Return partition by columns in a window function expression
+    pub fn get_partition_exprs(&self, expr: PyExpr) -> PyResult<Vec<PyExpr>> {
+        match expr.expr.unalias() {
+            Expr::WindowFunction(boxed_window_fn) => {
+                py_expr_list(&boxed_window_fn.params.partition_by)
+            }
+            other => Err(not_window_function_err(other)),
+        }
+    }
+
+    /// Return input args for window function
+    pub fn get_args(&self, expr: PyExpr) -> PyResult<Vec<PyExpr>> {
+        match expr.expr.unalias() {
+            Expr::WindowFunction(boxed_window_fn) => py_expr_list(&boxed_window_fn.params.args),
+            other => Err(not_window_function_err(other)),
+        }
+    }
+
+    /// Return window function name
+    pub fn window_func_name(&self, expr: PyExpr) -> PyResult<String> {
+        match expr.expr.unalias() {
+            Expr::WindowFunction(boxed_window_fn) => Ok(boxed_window_fn.fun.to_string()),
+            other => Err(not_window_function_err(other)),
+        }
+    }
+
+    /// Returns a Pywindow frame for a given window function expression
+    pub fn get_frame(&self, expr: PyExpr) -> Option<PyWindowFrame> {
+        match expr.expr.unalias() {
+            Expr::WindowFunction(boxed_window_fn) => {
+                Some(boxed_window_fn.params.window_frame.into())
+            }
+            _ => None,
+        }
+    }
+}
+
+fn not_window_function_err(expr: Expr) -> PyErr {
+    py_type_err(format!(
+        "Provided {} Expr {:?} is not a WindowFunction type",
+        expr.variant_name(),
+        expr
+    ))
+}
+
+#[pymethods]
+impl PyWindowFrame {
+    #[new]
+    #[pyo3(signature=(unit, start_bound, end_bound))]
+    pub fn new(
+        unit: &str,
+        start_bound: Option<PyScalarValue>,
+        end_bound: Option<PyScalarValue>,
+    ) -> PyResult<Self> {
+        let units = unit.to_ascii_lowercase();
+        let units = match units.as_str() {
+            "rows" => WindowFrameUnits::Rows,
+            "range" => WindowFrameUnits::Range,
+            "groups" => WindowFrameUnits::Groups,
+            _ => {
+                return Err(PyNotImplementedError::new_err(format!("{units:?}")));
+            }
+        };
+        let start_bound = match start_bound {
+            Some(start_bound) => WindowFrameBound::Preceding(start_bound.0),
+            None => match units {
+                WindowFrameUnits::Range => WindowFrameBound::Preceding(ScalarValue::UInt64(None)),
+                WindowFrameUnits::Rows => WindowFrameBound::Preceding(ScalarValue::UInt64(None)),
+                WindowFrameUnits::Groups => {
+                    return Err(PyNotImplementedError::new_err(format!("{units:?}")));
+                }
+            },
+        };
+        let end_bound = match end_bound {
+            Some(end_bound) => WindowFrameBound::Following(end_bound.0),
+            None => match units {
+                WindowFrameUnits::Rows => WindowFrameBound::Following(ScalarValue::UInt64(None)),
+                WindowFrameUnits::Range => WindowFrameBound::Following(ScalarValue::UInt64(None)),
+                WindowFrameUnits::Groups => {
+                    return Err(PyNotImplementedError::new_err(format!("{units:?}")));
+                }
+            },
+        };
+        Ok(PyWindowFrame {
+            window_frame: WindowFrame::new_bounds(units, start_bound, end_bound),
+        })
+    }
+
+    /// Returns the window frame units for the bounds
+    pub fn get_frame_units(&self) -> PyResult<String> {
+        Ok(self.window_frame.units.to_string())
+    }
+    /// Returns starting bound
+    pub fn get_lower_bound(&self) -> PyResult<PyWindowFrameBound> {
+        Ok(self.window_frame.start_bound.clone().into())
+    }
+    /// Returns end bound
+    pub fn get_upper_bound(&self) -> PyResult<PyWindowFrameBound> {
+        Ok(self.window_frame.end_bound.clone().into())
+    }
+
+    /// Get a String representation of this window frame
+    fn __repr__(&self) -> String {
+        format!("{self}")
+    }
+}
+
+#[pymethods]
+impl PyWindowFrameBound {
+    /// Returns if the frame bound is current row
+    pub fn is_current_row(&self) -> bool {
+        matches!(self.frame_bound, WindowFrameBound::CurrentRow)
+    }
+
+    /// Returns if the frame bound is preceding
+    pub fn is_preceding(&self) -> bool {
+        matches!(self.frame_bound, WindowFrameBound::Preceding(_))
+    }
+
+    /// Returns if the frame bound is following
+    pub fn is_following(&self) -> bool {
+        matches!(self.frame_bound, WindowFrameBound::Following(_))
+    }
+    /// Returns the offset of the window frame
+    pub fn get_offset(&self) -> PyDataFusionResult<Option<u64>> {
+        match &self.frame_bound {
+            WindowFrameBound::Preceding(val) | WindowFrameBound::Following(val) => match val {
+                x if x.is_null() => Ok(None),
+                ScalarValue::UInt64(v) => Ok(*v),
+                // The cast below is only safe because window bounds cannot be negative
+                ScalarValue::Int64(v) => Ok(v.map(|n| n as u64)),
+                ScalarValue::Utf8(Some(s)) => match s.parse::<u64>() {
+                    Ok(s) => Ok(Some(s)),
+                    Err(_e) => Err(DataFusionError::Plan(format!(
+                        "Unable to parse u64 from Utf8 value '{s}'"
+                    ))
+                    .into()),
+                },
+                ref x => {
+                    Err(DataFusionError::Plan(format!("Unexpected window frame bound: {x}")).into())
+                }
+            },
+            WindowFrameBound::CurrentRow => Ok(None),
+        }
+    }
+    /// Returns if the frame bound is unbounded
+    pub fn is_unbounded(&self) -> PyResult<bool> {
+        match &self.frame_bound {
+            WindowFrameBound::Preceding(v) | WindowFrameBound::Following(v) => Ok(v.is_null()),
+            WindowFrameBound::CurrentRow => Ok(false),
+        }
+    }
+}
+
+impl LogicalNode for PyWindowExpr {
+    fn inputs(&self) -> Vec<PyLogicalPlan> {
+        vec![self.window.input.as_ref().clone().into()]
+    }
+
+    fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.clone().into_bound_py_any(py)
+    }
+}
diff --git a/src/functions.rs b/src/functions.rs
index 8acffeb55..c32134054 100644
--- a/src/functions.rs
+++ b/src/functions.rs
@@ -15,20 +15,60 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use pyo3::{prelude::*, wrap_pyfunction};
+use std::collections::HashMap;
 
-use datafusion_common::Column;
-use datafusion_expr::expr::AggregateFunction;
-use datafusion_expr::expr::{Sort, WindowFunction};
-use datafusion_expr::window_function::find_df_window_func;
-use datafusion_expr::{aggregate_function, lit, BuiltinScalarFunction, Expr, WindowFrame};
+use datafusion::common::{Column, ScalarValue, TableReference};
+use datafusion::execution::FunctionRegistry;
+use datafusion::functions_aggregate::all_default_aggregate_functions;
+use datafusion::functions_window::all_default_window_functions;
+use datafusion::logical_expr::expr::{
+    Alias, FieldMetadata, NullTreatment as DFNullTreatment, WindowFunction, WindowFunctionParams,
+};
+use datafusion::logical_expr::{Expr, ExprFunctionExt, WindowFrame, WindowFunctionDefinition, lit};
+use datafusion::{functions, functions_aggregate, functions_window};
+use pyo3::prelude::*;
+use pyo3::wrap_pyfunction;
 
-use crate::errors::DataFusionError;
+use crate::common::data_type::{NullTreatment, PyScalarValue};
+use crate::context::PySessionContext;
+use crate::errors::{PyDataFusionError, PyDataFusionResult};
 use crate::expr::PyExpr;
+use crate::expr::conditional_expr::PyCaseBuilder;
+use crate::expr::sort_expr::{PySortExpr, to_sort_expressions};
+use crate::expr::window::PyWindowFrame;
+
+fn add_builder_fns_to_aggregate(
+    agg_fn: Expr,
+    distinct: Option<bool>,
+    filter: Option<PyExpr>,
+    order_by: Option<Vec<PySortExpr>>,
+    null_treatment: Option<NullTreatment>,
+) -> PyDataFusionResult<PyExpr> {
+    // Since ExprFuncBuilder::new() is private, we can guarantee initializing
+    // a builder with an `null_treatment` with option None
+    let mut builder = agg_fn.null_treatment(None);
+
+    if let Some(order_by_cols) = order_by {
+        let order_by_cols = to_sort_expressions(order_by_cols);
+        builder = builder.order_by(order_by_cols);
+    }
+
+    if let Some(true) = distinct {
+        builder = builder.distinct();
+    }
+
+    if let Some(filter) = filter {
+        builder = builder.filter(filter.expr);
+    }
+
+    builder = builder.null_treatment(null_treatment.map(DFNullTreatment::from));
+
+    Ok(builder.build()?.into())
+}
 
 #[pyfunction]
 fn in_list(expr: PyExpr, value: Vec<PyExpr>, negated: bool) -> PyExpr {
-    datafusion_expr::in_list(
+    datafusion::logical_expr::in_list(
         expr.expr,
         value.into_iter().map(|x| x.expr).collect::<Vec<_>>(),
         negated,
@@ -36,53 +76,162 @@ fn in_list(expr: PyExpr, value: Vec<PyExpr>, negated: bool) -> PyExpr {
     .into()
 }
 
+#[pyfunction]
+fn make_array(exprs: Vec<PyExpr>) -> PyExpr {
+    datafusion::functions_nested::expr_fn::make_array(exprs.into_iter().map(|x| x.into()).collect())
+        .into()
+}
+
+#[pyfunction]
+fn array_concat(exprs: Vec<PyExpr>) -> PyExpr {
+    let exprs = exprs.into_iter().map(|x| x.into()).collect();
+    datafusion::functions_nested::expr_fn::array_concat(exprs).into()
+}
+
+#[pyfunction]
+fn array_cat(exprs: Vec<PyExpr>) -> PyExpr {
+    array_concat(exprs)
+}
+
+#[pyfunction]
+#[pyo3(signature = (array, element, index=None))]
+fn array_position(array: PyExpr, element: PyExpr, index: Option<i64>) -> PyExpr {
+    let index = ScalarValue::Int64(index);
+    let index = Expr::Literal(index, None);
+    datafusion::functions_nested::expr_fn::array_position(array.into(), element.into(), index)
+        .into()
+}
+
+#[pyfunction]
+#[pyo3(signature = (array, begin, end, stride=None))]
+fn array_slice(array: PyExpr, begin: PyExpr, end: PyExpr, stride: Option<PyExpr>) -> PyExpr {
+    datafusion::functions_nested::expr_fn::array_slice(
+        array.into(),
+        begin.into(),
+        end.into(),
+        stride.map(Into::into),
+    )
+    .into()
+}
+
 /// Computes a binary hash of the given data. type is the algorithm to use.
 /// Standard algorithms are md5, sha224, sha256, sha384, sha512, blake2s, blake2b, and blake3.
 // #[pyfunction(value, method)]
 #[pyfunction]
-#[pyo3(signature = (value, method))]
 fn digest(value: PyExpr, method: PyExpr) -> PyExpr {
     PyExpr {
-        expr: datafusion_expr::digest(value.expr, method.expr),
+        expr: functions::expr_fn::digest(value.expr, method.expr),
     }
 }
 
 /// Concatenates the text representations of all the arguments.
 /// NULL arguments are ignored.
 #[pyfunction]
-#[pyo3(signature = (*args))]
 fn concat(args: Vec<PyExpr>) -> PyResult<PyExpr> {
     let args = args.into_iter().map(|e| e.expr).collect::<Vec<_>>();
-    Ok(datafusion_expr::concat(&args).into())
+    Ok(functions::string::expr_fn::concat(args).into())
 }
 
 /// Concatenates all but the first argument, with separators.
 /// The first argument is used as the separator string, and should not be NULL.
 /// Other NULL arguments are ignored.
 #[pyfunction]
-#[pyo3(signature = (sep, *args))]
 fn concat_ws(sep: String, args: Vec<PyExpr>) -> PyResult<PyExpr> {
     let args = args.into_iter().map(|e| e.expr).collect::<Vec<_>>();
-    Ok(datafusion_expr::concat_ws(lit(sep), args).into())
+    Ok(functions::string::expr_fn::concat_ws(lit(sep), args).into())
+}
+
+#[pyfunction]
+#[pyo3(signature = (values, regex, flags=None))]
+fn regexp_like(values: PyExpr, regex: PyExpr, flags: Option<PyExpr>) -> PyResult<PyExpr> {
+    Ok(functions::expr_fn::regexp_like(values.expr, regex.expr, flags.map(|x| x.expr)).into())
+}
+
+#[pyfunction]
+#[pyo3(signature = (values, regex, flags=None))]
+fn regexp_match(values: PyExpr, regex: PyExpr, flags: Option<PyExpr>) -> PyResult<PyExpr> {
+    Ok(functions::expr_fn::regexp_match(values.expr, regex.expr, flags.map(|x| x.expr)).into())
+}
+
+#[pyfunction]
+#[pyo3(signature = (string, pattern, replacement, flags=None))]
+/// Replaces substring(s) matching a POSIX regular expression.
+fn regexp_replace(
+    string: PyExpr,
+    pattern: PyExpr,
+    replacement: PyExpr,
+    flags: Option<PyExpr>,
+) -> PyResult<PyExpr> {
+    Ok(functions::expr_fn::regexp_replace(
+        string.into(),
+        pattern.into(),
+        replacement.into(),
+        flags.map(|x| x.expr),
+    )
+    .into())
+}
+
+#[pyfunction]
+#[pyo3(signature = (string, pattern, start, flags=None))]
+/// Returns the number of matches found in the string.
+fn regexp_count(
+    string: PyExpr,
+    pattern: PyExpr,
+    start: Option<PyExpr>,
+    flags: Option<PyExpr>,
+) -> PyResult<PyExpr> {
+    Ok(functions::expr_fn::regexp_count(
+        string.expr,
+        pattern.expr,
+        start.map(|x| x.expr),
+        flags.map(|x| x.expr),
+    )
+    .into())
+}
+
+#[pyfunction]
+#[pyo3(signature = (values, regex, start=None, n=None, flags=None, subexpr=None))]
+/// Returns the position in a string where the specified occurrence of a regular expression is located
+fn regexp_instr(
+    values: PyExpr,
+    regex: PyExpr,
+    start: Option<PyExpr>,
+    n: Option<PyExpr>,
+    flags: Option<PyExpr>,
+    subexpr: Option<PyExpr>,
+) -> PyResult<PyExpr> {
+    Ok(functions::expr_fn::regexp_instr(
+        values.into(),
+        regex.into(),
+        start.map(|x| x.expr).or(Some(lit(1))),
+        n.map(|x| x.expr).or(Some(lit(1))),
+        None,
+        flags.map(|x| x.expr).or(Some(lit(""))),
+        subexpr.map(|x| x.expr).or(Some(lit(0))),
+    )
+    .into())
 }
 
 /// Creates a new Sort Expr
 #[pyfunction]
-fn order_by(expr: PyExpr, asc: Option<bool>, nulls_first: Option<bool>) -> PyResult<PyExpr> {
-    Ok(PyExpr {
-        expr: datafusion_expr::Expr::Sort(Sort {
-            expr: Box::new(expr.expr),
-            asc: asc.unwrap_or(true),
-            nulls_first: nulls_first.unwrap_or(true),
-        }),
-    })
+fn order_by(expr: PyExpr, asc: bool, nulls_first: bool) -> PyResult<PySortExpr> {
+    Ok(PySortExpr::from(datafusion::logical_expr::expr::Sort {
+        expr: expr.expr,
+        asc,
+        nulls_first,
+    }))
 }
 
 /// Creates a new Alias Expr
 #[pyfunction]
-fn alias(expr: PyExpr, name: &str) -> PyResult<PyExpr> {
+#[pyo3(signature = (expr, name, metadata=None))]
+fn alias(expr: PyExpr, name: &str, metadata: Option<HashMap<String, String>>) -> PyResult<PyExpr> {
+    let relation: Option<TableReference> = None;
+    let metadata = metadata.map(|m| FieldMetadata::new(m.into_iter().collect()));
     Ok(PyExpr {
-        expr: datafusion_expr::Expr::Alias(Box::new(expr.expr), String::from(name)),
+        expr: datafusion::logical_expr::Expr::Alias(
+            Alias::new(expr.expr, relation, name).with_metadata(metadata),
+        ),
     })
 }
 
@@ -90,293 +239,759 @@ fn alias(expr: PyExpr, name: &str) -> PyResult<PyExpr> {
 #[pyfunction]
 fn col(name: &str) -> PyResult<PyExpr> {
     Ok(PyExpr {
-        expr: datafusion_expr::Expr::Column(Column {
-            relation: None,
-            name: name.to_string(),
-        }),
+        expr: datafusion::logical_expr::Expr::Column(Column::new_unqualified(name)),
     })
 }
 
-/// Create a COUNT(1) aggregate expression
+/// Create a CASE WHEN statement with literal WHEN expressions for comparison to the base expression.
 #[pyfunction]
-fn count_star() -> PyResult<PyExpr> {
-    Ok(PyExpr {
-        expr: Expr::AggregateFunction(AggregateFunction {
-            fun: aggregate_function::AggregateFunction::Count,
-            args: vec![lit(1)],
-            distinct: false,
-            filter: None,
-        }),
-    })
+fn case(expr: PyExpr) -> PyResult<PyCaseBuilder> {
+    Ok(PyCaseBuilder::new(Some(expr)))
+}
+
+/// Create a CASE WHEN statement with literal WHEN expressions for comparison to the base expression.
+#[pyfunction]
+fn when(when: PyExpr, then: PyExpr) -> PyResult<PyCaseBuilder> {
+    Ok(PyCaseBuilder::new(None).when(when, then))
+}
+
+/// Helper function to find the appropriate window function.
+///
+/// Search procedure:
+/// 1) Search built in window functions, which are being deprecated.
+/// 1) If a session context is provided:
+///      1) search User Defined Aggregate Functions (UDAFs)
+///      1) search registered window functions
+///      1) search registered aggregate functions
+/// 1) If no function has been found, search default aggregate functions.
+///
+/// NOTE: we search the built-ins first because the `UDAF` versions currently do not have the same behavior.
+fn find_window_fn(
+    name: &str,
+    ctx: Option<PySessionContext>,
+) -> PyDataFusionResult<WindowFunctionDefinition> {
+    if let Some(ctx) = ctx {
+        // search UDAFs
+        let udaf = ctx
+            .ctx
+            .udaf(name)
+            .map(WindowFunctionDefinition::AggregateUDF)
+            .ok();
+
+        if let Some(udaf) = udaf {
+            return Ok(udaf);
+        }
+
+        let session_state = ctx.ctx.state();
+
+        // search registered window functions
+        let window_fn = session_state
+            .window_functions()
+            .get(name)
+            .map(|f| WindowFunctionDefinition::WindowUDF(f.clone()));
+
+        if let Some(window_fn) = window_fn {
+            return Ok(window_fn);
+        }
+
+        // search registered aggregate functions
+        let agg_fn = session_state
+            .aggregate_functions()
+            .get(name)
+            .map(|f| WindowFunctionDefinition::AggregateUDF(f.clone()));
+
+        if let Some(agg_fn) = agg_fn {
+            return Ok(agg_fn);
+        }
+    }
+
+    // search default aggregate functions
+    let agg_fn = all_default_aggregate_functions()
+        .iter()
+        .find(|v| v.name() == name || v.aliases().contains(&name.to_string()))
+        .map(|f| WindowFunctionDefinition::AggregateUDF(f.clone()));
+
+    if let Some(agg_fn) = agg_fn {
+        return Ok(agg_fn);
+    }
+
+    // search default window functions
+    let window_fn = all_default_window_functions()
+        .iter()
+        .find(|v| v.name() == name || v.aliases().contains(&name.to_string()))
+        .map(|f| WindowFunctionDefinition::WindowUDF(f.clone()));
+
+    if let Some(window_fn) = window_fn {
+        return Ok(window_fn);
+    }
+
+    Err(PyDataFusionError::Common(format!(
+        "window function `{name}` not found"
+    )))
 }
 
 /// Creates a new Window function expression
+#[allow(clippy::too_many_arguments)]
 #[pyfunction]
+#[pyo3(signature = (name, args, partition_by=None, order_by=None, window_frame=None, filter=None, distinct=false, ctx=None))]
 fn window(
     name: &str,
     args: Vec<PyExpr>,
     partition_by: Option<Vec<PyExpr>>,
-    order_by: Option<Vec<PyExpr>>,
+    order_by: Option<Vec<PySortExpr>>,
+    window_frame: Option<PyWindowFrame>,
+    filter: Option<PyExpr>,
+    distinct: bool,
+    ctx: Option<PySessionContext>,
 ) -> PyResult<PyExpr> {
-    let fun = find_df_window_func(name);
-    if fun.is_none() {
-        return Err(DataFusionError::Common("window function not found".to_string()).into());
-    }
-    let fun = fun.unwrap();
-    let window_frame = WindowFrame::new(order_by.is_some());
+    let fun = find_window_fn(name, ctx)?;
+
+    let window_frame = window_frame
+        .map(|w| w.into())
+        .unwrap_or(WindowFrame::new(order_by.as_ref().map(|v| !v.is_empty())));
+    let filter = filter.map(|f| f.expr.into());
+
     Ok(PyExpr {
-        expr: datafusion_expr::Expr::WindowFunction(WindowFunction {
+        expr: datafusion::logical_expr::Expr::WindowFunction(Box::new(WindowFunction {
             fun,
-            args: args.into_iter().map(|x| x.expr).collect::<Vec<_>>(),
-            partition_by: partition_by
-                .unwrap_or_default()
-                .into_iter()
-                .map(|x| x.expr)
-                .collect::<Vec<_>>(),
-            order_by: order_by
-                .unwrap_or_default()
-                .into_iter()
-                .map(|x| x.expr)
-                .collect::<Vec<_>>(),
-            window_frame,
-        }),
+            params: WindowFunctionParams {
+                args: args.into_iter().map(|x| x.expr).collect::<Vec<_>>(),
+                partition_by: partition_by
+                    .unwrap_or_default()
+                    .into_iter()
+                    .map(|x| x.expr)
+                    .collect::<Vec<_>>(),
+                order_by: order_by
+                    .unwrap_or_default()
+                    .into_iter()
+                    .map(|x| x.into())
+                    .collect::<Vec<_>>(),
+                window_frame,
+                filter,
+                distinct,
+                null_treatment: None,
+            },
+        })),
     })
 }
 
-macro_rules! scalar_function {
-    ($NAME: ident, $FUNC: ident) => {
-        scalar_function!($NAME, $FUNC, stringify!($NAME));
+// Generates a [pyo3] wrapper for associated aggregate functions.
+// All of the builder options are exposed to the python internal
+// function and we rely on the wrappers to only use those that
+// are appropriate.
+macro_rules! aggregate_function {
+    ($NAME: ident) => {
+        aggregate_function!($NAME, expr);
     };
+    ($NAME: ident, $($arg:ident)*) => {
+        #[pyfunction]
+        #[pyo3(signature = ($($arg),*, distinct=None, filter=None, order_by=None, null_treatment=None))]
+        fn $NAME(
+            $($arg: PyExpr),*,
+            distinct: Option<bool>,
+            filter: Option<PyExpr>,
+            order_by: Option<Vec<PySortExpr>>,
+            null_treatment: Option<NullTreatment>
+        ) -> PyDataFusionResult<PyExpr> {
+            let agg_fn = functions_aggregate::expr_fn::$NAME($($arg.into()),*);
 
-    ($NAME: ident, $FUNC: ident, $DOC: expr) => {
+            add_builder_fns_to_aggregate(agg_fn, distinct, filter, order_by, null_treatment)
+        }
+    };
+}
+
+/// Generates a [pyo3] wrapper for [datafusion::functions::expr_fn]
+///
+/// These functions have explicit named arguments.
+macro_rules! expr_fn {
+    ($FUNC: ident) => {
+        expr_fn!($FUNC, , stringify!($FUNC));
+    };
+    ($FUNC:ident, $($arg:ident)*) => {
+        expr_fn!($FUNC, $($arg)*, stringify!($FUNC));
+    };
+    ($FUNC: ident, $DOC: expr) => {
+        expr_fn!($FUNC, ,$DOC);
+    };
+    ($FUNC: ident, $($arg:ident)*, $DOC: expr) => {
+        #[doc = $DOC]
+        #[pyfunction]
+        fn $FUNC($($arg: PyExpr),*) -> PyExpr {
+            functions::expr_fn::$FUNC($($arg.into()),*).into()
+        }
+    };
+}
+/// Generates a [pyo3] wrapper for [datafusion::functions::expr_fn]
+///
+/// These functions take a single `Vec<PyExpr>` argument using `pyo3(signature = (*args))`.
+macro_rules! expr_fn_vec {
+    ($FUNC: ident) => {
+        expr_fn_vec!($FUNC, stringify!($FUNC));
+    };
+    ($FUNC: ident, $DOC: expr) => {
         #[doc = $DOC]
         #[pyfunction]
         #[pyo3(signature = (*args))]
-        fn $NAME(args: Vec<PyExpr>) -> PyExpr {
-            let expr = datafusion_expr::Expr::ScalarFunction {
-                fun: BuiltinScalarFunction::$FUNC,
-                args: args.into_iter().map(|e| e.into()).collect(),
-            };
-            expr.into()
+        fn $FUNC(args: Vec<PyExpr>) -> PyExpr {
+            let args = args.into_iter().map(|e| e.into()).collect::<Vec<_>>();
+            functions::expr_fn::$FUNC(args).into()
         }
     };
 }
 
-macro_rules! aggregate_function {
-    ($NAME: ident, $FUNC: ident) => {
-        aggregate_function!($NAME, $FUNC, stringify!($NAME));
+/// Generates a [pyo3] wrapper for [datafusion_functions_nested::expr_fn]
+///
+/// These functions have explicit named arguments.
+macro_rules! array_fn {
+    ($FUNC: ident) => {
+        array_fn!($FUNC, , stringify!($FUNC));
+    };
+    ($FUNC:ident,  $($arg:ident)*) => {
+        array_fn!($FUNC, $($arg)*, stringify!($FUNC));
     };
-    ($NAME: ident, $FUNC: ident, $DOC: expr) => {
+    ($FUNC: ident, $DOC: expr) => {
+        array_fn!($FUNC, , $DOC);
+    };
+    ($FUNC: ident, $($arg:ident)*, $DOC:expr) => {
         #[doc = $DOC]
         #[pyfunction]
-        #[pyo3(signature = (*args, distinct=false))]
-        fn $NAME(args: Vec<PyExpr>, distinct: bool) -> PyExpr {
-            let expr = datafusion_expr::Expr::AggregateFunction(AggregateFunction {
-                fun: datafusion_expr::aggregate_function::AggregateFunction::$FUNC,
-                args: args.into_iter().map(|e| e.into()).collect(),
-                distinct,
-                filter: None,
-            });
-            expr.into()
+        fn $FUNC($($arg: PyExpr),*) -> PyExpr {
+            datafusion::functions_nested::expr_fn::$FUNC($($arg.into()),*).into()
         }
     };
 }
 
-scalar_function!(abs, Abs);
-scalar_function!(acos, Acos);
-scalar_function!(ascii, Ascii, "Returns the numeric code of the first character of the argument. In UTF8 encoding, returns the Unicode code point of the character. In other multibyte encodings, the argument must be an ASCII character.");
-scalar_function!(asin, Asin);
-scalar_function!(atan, Atan);
-scalar_function!(atan2, Atan2);
-scalar_function!(
+expr_fn!(abs, num);
+expr_fn!(acos, num);
+expr_fn!(acosh, num);
+expr_fn!(
+    ascii,
+    arg1,
+    "Returns the numeric code of the first character of the argument. In UTF8 encoding, returns the Unicode code point of the character. In other multibyte encodings, the argument must be an ASCII character."
+);
+expr_fn!(asin, num);
+expr_fn!(asinh, num);
+expr_fn!(atan, num);
+expr_fn!(atanh, num);
+expr_fn!(atan2, y x);
+expr_fn!(
     bit_length,
-    BitLength,
+    arg,
     "Returns number of bits in the string (8 times the octet_length)."
 );
-scalar_function!(btrim, Btrim, "Removes the longest string containing only characters in characters (a space by default) from the start and end of string.");
-scalar_function!(ceil, Ceil);
-scalar_function!(
+expr_fn_vec!(
+    btrim,
+    "Removes the longest string containing only characters in characters (a space by default) from the start and end of string."
+);
+expr_fn!(cbrt, num);
+expr_fn!(ceil, num);
+expr_fn!(
     character_length,
-    CharacterLength,
+    string,
     "Returns number of characters in the string."
 );
-scalar_function!(length, CharacterLength);
-scalar_function!(char_length, CharacterLength);
-scalar_function!(chr, Chr, "Returns the character with the given code.");
-scalar_function!(coalesce, Coalesce);
-scalar_function!(cos, Cos);
-scalar_function!(exp, Exp);
-scalar_function!(floor, Floor);
-scalar_function!(initcap, InitCap, "Converts the first letter of each word to upper case and the rest to lower case. Words are sequences of alphanumeric characters separated by non-alphanumeric characters.");
-scalar_function!(left, Left, "Returns first n characters in the string, or when n is negative, returns all but last |n| characters.");
-scalar_function!(ln, Ln);
-scalar_function!(log, Log);
-scalar_function!(log10, Log10);
-scalar_function!(log2, Log2);
-scalar_function!(lower, Lower, "Converts the string to all lower case");
-scalar_function!(lpad, Lpad, "Extends the string to length length by prepending the characters fill (a space by default). If the string is already longer than length then it is truncated (on the right).");
-scalar_function!(ltrim, Ltrim, "Removes the longest string containing only characters in characters (a space by default) from the start of string.");
-scalar_function!(
+expr_fn!(length, string);
+expr_fn!(char_length, string);
+expr_fn!(chr, arg, "Returns the character with the given code.");
+expr_fn_vec!(coalesce);
+expr_fn!(cos, num);
+expr_fn!(cosh, num);
+expr_fn!(cot, num);
+expr_fn!(degrees, num);
+expr_fn!(decode, input encoding);
+expr_fn!(encode, input encoding);
+expr_fn!(ends_with, string suffix, "Returns true if string ends with suffix.");
+expr_fn!(exp, num);
+expr_fn!(factorial, num);
+expr_fn!(floor, num);
+expr_fn!(gcd, x y);
+expr_fn!(
+    initcap,
+    string,
+    "Converts the first letter of each word to upper case and the rest to lower case. Words are sequences of alphanumeric characters separated by non-alphanumeric characters."
+);
+expr_fn!(isnan, num);
+expr_fn!(iszero, num);
+expr_fn!(levenshtein, string1 string2);
+expr_fn!(lcm, x y);
+expr_fn!(left, string n, "Returns first n characters in the string, or when n is negative, returns all but last |n| characters.");
+expr_fn!(ln, num);
+expr_fn!(log, base num);
+expr_fn!(log10, num);
+expr_fn!(log2, num);
+expr_fn!(lower, arg1, "Converts the string to all lower case");
+expr_fn_vec!(
+    lpad,
+    "Extends the string to length length by prepending the characters fill (a space by default). If the string is already longer than length then it is truncated (on the right)."
+);
+expr_fn_vec!(
+    ltrim,
+    "Removes the longest string containing only characters in characters (a space by default) from the start of string."
+);
+expr_fn!(
     md5,
-    MD5,
+    input_arg,
     "Computes the MD5 hash of the argument, with the result written in hexadecimal."
 );
-scalar_function!(octet_length, OctetLength, "Returns number of bytes in the string. Since this version of the function accepts type character directly, it will not strip trailing spaces.");
-scalar_function!(power, Power);
-scalar_function!(pow, Power);
-scalar_function!(regexp_match, RegexpMatch);
-scalar_function!(
-    regexp_replace,
-    RegexpReplace,
-    "Replaces substring(s) matching a POSIX regular expression"
+expr_fn!(
+    nanvl,
+    x y,
+    "Returns x if x is not NaN otherwise returns y."
+);
+expr_fn!(
+    nvl,
+    x y,
+    "Returns x if x is not NULL otherwise returns y."
 );
-scalar_function!(
-    repeat,
-    Repeat,
-    "Repeats string the specified number of times."
+expr_fn!(nullif, arg_1 arg_2);
+expr_fn!(
+    octet_length,
+    args,
+    "Returns number of bytes in the string. Since this version of the function accepts type character directly, it will not strip trailing spaces."
 );
-scalar_function!(
+expr_fn_vec!(overlay);
+expr_fn!(pi);
+expr_fn!(power, base exponent);
+expr_fn!(radians, num);
+expr_fn!(repeat, string n, "Repeats string the specified number of times.");
+expr_fn!(
     replace,
-    Replace,
+    string from to,
     "Replaces all occurrences in string of substring from with substring to."
 );
-scalar_function!(
+expr_fn!(
     reverse,
-    Reverse,
+    string,
     "Reverses the order of the characters in the string."
 );
-scalar_function!(right, Right, "Returns last n characters in the string, or when n is negative, returns all but first |n| characters.");
-scalar_function!(round, Round);
-scalar_function!(rpad, Rpad, "Extends the string to length length by appending the characters fill (a space by default). If the string is already longer than length then it is truncated.");
-scalar_function!(rtrim, Rtrim, "Removes the longest string containing only characters in characters (a space by default) from the end of string.");
-scalar_function!(sha224, SHA224);
-scalar_function!(sha256, SHA256);
-scalar_function!(sha384, SHA384);
-scalar_function!(sha512, SHA512);
-scalar_function!(signum, Signum);
-scalar_function!(sin, Sin);
-scalar_function!(
+expr_fn!(right, string n, "Returns last n characters in the string, or when n is negative, returns all but first |n| characters.");
+expr_fn_vec!(round);
+expr_fn_vec!(
+    rpad,
+    "Extends the string to length length by appending the characters fill (a space by default). If the string is already longer than length then it is truncated."
+);
+expr_fn_vec!(
+    rtrim,
+    "Removes the longest string containing only characters in characters (a space by default) from the end of string."
+);
+expr_fn!(sha224, input_arg1);
+expr_fn!(sha256, input_arg1);
+expr_fn!(sha384, input_arg1);
+expr_fn!(sha512, input_arg1);
+expr_fn!(signum, num);
+expr_fn!(sin, num);
+expr_fn!(sinh, num);
+expr_fn!(
     split_part,
-    SplitPart,
+    string delimiter index,
     "Splits string at occurrences of delimiter and returns the n'th field (counting from one)."
 );
-scalar_function!(sqrt, Sqrt);
-scalar_function!(
-    starts_with,
-    StartsWith,
-    "Returns true if string starts with prefix."
-);
-scalar_function!(strpos, Strpos, "Returns starting index of specified substring within string, or zero if it's not present. (Same as position(substring in string), but note the reversed argument order.)");
-scalar_function!(substr, Substr);
-scalar_function!(tan, Tan);
-scalar_function!(
+expr_fn!(sqrt, num);
+expr_fn!(starts_with, string prefix, "Returns true if string starts with prefix.");
+expr_fn!(strpos, string substring, "Returns starting index of specified substring within string, or zero if it's not present. (Same as position(substring in string), but note the reversed argument order.)");
+expr_fn!(substr, string position);
+expr_fn!(substr_index, string delimiter count);
+expr_fn!(substring, string position length);
+expr_fn!(find_in_set, string string_list);
+expr_fn!(tan, num);
+expr_fn!(tanh, num);
+expr_fn!(
     to_hex,
-    ToHex,
+    arg1,
     "Converts the number to its equivalent hexadecimal representation."
 );
-scalar_function!(now, Now);
-scalar_function!(to_timestamp, ToTimestamp);
-scalar_function!(to_timestamp_millis, ToTimestampMillis);
-scalar_function!(to_timestamp_micros, ToTimestampMicros);
-scalar_function!(to_timestamp_seconds, ToTimestampSeconds);
-scalar_function!(current_date, CurrentDate);
-scalar_function!(current_time, CurrentTime);
-scalar_function!(datepart, DatePart);
-scalar_function!(date_part, DatePart);
-scalar_function!(date_trunc, DateTrunc);
-scalar_function!(datetrunc, DateTrunc);
-scalar_function!(date_bin, DateBin);
-scalar_function!(translate, Translate, "Replaces each character in string that matches a character in the from set with the corresponding character in the to set. If from is longer than to, occurrences of the extra characters in from are deleted.");
-scalar_function!(trim, Trim, "Removes the longest string containing only characters in characters (a space by default) from the start, end, or both ends (BOTH is the default) of string.");
-scalar_function!(trunc, Trunc);
-scalar_function!(upper, Upper, "Converts the string to all upper case.");
-scalar_function!(make_array, MakeArray);
-scalar_function!(array, MakeArray);
-scalar_function!(nullif, NullIf);
-scalar_function!(uuid, Uuid);
-scalar_function!(r#struct, Struct); // Use raw identifier since struct is a keyword
-scalar_function!(from_unixtime, FromUnixtime);
-scalar_function!(arrow_typeof, ArrowTypeof);
-scalar_function!(random, Random);
-
-aggregate_function!(approx_distinct, ApproxDistinct);
-aggregate_function!(approx_median, ApproxMedian);
-aggregate_function!(approx_percentile_cont, ApproxPercentileCont);
-aggregate_function!(
-    approx_percentile_cont_with_weight,
-    ApproxPercentileContWithWeight
+expr_fn!(now);
+expr_fn_vec!(to_date);
+expr_fn_vec!(to_local_time);
+expr_fn_vec!(to_time);
+expr_fn_vec!(to_timestamp);
+expr_fn_vec!(to_timestamp_millis);
+expr_fn_vec!(to_timestamp_nanos);
+expr_fn_vec!(to_timestamp_micros);
+expr_fn_vec!(to_timestamp_seconds);
+expr_fn_vec!(to_unixtime);
+expr_fn!(current_date);
+expr_fn!(current_time);
+expr_fn!(date_part, part date);
+expr_fn!(date_trunc, part date);
+expr_fn!(date_bin, stride source origin);
+expr_fn!(make_date, year month day);
+expr_fn!(to_char, datetime format);
+
+expr_fn!(translate, string from to, "Replaces each character in string that matches a character in the from set with the corresponding character in the to set. If from is longer than to, occurrences of the extra characters in from are deleted.");
+expr_fn_vec!(
+    trim,
+    "Removes the longest string containing only characters in characters (a space by default) from the start, end, or both ends (BOTH is the default) of string."
 );
-aggregate_function!(array_agg, ArrayAgg);
-aggregate_function!(avg, Avg);
-aggregate_function!(corr, Correlation);
-aggregate_function!(count, Count);
-aggregate_function!(covar, Covariance);
-aggregate_function!(covar_pop, CovariancePop);
-aggregate_function!(covar_samp, Covariance);
-aggregate_function!(grouping, Grouping);
-aggregate_function!(max, Max);
-aggregate_function!(mean, Avg);
-aggregate_function!(median, Median);
-aggregate_function!(min, Min);
-aggregate_function!(sum, Sum);
-aggregate_function!(stddev, Stddev);
-aggregate_function!(stddev_pop, StddevPop);
-aggregate_function!(stddev_samp, Stddev);
-aggregate_function!(var, Variance);
-aggregate_function!(var_pop, VariancePop);
-aggregate_function!(var_samp, Variance);
-
-pub(crate) fn init_module(m: &PyModule) -> PyResult<()> {
+expr_fn_vec!(trunc);
+expr_fn!(upper, arg1, "Converts the string to all upper case.");
+expr_fn!(uuid);
+expr_fn_vec!(r#struct); // Use raw identifier since struct is a keyword
+expr_fn_vec!(named_struct);
+expr_fn!(from_unixtime, unixtime);
+expr_fn!(arrow_typeof, arg_1);
+expr_fn!(arrow_cast, arg_1 datatype);
+expr_fn!(random);
+
+// Array Functions
+array_fn!(array_append, array element);
+array_fn!(array_to_string, array delimiter);
+array_fn!(array_dims, array);
+array_fn!(array_distinct, array);
+array_fn!(array_element, array element);
+array_fn!(array_empty, array);
+array_fn!(array_length, array);
+array_fn!(array_has, first_array second_array);
+array_fn!(array_has_all, first_array second_array);
+array_fn!(array_has_any, first_array second_array);
+array_fn!(array_positions, array element);
+array_fn!(array_ndims, array);
+array_fn!(array_prepend, element array);
+array_fn!(array_pop_back, array);
+array_fn!(array_pop_front, array);
+array_fn!(array_remove, array element);
+array_fn!(array_remove_n, array element max);
+array_fn!(array_remove_all, array element);
+array_fn!(array_repeat, element count);
+array_fn!(array_replace, array from to);
+array_fn!(array_replace_n, array from to max);
+array_fn!(array_replace_all, array from to);
+array_fn!(array_sort, array desc null_first);
+array_fn!(array_intersect, first_array second_array);
+array_fn!(array_union, array1 array2);
+array_fn!(array_except, first_array second_array);
+array_fn!(array_resize, array size value);
+array_fn!(cardinality, array);
+array_fn!(flatten, array);
+array_fn!(range, start stop step);
+
+aggregate_function!(array_agg);
+aggregate_function!(max);
+aggregate_function!(min);
+aggregate_function!(avg);
+aggregate_function!(sum);
+aggregate_function!(bit_and);
+aggregate_function!(bit_or);
+aggregate_function!(bit_xor);
+aggregate_function!(bool_and);
+aggregate_function!(bool_or);
+aggregate_function!(corr, y x);
+aggregate_function!(count);
+aggregate_function!(covar_samp, y x);
+aggregate_function!(covar_pop, y x);
+aggregate_function!(median);
+aggregate_function!(regr_slope, y x);
+aggregate_function!(regr_intercept, y x);
+aggregate_function!(regr_count, y x);
+aggregate_function!(regr_r2, y x);
+aggregate_function!(regr_avgx, y x);
+aggregate_function!(regr_avgy, y x);
+aggregate_function!(regr_sxx, y x);
+aggregate_function!(regr_syy, y x);
+aggregate_function!(regr_sxy, y x);
+aggregate_function!(stddev);
+aggregate_function!(stddev_pop);
+aggregate_function!(var_sample);
+aggregate_function!(var_pop);
+aggregate_function!(approx_distinct);
+aggregate_function!(approx_median);
+
+// Code is commented out since grouping is not yet implemented
+// https://github.com/apache/datafusion-python/issues/861
+// aggregate_function!(grouping);
+
+#[pyfunction]
+#[pyo3(signature = (sort_expression, percentile, num_centroids=None, filter=None))]
+pub fn approx_percentile_cont(
+    sort_expression: PySortExpr,
+    percentile: f64,
+    num_centroids: Option<i64>, // enforces optional arguments at the end, currently
+    filter: Option<PyExpr>,
+) -> PyDataFusionResult<PyExpr> {
+    let agg_fn = functions_aggregate::expr_fn::approx_percentile_cont(
+        sort_expression.sort,
+        lit(percentile),
+        num_centroids.map(lit),
+    );
+
+    add_builder_fns_to_aggregate(agg_fn, None, filter, None, None)
+}
+
+#[pyfunction]
+#[pyo3(signature = (sort_expression, weight, percentile, num_centroids=None, filter=None))]
+pub fn approx_percentile_cont_with_weight(
+    sort_expression: PySortExpr,
+    weight: PyExpr,
+    percentile: f64,
+    num_centroids: Option<i64>,
+    filter: Option<PyExpr>,
+) -> PyDataFusionResult<PyExpr> {
+    let agg_fn = functions_aggregate::expr_fn::approx_percentile_cont_with_weight(
+        sort_expression.sort,
+        weight.expr,
+        lit(percentile),
+        num_centroids.map(lit),
+    );
+
+    add_builder_fns_to_aggregate(agg_fn, None, filter, None, None)
+}
+
+// We handle last_value explicitly because the signature expects an order_by
+// https://github.com/apache/datafusion/issues/12376
+#[pyfunction]
+#[pyo3(signature = (expr, distinct=None, filter=None, order_by=None, null_treatment=None))]
+pub fn last_value(
+    expr: PyExpr,
+    distinct: Option<bool>,
+    filter: Option<PyExpr>,
+    order_by: Option<Vec<PySortExpr>>,
+    null_treatment: Option<NullTreatment>,
+) -> PyDataFusionResult<PyExpr> {
+    // If we initialize the UDAF with order_by directly, then it gets over-written by the builder
+    let agg_fn = functions_aggregate::expr_fn::last_value(expr.expr, vec![]);
+
+    add_builder_fns_to_aggregate(agg_fn, distinct, filter, order_by, null_treatment)
+}
+// We handle first_value explicitly because the signature expects an order_by
+// https://github.com/apache/datafusion/issues/12376
+#[pyfunction]
+#[pyo3(signature = (expr, distinct=None, filter=None, order_by=None, null_treatment=None))]
+pub fn first_value(
+    expr: PyExpr,
+    distinct: Option<bool>,
+    filter: Option<PyExpr>,
+    order_by: Option<Vec<PySortExpr>>,
+    null_treatment: Option<NullTreatment>,
+) -> PyDataFusionResult<PyExpr> {
+    // If we initialize the UDAF with order_by directly, then it gets over-written by the builder
+    let agg_fn = functions_aggregate::expr_fn::first_value(expr.expr, vec![]);
+
+    add_builder_fns_to_aggregate(agg_fn, distinct, filter, order_by, null_treatment)
+}
+
+// nth_value requires a non-expr argument
+#[pyfunction]
+#[pyo3(signature = (expr, n, distinct=None, filter=None, order_by=None, null_treatment=None))]
+pub fn nth_value(
+    expr: PyExpr,
+    n: i64,
+    distinct: Option<bool>,
+    filter: Option<PyExpr>,
+    order_by: Option<Vec<PySortExpr>>,
+    null_treatment: Option<NullTreatment>,
+) -> PyDataFusionResult<PyExpr> {
+    let agg_fn = datafusion::functions_aggregate::nth_value::nth_value(expr.expr, n, vec![]);
+    add_builder_fns_to_aggregate(agg_fn, distinct, filter, order_by, null_treatment)
+}
+
+// string_agg requires a non-expr argument
+#[pyfunction]
+#[pyo3(signature = (expr, delimiter, distinct=None, filter=None, order_by=None, null_treatment=None))]
+pub fn string_agg(
+    expr: PyExpr,
+    delimiter: String,
+    distinct: Option<bool>,
+    filter: Option<PyExpr>,
+    order_by: Option<Vec<PySortExpr>>,
+    null_treatment: Option<NullTreatment>,
+) -> PyDataFusionResult<PyExpr> {
+    let agg_fn = datafusion::functions_aggregate::string_agg::string_agg(expr.expr, lit(delimiter));
+    add_builder_fns_to_aggregate(agg_fn, distinct, filter, order_by, null_treatment)
+}
+
+pub(crate) fn add_builder_fns_to_window(
+    window_fn: Expr,
+    partition_by: Option<Vec<PyExpr>>,
+    window_frame: Option<PyWindowFrame>,
+    order_by: Option<Vec<PySortExpr>>,
+    null_treatment: Option<NullTreatment>,
+) -> PyDataFusionResult<PyExpr> {
+    let null_treatment = null_treatment.map(|n| n.into());
+    let mut builder = window_fn.null_treatment(null_treatment);
+
+    if let Some(partition_cols) = partition_by {
+        builder = builder.partition_by(
+            partition_cols
+                .into_iter()
+                .map(|col| col.clone().into())
+                .collect(),
+        );
+    }
+
+    if let Some(order_by_cols) = order_by {
+        let order_by_cols = to_sort_expressions(order_by_cols);
+        builder = builder.order_by(order_by_cols);
+    }
+
+    if let Some(window_frame) = window_frame {
+        builder = builder.window_frame(window_frame.into());
+    }
+
+    Ok(builder.build().map(|e| e.into())?)
+}
+
+#[pyfunction]
+#[pyo3(signature = (arg, shift_offset, default_value=None, partition_by=None, order_by=None))]
+pub fn lead(
+    arg: PyExpr,
+    shift_offset: i64,
+    default_value: Option<PyScalarValue>,
+    partition_by: Option<Vec<PyExpr>>,
+    order_by: Option<Vec<PySortExpr>>,
+) -> PyDataFusionResult<PyExpr> {
+    let default_value = default_value.map(|v| v.into());
+    let window_fn = functions_window::expr_fn::lead(arg.expr, Some(shift_offset), default_value);
+
+    add_builder_fns_to_window(window_fn, partition_by, None, order_by, None)
+}
+
+#[pyfunction]
+#[pyo3(signature = (arg, shift_offset, default_value=None, partition_by=None, order_by=None))]
+pub fn lag(
+    arg: PyExpr,
+    shift_offset: i64,
+    default_value: Option<PyScalarValue>,
+    partition_by: Option<Vec<PyExpr>>,
+    order_by: Option<Vec<PySortExpr>>,
+) -> PyDataFusionResult<PyExpr> {
+    let default_value = default_value.map(|v| v.into());
+    let window_fn = functions_window::expr_fn::lag(arg.expr, Some(shift_offset), default_value);
+
+    add_builder_fns_to_window(window_fn, partition_by, None, order_by, None)
+}
+
+#[pyfunction]
+#[pyo3(signature = (partition_by=None, order_by=None))]
+pub fn row_number(
+    partition_by: Option<Vec<PyExpr>>,
+    order_by: Option<Vec<PySortExpr>>,
+) -> PyDataFusionResult<PyExpr> {
+    let window_fn = functions_window::expr_fn::row_number();
+
+    add_builder_fns_to_window(window_fn, partition_by, None, order_by, None)
+}
+
+#[pyfunction]
+#[pyo3(signature = (partition_by=None, order_by=None))]
+pub fn rank(
+    partition_by: Option<Vec<PyExpr>>,
+    order_by: Option<Vec<PySortExpr>>,
+) -> PyDataFusionResult<PyExpr> {
+    let window_fn = functions_window::expr_fn::rank();
+
+    add_builder_fns_to_window(window_fn, partition_by, None, order_by, None)
+}
+
+#[pyfunction]
+#[pyo3(signature = (partition_by=None, order_by=None))]
+pub fn dense_rank(
+    partition_by: Option<Vec<PyExpr>>,
+    order_by: Option<Vec<PySortExpr>>,
+) -> PyDataFusionResult<PyExpr> {
+    let window_fn = functions_window::expr_fn::dense_rank();
+
+    add_builder_fns_to_window(window_fn, partition_by, None, order_by, None)
+}
+
+#[pyfunction]
+#[pyo3(signature = (partition_by=None, order_by=None))]
+pub fn percent_rank(
+    partition_by: Option<Vec<PyExpr>>,
+    order_by: Option<Vec<PySortExpr>>,
+) -> PyDataFusionResult<PyExpr> {
+    let window_fn = functions_window::expr_fn::percent_rank();
+
+    add_builder_fns_to_window(window_fn, partition_by, None, order_by, None)
+}
+
+#[pyfunction]
+#[pyo3(signature = (partition_by=None, order_by=None))]
+pub fn cume_dist(
+    partition_by: Option<Vec<PyExpr>>,
+    order_by: Option<Vec<PySortExpr>>,
+) -> PyDataFusionResult<PyExpr> {
+    let window_fn = functions_window::expr_fn::cume_dist();
+
+    add_builder_fns_to_window(window_fn, partition_by, None, order_by, None)
+}
+
+#[pyfunction]
+#[pyo3(signature = (arg, partition_by=None, order_by=None))]
+pub fn ntile(
+    arg: PyExpr,
+    partition_by: Option<Vec<PyExpr>>,
+    order_by: Option<Vec<PySortExpr>>,
+) -> PyDataFusionResult<PyExpr> {
+    let window_fn = functions_window::expr_fn::ntile(arg.into());
+
+    add_builder_fns_to_window(window_fn, partition_by, None, order_by, None)
+}
+
+pub(crate) fn init_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(abs))?;
     m.add_wrapped(wrap_pyfunction!(acos))?;
+    m.add_wrapped(wrap_pyfunction!(acosh))?;
     m.add_wrapped(wrap_pyfunction!(approx_distinct))?;
     m.add_wrapped(wrap_pyfunction!(alias))?;
     m.add_wrapped(wrap_pyfunction!(approx_median))?;
     m.add_wrapped(wrap_pyfunction!(approx_percentile_cont))?;
     m.add_wrapped(wrap_pyfunction!(approx_percentile_cont_with_weight))?;
-    m.add_wrapped(wrap_pyfunction!(array))?;
+    m.add_wrapped(wrap_pyfunction!(range))?;
     m.add_wrapped(wrap_pyfunction!(array_agg))?;
     m.add_wrapped(wrap_pyfunction!(arrow_typeof))?;
+    m.add_wrapped(wrap_pyfunction!(arrow_cast))?;
     m.add_wrapped(wrap_pyfunction!(ascii))?;
     m.add_wrapped(wrap_pyfunction!(asin))?;
+    m.add_wrapped(wrap_pyfunction!(asinh))?;
     m.add_wrapped(wrap_pyfunction!(atan))?;
+    m.add_wrapped(wrap_pyfunction!(atanh))?;
     m.add_wrapped(wrap_pyfunction!(atan2))?;
     m.add_wrapped(wrap_pyfunction!(avg))?;
     m.add_wrapped(wrap_pyfunction!(bit_length))?;
     m.add_wrapped(wrap_pyfunction!(btrim))?;
+    m.add_wrapped(wrap_pyfunction!(cbrt))?;
     m.add_wrapped(wrap_pyfunction!(ceil))?;
     m.add_wrapped(wrap_pyfunction!(character_length))?;
     m.add_wrapped(wrap_pyfunction!(chr))?;
     m.add_wrapped(wrap_pyfunction!(char_length))?;
     m.add_wrapped(wrap_pyfunction!(coalesce))?;
+    m.add_wrapped(wrap_pyfunction!(case))?;
+    m.add_wrapped(wrap_pyfunction!(when))?;
     m.add_wrapped(wrap_pyfunction!(col))?;
     m.add_wrapped(wrap_pyfunction!(concat_ws))?;
     m.add_wrapped(wrap_pyfunction!(concat))?;
     m.add_wrapped(wrap_pyfunction!(corr))?;
     m.add_wrapped(wrap_pyfunction!(cos))?;
+    m.add_wrapped(wrap_pyfunction!(cosh))?;
+    m.add_wrapped(wrap_pyfunction!(cot))?;
     m.add_wrapped(wrap_pyfunction!(count))?;
-    m.add_wrapped(wrap_pyfunction!(count_star))?;
-    m.add_wrapped(wrap_pyfunction!(covar))?;
     m.add_wrapped(wrap_pyfunction!(covar_pop))?;
     m.add_wrapped(wrap_pyfunction!(covar_samp))?;
     m.add_wrapped(wrap_pyfunction!(current_date))?;
     m.add_wrapped(wrap_pyfunction!(current_time))?;
+    m.add_wrapped(wrap_pyfunction!(degrees))?;
     m.add_wrapped(wrap_pyfunction!(date_bin))?;
-    m.add_wrapped(wrap_pyfunction!(datepart))?;
     m.add_wrapped(wrap_pyfunction!(date_part))?;
-    m.add_wrapped(wrap_pyfunction!(datetrunc))?;
     m.add_wrapped(wrap_pyfunction!(date_trunc))?;
+    m.add_wrapped(wrap_pyfunction!(make_date))?;
     m.add_wrapped(wrap_pyfunction!(digest))?;
+    m.add_wrapped(wrap_pyfunction!(ends_with))?;
     m.add_wrapped(wrap_pyfunction!(exp))?;
+    m.add_wrapped(wrap_pyfunction!(factorial))?;
     m.add_wrapped(wrap_pyfunction!(floor))?;
     m.add_wrapped(wrap_pyfunction!(from_unixtime))?;
-    m.add_wrapped(wrap_pyfunction!(grouping))?;
+    m.add_wrapped(wrap_pyfunction!(gcd))?;
+    // m.add_wrapped(wrap_pyfunction!(grouping))?;
     m.add_wrapped(wrap_pyfunction!(in_list))?;
     m.add_wrapped(wrap_pyfunction!(initcap))?;
+    m.add_wrapped(wrap_pyfunction!(isnan))?;
+    m.add_wrapped(wrap_pyfunction!(iszero))?;
+    m.add_wrapped(wrap_pyfunction!(levenshtein))?;
+    m.add_wrapped(wrap_pyfunction!(lcm))?;
     m.add_wrapped(wrap_pyfunction!(left))?;
     m.add_wrapped(wrap_pyfunction!(length))?;
     m.add_wrapped(wrap_pyfunction!(ln))?;
-    m.add_wrapped(wrap_pyfunction!(log))?;
+    m.add_wrapped(wrap_pyfunction!(self::log))?;
     m.add_wrapped(wrap_pyfunction!(log10))?;
     m.add_wrapped(wrap_pyfunction!(log2))?;
     m.add_wrapped(wrap_pyfunction!(lower))?;
@@ -385,16 +1000,23 @@ pub(crate) fn init_module(m: &PyModule) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(max))?;
     m.add_wrapped(wrap_pyfunction!(make_array))?;
     m.add_wrapped(wrap_pyfunction!(md5))?;
-    m.add_wrapped(wrap_pyfunction!(mean))?;
     m.add_wrapped(wrap_pyfunction!(median))?;
     m.add_wrapped(wrap_pyfunction!(min))?;
+    m.add_wrapped(wrap_pyfunction!(named_struct))?;
+    m.add_wrapped(wrap_pyfunction!(nanvl))?;
+    m.add_wrapped(wrap_pyfunction!(nvl))?;
     m.add_wrapped(wrap_pyfunction!(now))?;
     m.add_wrapped(wrap_pyfunction!(nullif))?;
     m.add_wrapped(wrap_pyfunction!(octet_length))?;
     m.add_wrapped(wrap_pyfunction!(order_by))?;
+    m.add_wrapped(wrap_pyfunction!(overlay))?;
+    m.add_wrapped(wrap_pyfunction!(pi))?;
     m.add_wrapped(wrap_pyfunction!(power))?;
-    m.add_wrapped(wrap_pyfunction!(pow))?;
+    m.add_wrapped(wrap_pyfunction!(radians))?;
     m.add_wrapped(wrap_pyfunction!(random))?;
+    m.add_wrapped(wrap_pyfunction!(regexp_count))?;
+    m.add_wrapped(wrap_pyfunction!(regexp_instr))?;
+    m.add_wrapped(wrap_pyfunction!(regexp_like))?;
     m.add_wrapped(wrap_pyfunction!(regexp_match))?;
     m.add_wrapped(wrap_pyfunction!(regexp_replace))?;
     m.add_wrapped(wrap_pyfunction!(repeat))?;
@@ -410,30 +1032,107 @@ pub(crate) fn init_module(m: &PyModule) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(sha512))?;
     m.add_wrapped(wrap_pyfunction!(signum))?;
     m.add_wrapped(wrap_pyfunction!(sin))?;
+    m.add_wrapped(wrap_pyfunction!(sinh))?;
     m.add_wrapped(wrap_pyfunction!(split_part))?;
     m.add_wrapped(wrap_pyfunction!(sqrt))?;
     m.add_wrapped(wrap_pyfunction!(starts_with))?;
     m.add_wrapped(wrap_pyfunction!(stddev))?;
     m.add_wrapped(wrap_pyfunction!(stddev_pop))?;
-    m.add_wrapped(wrap_pyfunction!(stddev_samp))?;
+    m.add_wrapped(wrap_pyfunction!(string_agg))?;
     m.add_wrapped(wrap_pyfunction!(strpos))?;
     m.add_wrapped(wrap_pyfunction!(r#struct))?; // Use raw identifier since struct is a keyword
     m.add_wrapped(wrap_pyfunction!(substr))?;
+    m.add_wrapped(wrap_pyfunction!(substr_index))?;
+    m.add_wrapped(wrap_pyfunction!(substring))?;
+    m.add_wrapped(wrap_pyfunction!(find_in_set))?;
     m.add_wrapped(wrap_pyfunction!(sum))?;
     m.add_wrapped(wrap_pyfunction!(tan))?;
+    m.add_wrapped(wrap_pyfunction!(tanh))?;
     m.add_wrapped(wrap_pyfunction!(to_hex))?;
+    m.add_wrapped(wrap_pyfunction!(to_char))?;
+    m.add_wrapped(wrap_pyfunction!(to_date))?;
+    m.add_wrapped(wrap_pyfunction!(to_local_time))?;
+    m.add_wrapped(wrap_pyfunction!(to_time))?;
     m.add_wrapped(wrap_pyfunction!(to_timestamp))?;
     m.add_wrapped(wrap_pyfunction!(to_timestamp_millis))?;
+    m.add_wrapped(wrap_pyfunction!(to_timestamp_nanos))?;
     m.add_wrapped(wrap_pyfunction!(to_timestamp_micros))?;
     m.add_wrapped(wrap_pyfunction!(to_timestamp_seconds))?;
+    m.add_wrapped(wrap_pyfunction!(to_unixtime))?;
     m.add_wrapped(wrap_pyfunction!(translate))?;
     m.add_wrapped(wrap_pyfunction!(trim))?;
     m.add_wrapped(wrap_pyfunction!(trunc))?;
     m.add_wrapped(wrap_pyfunction!(upper))?;
     m.add_wrapped(wrap_pyfunction!(self::uuid))?; // Use self to avoid name collision
-    m.add_wrapped(wrap_pyfunction!(var))?;
     m.add_wrapped(wrap_pyfunction!(var_pop))?;
-    m.add_wrapped(wrap_pyfunction!(var_samp))?;
+    m.add_wrapped(wrap_pyfunction!(var_sample))?;
     m.add_wrapped(wrap_pyfunction!(window))?;
+    m.add_wrapped(wrap_pyfunction!(regr_avgx))?;
+    m.add_wrapped(wrap_pyfunction!(regr_avgy))?;
+    m.add_wrapped(wrap_pyfunction!(regr_count))?;
+    m.add_wrapped(wrap_pyfunction!(regr_intercept))?;
+    m.add_wrapped(wrap_pyfunction!(regr_r2))?;
+    m.add_wrapped(wrap_pyfunction!(regr_slope))?;
+    m.add_wrapped(wrap_pyfunction!(regr_sxx))?;
+    m.add_wrapped(wrap_pyfunction!(regr_sxy))?;
+    m.add_wrapped(wrap_pyfunction!(regr_syy))?;
+    m.add_wrapped(wrap_pyfunction!(first_value))?;
+    m.add_wrapped(wrap_pyfunction!(last_value))?;
+    m.add_wrapped(wrap_pyfunction!(nth_value))?;
+    m.add_wrapped(wrap_pyfunction!(bit_and))?;
+    m.add_wrapped(wrap_pyfunction!(bit_or))?;
+    m.add_wrapped(wrap_pyfunction!(bit_xor))?;
+    m.add_wrapped(wrap_pyfunction!(bool_and))?;
+    m.add_wrapped(wrap_pyfunction!(bool_or))?;
+
+    //Binary String Functions
+    m.add_wrapped(wrap_pyfunction!(encode))?;
+    m.add_wrapped(wrap_pyfunction!(decode))?;
+
+    // Array Functions
+    m.add_wrapped(wrap_pyfunction!(array_append))?;
+    m.add_wrapped(wrap_pyfunction!(array_concat))?;
+    m.add_wrapped(wrap_pyfunction!(array_cat))?;
+    m.add_wrapped(wrap_pyfunction!(array_dims))?;
+    m.add_wrapped(wrap_pyfunction!(array_distinct))?;
+    m.add_wrapped(wrap_pyfunction!(array_element))?;
+    m.add_wrapped(wrap_pyfunction!(array_empty))?;
+    m.add_wrapped(wrap_pyfunction!(array_length))?;
+    m.add_wrapped(wrap_pyfunction!(array_has))?;
+    m.add_wrapped(wrap_pyfunction!(array_has_all))?;
+    m.add_wrapped(wrap_pyfunction!(array_has_any))?;
+    m.add_wrapped(wrap_pyfunction!(array_position))?;
+    m.add_wrapped(wrap_pyfunction!(array_positions))?;
+    m.add_wrapped(wrap_pyfunction!(array_to_string))?;
+    m.add_wrapped(wrap_pyfunction!(array_intersect))?;
+    m.add_wrapped(wrap_pyfunction!(array_union))?;
+    m.add_wrapped(wrap_pyfunction!(array_except))?;
+    m.add_wrapped(wrap_pyfunction!(array_resize))?;
+    m.add_wrapped(wrap_pyfunction!(array_ndims))?;
+    m.add_wrapped(wrap_pyfunction!(array_prepend))?;
+    m.add_wrapped(wrap_pyfunction!(array_pop_back))?;
+    m.add_wrapped(wrap_pyfunction!(array_pop_front))?;
+    m.add_wrapped(wrap_pyfunction!(array_remove))?;
+    m.add_wrapped(wrap_pyfunction!(array_remove_n))?;
+    m.add_wrapped(wrap_pyfunction!(array_remove_all))?;
+    m.add_wrapped(wrap_pyfunction!(array_repeat))?;
+    m.add_wrapped(wrap_pyfunction!(array_replace))?;
+    m.add_wrapped(wrap_pyfunction!(array_replace_n))?;
+    m.add_wrapped(wrap_pyfunction!(array_replace_all))?;
+    m.add_wrapped(wrap_pyfunction!(array_sort))?;
+    m.add_wrapped(wrap_pyfunction!(array_slice))?;
+    m.add_wrapped(wrap_pyfunction!(flatten))?;
+    m.add_wrapped(wrap_pyfunction!(cardinality))?;
+
+    // Window Functions
+    m.add_wrapped(wrap_pyfunction!(lead))?;
+    m.add_wrapped(wrap_pyfunction!(lag))?;
+    m.add_wrapped(wrap_pyfunction!(rank))?;
+    m.add_wrapped(wrap_pyfunction!(row_number))?;
+    m.add_wrapped(wrap_pyfunction!(dense_rank))?;
+    m.add_wrapped(wrap_pyfunction!(percent_rank))?;
+    m.add_wrapped(wrap_pyfunction!(cume_dist))?;
+    m.add_wrapped(wrap_pyfunction!(ntile))?;
+
     Ok(())
 }
diff --git a/src/lib.rs b/src/lib.rs
index 4a6574c16..468243a3d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -15,93 +15,133 @@
 // specific language governing permissions and limitations
 // under the License.
 
+// Re-export Apache Arrow DataFusion dependencies
+pub use datafusion::{
+    self, common as datafusion_common, logical_expr as datafusion_expr, optimizer,
+    sql as datafusion_sql,
+};
+#[cfg(feature = "substrait")]
+pub use datafusion_substrait;
 #[cfg(feature = "mimalloc")]
 use mimalloc::MiMalloc;
 use pyo3::prelude::*;
 
-// Re-export Apache Arrow DataFusion dependencies
-pub use datafusion;
-pub use datafusion_common;
-pub use datafusion_expr;
-pub use datafusion_optimizer;
-pub use datafusion_sql;
-pub use datafusion_substrait;
-
 #[allow(clippy::borrow_deref_ref)]
 pub mod catalog;
 pub mod common;
+
 #[allow(clippy::borrow_deref_ref)]
 mod config;
 #[allow(clippy::borrow_deref_ref)]
-mod context;
+pub mod context;
 #[allow(clippy::borrow_deref_ref)]
-mod dataframe;
+pub mod dataframe;
 mod dataset;
 mod dataset_exec;
 pub mod errors;
 #[allow(clippy::borrow_deref_ref)]
-mod expr;
+pub mod expr;
 #[allow(clippy::borrow_deref_ref)]
 mod functions;
+mod options;
 pub mod physical_plan;
 mod pyarrow_filter_expression;
+pub mod pyarrow_util;
 mod record_batch;
 pub mod sql;
 pub mod store;
+pub mod table;
+pub mod unparser;
+
+mod array;
+#[cfg(feature = "substrait")]
 pub mod substrait;
 #[allow(clippy::borrow_deref_ref)]
 mod udaf;
 #[allow(clippy::borrow_deref_ref)]
 mod udf;
+pub mod udtf;
+mod udwf;
 pub mod utils;
 
 #[cfg(feature = "mimalloc")]
 #[global_allocator]
 static GLOBAL: MiMalloc = MiMalloc;
 
+// Used to define Tokio Runtime as a Python module attribute
+pub(crate) struct TokioRuntime(tokio::runtime::Runtime);
+
 /// Low-level DataFusion internal package.
 ///
 /// The higher-level public API is defined in pure python files under the
 /// datafusion directory.
 #[pymodule]
-fn _internal(py: Python, m: &PyModule) -> PyResult<()> {
+fn _internal(py: Python, m: Bound<'_, PyModule>) -> PyResult<()> {
+    // Initialize logging
+    pyo3_log::init();
+
     // Register the python classes
-    m.add_class::<catalog::PyCatalog>()?;
-    m.add_class::<catalog::PyDatabase>()?;
-    m.add_class::<catalog::PyTable>()?;
-    m.add_class::<context::PyRuntimeConfig>()?;
+    m.add_class::<context::PyRuntimeEnvBuilder>()?;
     m.add_class::<context::PySessionConfig>()?;
     m.add_class::<context::PySessionContext>()?;
+    m.add_class::<context::PySQLOptions>()?;
     m.add_class::<dataframe::PyDataFrame>()?;
+    m.add_class::<dataframe::PyInsertOp>()?;
+    m.add_class::<dataframe::PyDataFrameWriteOptions>()?;
+    m.add_class::<dataframe::PyParquetColumnOptions>()?;
+    m.add_class::<dataframe::PyParquetWriterOptions>()?;
     m.add_class::<udf::PyScalarUDF>()?;
     m.add_class::<udaf::PyAggregateUDF>()?;
+    m.add_class::<udwf::PyWindowUDF>()?;
+    m.add_class::<udtf::PyTableFunction>()?;
     m.add_class::<config::PyConfig>()?;
     m.add_class::<sql::logical::PyLogicalPlan>()?;
     m.add_class::<physical_plan::PyExecutionPlan>()?;
+    m.add_class::<record_batch::PyRecordBatch>()?;
+    m.add_class::<record_batch::PyRecordBatchStream>()?;
+
+    let catalog = PyModule::new(py, "catalog")?;
+    catalog::init_module(&catalog)?;
+    m.add_submodule(&catalog)?;
 
     // Register `common` as a submodule. Matching `datafusion-common` https://docs.rs/datafusion-common/latest/datafusion_common/
     let common = PyModule::new(py, "common")?;
-    common::init_module(common)?;
-    m.add_submodule(common)?;
+    common::init_module(&common)?;
+    m.add_submodule(&common)?;
 
     // Register `expr` as a submodule. Matching `datafusion-expr` https://docs.rs/datafusion-expr/latest/datafusion_expr/
     let expr = PyModule::new(py, "expr")?;
-    expr::init_module(expr)?;
-    m.add_submodule(expr)?;
+    expr::init_module(&expr)?;
+    m.add_submodule(&expr)?;
+
+    let unparser = PyModule::new(py, "unparser")?;
+    unparser::init_module(&unparser)?;
+    m.add_submodule(&unparser)?;
 
     // Register the functions as a submodule
     let funcs = PyModule::new(py, "functions")?;
-    functions::init_module(funcs)?;
-    m.add_submodule(funcs)?;
+    functions::init_module(&funcs)?;
+    m.add_submodule(&funcs)?;
 
     let store = PyModule::new(py, "object_store")?;
-    store::init_module(store)?;
-    m.add_submodule(store)?;
+    store::init_module(&store)?;
+    m.add_submodule(&store)?;
+
+    let options = PyModule::new(py, "options")?;
+    options::init_module(&options)?;
+    m.add_submodule(&options)?;
 
     // Register substrait as a submodule
-    let substrait = PyModule::new(py, "substrait")?;
-    substrait::init_module(substrait)?;
-    m.add_submodule(substrait)?;
+    #[cfg(feature = "substrait")]
+    setup_substrait_module(py, &m)?;
 
     Ok(())
 }
+
+#[cfg(feature = "substrait")]
+fn setup_substrait_module(py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
+    let substrait = PyModule::new(py, "substrait")?;
+    substrait::init_module(&substrait)?;
+    m.add_submodule(&substrait)?;
+    Ok(())
+}
diff --git a/src/options.rs b/src/options.rs
new file mode 100644
index 000000000..6b6037695
--- /dev/null
+++ b/src/options.rs
@@ -0,0 +1,159 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use arrow::datatypes::{DataType, Schema};
+use arrow::pyarrow::PyArrowType;
+use datafusion::prelude::CsvReadOptions;
+use pyo3::prelude::{PyModule, PyModuleMethods};
+use pyo3::{Bound, PyResult, pyclass, pymethods};
+
+use crate::context::parse_file_compression_type;
+use crate::errors::PyDataFusionError;
+use crate::expr::sort_expr::PySortExpr;
+
+/// Options for reading CSV files
+#[pyclass(name = "CsvReadOptions", module = "datafusion.options", frozen)]
+pub struct PyCsvReadOptions {
+    pub has_header: bool,
+    pub delimiter: u8,
+    pub quote: u8,
+    pub terminator: Option<u8>,
+    pub escape: Option<u8>,
+    pub comment: Option<u8>,
+    pub newlines_in_values: bool,
+    pub schema: Option<PyArrowType<Schema>>,
+    pub schema_infer_max_records: usize,
+    pub file_extension: String,
+    pub table_partition_cols: Vec<(String, PyArrowType<DataType>)>,
+    pub file_compression_type: String,
+    pub file_sort_order: Vec<Vec<PySortExpr>>,
+    pub null_regex: Option<String>,
+    pub truncated_rows: bool,
+}
+
+#[pymethods]
+impl PyCsvReadOptions {
+    #[allow(clippy::too_many_arguments)]
+    #[pyo3(signature = (
+        has_header=true,
+        delimiter=b',',
+        quote=b'"',
+        terminator=None,
+        escape=None,
+        comment=None,
+        newlines_in_values=false,
+        schema=None,
+        schema_infer_max_records=1000,
+        file_extension=".csv".to_string(),
+        table_partition_cols=vec![],
+        file_compression_type="".to_string(),
+        file_sort_order=vec![],
+        null_regex=None,
+        truncated_rows=false
+    ))]
+    #[new]
+    fn new(
+        has_header: bool,
+        delimiter: u8,
+        quote: u8,
+        terminator: Option<u8>,
+        escape: Option<u8>,
+        comment: Option<u8>,
+        newlines_in_values: bool,
+        schema: Option<PyArrowType<Schema>>,
+        schema_infer_max_records: usize,
+        file_extension: String,
+        table_partition_cols: Vec<(String, PyArrowType<DataType>)>,
+        file_compression_type: String,
+        file_sort_order: Vec<Vec<PySortExpr>>,
+        null_regex: Option<String>,
+        truncated_rows: bool,
+    ) -> Self {
+        Self {
+            has_header,
+            delimiter,
+            quote,
+            terminator,
+            escape,
+            comment,
+            newlines_in_values,
+            schema,
+            schema_infer_max_records,
+            file_extension,
+            table_partition_cols,
+            file_compression_type,
+            file_sort_order,
+            null_regex,
+            truncated_rows,
+        }
+    }
+}
+
+impl<'a> TryFrom<&'a PyCsvReadOptions> for CsvReadOptions<'a> {
+    type Error = PyDataFusionError;
+
+    fn try_from(value: &'a PyCsvReadOptions) -> Result<CsvReadOptions<'a>, Self::Error> {
+        let partition_cols: Vec<(String, DataType)> = value
+            .table_partition_cols
+            .iter()
+            .map(|(name, dtype)| (name.clone(), dtype.0.clone()))
+            .collect();
+
+        let compression = parse_file_compression_type(Some(value.file_compression_type.clone()))?;
+
+        let sort_order: Vec<Vec<datafusion::logical_expr::SortExpr>> = value
+            .file_sort_order
+            .iter()
+            .map(|inner| {
+                inner
+                    .iter()
+                    .map(|sort_expr| sort_expr.sort.clone())
+                    .collect()
+            })
+            .collect();
+
+        // Explicit struct initialization to catch upstream changes
+        let mut options = CsvReadOptions {
+            has_header: value.has_header,
+            delimiter: value.delimiter,
+            quote: value.quote,
+            terminator: value.terminator,
+            escape: value.escape,
+            comment: value.comment,
+            newlines_in_values: value.newlines_in_values,
+            schema: None, // Will be set separately due to lifetime constraints
+            schema_infer_max_records: value.schema_infer_max_records,
+            file_extension: value.file_extension.as_str(),
+            table_partition_cols: partition_cols,
+            file_compression_type: compression,
+            file_sort_order: sort_order,
+            null_regex: value.null_regex.clone(),
+            truncated_rows: value.truncated_rows,
+        };
+
+        // Set schema separately to handle the lifetime
+        options.schema = value.schema.as_ref().map(|s| &s.0);
+
+        Ok(options)
+    }
+}
+
+pub(crate) fn init_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_class::<PyCsvReadOptions>()?;
+
+    Ok(())
+}
diff --git a/src/physical_plan.rs b/src/physical_plan.rs
index 340d527fa..8674a8b55 100644
--- a/src/physical_plan.rs
+++ b/src/physical_plan.rs
@@ -15,12 +15,25 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion::physical_plan::{displayable, ExecutionPlan};
 use std::sync::Arc;
 
+use datafusion::physical_plan::{ExecutionPlan, ExecutionPlanProperties, displayable};
+use datafusion_proto::physical_plan::{AsExecutionPlan, DefaultPhysicalExtensionCodec};
+use prost::Message;
+use pyo3::exceptions::PyRuntimeError;
 use pyo3::prelude::*;
+use pyo3::types::PyBytes;
 
-#[pyclass(name = "ExecutionPlan", module = "datafusion", subclass)]
+use crate::context::PySessionContext;
+use crate::errors::PyDataFusionResult;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "ExecutionPlan",
+    module = "datafusion",
+    subclass
+)]
 #[derive(Debug, Clone)]
 pub struct PyExecutionPlan {
     pub plan: Arc<dyn ExecutionPlan>,
@@ -40,7 +53,7 @@ impl PyExecutionPlan {
         self.plan
             .children()
             .iter()
-            .map(|p| p.to_owned().into())
+            .map(|&p| p.to_owned().into())
             .collect()
     }
 
@@ -51,7 +64,45 @@ impl PyExecutionPlan {
 
     pub fn display_indent(&self) -> String {
         let d = displayable(self.plan.as_ref());
-        format!("{}", d.indent())
+        format!("{}", d.indent(false))
+    }
+
+    pub fn to_proto<'py>(&'py self, py: Python<'py>) -> PyDataFusionResult<Bound<'py, PyBytes>> {
+        let codec = DefaultPhysicalExtensionCodec {};
+        let proto = datafusion_proto::protobuf::PhysicalPlanNode::try_from_physical_plan(
+            self.plan.clone(),
+            &codec,
+        )?;
+
+        let bytes = proto.encode_to_vec();
+        Ok(PyBytes::new(py, &bytes))
+    }
+
+    #[staticmethod]
+    pub fn from_proto(
+        ctx: PySessionContext,
+        proto_msg: Bound<'_, PyBytes>,
+    ) -> PyDataFusionResult<Self> {
+        let bytes: &[u8] = proto_msg.extract().map_err(Into::<PyErr>::into)?;
+        let proto_plan =
+            datafusion_proto::protobuf::PhysicalPlanNode::decode(bytes).map_err(|e| {
+                PyRuntimeError::new_err(format!(
+                    "Unable to decode logical node from serialized bytes: {e}"
+                ))
+            })?;
+
+        let codec = DefaultPhysicalExtensionCodec {};
+        let plan = proto_plan.try_into_physical_plan(ctx.ctx.task_ctx().as_ref(), &codec)?;
+        Ok(Self::new(plan))
+    }
+
+    fn __repr__(&self) -> String {
+        self.display_indent()
+    }
+
+    #[getter]
+    pub fn partition_count(&self) -> usize {
+        self.plan.output_partitioning().partition_count()
     }
 }
 
diff --git a/src/pyarrow_filter_expression.rs b/src/pyarrow_filter_expression.rs
index d35101237..e3b4b6009 100644
--- a/src/pyarrow_filter_expression.rs
+++ b/src/pyarrow_filter_expression.rs
@@ -15,26 +15,27 @@
 // specific language governing permissions and limitations
 // under the License.
 
-/// Converts a Datafusion logical plan expression (Expr) into a PyArrow compute expression
-use pyo3::prelude::*;
-
 use std::convert::TryFrom;
 use std::result::Result;
 
-use datafusion_common::{Column, ScalarValue};
-use datafusion_expr::{Between, BinaryExpr, Expr, Operator};
+use datafusion::common::{Column, ScalarValue};
+use datafusion::logical_expr::expr::InList;
+use datafusion::logical_expr::{Between, BinaryExpr, Expr, Operator};
+/// Converts a Datafusion logical plan expression (Expr) into a PyArrow compute expression
+use pyo3::{IntoPyObjectExt, prelude::*};
 
-use crate::errors::DataFusionError;
+use crate::errors::{PyDataFusionError, PyDataFusionResult};
+use crate::pyarrow_util::scalar_to_pyarrow;
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 #[repr(transparent)]
-pub(crate) struct PyArrowFilterExpression(PyObject);
+pub(crate) struct PyArrowFilterExpression(Py<PyAny>);
 
 fn operator_to_py<'py>(
     operator: &Operator,
-    op: &'py PyModule,
-) -> Result<&'py PyAny, DataFusionError> {
-    let py_op: &PyAny = match operator {
+    op: &Bound<'py, PyModule>,
+) -> PyDataFusionResult<Bound<'py, PyAny>> {
+    let py_op: Bound<'_, PyAny> = match operator {
         Operator::Eq => op.getattr("eq")?,
         Operator::NotEq => op.getattr("ne")?,
         Operator::Lt => op.getattr("lt")?,
@@ -44,81 +45,69 @@ fn operator_to_py<'py>(
         Operator::And => op.getattr("and_")?,
         Operator::Or => op.getattr("or_")?,
         _ => {
-            return Err(DataFusionError::Common(format!(
+            return Err(PyDataFusionError::Common(format!(
                 "Unsupported operator {operator:?}"
-            )))
+            )));
         }
     };
     Ok(py_op)
 }
 
-fn extract_scalar_list(exprs: &[Expr], py: Python) -> Result<Vec<PyObject>, DataFusionError> {
-    let ret: Result<Vec<PyObject>, DataFusionError> = exprs
+fn extract_scalar_list<'py>(
+    exprs: &[Expr],
+    py: Python<'py>,
+) -> PyDataFusionResult<Vec<Bound<'py, PyAny>>> {
+    exprs
         .iter()
         .map(|expr| match expr {
-            Expr::Literal(v) => match v {
-                ScalarValue::Boolean(Some(b)) => Ok(b.into_py(py)),
-                ScalarValue::Int8(Some(i)) => Ok(i.into_py(py)),
-                ScalarValue::Int16(Some(i)) => Ok(i.into_py(py)),
-                ScalarValue::Int32(Some(i)) => Ok(i.into_py(py)),
-                ScalarValue::Int64(Some(i)) => Ok(i.into_py(py)),
-                ScalarValue::UInt8(Some(i)) => Ok(i.into_py(py)),
-                ScalarValue::UInt16(Some(i)) => Ok(i.into_py(py)),
-                ScalarValue::UInt32(Some(i)) => Ok(i.into_py(py)),
-                ScalarValue::UInt64(Some(i)) => Ok(i.into_py(py)),
-                ScalarValue::Float32(Some(f)) => Ok(f.into_py(py)),
-                ScalarValue::Float64(Some(f)) => Ok(f.into_py(py)),
-                ScalarValue::Utf8(Some(s)) => Ok(s.into_py(py)),
-                _ => Err(DataFusionError::Common(format!(
+            // TODO: should we also leverage `ScalarValue::to_pyarrow` here?
+            Expr::Literal(v, _) => match v {
+                // The unwraps here are for infallible conversions
+                ScalarValue::Boolean(Some(b)) => Ok(b.into_bound_py_any(py)?),
+                ScalarValue::Int8(Some(i)) => Ok(i.into_bound_py_any(py)?),
+                ScalarValue::Int16(Some(i)) => Ok(i.into_bound_py_any(py)?),
+                ScalarValue::Int32(Some(i)) => Ok(i.into_bound_py_any(py)?),
+                ScalarValue::Int64(Some(i)) => Ok(i.into_bound_py_any(py)?),
+                ScalarValue::UInt8(Some(i)) => Ok(i.into_bound_py_any(py)?),
+                ScalarValue::UInt16(Some(i)) => Ok(i.into_bound_py_any(py)?),
+                ScalarValue::UInt32(Some(i)) => Ok(i.into_bound_py_any(py)?),
+                ScalarValue::UInt64(Some(i)) => Ok(i.into_bound_py_any(py)?),
+                ScalarValue::Float32(Some(f)) => Ok(f.into_bound_py_any(py)?),
+                ScalarValue::Float64(Some(f)) => Ok(f.into_bound_py_any(py)?),
+                ScalarValue::Utf8(Some(s)) => Ok(s.into_bound_py_any(py)?),
+                _ => Err(PyDataFusionError::Common(format!(
                     "PyArrow can't handle ScalarValue: {v:?}"
                 ))),
             },
-            _ => Err(DataFusionError::Common(format!(
+            _ => Err(PyDataFusionError::Common(format!(
                 "Only a list of Literals are supported got {expr:?}"
             ))),
         })
-        .collect();
-    ret
+        .collect()
 }
 
 impl PyArrowFilterExpression {
-    pub fn inner(&self) -> &PyObject {
+    pub fn inner(&self) -> &Py<PyAny> {
         &self.0
     }
 }
 
 impl TryFrom<&Expr> for PyArrowFilterExpression {
-    type Error = DataFusionError;
+    type Error = PyDataFusionError;
 
     // Converts a Datafusion filter Expr into an expression string that can be evaluated by Python
     // Note that pyarrow.compute.{field,scalar} are put into Python globals() when evaluated
     // isin, is_null, and is_valid (~is_null) are methods of pyarrow.dataset.Expression
     // https://arrow.apache.org/docs/python/generated/pyarrow.dataset.Expression.html#pyarrow-dataset-expression
     fn try_from(expr: &Expr) -> Result<Self, Self::Error> {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let pc = Python::import(py, "pyarrow.compute")?;
             let op_module = Python::import(py, "operator")?;
-            let pc_expr: Result<&PyAny, DataFusionError> = match expr {
+            let pc_expr: PyDataFusionResult<Bound<'_, PyAny>> = match expr {
                 Expr::Column(Column { name, .. }) => Ok(pc.getattr("field")?.call1((name,))?),
-                Expr::Literal(v) => match v {
-                    ScalarValue::Boolean(Some(b)) => Ok(pc.getattr("scalar")?.call1((*b,))?),
-                    ScalarValue::Int8(Some(i)) => Ok(pc.getattr("scalar")?.call1((*i,))?),
-                    ScalarValue::Int16(Some(i)) => Ok(pc.getattr("scalar")?.call1((*i,))?),
-                    ScalarValue::Int32(Some(i)) => Ok(pc.getattr("scalar")?.call1((*i,))?),
-                    ScalarValue::Int64(Some(i)) => Ok(pc.getattr("scalar")?.call1((*i,))?),
-                    ScalarValue::UInt8(Some(i)) => Ok(pc.getattr("scalar")?.call1((*i,))?),
-                    ScalarValue::UInt16(Some(i)) => Ok(pc.getattr("scalar")?.call1((*i,))?),
-                    ScalarValue::UInt32(Some(i)) => Ok(pc.getattr("scalar")?.call1((*i,))?),
-                    ScalarValue::UInt64(Some(i)) => Ok(pc.getattr("scalar")?.call1((*i,))?),
-                    ScalarValue::Float32(Some(f)) => Ok(pc.getattr("scalar")?.call1((*f,))?),
-                    ScalarValue::Float64(Some(f)) => Ok(pc.getattr("scalar")?.call1((*f,))?),
-                    ScalarValue::Utf8(Some(s)) => Ok(pc.getattr("scalar")?.call1((s,))?),
-                    _ => Err(DataFusionError::Common(format!(
-                        "PyArrow can't handle ScalarValue: {v:?}"
-                    ))),
-                },
+                Expr::Literal(scalar, _) => Ok(scalar_to_pyarrow(scalar, py)?),
                 Expr::BinaryExpr(BinaryExpr { left, op, right }) => {
-                    let operator = operator_to_py(op, op_module)?;
+                    let operator = operator_to_py(op, &op_module)?;
                     let left = PyArrowFilterExpression::try_from(left.as_ref())?.0;
                     let right = PyArrowFilterExpression::try_from(right.as_ref())?.0;
                     Ok(operator.call1((left, right))?)
@@ -131,14 +120,20 @@ impl TryFrom<&Expr> for PyArrowFilterExpression {
                 Expr::IsNotNull(expr) => {
                     let py_expr = PyArrowFilterExpression::try_from(expr.as_ref())?
                         .0
-                        .into_ref(py);
+                        .into_bound(py);
                     Ok(py_expr.call_method0("is_valid")?)
                 }
                 Expr::IsNull(expr) => {
                     let expr = PyArrowFilterExpression::try_from(expr.as_ref())?
                         .0
-                        .into_ref(py);
-                    Ok(expr.call_method1("is_null", (expr,))?)
+                        .into_bound(py);
+
+                    // https://arrow.apache.org/docs/python/generated/pyarrow.dataset.Expression.html#pyarrow.dataset.Expression.is_null
+                    // Whether floating-point NaNs are considered null.
+                    let nan_is_null = false;
+
+                    let res = expr.call_method1("is_null", (nan_is_null,))?;
+                    Ok(res)
                 }
                 Expr::Between(Between {
                     expr,
@@ -161,21 +156,21 @@ impl TryFrom<&Expr> for PyArrowFilterExpression {
 
                     Ok(if *negated { invert.call1((ret,))? } else { ret })
                 }
-                Expr::InList {
+                Expr::InList(InList {
                     expr,
                     list,
                     negated,
-                } => {
+                }) => {
                     let expr = PyArrowFilterExpression::try_from(expr.as_ref())?
                         .0
-                        .into_ref(py);
+                        .into_bound(py);
                     let scalars = extract_scalar_list(list, py)?;
                     let ret = expr.call_method1("isin", (scalars,))?;
                     let invert = op_module.getattr("invert")?;
 
                     Ok(if *negated { invert.call1((ret,))? } else { ret })
                 }
-                _ => Err(DataFusionError::Common(format!(
+                _ => Err(PyDataFusionError::Common(format!(
                     "Unsupported Datafusion expression {expr:?}"
                 ))),
             };
diff --git a/src/pyarrow_util.rs b/src/pyarrow_util.rs
new file mode 100644
index 000000000..1401a4938
--- /dev/null
+++ b/src/pyarrow_util.rs
@@ -0,0 +1,163 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+//! Conversions between PyArrow and DataFusion types
+
+use std::sync::Arc;
+
+use arrow::array::{Array, ArrayData, ArrayRef, ListArray, make_array};
+use arrow::buffer::OffsetBuffer;
+use arrow::datatypes::Field;
+use arrow::pyarrow::{FromPyArrow, ToPyArrow};
+use datafusion::common::exec_err;
+use datafusion::scalar::ScalarValue;
+use pyo3::types::{PyAnyMethods, PyList};
+use pyo3::{Borrowed, Bound, FromPyObject, PyAny, PyErr, PyResult, Python};
+
+use crate::common::data_type::PyScalarValue;
+use crate::errors::PyDataFusionError;
+
+/// Helper function to turn an Array into a ScalarValue. If ``as_list_array`` is true,
+/// the array will be turned into a ``ListArray``. Otherwise, we extract the first value
+/// from the array.
+fn array_to_scalar_value(array: ArrayRef, as_list_array: bool) -> PyResult<PyScalarValue> {
+    if as_list_array {
+        let field = Arc::new(Field::new_list_field(
+            array.data_type().clone(),
+            array.nulls().is_some(),
+        ));
+        let offsets = OffsetBuffer::from_lengths(vec![array.len()]);
+        let list_array = ListArray::new(field, offsets, array, None);
+        Ok(PyScalarValue(ScalarValue::List(Arc::new(list_array))))
+    } else {
+        let scalar = ScalarValue::try_from_array(&array, 0).map_err(PyDataFusionError::from)?;
+        Ok(PyScalarValue(scalar))
+    }
+}
+
+/// Helper function to take any Python object that contains an Arrow PyCapsule
+/// interface and attempt to extract a scalar value from it. If `as_list_array`
+/// is true, the array will be turned into a ``ListArray``. Otherwise, we extract
+/// the first value from the array.
+fn pyobj_extract_scalar_via_capsule(
+    value: &Bound<'_, PyAny>,
+    as_list_array: bool,
+) -> PyResult<PyScalarValue> {
+    let array_data = ArrayData::from_pyarrow_bound(value)?;
+    let array = make_array(array_data);
+
+    array_to_scalar_value(array, as_list_array)
+}
+
+impl FromPyArrow for PyScalarValue {
+    fn from_pyarrow_bound(value: &Bound<'_, PyAny>) -> PyResult<Self> {
+        let py = value.py();
+        let pyarrow_mod = py.import("pyarrow");
+
+        // Is it a PyArrow object?
+        if let Ok(pa) = pyarrow_mod.as_ref() {
+            let scalar_type = pa.getattr("Scalar")?;
+            if value.is_instance(&scalar_type)? {
+                let typ = value.getattr("type")?;
+
+                // construct pyarrow array from the python value and pyarrow type
+                let factory = py.import("pyarrow")?.getattr("array")?;
+                let args = PyList::new(py, [value])?;
+                let array = factory.call1((args, typ))?;
+
+                return pyobj_extract_scalar_via_capsule(&array, false);
+            }
+
+            let array_type = pa.getattr("Array")?;
+            if value.is_instance(&array_type)? {
+                return pyobj_extract_scalar_via_capsule(value, true);
+            }
+        }
+
+        // Is it a NanoArrow scalar?
+        if let Ok(na) = py.import("nanoarrow") {
+            let scalar_type = py.import("nanoarrow.array")?.getattr("Scalar")?;
+            if value.is_instance(&scalar_type)? {
+                return pyobj_extract_scalar_via_capsule(value, false);
+            }
+            let array_type = na.getattr("Array")?;
+            if value.is_instance(&array_type)? {
+                return pyobj_extract_scalar_via_capsule(value, true);
+            }
+        }
+
+        // Is it a arro3 scalar?
+        if let Ok(arro3) = py.import("arro3").and_then(|arro3| arro3.getattr("core")) {
+            let scalar_type = arro3.getattr("Scalar")?;
+            if value.is_instance(&scalar_type)? {
+                return pyobj_extract_scalar_via_capsule(value, false);
+            }
+            let array_type = arro3.getattr("Array")?;
+            if value.is_instance(&array_type)? {
+                return pyobj_extract_scalar_via_capsule(value, true);
+            }
+        }
+
+        // Does it have a PyCapsule interface but isn't one of our known libraries?
+        // If so do our "best guess". Try checking type name, and if that fails
+        // return a single value if the length is 1 and return a List value otherwise
+        if value.hasattr("__arrow_c_array__")? {
+            let type_name = value.get_type().repr()?;
+            if type_name.contains("Scalar")? {
+                return pyobj_extract_scalar_via_capsule(value, false);
+            }
+            if type_name.contains("Array")? {
+                return pyobj_extract_scalar_via_capsule(value, true);
+            }
+
+            let array_data = ArrayData::from_pyarrow_bound(value)?;
+            let array = make_array(array_data);
+
+            let as_array_list = array.len() != 1;
+            return array_to_scalar_value(array, as_array_list);
+        }
+
+        // Last attempt - try to create a PyArrow scalar from a plain Python object
+        if let Ok(pa) = pyarrow_mod.as_ref() {
+            let scalar = pa.call_method1("scalar", (value,))?;
+
+            PyScalarValue::from_pyarrow_bound(&scalar)
+        } else {
+            exec_err!("Unable to import scalar value").map_err(PyDataFusionError::from)?
+        }
+    }
+}
+
+impl<'source> FromPyObject<'_, 'source> for PyScalarValue {
+    type Error = PyErr;
+
+    fn extract(value: Borrowed<'_, 'source, PyAny>) -> Result<Self, Self::Error> {
+        Self::from_pyarrow_bound(&value)
+    }
+}
+
+pub fn scalar_to_pyarrow<'py>(
+    scalar: &ScalarValue,
+    py: Python<'py>,
+) -> PyResult<Bound<'py, PyAny>> {
+    let array = scalar.to_array().map_err(PyDataFusionError::from)?;
+    // convert to pyarrow array using C data interface
+    let pyarray = array.to_data().to_pyarrow(py)?;
+    let pyscalar = pyarray.call_method1("__getitem__", (0,))?;
+
+    Ok(pyscalar)
+}
diff --git a/src/record_batch.rs b/src/record_batch.rs
index 15b70e8ce..e8abc641b 100644
--- a/src/record_batch.rs
+++ b/src/record_batch.rs
@@ -15,21 +15,28 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::utils::wait_for_future;
-use datafusion::arrow::pyarrow::PyArrowConvert;
+use std::sync::Arc;
+
+use datafusion::arrow::pyarrow::ToPyArrow;
 use datafusion::arrow::record_batch::RecordBatch;
 use datafusion::physical_plan::SendableRecordBatchStream;
 use futures::StreamExt;
-use pyo3::{pyclass, pymethods, PyObject, PyResult, Python};
+use pyo3::exceptions::{PyStopAsyncIteration, PyStopIteration};
+use pyo3::prelude::*;
+use pyo3::{PyAny, PyResult, Python, pyclass, pymethods};
+use tokio::sync::Mutex;
 
-#[pyclass(name = "RecordBatch", module = "datafusion", subclass)]
+use crate::errors::PyDataFusionError;
+use crate::utils::wait_for_future;
+
+#[pyclass(name = "RecordBatch", module = "datafusion", subclass, frozen)]
 pub struct PyRecordBatch {
     batch: RecordBatch,
 }
 
 #[pymethods]
 impl PyRecordBatch {
-    fn to_pyarrow(&self, py: Python) -> PyResult<PyObject> {
+    fn to_pyarrow<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
         self.batch.to_pyarrow(py)
     }
 }
@@ -40,25 +47,67 @@ impl From<RecordBatch> for PyRecordBatch {
     }
 }
 
-#[pyclass(name = "RecordBatchStream", module = "datafusion", subclass)]
+#[pyclass(name = "RecordBatchStream", module = "datafusion", subclass, frozen)]
 pub struct PyRecordBatchStream {
-    stream: SendableRecordBatchStream,
+    stream: Arc<Mutex<SendableRecordBatchStream>>,
 }
 
 impl PyRecordBatchStream {
     pub fn new(stream: SendableRecordBatchStream) -> Self {
-        Self { stream }
+        Self {
+            stream: Arc::new(Mutex::new(stream)),
+        }
     }
 }
 
 #[pymethods]
 impl PyRecordBatchStream {
-    fn next(&mut self, py: Python) -> PyResult<Option<PyRecordBatch>> {
-        let result = self.stream.next();
-        match wait_for_future(py, result) {
-            None => Ok(None),
-            Some(Ok(b)) => Ok(Some(b.into())),
-            Some(Err(e)) => Err(e.into()),
+    fn next(&self, py: Python) -> PyResult<PyRecordBatch> {
+        let stream = self.stream.clone();
+        wait_for_future(py, next_stream(stream, true))?
+    }
+
+    fn __next__(&self, py: Python) -> PyResult<PyRecordBatch> {
+        self.next(py)
+    }
+
+    fn __anext__<'py>(&'py self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        let stream = self.stream.clone();
+        pyo3_async_runtimes::tokio::future_into_py(py, next_stream(stream, false))
+    }
+
+    fn __iter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
+        slf
+    }
+
+    fn __aiter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
+        slf
+    }
+}
+
+/// Polls the next batch from a `SendableRecordBatchStream`, converting the `Option<Result<_>>` form.
+pub(crate) async fn poll_next_batch(
+    stream: &mut SendableRecordBatchStream,
+) -> datafusion::error::Result<Option<RecordBatch>> {
+    stream.next().await.transpose()
+}
+
+async fn next_stream(
+    stream: Arc<Mutex<SendableRecordBatchStream>>,
+    sync: bool,
+) -> PyResult<PyRecordBatch> {
+    let mut stream = stream.lock().await;
+    match poll_next_batch(&mut stream).await {
+        Ok(Some(batch)) => Ok(batch.into()),
+        Ok(None) => {
+            // Depending on whether the iteration is sync or not, we raise either a
+            // StopIteration or a StopAsyncIteration
+            if sync {
+                Err(PyStopIteration::new_err("stream exhausted"))
+            } else {
+                Err(PyStopAsyncIteration::new_err("stream exhausted"))
+            }
         }
+        Err(e) => Err(PyDataFusionError::from(e))?,
     }
 }
diff --git a/src/sql.rs b/src/sql.rs
index 9f1fe81be..dea9b566a 100644
--- a/src/sql.rs
+++ b/src/sql.rs
@@ -17,3 +17,4 @@
 
 pub mod exceptions;
 pub mod logical;
+pub(crate) mod util;
diff --git a/src/sql/exceptions.rs b/src/sql/exceptions.rs
index c458402a0..cfb02274b 100644
--- a/src/sql/exceptions.rs
+++ b/src/sql/exceptions.rs
@@ -17,13 +17,7 @@
 
 use std::fmt::{Debug, Display};
 
-use pyo3::{create_exception, PyErr};
-
-// Identifies exceptions that occur while attempting to generate a `LogicalPlan` from a SQL string
-create_exception!(rust, ParsingException, pyo3::exceptions::PyException);
-
-// Identifies exceptions that occur during attempts to optimization an existing `LogicalPlan`
-create_exception!(rust, OptimizationException, pyo3::exceptions::PyException);
+use pyo3::PyErr;
 
 pub fn py_type_err(e: impl Debug + Display) -> PyErr {
     PyErr::new::<pyo3::exceptions::PyTypeError, _>(format!("{e}"))
@@ -33,10 +27,6 @@ pub fn py_runtime_err(e: impl Debug + Display) -> PyErr {
     PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(format!("{e}"))
 }
 
-pub fn py_parsing_exp(e: impl Debug + Display) -> PyErr {
-    PyErr::new::<ParsingException, _>(format!("{e}"))
-}
-
-pub fn py_optimization_exp(e: impl Debug + Display) -> PyErr {
-    PyErr::new::<OptimizationException, _>(format!("{e}"))
+pub fn py_value_err(e: impl Debug + Display) -> PyErr {
+    PyErr::new::<pyo3::exceptions::PyValueError, _>(format!("{e}"))
 }
diff --git a/src/sql/logical.rs b/src/sql/logical.rs
index a22f269f1..631aa9b09 100644
--- a/src/sql/logical.rs
+++ b/src/sql/logical.rs
@@ -17,24 +17,64 @@
 
 use std::sync::Arc;
 
-use crate::errors::py_unsupported_variant_err;
+use datafusion::logical_expr::{DdlStatement, LogicalPlan, Statement};
+use datafusion_proto::logical_plan::{AsLogicalPlan, DefaultLogicalExtensionCodec};
+use prost::Message;
+use pyo3::exceptions::PyRuntimeError;
+use pyo3::prelude::*;
+use pyo3::types::PyBytes;
+
+use crate::context::PySessionContext;
+use crate::errors::PyDataFusionResult;
 use crate::expr::aggregate::PyAggregate;
 use crate::expr::analyze::PyAnalyze;
+use crate::expr::copy_to::PyCopyTo;
+use crate::expr::create_catalog::PyCreateCatalog;
+use crate::expr::create_catalog_schema::PyCreateCatalogSchema;
+use crate::expr::create_external_table::PyCreateExternalTable;
+use crate::expr::create_function::PyCreateFunction;
+use crate::expr::create_index::PyCreateIndex;
+use crate::expr::create_memory_table::PyCreateMemoryTable;
+use crate::expr::create_view::PyCreateView;
+use crate::expr::describe_table::PyDescribeTable;
+use crate::expr::distinct::PyDistinct;
+use crate::expr::dml::PyDmlStatement;
+use crate::expr::drop_catalog_schema::PyDropCatalogSchema;
+use crate::expr::drop_function::PyDropFunction;
+use crate::expr::drop_table::PyDropTable;
+use crate::expr::drop_view::PyDropView;
 use crate::expr::empty_relation::PyEmptyRelation;
 use crate::expr::explain::PyExplain;
 use crate::expr::extension::PyExtension;
 use crate::expr::filter::PyFilter;
+use crate::expr::join::PyJoin;
 use crate::expr::limit::PyLimit;
+use crate::expr::logical_node::LogicalNode;
 use crate::expr::projection::PyProjection;
+use crate::expr::recursive_query::PyRecursiveQuery;
+use crate::expr::repartition::PyRepartition;
 use crate::expr::sort::PySort;
+use crate::expr::statement::{
+    PyDeallocate, PyExecute, PyPrepare, PyResetVariable, PySetVariable, PyTransactionEnd,
+    PyTransactionStart,
+};
+use crate::expr::subquery::PySubquery;
+use crate::expr::subquery_alias::PySubqueryAlias;
 use crate::expr::table_scan::PyTableScan;
-use datafusion_expr::LogicalPlan;
-use pyo3::prelude::*;
+use crate::expr::union::PyUnion;
+use crate::expr::unnest::PyUnnest;
+use crate::expr::values::PyValues;
+use crate::expr::window::PyWindowExpr;
 
-use crate::expr::logical_node::LogicalNode;
-
-#[pyclass(name = "LogicalPlan", module = "datafusion", subclass)]
-#[derive(Debug, Clone)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "LogicalPlan",
+    module = "datafusion",
+    subclass,
+    eq
+)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct PyLogicalPlan {
     pub(crate) plan: Arc<LogicalPlan>,
 }
@@ -55,23 +95,76 @@ impl PyLogicalPlan {
 #[pymethods]
 impl PyLogicalPlan {
     /// Return the specific logical operator
-    fn to_variant(&self, py: Python) -> PyResult<PyObject> {
-        Python::with_gil(|_| match self.plan.as_ref() {
+    pub fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        match self.plan.as_ref() {
             LogicalPlan::Aggregate(plan) => PyAggregate::from(plan.clone()).to_variant(py),
             LogicalPlan::Analyze(plan) => PyAnalyze::from(plan.clone()).to_variant(py),
+            LogicalPlan::Distinct(plan) => PyDistinct::from(plan.clone()).to_variant(py),
             LogicalPlan::EmptyRelation(plan) => PyEmptyRelation::from(plan.clone()).to_variant(py),
             LogicalPlan::Explain(plan) => PyExplain::from(plan.clone()).to_variant(py),
             LogicalPlan::Extension(plan) => PyExtension::from(plan.clone()).to_variant(py),
             LogicalPlan::Filter(plan) => PyFilter::from(plan.clone()).to_variant(py),
+            LogicalPlan::Join(plan) => PyJoin::from(plan.clone()).to_variant(py),
             LogicalPlan::Limit(plan) => PyLimit::from(plan.clone()).to_variant(py),
             LogicalPlan::Projection(plan) => PyProjection::from(plan.clone()).to_variant(py),
             LogicalPlan::Sort(plan) => PySort::from(plan.clone()).to_variant(py),
             LogicalPlan::TableScan(plan) => PyTableScan::from(plan.clone()).to_variant(py),
-            other => Err(py_unsupported_variant_err(format!(
-                "Cannot convert this plan to a LogicalNode: {:?}",
-                other
-            ))),
-        })
+            LogicalPlan::Subquery(plan) => PySubquery::from(plan.clone()).to_variant(py),
+            LogicalPlan::SubqueryAlias(plan) => PySubqueryAlias::from(plan.clone()).to_variant(py),
+            LogicalPlan::Unnest(plan) => PyUnnest::from(plan.clone()).to_variant(py),
+            LogicalPlan::Window(plan) => PyWindowExpr::from(plan.clone()).to_variant(py),
+            LogicalPlan::Repartition(plan) => PyRepartition::from(plan.clone()).to_variant(py),
+            LogicalPlan::Union(plan) => PyUnion::from(plan.clone()).to_variant(py),
+            LogicalPlan::Statement(plan) => match plan {
+                Statement::TransactionStart(plan) => {
+                    PyTransactionStart::from(plan.clone()).to_variant(py)
+                }
+                Statement::TransactionEnd(plan) => {
+                    PyTransactionEnd::from(plan.clone()).to_variant(py)
+                }
+                Statement::SetVariable(plan) => PySetVariable::from(plan.clone()).to_variant(py),
+                Statement::ResetVariable(plan) => {
+                    PyResetVariable::from(plan.clone()).to_variant(py)
+                }
+                Statement::Prepare(plan) => PyPrepare::from(plan.clone()).to_variant(py),
+                Statement::Execute(plan) => PyExecute::from(plan.clone()).to_variant(py),
+                Statement::Deallocate(plan) => PyDeallocate::from(plan.clone()).to_variant(py),
+            },
+            LogicalPlan::Values(plan) => PyValues::from(plan.clone()).to_variant(py),
+            LogicalPlan::Dml(plan) => PyDmlStatement::from(plan.clone()).to_variant(py),
+            LogicalPlan::Ddl(plan) => match plan {
+                DdlStatement::CreateExternalTable(plan) => {
+                    PyCreateExternalTable::from(plan.clone()).to_variant(py)
+                }
+                DdlStatement::CreateMemoryTable(plan) => {
+                    PyCreateMemoryTable::from(plan.clone()).to_variant(py)
+                }
+                DdlStatement::CreateView(plan) => PyCreateView::from(plan.clone()).to_variant(py),
+                DdlStatement::CreateCatalogSchema(plan) => {
+                    PyCreateCatalogSchema::from(plan.clone()).to_variant(py)
+                }
+                DdlStatement::CreateCatalog(plan) => {
+                    PyCreateCatalog::from(plan.clone()).to_variant(py)
+                }
+                DdlStatement::CreateIndex(plan) => PyCreateIndex::from(plan.clone()).to_variant(py),
+                DdlStatement::DropTable(plan) => PyDropTable::from(plan.clone()).to_variant(py),
+                DdlStatement::DropView(plan) => PyDropView::from(plan.clone()).to_variant(py),
+                DdlStatement::DropCatalogSchema(plan) => {
+                    PyDropCatalogSchema::from(plan.clone()).to_variant(py)
+                }
+                DdlStatement::CreateFunction(plan) => {
+                    PyCreateFunction::from(plan.clone()).to_variant(py)
+                }
+                DdlStatement::DropFunction(plan) => {
+                    PyDropFunction::from(plan.clone()).to_variant(py)
+                }
+            },
+            LogicalPlan::Copy(plan) => PyCopyTo::from(plan.clone()).to_variant(py),
+            LogicalPlan::DescribeTable(plan) => PyDescribeTable::from(plan.clone()).to_variant(py),
+            LogicalPlan::RecursiveQuery(plan) => {
+                PyRecursiveQuery::from(plan.clone()).to_variant(py)
+            }
+        }
     }
 
     /// Get the inputs to this plan
@@ -100,7 +193,34 @@ impl PyLogicalPlan {
     }
 
     fn display_graphviz(&self) -> String {
-        format!("{}", self.plan.display_indent_schema())
+        format!("{}", self.plan.display_graphviz())
+    }
+
+    pub fn to_proto<'py>(&'py self, py: Python<'py>) -> PyDataFusionResult<Bound<'py, PyBytes>> {
+        let codec = DefaultLogicalExtensionCodec {};
+        let proto =
+            datafusion_proto::protobuf::LogicalPlanNode::try_from_logical_plan(&self.plan, &codec)?;
+
+        let bytes = proto.encode_to_vec();
+        Ok(PyBytes::new(py, &bytes))
+    }
+
+    #[staticmethod]
+    pub fn from_proto(
+        ctx: PySessionContext,
+        proto_msg: Bound<'_, PyBytes>,
+    ) -> PyDataFusionResult<Self> {
+        let bytes: &[u8] = proto_msg.extract().map_err(Into::<PyErr>::into)?;
+        let proto_plan =
+            datafusion_proto::protobuf::LogicalPlanNode::decode(bytes).map_err(|e| {
+                PyRuntimeError::new_err(format!(
+                    "Unable to decode logical node from serialized bytes: {e}"
+                ))
+            })?;
+
+        let codec = DefaultLogicalExtensionCodec {};
+        let plan = proto_plan.try_into_logical_plan(&ctx.ctx.task_ctx(), &codec)?;
+        Ok(Self::new(plan))
     }
 }
 
diff --git a/src/sql/util.rs b/src/sql/util.rs
new file mode 100644
index 000000000..d1e8964f8
--- /dev/null
+++ b/src/sql/util.rs
@@ -0,0 +1,87 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::collections::HashMap;
+
+use datafusion::common::{DataFusionError, exec_err, plan_datafusion_err};
+use datafusion::logical_expr::sqlparser::dialect::dialect_from_str;
+use datafusion::sql::sqlparser::dialect::Dialect;
+use datafusion::sql::sqlparser::parser::Parser;
+use datafusion::sql::sqlparser::tokenizer::{Token, Tokenizer};
+
+fn tokens_from_replacements(
+    placeholder: &str,
+    replacements: &HashMap<String, Vec<Token>>,
+) -> Option<Vec<Token>> {
+    if let Some(pattern) = placeholder.strip_prefix("$") {
+        replacements.get(pattern).cloned()
+    } else {
+        None
+    }
+}
+
+fn get_tokens_for_string_replacement(
+    dialect: &dyn Dialect,
+    replacements: HashMap<String, String>,
+) -> Result<HashMap<String, Vec<Token>>, DataFusionError> {
+    replacements
+        .into_iter()
+        .map(|(name, value)| {
+            let tokens = Tokenizer::new(dialect, &value)
+                .tokenize()
+                .map_err(|err| DataFusionError::External(err.into()))?;
+            Ok((name, tokens))
+        })
+        .collect()
+}
+
+pub(crate) fn replace_placeholders_with_strings(
+    query: &str,
+    dialect: &str,
+    replacements: HashMap<String, String>,
+) -> Result<String, DataFusionError> {
+    let dialect = dialect_from_str(dialect)
+        .ok_or_else(|| plan_datafusion_err!("Unsupported SQL dialect: {dialect}."))?;
+
+    let replacements = get_tokens_for_string_replacement(dialect.as_ref(), replacements)?;
+
+    let tokens = Tokenizer::new(dialect.as_ref(), query)
+        .tokenize()
+        .map_err(|err| DataFusionError::External(err.into()))?;
+
+    let replaced_tokens = tokens
+        .into_iter()
+        .flat_map(|token| {
+            if let Token::Placeholder(placeholder) = &token {
+                tokens_from_replacements(placeholder, &replacements).unwrap_or(vec![token])
+            } else {
+                vec![token]
+            }
+        })
+        .collect::<Vec<Token>>();
+
+    let statement = Parser::new(dialect.as_ref())
+        .with_tokens(replaced_tokens)
+        .parse_statements()
+        .map_err(|err| DataFusionError::External(Box::new(err)))?;
+
+    if statement.len() != 1 {
+        return exec_err!("placeholder replacement should return exactly one statement");
+    }
+
+    Ok(statement[0].to_string())
+}
diff --git a/src/store.rs b/src/store.rs
index 7d9bb7518..8535e83b7 100644
--- a/src/store.rs
+++ b/src/store.rs
@@ -17,12 +17,14 @@
 
 use std::sync::Arc;
 
-use pyo3::prelude::*;
-
 use object_store::aws::{AmazonS3, AmazonS3Builder};
 use object_store::azure::{MicrosoftAzure, MicrosoftAzureBuilder};
 use object_store::gcp::{GoogleCloudStorage, GoogleCloudStorageBuilder};
+use object_store::http::{HttpBuilder, HttpStore};
 use object_store::local::LocalFileSystem;
+use pyo3::exceptions::PyValueError;
+use pyo3::prelude::*;
+use url::Url;
 
 #[derive(FromPyObject)]
 pub enum StorageContexts {
@@ -30,13 +32,15 @@ pub enum StorageContexts {
     GoogleCloudStorage(PyGoogleCloudContext),
     MicrosoftAzure(PyMicrosoftAzureContext),
     LocalFileSystem(PyLocalFileSystemContext),
+    HTTP(PyHttpContext),
 }
 
 #[pyclass(
+    from_py_object,
+    frozen,
     name = "LocalFileSystem",
     module = "datafusion.store",
-    subclass,
-    unsendable
+    subclass
 )]
 #[derive(Debug, Clone)]
 pub struct PyLocalFileSystemContext {
@@ -64,10 +68,11 @@ impl PyLocalFileSystemContext {
 }
 
 #[pyclass(
+    from_py_object,
+    frozen,
     name = "MicrosoftAzure",
     module = "datafusion.store",
-    subclass,
-    unsendable
+    subclass
 )]
 #[derive(Debug, Clone)]
 pub struct PyMicrosoftAzureContext {
@@ -78,7 +83,7 @@ pub struct PyMicrosoftAzureContext {
 #[pymethods]
 impl PyMicrosoftAzureContext {
     #[allow(clippy::too_many_arguments)]
-    #[pyo3(signature = (container_name, account=None, access_key=None, bearer_token=None, client_id=None, client_secret=None, tenant_id=None, sas_query_pairs=None, use_emulator=None, allow_http=None))]
+    #[pyo3(signature = (container_name, account=None, access_key=None, bearer_token=None, client_id=None, client_secret=None, tenant_id=None, sas_query_pairs=None, use_emulator=None, allow_http=None, use_fabric_endpoint=None))]
     #[new]
     fn new(
         container_name: String,
@@ -91,6 +96,7 @@ impl PyMicrosoftAzureContext {
         sas_query_pairs: Option<Vec<(String, String)>>,
         use_emulator: Option<bool>,
         allow_http: Option<bool>,
+        use_fabric_endpoint: Option<bool>,
     ) -> Self {
         let mut builder = MicrosoftAzureBuilder::from_env().with_container_name(&container_name);
 
@@ -129,6 +135,10 @@ impl PyMicrosoftAzureContext {
             builder = builder.with_allow_http(allow_http);
         }
 
+        if let Some(use_fabric_endpoint) = use_fabric_endpoint {
+            builder = builder.with_use_fabric_endpoint(use_fabric_endpoint);
+        }
+
         Self {
             inner: Arc::new(
                 builder
@@ -141,10 +151,11 @@ impl PyMicrosoftAzureContext {
 }
 
 #[pyclass(
+    from_py_object,
+    frozen,
     name = "GoogleCloud",
     module = "datafusion.store",
-    subclass,
-    unsendable
+    subclass
 )]
 #[derive(Debug, Clone)]
 pub struct PyGoogleCloudContext {
@@ -175,7 +186,13 @@ impl PyGoogleCloudContext {
     }
 }
 
-#[pyclass(name = "AmazonS3", module = "datafusion.store", subclass, unsendable)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "AmazonS3",
+    module = "datafusion.store",
+    subclass
+)]
 #[derive(Debug, Clone)]
 pub struct PyAmazonS3Context {
     pub inner: Arc<AmazonS3>,
@@ -185,13 +202,14 @@ pub struct PyAmazonS3Context {
 #[pymethods]
 impl PyAmazonS3Context {
     #[allow(clippy::too_many_arguments)]
-    #[pyo3(signature = (bucket_name, region=None, access_key_id=None, secret_access_key=None, endpoint=None, allow_http=false, imdsv1_fallback=false))]
+    #[pyo3(signature = (bucket_name, region=None, access_key_id=None, secret_access_key=None, session_token=None, endpoint=None, allow_http=false, imdsv1_fallback=false))]
     #[new]
     fn new(
         bucket_name: String,
         region: Option<String>,
         access_key_id: Option<String>,
         secret_access_key: Option<String>,
+        session_token: Option<String>,
         endpoint: Option<String>,
         //retry_config: RetryConfig,
         allow_http: bool,
@@ -212,6 +230,10 @@ impl PyAmazonS3Context {
             builder = builder.with_secret_access_key(secret_access_key);
         };
 
+        if let Some(session_token) = session_token {
+            builder = builder.with_token(session_token);
+        }
+
         if let Some(endpoint) = endpoint {
             builder = builder.with_endpoint(endpoint);
         };
@@ -234,10 +256,43 @@ impl PyAmazonS3Context {
     }
 }
 
-pub(crate) fn init_module(m: &PyModule) -> PyResult<()> {
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Http",
+    module = "datafusion.store",
+    subclass
+)]
+#[derive(Debug, Clone)]
+pub struct PyHttpContext {
+    pub url: String,
+    pub store: Arc<HttpStore>,
+}
+
+#[pymethods]
+impl PyHttpContext {
+    #[new]
+    fn new(url: String) -> PyResult<Self> {
+        let store = match Url::parse(url.as_str()) {
+            Ok(url) => HttpBuilder::new()
+                .with_url(url.origin().ascii_serialization())
+                .build(),
+            Err(_) => HttpBuilder::new().build(),
+        }
+        .map_err(|e| PyValueError::new_err(format!("Error: {:?}", e.to_string())))?;
+
+        Ok(Self {
+            url,
+            store: Arc::new(store),
+        })
+    }
+}
+
+pub(crate) fn init_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<PyAmazonS3Context>()?;
     m.add_class::<PyMicrosoftAzureContext>()?;
     m.add_class::<PyGoogleCloudContext>()?;
     m.add_class::<PyLocalFileSystemContext>()?;
+    m.add_class::<PyHttpContext>()?;
     Ok(())
 }
diff --git a/src/substrait.rs b/src/substrait.rs
index 2bde01123..c2f112520 100644
--- a/src/substrait.rs
+++ b/src/substrait.rs
@@ -15,21 +15,52 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use datafusion_substrait::logical_plan::{consumer, producer};
+use datafusion_substrait::serializer;
+use datafusion_substrait::substrait::proto::Plan;
+use prost::Message;
 use pyo3::prelude::*;
+use pyo3::types::PyBytes;
 
 use crate::context::PySessionContext;
-use crate::errors::{py_datafusion_err, DataFusionError};
+use crate::errors::{PyDataFusionError, PyDataFusionResult, py_datafusion_err, to_datafusion_err};
 use crate::sql::logical::PyLogicalPlan;
 use crate::utils::wait_for_future;
 
-use datafusion_substrait::logical_plan::{consumer, producer};
-use datafusion_substrait::serializer;
-use datafusion_substrait::substrait::proto::Plan;
-
-#[pyclass(name = "plan", module = "datafusion.substrait", subclass, unsendable)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Plan",
+    module = "datafusion.substrait",
+    subclass
+)]
 #[derive(Debug, Clone)]
-pub(crate) struct PyPlan {
-    pub(crate) plan: Plan,
+pub struct PyPlan {
+    pub plan: Plan,
+}
+
+#[pymethods]
+impl PyPlan {
+    fn encode(&self, py: Python) -> PyResult<Py<PyAny>> {
+        let mut proto_bytes = Vec::<u8>::new();
+        self.plan
+            .encode(&mut proto_bytes)
+            .map_err(PyDataFusionError::EncodeError)?;
+        Ok(PyBytes::new(py, &proto_bytes).into())
+    }
+
+    /// Get the JSON representation of the substrait plan
+    fn to_json(&self) -> PyDataFusionResult<String> {
+        let json = serde_json::to_string_pretty(&self.plan).map_err(to_datafusion_err)?;
+        Ok(json)
+    }
+
+    /// Parse a Substrait Plan from its JSON representation
+    #[staticmethod]
+    fn from_json(json: &str) -> PyDataFusionResult<PyPlan> {
+        let plan: Plan = serde_json::from_str(json).map_err(to_datafusion_err)?;
+        Ok(PyPlan { plan })
+    }
 }
 
 impl From<PyPlan> for Plan {
@@ -47,64 +78,82 @@ impl From<Plan> for PyPlan {
 /// A PySubstraitSerializer is a representation of a Serializer that is capable of both serializing
 /// a `LogicalPlan` instance to Substrait Protobuf bytes and also deserialize Substrait Protobuf bytes
 /// to a valid `LogicalPlan` instance.
-#[pyclass(name = "serde", module = "datafusion.substrait", subclass, unsendable)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Serde",
+    module = "datafusion.substrait",
+    subclass
+)]
 #[derive(Debug, Clone)]
-pub(crate) struct PySubstraitSerializer;
+pub struct PySubstraitSerializer;
 
 #[pymethods]
 impl PySubstraitSerializer {
     #[staticmethod]
-    pub fn serialize(sql: &str, ctx: PySessionContext, path: &str, py: Python) -> PyResult<()> {
-        wait_for_future(py, serializer::serialize(sql, &ctx.ctx, path))
-            .map_err(DataFusionError::from)?;
+    pub fn serialize(
+        sql: &str,
+        ctx: PySessionContext,
+        path: &str,
+        py: Python,
+    ) -> PyDataFusionResult<()> {
+        wait_for_future(py, serializer::serialize(sql, &ctx.ctx, path))??;
         Ok(())
     }
 
     #[staticmethod]
-    pub fn serialize_to_plan(sql: &str, ctx: PySessionContext, py: Python) -> PyResult<PyPlan> {
-        match PySubstraitSerializer::serialize_bytes(sql, ctx, py) {
-            Ok(proto_bytes) => PySubstraitSerializer::deserialize_bytes(proto_bytes, py),
-            Err(e) => Err(py_datafusion_err(e)),
-        }
+    pub fn serialize_to_plan(
+        sql: &str,
+        ctx: PySessionContext,
+        py: Python,
+    ) -> PyDataFusionResult<PyPlan> {
+        PySubstraitSerializer::serialize_bytes(sql, ctx, py).and_then(|proto_bytes| {
+            let proto_bytes = proto_bytes.bind(py).cast::<PyBytes>().unwrap();
+            PySubstraitSerializer::deserialize_bytes(proto_bytes.as_bytes().to_vec(), py)
+        })
     }
 
     #[staticmethod]
-    pub fn serialize_bytes(sql: &str, ctx: PySessionContext, py: Python) -> PyResult<Vec<u8>> {
-        let proto_bytes: Vec<u8> = wait_for_future(py, serializer::serialize_bytes(sql, &ctx.ctx))
-            .map_err(DataFusionError::from)?;
-        Ok(proto_bytes)
+    pub fn serialize_bytes(
+        sql: &str,
+        ctx: PySessionContext,
+        py: Python,
+    ) -> PyDataFusionResult<Py<PyAny>> {
+        let proto_bytes: Vec<u8> =
+            wait_for_future(py, serializer::serialize_bytes(sql, &ctx.ctx))??;
+        Ok(PyBytes::new(py, &proto_bytes).into())
     }
 
     #[staticmethod]
-    pub fn deserialize(path: &str, py: Python) -> PyResult<PyPlan> {
-        let plan =
-            wait_for_future(py, serializer::deserialize(path)).map_err(DataFusionError::from)?;
+    pub fn deserialize(path: &str, py: Python) -> PyDataFusionResult<PyPlan> {
+        let plan = wait_for_future(py, serializer::deserialize(path))??;
         Ok(PyPlan { plan: *plan })
     }
 
     #[staticmethod]
-    pub fn deserialize_bytes(proto_bytes: Vec<u8>, py: Python) -> PyResult<PyPlan> {
-        let plan = wait_for_future(py, serializer::deserialize_bytes(proto_bytes))
-            .map_err(DataFusionError::from)?;
+    pub fn deserialize_bytes(proto_bytes: Vec<u8>, py: Python) -> PyDataFusionResult<PyPlan> {
+        let plan = wait_for_future(py, serializer::deserialize_bytes(proto_bytes))??;
         Ok(PyPlan { plan: *plan })
     }
 }
 
 #[pyclass(
-    name = "producer",
+    from_py_object,
+    frozen,
+    name = "Producer",
     module = "datafusion.substrait",
-    subclass,
-    unsendable
+    subclass
 )]
 #[derive(Debug, Clone)]
-pub(crate) struct PySubstraitProducer;
+pub struct PySubstraitProducer;
 
 #[pymethods]
 impl PySubstraitProducer {
     /// Convert DataFusion LogicalPlan to Substrait Plan
     #[staticmethod]
-    pub fn to_substrait_plan(plan: PyLogicalPlan) -> PyResult<PyPlan> {
-        match producer::to_substrait_plan(&plan.plan) {
+    pub fn to_substrait_plan(plan: PyLogicalPlan, ctx: &PySessionContext) -> PyResult<PyPlan> {
+        let session_state = ctx.ctx.state();
+        match producer::to_substrait_plan(&plan.plan, &session_state) {
             Ok(plan) => Ok(PyPlan { plan: *plan }),
             Err(e) => Err(py_datafusion_err(e)),
         }
@@ -112,30 +161,33 @@ impl PySubstraitProducer {
 }
 
 #[pyclass(
-    name = "consumer",
+    from_py_object,
+    frozen,
+    name = "Consumer",
     module = "datafusion.substrait",
-    subclass,
-    unsendable
+    subclass
 )]
 #[derive(Debug, Clone)]
-pub(crate) struct PySubstraitConsumer;
+pub struct PySubstraitConsumer;
 
 #[pymethods]
 impl PySubstraitConsumer {
     /// Convert Substrait Plan to DataFusion DataFrame
     #[staticmethod]
     pub fn from_substrait_plan(
-        ctx: &mut PySessionContext,
+        ctx: &PySessionContext,
         plan: PyPlan,
         py: Python,
-    ) -> PyResult<PyLogicalPlan> {
-        let result = consumer::from_substrait_plan(&mut ctx.ctx, &plan.plan);
-        let logical_plan = wait_for_future(py, result).map_err(DataFusionError::from)?;
+    ) -> PyDataFusionResult<PyLogicalPlan> {
+        let session_state = ctx.ctx.state();
+        let result = consumer::from_substrait_plan(&session_state, &plan.plan);
+        let logical_plan = wait_for_future(py, result)??;
         Ok(PyLogicalPlan::new(logical_plan))
     }
 }
 
-pub(crate) fn init_module(m: &PyModule) -> PyResult<()> {
+pub fn init_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_class::<PyPlan>()?;
     m.add_class::<PySubstraitConsumer>()?;
     m.add_class::<PySubstraitProducer>()?;
     m.add_class::<PySubstraitSerializer>()?;
diff --git a/src/table.rs b/src/table.rs
new file mode 100644
index 000000000..b9f30af9c
--- /dev/null
+++ b/src/table.rs
@@ -0,0 +1,208 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::any::Any;
+use std::sync::Arc;
+
+use arrow::datatypes::SchemaRef;
+use arrow::pyarrow::ToPyArrow;
+use async_trait::async_trait;
+use datafusion::catalog::Session;
+use datafusion::common::Column;
+use datafusion::datasource::{TableProvider, TableType};
+use datafusion::logical_expr::{Expr, LogicalPlanBuilder, TableProviderFilterPushDown};
+use datafusion::physical_plan::ExecutionPlan;
+use datafusion::prelude::DataFrame;
+use pyo3::IntoPyObjectExt;
+use pyo3::prelude::*;
+
+use crate::context::PySessionContext;
+use crate::dataframe::PyDataFrame;
+use crate::dataset::Dataset;
+use crate::utils::table_provider_from_pycapsule;
+
+/// This struct is used as a common method for all TableProviders,
+/// whether they refer to an FFI provider, an internally known
+/// implementation, a dataset, or a dataframe view.
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "RawTable",
+    module = "datafusion.catalog",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyTable {
+    pub table: Arc<dyn TableProvider>,
+}
+
+impl PyTable {
+    pub fn table(&self) -> Arc<dyn TableProvider> {
+        self.table.clone()
+    }
+}
+
+#[pymethods]
+impl PyTable {
+    /// Instantiate from any Python object that supports any of the table
+    /// types. We do not know a priori when using this method if the object
+    /// will be passed a wrapped or raw class. Here we handle all of the
+    /// following object types:
+    ///
+    /// - PyTable (essentially a clone operation), but either raw or wrapped
+    /// - DataFrame, either raw or wrapped
+    /// - FFI Table Providers via PyCapsule
+    /// - PyArrow Dataset objects
+    #[new]
+    pub fn new(obj: Bound<'_, PyAny>, session: Option<Bound<PyAny>>) -> PyResult<Self> {
+        let py = obj.py();
+        if let Ok(py_table) = obj.extract::<PyTable>() {
+            Ok(py_table)
+        } else if let Ok(py_table) = obj
+            .getattr("_inner")
+            .and_then(|inner| inner.extract::<PyTable>().map_err(Into::<PyErr>::into))
+        {
+            Ok(py_table)
+        } else if let Ok(py_df) = obj.extract::<PyDataFrame>() {
+            let provider = py_df.inner_df().as_ref().clone().into_view();
+            Ok(PyTable::from(provider))
+        } else if let Ok(py_df) = obj
+            .getattr("df")
+            .and_then(|inner| inner.extract::<PyDataFrame>().map_err(Into::<PyErr>::into))
+        {
+            let provider = py_df.inner_df().as_ref().clone().into_view();
+            Ok(PyTable::from(provider))
+        } else if let Some(provider) = {
+            let session = match session {
+                Some(session) => session,
+                None => PySessionContext::global_ctx()?.into_bound_py_any(obj.py())?,
+            };
+            table_provider_from_pycapsule(obj.clone(), session)?
+        } {
+            Ok(PyTable::from(provider))
+        } else {
+            let provider = Arc::new(Dataset::new(&obj, py)?) as Arc<dyn TableProvider>;
+            Ok(PyTable::from(provider))
+        }
+    }
+
+    /// Get a reference to the schema for this table
+    #[getter]
+    fn schema<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.table.schema().to_pyarrow(py)
+    }
+
+    /// Get the type of this table for metadata/catalog purposes.
+    #[getter]
+    fn kind(&self) -> &str {
+        match self.table.table_type() {
+            TableType::Base => "physical",
+            TableType::View => "view",
+            TableType::Temporary => "temporary",
+        }
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        let kind = self.kind();
+        Ok(format!("Table(kind={kind})"))
+    }
+}
+
+impl From<Arc<dyn TableProvider>> for PyTable {
+    fn from(table: Arc<dyn TableProvider>) -> Self {
+        Self { table }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct TempViewTable {
+    df: Arc<DataFrame>,
+}
+
+/// This is nearly identical to `DataFrameTableProvider`
+/// except that it is for temporary tables.
+/// Remove when https://github.com/apache/datafusion/issues/18026
+/// closes.
+impl TempViewTable {
+    pub(crate) fn new(df: Arc<DataFrame>) -> Self {
+        Self { df }
+    }
+}
+
+#[async_trait]
+impl TableProvider for TempViewTable {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn schema(&self) -> SchemaRef {
+        Arc::new(self.df.schema().as_arrow().clone())
+    }
+
+    fn table_type(&self) -> TableType {
+        TableType::Temporary
+    }
+
+    async fn scan(
+        &self,
+        state: &dyn Session,
+        projection: Option<&Vec<usize>>,
+        filters: &[Expr],
+        limit: Option<usize>,
+    ) -> datafusion::common::Result<Arc<dyn ExecutionPlan>> {
+        let filter = filters.iter().cloned().reduce(|acc, new| acc.and(new));
+        let plan = self.df.logical_plan().clone();
+        let mut plan = LogicalPlanBuilder::from(plan);
+
+        if let Some(filter) = filter {
+            plan = plan.filter(filter)?;
+        }
+
+        let mut plan = if let Some(projection) = projection {
+            // avoiding adding a redundant projection (e.g. SELECT * FROM view)
+            let current_projection = (0..plan.schema().fields().len()).collect::<Vec<usize>>();
+            if projection == &current_projection {
+                plan
+            } else {
+                let fields: Vec<Expr> = projection
+                    .iter()
+                    .map(|i| {
+                        Expr::Column(Column::from(
+                            self.df.logical_plan().schema().qualified_field(*i),
+                        ))
+                    })
+                    .collect();
+                plan.project(fields)?
+            }
+        } else {
+            plan
+        };
+
+        if let Some(limit) = limit {
+            plan = plan.limit(0, Some(limit))?;
+        }
+
+        state.create_physical_plan(&plan.build()?).await
+    }
+
+    fn supports_filters_pushdown(
+        &self,
+        filters: &[&Expr],
+    ) -> datafusion::common::Result<Vec<TableProviderFilterPushDown>> {
+        Ok(vec![TableProviderFilterPushDown::Exact; filters.len()])
+    }
+}
diff --git a/src/udaf.rs b/src/udaf.rs
index d5866f840..7ba499c66 100644
--- a/src/udaf.rs
+++ b/src/udaf.rs
@@ -15,54 +15,73 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::ptr::NonNull;
 use std::sync::Arc;
 
-use pyo3::{prelude::*, types::PyTuple};
-
-use datafusion::arrow::array::{Array, ArrayRef};
+use datafusion::arrow::array::ArrayRef;
 use datafusion::arrow::datatypes::DataType;
-use datafusion::arrow::pyarrow::{PyArrowConvert, PyArrowType};
+use datafusion::arrow::pyarrow::{PyArrowType, ToPyArrow};
 use datafusion::common::ScalarValue;
 use datafusion::error::{DataFusionError, Result};
-use datafusion_expr::{create_udaf, Accumulator, AccumulatorFunctionImplementation, AggregateUDF};
-
+use datafusion::logical_expr::{
+    Accumulator, AccumulatorFactoryFunction, AggregateUDF, AggregateUDFImpl, create_udaf,
+};
+use datafusion_ffi::udaf::FFI_AggregateUDF;
+use pyo3::ffi::c_str;
+use pyo3::prelude::*;
+use pyo3::types::{PyCapsule, PyTuple};
+
+use crate::common::data_type::PyScalarValue;
+use crate::errors::{PyDataFusionResult, py_datafusion_err, to_datafusion_err};
 use crate::expr::PyExpr;
-use crate::utils::parse_volatility;
+use crate::utils::{parse_volatility, validate_pycapsule};
 
 #[derive(Debug)]
 struct RustAccumulator {
-    accum: PyObject,
+    accum: Py<PyAny>,
 }
 
 impl RustAccumulator {
-    fn new(accum: PyObject) -> Self {
+    fn new(accum: Py<PyAny>) -> Self {
         Self { accum }
     }
 }
 
 impl Accumulator for RustAccumulator {
-    fn state(&self) -> Result<Vec<ScalarValue>> {
-        Python::with_gil(|py| self.accum.as_ref(py).call_method0("state")?.extract())
-            .map_err(|e| DataFusionError::Execution(format!("{e}")))
+    fn state(&mut self) -> Result<Vec<ScalarValue>> {
+        Python::attach(|py| -> PyResult<Vec<ScalarValue>> {
+            let values = self.accum.bind(py).call_method0("state")?;
+            let mut scalars = Vec::new();
+            for item in values.try_iter()? {
+                let item: Bound<'_, PyAny> = item?;
+                let scalar = item.extract::<PyScalarValue>()?.0;
+                scalars.push(scalar);
+            }
+            Ok(scalars)
+        })
+        .map_err(|e| DataFusionError::Execution(format!("{e}")))
     }
 
-    fn evaluate(&self) -> Result<ScalarValue> {
-        Python::with_gil(|py| self.accum.as_ref(py).call_method0("evaluate")?.extract())
-            .map_err(|e| DataFusionError::Execution(format!("{e}")))
+    fn evaluate(&mut self) -> Result<ScalarValue> {
+        Python::attach(|py| -> PyResult<ScalarValue> {
+            let value = self.accum.bind(py).call_method0("evaluate")?;
+            value.extract::<PyScalarValue>().map(|v| v.0)
+        })
+        .map_err(|e| DataFusionError::Execution(format!("{e}")))
     }
 
     fn update_batch(&mut self, values: &[ArrayRef]) -> Result<()> {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             // 1. cast args to Pyarrow array
             let py_args = values
                 .iter()
-                .map(|arg| arg.data().to_owned().to_pyarrow(py).unwrap())
+                .map(|arg| arg.to_data().to_pyarrow(py).unwrap())
                 .collect::<Vec<_>>();
-            let py_args = PyTuple::new(py, py_args);
+            let py_args = PyTuple::new(py, py_args).map_err(to_datafusion_err)?;
 
             // 2. call function
             self.accum
-                .as_ref(py)
+                .bind(py)
                 .call_method1("update", py_args)
                 .map_err(|e| DataFusionError::Execution(format!("{e}")))?;
 
@@ -71,19 +90,22 @@ impl Accumulator for RustAccumulator {
     }
 
     fn merge_batch(&mut self, states: &[ArrayRef]) -> Result<()> {
-        Python::with_gil(|py| {
-            let state = &states[0];
-
-            // 1. cast states to Pyarrow array
-            let state = state
-                .data()
-                .to_pyarrow(py)
-                .map_err(|e| DataFusionError::Execution(format!("{e}")))?;
+        Python::attach(|py| {
+            // // 1. cast states to Pyarrow arrays
+            let py_states: Result<Vec<Bound<'_, PyAny>>> = states
+                .iter()
+                .map(|state| {
+                    state
+                        .to_data()
+                        .to_pyarrow(py)
+                        .map_err(|e| DataFusionError::Execution(format!("{e}")))
+                })
+                .collect();
 
             // 2. call merge
             self.accum
-                .as_ref(py)
-                .call_method1("merge", (state,))
+                .bind(py)
+                .call_method1("merge", (py_states?,))
                 .map_err(|e| DataFusionError::Execution(format!("{e}")))?;
 
             Ok(())
@@ -93,11 +115,39 @@ impl Accumulator for RustAccumulator {
     fn size(&self) -> usize {
         std::mem::size_of_val(self)
     }
+
+    fn retract_batch(&mut self, values: &[ArrayRef]) -> Result<()> {
+        Python::attach(|py| {
+            // 1. cast args to Pyarrow array
+            let py_args = values
+                .iter()
+                .map(|arg| arg.to_data().to_pyarrow(py).unwrap())
+                .collect::<Vec<_>>();
+            let py_args = PyTuple::new(py, py_args).map_err(to_datafusion_err)?;
+
+            // 2. call function
+            self.accum
+                .bind(py)
+                .call_method1("retract_batch", py_args)
+                .map_err(|e| DataFusionError::Execution(format!("{e}")))?;
+
+            Ok(())
+        })
+    }
+
+    fn supports_retract_batch(&self) -> bool {
+        Python::attach(
+            |py| match self.accum.bind(py).call_method0("supports_retract_batch") {
+                Ok(x) => x.extract().unwrap_or(false),
+                Err(_) => false,
+            },
+        )
+    }
 }
 
-pub fn to_rust_accumulator(accum: PyObject) -> AccumulatorFunctionImplementation {
-    Arc::new(move |_| -> Result<Box<dyn Accumulator>> {
-        let accum = Python::with_gil(|py| {
+pub fn to_rust_accumulator(accum: Py<PyAny>) -> AccumulatorFactoryFunction {
+    Arc::new(move |_args| -> Result<Box<dyn Accumulator>> {
+        let accum = Python::attach(|py| {
             accum
                 .call0(py)
                 .map_err(|e| DataFusionError::Execution(format!("{e}")))
@@ -106,8 +156,26 @@ pub fn to_rust_accumulator(accum: PyObject) -> AccumulatorFunctionImplementation
     })
 }
 
+fn aggregate_udf_from_capsule(capsule: &Bound<'_, PyCapsule>) -> PyDataFusionResult<AggregateUDF> {
+    validate_pycapsule(capsule, "datafusion_aggregate_udf")?;
+
+    let data: NonNull<FFI_AggregateUDF> = capsule
+        .pointer_checked(Some(c_str!("datafusion_aggregate_udf")))?
+        .cast();
+    let udaf = unsafe { data.as_ref() };
+    let udaf: Arc<dyn AggregateUDFImpl> = udaf.into();
+
+    Ok(AggregateUDF::new_from_shared_impl(udaf))
+}
+
 /// Represents an AggregateUDF
-#[pyclass(name = "AggregateUDF", module = "datafusion", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "AggregateUDF",
+    module = "datafusion",
+    subclass
+)]
 #[derive(Debug, Clone)]
 pub struct PyAggregateUDF {
     pub(crate) function: AggregateUDF,
@@ -115,11 +183,12 @@ pub struct PyAggregateUDF {
 
 #[pymethods]
 impl PyAggregateUDF {
-    #[new(name, accumulator, input_type, return_type, state_type, volatility)]
+    #[new]
+    #[pyo3(signature=(name, accumulator, input_type, return_type, state_type, volatility))]
     fn new(
         name: &str,
-        accumulator: PyObject,
-        input_type: PyArrowType<DataType>,
+        accumulator: Py<PyAny>,
+        input_type: PyArrowType<Vec<DataType>>,
         return_type: PyArrowType<DataType>,
         state_type: PyArrowType<Vec<DataType>>,
         volatility: &str,
@@ -135,6 +204,26 @@ impl PyAggregateUDF {
         Ok(Self { function })
     }
 
+    #[staticmethod]
+    pub fn from_pycapsule(func: Bound<'_, PyAny>) -> PyDataFusionResult<Self> {
+        if func.is_instance_of::<PyCapsule>() {
+            let capsule = func.cast::<PyCapsule>().map_err(py_datafusion_err)?;
+            let function = aggregate_udf_from_capsule(capsule)?;
+            return Ok(Self { function });
+        }
+
+        if func.hasattr("__datafusion_aggregate_udf__")? {
+            let capsule = func.getattr("__datafusion_aggregate_udf__")?.call0()?;
+            let capsule = capsule.cast::<PyCapsule>().map_err(py_datafusion_err)?;
+            let function = aggregate_udf_from_capsule(capsule)?;
+            return Ok(Self { function });
+        }
+
+        Err(crate::errors::PyDataFusionError::Common(
+            "__datafusion_aggregate_udf__ does not exist on AggregateUDF object.".to_string(),
+        ))
+    }
+
     /// creates a new PyExpr with the call of the udf
     #[pyo3(signature = (*args))]
     fn __call__(&self, args: Vec<PyExpr>) -> PyResult<PyExpr> {
@@ -143,6 +232,6 @@ impl PyAggregateUDF {
     }
 
     fn __repr__(&self) -> PyResult<String> {
-        Ok(format!("AggregateUDF({})", self.function.name))
+        Ok(format!("AggregateUDF({})", self.function.name()))
     }
 }
diff --git a/src/udf.rs b/src/udf.rs
index f3e6cfb58..2d60abc09 100644
--- a/src/udf.rs
+++ b/src/udf.rs
@@ -15,52 +15,153 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::any::Any;
+use std::hash::{Hash, Hasher};
+use std::ptr::NonNull;
 use std::sync::Arc;
 
-use pyo3::{prelude::*, types::PyTuple};
-
-use datafusion::arrow::array::{make_array, Array, ArrayData, ArrayRef};
+use arrow::datatypes::{Field, FieldRef};
+use arrow::pyarrow::ToPyArrow;
+use datafusion::arrow::array::{ArrayData, make_array};
 use datafusion::arrow::datatypes::DataType;
-use datafusion::arrow::pyarrow::{PyArrowConvert, PyArrowType};
+use datafusion::arrow::pyarrow::{FromPyArrow, PyArrowType};
+use datafusion::common::internal_err;
 use datafusion::error::DataFusionError;
-use datafusion::physical_plan::functions::make_scalar_function;
-use datafusion::physical_plan::udf::ScalarUDF;
-use datafusion_expr::create_udf;
-use datafusion_expr::function::ScalarFunctionImplementation;
+use datafusion::logical_expr::{
+    ColumnarValue, ReturnFieldArgs, ScalarFunctionArgs, ScalarUDF, ScalarUDFImpl, Signature,
+    Volatility,
+};
+use datafusion_ffi::udf::FFI_ScalarUDF;
+use pyo3::ffi::c_str;
+use pyo3::prelude::*;
+use pyo3::types::{PyCapsule, PyTuple};
 
+use crate::array::PyArrowArrayExportable;
+use crate::errors::{PyDataFusionResult, py_datafusion_err, to_datafusion_err};
 use crate::expr::PyExpr;
-use crate::utils::parse_volatility;
-
-/// Create a DataFusion's UDF implementation from a python function
-/// that expects pyarrow arrays. This is more efficient as it performs
-/// a zero-copy of the contents.
-fn to_rust_function(func: PyObject) -> ScalarFunctionImplementation {
-    make_scalar_function(
-        move |args: &[ArrayRef]| -> Result<ArrayRef, DataFusionError> {
-            Python::with_gil(|py| {
-                // 1. cast args to Pyarrow arrays
-                let py_args = args
-                    .iter()
-                    .map(|arg| arg.data().to_owned().to_pyarrow(py).unwrap())
-                    .collect::<Vec<_>>();
-                let py_args = PyTuple::new(py, py_args);
-
-                // 2. call function
-                let value = func
-                    .as_ref(py)
-                    .call(py_args, None)
-                    .map_err(|e| DataFusionError::Execution(format!("{e:?}")))?;
-
-                // 3. cast to arrow::array::Array
-                let array_data = ArrayData::from_pyarrow(value).unwrap();
-                Ok(make_array(array_data))
-            })
-        },
-    )
+use crate::utils::{parse_volatility, validate_pycapsule};
+
+/// This struct holds the Python written function that is a
+/// ScalarUDF.
+#[derive(Debug)]
+struct PythonFunctionScalarUDF {
+    name: String,
+    func: Py<PyAny>,
+    signature: Signature,
+    return_field: FieldRef,
+}
+
+impl PythonFunctionScalarUDF {
+    fn new(
+        name: String,
+        func: Py<PyAny>,
+        input_fields: Vec<Field>,
+        return_field: Field,
+        volatility: Volatility,
+    ) -> Self {
+        let input_types = input_fields.iter().map(|f| f.data_type().clone()).collect();
+        let signature = Signature::exact(input_types, volatility);
+        Self {
+            name,
+            func,
+            signature,
+            return_field: Arc::new(return_field),
+        }
+    }
+}
+
+impl Eq for PythonFunctionScalarUDF {}
+impl PartialEq for PythonFunctionScalarUDF {
+    fn eq(&self, other: &Self) -> bool {
+        self.name == other.name
+            && self.signature == other.signature
+            && self.return_field == other.return_field
+            && Python::attach(|py| self.func.bind(py).eq(other.func.bind(py)).unwrap_or(false))
+    }
+}
+
+impl Hash for PythonFunctionScalarUDF {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.name.hash(state);
+        self.signature.hash(state);
+        self.return_field.hash(state);
+
+        Python::attach(|py| {
+            let py_hash = self.func.bind(py).hash().unwrap_or(0); // Handle unhashable objects
+
+            state.write_isize(py_hash);
+        });
+    }
+}
+
+impl ScalarUDFImpl for PythonFunctionScalarUDF {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    fn signature(&self) -> &Signature {
+        &self.signature
+    }
+
+    fn return_type(&self, _arg_types: &[DataType]) -> datafusion::common::Result<DataType> {
+        internal_err!(
+            "return_field should not be called when return_field_from_args is implemented."
+        )
+    }
+
+    fn return_field_from_args(
+        &self,
+        _args: ReturnFieldArgs,
+    ) -> datafusion::common::Result<FieldRef> {
+        Ok(Arc::clone(&self.return_field))
+    }
+
+    fn invoke_with_args(
+        &self,
+        args: ScalarFunctionArgs,
+    ) -> datafusion::common::Result<ColumnarValue> {
+        let num_rows = args.number_rows;
+        Python::attach(|py| {
+            // 1. cast args to Pyarrow arrays
+            let py_args = args
+                .args
+                .into_iter()
+                .zip(args.arg_fields)
+                .map(|(arg, field)| {
+                    let array = arg.to_array(num_rows)?;
+                    PyArrowArrayExportable::new(array, field)
+                        .to_pyarrow(py)
+                        .map_err(to_datafusion_err)
+                })
+                .collect::<Result<Vec<_>, _>>()?;
+            let py_args = PyTuple::new(py, py_args).map_err(to_datafusion_err)?;
+
+            // 2. call function
+            let value = self
+                .func
+                .call(py, py_args, None)
+                .map_err(|e| DataFusionError::Execution(format!("{e:?}")))?;
+
+            // 3. cast to arrow::array::Array
+            let array_data = ArrayData::from_pyarrow_bound(value.bind(py))
+                .map_err(|e| DataFusionError::Execution(format!("{e:?}")))?;
+            Ok(ColumnarValue::Array(make_array(array_data)))
+        })
+    }
 }
 
 /// Represents a PyScalarUDF
-#[pyclass(name = "ScalarUDF", module = "datafusion", subclass)]
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "ScalarUDF",
+    module = "datafusion",
+    subclass
+)]
 #[derive(Debug, Clone)]
 pub struct PyScalarUDF {
     pub(crate) function: ScalarUDF,
@@ -68,24 +169,50 @@ pub struct PyScalarUDF {
 
 #[pymethods]
 impl PyScalarUDF {
-    #[new(name, func, input_types, return_type, volatility)]
+    #[new]
+    #[pyo3(signature=(name, func, input_types, return_type, volatility))]
     fn new(
-        name: &str,
-        func: PyObject,
-        input_types: PyArrowType<Vec<DataType>>,
-        return_type: PyArrowType<DataType>,
+        name: String,
+        func: Py<PyAny>,
+        input_types: PyArrowType<Vec<Field>>,
+        return_type: PyArrowType<Field>,
         volatility: &str,
     ) -> PyResult<Self> {
-        let function = create_udf(
+        let py_function = PythonFunctionScalarUDF::new(
             name,
+            func,
             input_types.0,
-            Arc::new(return_type.0),
+            return_type.0,
             parse_volatility(volatility)?,
-            to_rust_function(func),
         );
+        let function = ScalarUDF::new_from_impl(py_function);
+
         Ok(Self { function })
     }
 
+    #[staticmethod]
+    pub fn from_pycapsule(func: Bound<'_, PyAny>) -> PyDataFusionResult<Self> {
+        if func.hasattr("__datafusion_scalar_udf__")? {
+            let capsule = func.getattr("__datafusion_scalar_udf__")?.call0()?;
+            let capsule = capsule.cast::<PyCapsule>().map_err(py_datafusion_err)?;
+            validate_pycapsule(capsule, "datafusion_scalar_udf")?;
+
+            let data: NonNull<FFI_ScalarUDF> = capsule
+                .pointer_checked(Some(c_str!("datafusion_scalar_udf")))?
+                .cast();
+            let udf = unsafe { data.as_ref() };
+            let udf: Arc<dyn ScalarUDFImpl> = udf.into();
+
+            Ok(Self {
+                function: ScalarUDF::new_from_shared_impl(udf),
+            })
+        } else {
+            Err(crate::errors::PyDataFusionError::Common(
+                "__datafusion_scalar_udf__ does not exist on ScalarUDF object.".to_string(),
+            ))
+        }
+    }
+
     /// creates a new PyExpr with the call of the udf
     #[pyo3(signature = (*args))]
     fn __call__(&self, args: Vec<PyExpr>) -> PyResult<PyExpr> {
@@ -94,6 +221,6 @@ impl PyScalarUDF {
     }
 
     fn __repr__(&self) -> PyResult<String> {
-        Ok(format!("ScalarUDF({})", self.function.name))
+        Ok(format!("ScalarUDF({})", self.function.name()))
     }
 }
diff --git a/src/udtf.rs b/src/udtf.rs
new file mode 100644
index 000000000..24df93e2b
--- /dev/null
+++ b/src/udtf.rs
@@ -0,0 +1,138 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::ptr::NonNull;
+use std::sync::Arc;
+
+use datafusion::catalog::{TableFunctionImpl, TableProvider};
+use datafusion::error::Result as DataFusionResult;
+use datafusion::logical_expr::Expr;
+use datafusion_ffi::udtf::FFI_TableFunction;
+use pyo3::IntoPyObjectExt;
+use pyo3::exceptions::{PyImportError, PyTypeError};
+use pyo3::ffi::c_str;
+use pyo3::prelude::*;
+use pyo3::types::{PyCapsule, PyTuple, PyType};
+
+use crate::context::PySessionContext;
+use crate::errors::{py_datafusion_err, to_datafusion_err};
+use crate::expr::PyExpr;
+use crate::table::PyTable;
+use crate::utils::validate_pycapsule;
+
+/// Represents a user defined table function
+#[pyclass(from_py_object, frozen, name = "TableFunction", module = "datafusion")]
+#[derive(Debug, Clone)]
+pub struct PyTableFunction {
+    pub(crate) name: String,
+    pub(crate) inner: PyTableFunctionInner,
+}
+
+// TODO: Implement pure python based user defined table functions
+#[derive(Debug, Clone)]
+pub(crate) enum PyTableFunctionInner {
+    PythonFunction(Arc<Py<PyAny>>),
+    FFIFunction(Arc<dyn TableFunctionImpl>),
+}
+
+#[pymethods]
+impl PyTableFunction {
+    #[new]
+    #[pyo3(signature=(name, func, session))]
+    pub fn new(
+        name: &str,
+        func: Bound<'_, PyAny>,
+        session: Option<Bound<PyAny>>,
+    ) -> PyResult<Self> {
+        let inner = if func.hasattr("__datafusion_table_function__")? {
+            let py = func.py();
+            let session = match session {
+                Some(session) => session,
+                None => PySessionContext::global_ctx()?.into_bound_py_any(py)?,
+            };
+            let capsule = func
+                .getattr("__datafusion_table_function__")?
+                .call1((session,)).map_err(|err| {
+                if err.get_type(py).is(PyType::new::<PyTypeError>(py)) {
+                    PyImportError::new_err("Incompatible libraries. DataFusion 52.0.0 introduced an incompatible signature change for table functions. Either downgrade DataFusion or upgrade your function library.")
+                } else {
+                    err
+                }
+            })?;
+            let capsule = capsule.cast::<PyCapsule>().map_err(py_datafusion_err)?;
+            validate_pycapsule(capsule, "datafusion_table_function")?;
+
+            let data: NonNull<FFI_TableFunction> = capsule
+                .pointer_checked(Some(c_str!("datafusion_table_function")))?
+                .cast();
+            let ffi_func = unsafe { data.as_ref() };
+            let foreign_func: Arc<dyn TableFunctionImpl> = ffi_func.to_owned().into();
+
+            PyTableFunctionInner::FFIFunction(foreign_func)
+        } else {
+            let py_obj = Arc::new(func.unbind());
+            PyTableFunctionInner::PythonFunction(py_obj)
+        };
+
+        Ok(Self {
+            name: name.to_string(),
+            inner,
+        })
+    }
+
+    #[pyo3(signature = (*args))]
+    pub fn __call__(&self, args: Vec<PyExpr>) -> PyResult<PyTable> {
+        let args: Vec<Expr> = args.iter().map(|e| e.expr.clone()).collect();
+        let table_provider = self.call(&args).map_err(py_datafusion_err)?;
+
+        Ok(PyTable::from(table_provider))
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("TableUDF({})", self.name))
+    }
+}
+
+#[allow(clippy::result_large_err)]
+fn call_python_table_function(
+    func: &Arc<Py<PyAny>>,
+    args: &[Expr],
+) -> DataFusionResult<Arc<dyn TableProvider>> {
+    let args = args
+        .iter()
+        .map(|arg| PyExpr::from(arg.clone()))
+        .collect::<Vec<_>>();
+
+    // move |args: &[ArrayRef]| -> Result<ArrayRef, DataFusionError> {
+    Python::attach(|py| {
+        let py_args = PyTuple::new(py, args)?;
+        let provider_obj = func.call1(py, py_args)?;
+        let provider = provider_obj.bind(py).clone();
+
+        Ok::<Arc<dyn TableProvider>, PyErr>(PyTable::new(provider, None)?.table)
+    })
+    .map_err(to_datafusion_err)
+}
+
+impl TableFunctionImpl for PyTableFunction {
+    fn call(&self, args: &[Expr]) -> DataFusionResult<Arc<dyn TableProvider>> {
+        match &self.inner {
+            PyTableFunctionInner::FFIFunction(func) => func.call(args),
+            PyTableFunctionInner::PythonFunction(obj) => call_python_table_function(obj, args),
+        }
+    }
+}
diff --git a/src/udwf.rs b/src/udwf.rs
new file mode 100644
index 000000000..de63e2f9a
--- /dev/null
+++ b/src/udwf.rs
@@ -0,0 +1,348 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::any::Any;
+use std::ops::Range;
+use std::ptr::NonNull;
+use std::sync::Arc;
+
+use arrow::array::{Array, ArrayData, ArrayRef, make_array};
+use datafusion::arrow::datatypes::DataType;
+use datafusion::arrow::pyarrow::{FromPyArrow, PyArrowType, ToPyArrow};
+use datafusion::error::{DataFusionError, Result};
+use datafusion::logical_expr::function::{PartitionEvaluatorArgs, WindowUDFFieldArgs};
+use datafusion::logical_expr::ptr_eq::PtrEq;
+use datafusion::logical_expr::window_state::WindowAggState;
+use datafusion::logical_expr::{
+    PartitionEvaluator, PartitionEvaluatorFactory, Signature, Volatility, WindowUDF, WindowUDFImpl,
+};
+use datafusion::scalar::ScalarValue;
+use datafusion_ffi::udwf::FFI_WindowUDF;
+use pyo3::exceptions::PyValueError;
+use pyo3::ffi::c_str;
+use pyo3::prelude::*;
+use pyo3::types::{PyCapsule, PyList, PyTuple};
+
+use crate::common::data_type::PyScalarValue;
+use crate::errors::{PyDataFusionResult, py_datafusion_err, to_datafusion_err};
+use crate::expr::PyExpr;
+use crate::utils::{parse_volatility, validate_pycapsule};
+
+#[derive(Debug)]
+struct RustPartitionEvaluator {
+    evaluator: Py<PyAny>,
+}
+
+impl RustPartitionEvaluator {
+    fn new(evaluator: Py<PyAny>) -> Self {
+        Self { evaluator }
+    }
+}
+
+impl PartitionEvaluator for RustPartitionEvaluator {
+    fn memoize(&mut self, _state: &mut WindowAggState) -> Result<()> {
+        Python::attach(|py| self.evaluator.bind(py).call_method0("memoize").map(|_| ()))
+            .map_err(|e| DataFusionError::Execution(format!("{e}")))
+    }
+
+    fn get_range(&self, idx: usize, n_rows: usize) -> Result<Range<usize>> {
+        Python::attach(|py| {
+            let py_args = vec![idx.into_pyobject(py)?, n_rows.into_pyobject(py)?];
+            let py_args = PyTuple::new(py, py_args)?;
+
+            self.evaluator
+                .bind(py)
+                .call_method1("get_range", py_args)
+                .and_then(|v| {
+                    let tuple: Bound<'_, PyTuple> = v.extract()?;
+                    if tuple.len() != 2 {
+                        return Err(PyValueError::new_err(format!(
+                            "Expected get_range to return tuple of length 2. Received length {}",
+                            tuple.len()
+                        )));
+                    }
+
+                    let start: usize = tuple.get_item(0).unwrap().extract()?;
+                    let end: usize = tuple.get_item(1).unwrap().extract()?;
+
+                    Ok(Range { start, end })
+                })
+        })
+        .map_err(|e| DataFusionError::Execution(format!("{e}")))
+    }
+
+    fn is_causal(&self) -> bool {
+        Python::attach(|py| {
+            self.evaluator
+                .bind(py)
+                .call_method0("is_causal")
+                .and_then(|v| v.extract())
+                .unwrap_or(false)
+        })
+    }
+
+    fn evaluate_all(&mut self, values: &[ArrayRef], num_rows: usize) -> Result<ArrayRef> {
+        Python::attach(|py| {
+            let py_values = PyList::new(
+                py,
+                values
+                    .iter()
+                    .map(|arg| arg.into_data().to_pyarrow(py).unwrap()),
+            )?;
+            let py_num_rows = num_rows.into_pyobject(py)?;
+            let py_args = PyTuple::new(py, vec![py_values.as_any(), &py_num_rows])?;
+
+            self.evaluator
+                .bind(py)
+                .call_method1("evaluate_all", py_args)
+                .map(|v| {
+                    let array_data = ArrayData::from_pyarrow_bound(&v).unwrap();
+                    make_array(array_data)
+                })
+        })
+        .map_err(to_datafusion_err)
+    }
+
+    fn evaluate(&mut self, values: &[ArrayRef], range: &Range<usize>) -> Result<ScalarValue> {
+        Python::attach(|py| {
+            let py_values = PyList::new(
+                py,
+                values
+                    .iter()
+                    .map(|arg| arg.into_data().to_pyarrow(py).unwrap()),
+            )?;
+            let range_tuple = PyTuple::new(py, vec![range.start, range.end])?;
+            let py_args = PyTuple::new(py, vec![py_values.as_any(), range_tuple.as_any()])?;
+
+            self.evaluator
+                .bind(py)
+                .call_method1("evaluate", py_args)
+                .and_then(|v| v.extract::<PyScalarValue>())
+                .map(|v| v.0)
+        })
+        .map_err(to_datafusion_err)
+    }
+
+    fn evaluate_all_with_rank(
+        &self,
+        num_rows: usize,
+        ranks_in_partition: &[Range<usize>],
+    ) -> Result<ArrayRef> {
+        Python::attach(|py| {
+            let ranks = ranks_in_partition
+                .iter()
+                .map(|r| PyTuple::new(py, vec![r.start, r.end]))
+                .collect::<PyResult<Vec<_>>>()?;
+
+            // 1. cast args to Pyarrow array
+            let py_args = vec![
+                num_rows.into_pyobject(py)?.into_any(),
+                PyList::new(py, ranks)?.into_any(),
+            ];
+
+            let py_args = PyTuple::new(py, py_args)?;
+
+            // 2. call function
+            self.evaluator
+                .bind(py)
+                .call_method1("evaluate_all_with_rank", py_args)
+                .map(|v| {
+                    let array_data = ArrayData::from_pyarrow_bound(&v).unwrap();
+                    make_array(array_data)
+                })
+        })
+        .map_err(to_datafusion_err)
+    }
+
+    fn supports_bounded_execution(&self) -> bool {
+        Python::attach(|py| {
+            self.evaluator
+                .bind(py)
+                .call_method0("supports_bounded_execution")
+                .and_then(|v| v.extract())
+                .unwrap_or(false)
+        })
+    }
+
+    fn uses_window_frame(&self) -> bool {
+        Python::attach(|py| {
+            self.evaluator
+                .bind(py)
+                .call_method0("uses_window_frame")
+                .and_then(|v| v.extract())
+                .unwrap_or(false)
+        })
+    }
+
+    fn include_rank(&self) -> bool {
+        Python::attach(|py| {
+            self.evaluator
+                .bind(py)
+                .call_method0("include_rank")
+                .and_then(|v| v.extract())
+                .unwrap_or(false)
+        })
+    }
+}
+
+pub fn to_rust_partition_evaluator(evaluator: Py<PyAny>) -> PartitionEvaluatorFactory {
+    Arc::new(move || -> Result<Box<dyn PartitionEvaluator>> {
+        let evaluator = Python::attach(|py| {
+            evaluator
+                .call0(py)
+                .map_err(|e| DataFusionError::Execution(e.to_string()))
+        })?;
+        Ok(Box::new(RustPartitionEvaluator::new(evaluator)))
+    })
+}
+
+/// Represents an WindowUDF
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "WindowUDF",
+    module = "datafusion",
+    subclass
+)]
+#[derive(Debug, Clone)]
+pub struct PyWindowUDF {
+    pub(crate) function: WindowUDF,
+}
+
+#[pymethods]
+impl PyWindowUDF {
+    #[new]
+    #[pyo3(signature=(name, evaluator, input_types, return_type, volatility))]
+    fn new(
+        name: &str,
+        evaluator: Py<PyAny>,
+        input_types: Vec<PyArrowType<DataType>>,
+        return_type: PyArrowType<DataType>,
+        volatility: &str,
+    ) -> PyResult<Self> {
+        let return_type = return_type.0;
+        let input_types = input_types.into_iter().map(|t| t.0).collect();
+
+        let function = WindowUDF::from(MultiColumnWindowUDF::new(
+            name,
+            input_types,
+            return_type,
+            parse_volatility(volatility)?,
+            to_rust_partition_evaluator(evaluator),
+        ));
+        Ok(Self { function })
+    }
+
+    /// creates a new PyExpr with the call of the udf
+    #[pyo3(signature = (*args))]
+    fn __call__(&self, args: Vec<PyExpr>) -> PyResult<PyExpr> {
+        let args = args.iter().map(|e| e.expr.clone()).collect();
+        Ok(self.function.call(args).into())
+    }
+
+    #[staticmethod]
+    pub fn from_pycapsule(func: Bound<'_, PyAny>) -> PyDataFusionResult<Self> {
+        let capsule = if func.hasattr("__datafusion_window_udf__")? {
+            func.getattr("__datafusion_window_udf__")?.call0()?
+        } else {
+            func
+        };
+
+        let capsule = capsule.cast::<PyCapsule>().map_err(py_datafusion_err)?;
+        validate_pycapsule(capsule, "datafusion_window_udf")?;
+
+        let data: NonNull<FFI_WindowUDF> = capsule
+            .pointer_checked(Some(c_str!("datafusion_window_udf")))?
+            .cast();
+        let udwf = unsafe { data.as_ref() };
+        let udwf: Arc<dyn WindowUDFImpl> = udwf.into();
+
+        Ok(Self {
+            function: WindowUDF::new_from_shared_impl(udwf),
+        })
+    }
+
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("WindowUDF({})", self.function.name()))
+    }
+}
+
+#[derive(Hash, Eq, PartialEq)]
+pub struct MultiColumnWindowUDF {
+    name: String,
+    signature: Signature,
+    return_type: DataType,
+    partition_evaluator_factory: PtrEq<PartitionEvaluatorFactory>,
+}
+
+impl std::fmt::Debug for MultiColumnWindowUDF {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_struct("WindowUDF")
+            .field("name", &self.name)
+            .field("signature", &self.signature)
+            .field("return_type", &"<func>")
+            .field("partition_evaluator_factory", &"<FUNC>")
+            .finish()
+    }
+}
+
+impl MultiColumnWindowUDF {
+    pub fn new(
+        name: impl Into<String>,
+        input_types: Vec<DataType>,
+        return_type: DataType,
+        volatility: Volatility,
+        partition_evaluator_factory: PartitionEvaluatorFactory,
+    ) -> Self {
+        let name = name.into();
+        let signature = Signature::exact(input_types, volatility);
+        Self {
+            name,
+            signature,
+            return_type,
+            partition_evaluator_factory: partition_evaluator_factory.into(),
+        }
+    }
+}
+
+impl WindowUDFImpl for MultiColumnWindowUDF {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    fn signature(&self) -> &Signature {
+        &self.signature
+    }
+
+    fn field(&self, field_args: WindowUDFFieldArgs) -> Result<arrow::datatypes::FieldRef> {
+        // TODO: Should nullable always be `true`?
+        Ok(arrow::datatypes::Field::new(field_args.name(), self.return_type.clone(), true).into())
+    }
+
+    // TODO: Enable passing partition_evaluator_args to python?
+    fn partition_evaluator(
+        &self,
+        _partition_evaluator_args: PartitionEvaluatorArgs,
+    ) -> Result<Box<dyn PartitionEvaluator>> {
+        let _ = _partition_evaluator_args;
+        (self.partition_evaluator_factory)()
+    }
+}
diff --git a/src/unparser/dialect.rs b/src/unparser/dialect.rs
new file mode 100644
index 000000000..52a2da00b
--- /dev/null
+++ b/src/unparser/dialect.rs
@@ -0,0 +1,69 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::sync::Arc;
+
+use datafusion::sql::unparser::dialect::{
+    DefaultDialect, Dialect, DuckDBDialect, MySqlDialect, PostgreSqlDialect, SqliteDialect,
+};
+use pyo3::prelude::*;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Dialect",
+    module = "datafusion.unparser",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyDialect {
+    pub dialect: Arc<dyn Dialect>,
+}
+
+#[pymethods]
+impl PyDialect {
+    #[staticmethod]
+    pub fn default() -> Self {
+        Self {
+            dialect: Arc::new(DefaultDialect {}),
+        }
+    }
+    #[staticmethod]
+    pub fn postgres() -> Self {
+        Self {
+            dialect: Arc::new(PostgreSqlDialect {}),
+        }
+    }
+    #[staticmethod]
+    pub fn mysql() -> Self {
+        Self {
+            dialect: Arc::new(MySqlDialect {}),
+        }
+    }
+    #[staticmethod]
+    pub fn sqlite() -> Self {
+        Self {
+            dialect: Arc::new(SqliteDialect {}),
+        }
+    }
+    #[staticmethod]
+    pub fn duckdb() -> Self {
+        Self {
+            dialect: Arc::new(DuckDBDialect::new()),
+        }
+    }
+}
diff --git a/src/unparser/mod.rs b/src/unparser/mod.rs
new file mode 100644
index 000000000..5142b918e
--- /dev/null
+++ b/src/unparser/mod.rs
@@ -0,0 +1,74 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+mod dialect;
+
+use std::sync::Arc;
+
+use datafusion::sql::unparser::Unparser;
+use datafusion::sql::unparser::dialect::Dialect;
+use dialect::PyDialect;
+use pyo3::exceptions::PyValueError;
+use pyo3::prelude::*;
+
+use crate::sql::logical::PyLogicalPlan;
+
+#[pyclass(
+    from_py_object,
+    frozen,
+    name = "Unparser",
+    module = "datafusion.unparser",
+    subclass
+)]
+#[derive(Clone)]
+pub struct PyUnparser {
+    dialect: Arc<dyn Dialect>,
+    pretty: bool,
+}
+
+#[pymethods]
+impl PyUnparser {
+    #[new]
+    pub fn new(dialect: PyDialect) -> Self {
+        Self {
+            dialect: dialect.dialect.clone(),
+            pretty: false,
+        }
+    }
+
+    pub fn plan_to_sql(&self, plan: &PyLogicalPlan) -> PyResult<String> {
+        let mut unparser = Unparser::new(self.dialect.as_ref());
+        unparser = unparser.with_pretty(self.pretty);
+        let sql = unparser
+            .plan_to_sql(&plan.plan())
+            .map_err(|e| PyValueError::new_err(e.to_string()))?;
+        Ok(sql.to_string())
+    }
+
+    pub fn with_pretty(&self, pretty: bool) -> Self {
+        Self {
+            dialect: self.dialect.clone(),
+            pretty,
+        }
+    }
+}
+
+pub(crate) fn init_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_class::<PyUnparser>()?;
+    m.add_class::<PyDialect>()?;
+    Ok(())
+}
diff --git a/src/utils.rs b/src/utils.rs
index 4158b7485..5085018f7 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -15,32 +15,224 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::errors::DataFusionError;
-use datafusion_expr::Volatility;
-use pyo3::prelude::*;
 use std::future::Future;
+use std::ptr::NonNull;
+use std::sync::{Arc, OnceLock};
+use std::time::Duration;
+
+use datafusion::datasource::TableProvider;
+use datafusion::execution::context::SessionContext;
+use datafusion::logical_expr::Volatility;
+use datafusion_ffi::proto::logical_extension_codec::FFI_LogicalExtensionCodec;
+use datafusion_ffi::table_provider::FFI_TableProvider;
+use pyo3::IntoPyObjectExt;
+use pyo3::exceptions::{PyImportError, PyTypeError, PyValueError};
+use pyo3::ffi::c_str;
+use pyo3::prelude::*;
+use pyo3::types::{PyCapsule, PyType};
 use tokio::runtime::Runtime;
+use tokio::task::JoinHandle;
+use tokio::time::sleep;
+
+use crate::TokioRuntime;
+use crate::context::PySessionContext;
+use crate::errors::{PyDataFusionError, PyDataFusionResult, py_datafusion_err, to_datafusion_err};
+
+/// Utility to get the Tokio Runtime from Python
+#[inline]
+pub(crate) fn get_tokio_runtime() -> &'static TokioRuntime {
+    // NOTE: Other pyo3 python libraries have had issues with using tokio
+    // behind a forking app-server like `gunicorn`
+    // If we run into that problem, in the future we can look to `delta-rs`
+    // which adds a check in that disallows calls from a forked process
+    // https://github.com/delta-io/delta-rs/blob/87010461cfe01563d91a4b9cd6fa468e2ad5f283/python/src/utils.rs#L10-L31
+    static RUNTIME: OnceLock<TokioRuntime> = OnceLock::new();
+    RUNTIME.get_or_init(|| TokioRuntime(tokio::runtime::Runtime::new().unwrap()))
+}
+
+#[inline]
+pub(crate) fn is_ipython_env(py: Python) -> &'static bool {
+    static IS_IPYTHON_ENV: OnceLock<bool> = OnceLock::new();
+    IS_IPYTHON_ENV.get_or_init(|| {
+        py.import("IPython")
+            .and_then(|ipython| ipython.call_method0("get_ipython"))
+            .map(|ipython| !ipython.is_none())
+            .unwrap_or(false)
+    })
+}
 
-/// Utility to collect rust futures with GIL released
-pub fn wait_for_future<F: Future>(py: Python, f: F) -> F::Output
+/// Utility to get the Global Datafussion CTX
+#[inline]
+pub(crate) fn get_global_ctx() -> &'static Arc<SessionContext> {
+    static CTX: OnceLock<Arc<SessionContext>> = OnceLock::new();
+    CTX.get_or_init(|| Arc::new(SessionContext::new()))
+}
+
+/// Utility to collect rust futures with GIL released and respond to
+/// Python interrupts such as ``KeyboardInterrupt``. If a signal is
+/// received while the future is running, the future is aborted and the
+/// corresponding Python exception is raised.
+pub fn wait_for_future<F>(py: Python, fut: F) -> PyResult<F::Output>
 where
-    F: Send,
+    F: Future + Send,
     F::Output: Send,
 {
-    let rt = Runtime::new().unwrap();
-    py.allow_threads(|| rt.block_on(f))
+    let runtime: &Runtime = &get_tokio_runtime().0;
+    const INTERVAL_CHECK_SIGNALS: Duration = Duration::from_millis(1_000);
+
+    // Some fast running processes that generate many `wait_for_future` calls like
+    // PartitionedDataFrameStreamReader::next require checking for interrupts early
+    py.run(cr"pass", None, None)?;
+    py.check_signals()?;
+
+    py.detach(|| {
+        runtime.block_on(async {
+            tokio::pin!(fut);
+            loop {
+                tokio::select! {
+                    res = &mut fut => break Ok(res),
+                    _ = sleep(INTERVAL_CHECK_SIGNALS) => {
+                        Python::attach(|py| {
+                                // Execute a no-op Python statement to trigger signal processing.
+                                // This is necessary because py.check_signals() alone doesn't
+                                // actually check for signals - it only raises an exception if
+                                // a signal was already set during a previous Python API call.
+                                // Running even trivial Python code forces the interpreter to
+                                // process any pending signals (like KeyboardInterrupt).
+                                py.run(cr"pass", None, None)?;
+                                py.check_signals()
+                        })?;
+                    }
+                }
+            }
+        })
+    })
+}
+
+/// Spawn a [`Future`] on the Tokio runtime and wait for completion
+/// while respecting Python signal handling.
+pub(crate) fn spawn_future<F, T>(py: Python, fut: F) -> PyDataFusionResult<T>
+where
+    F: Future<Output = datafusion::common::Result<T>> + Send + 'static,
+    T: Send + 'static,
+{
+    let rt = &get_tokio_runtime().0;
+    let handle: JoinHandle<datafusion::common::Result<T>> = rt.spawn(fut);
+    // Wait for the join handle while respecting Python signal handling.
+    // We handle errors in two steps so `?` maps the error types correctly:
+    // 1) convert any Python-related error from `wait_for_future` into `PyDataFusionError`
+    // 2) convert any DataFusion error (inner result) into `PyDataFusionError`
+    let inner_result = wait_for_future(py, async {
+        // handle.await yields `Result<datafusion::common::Result<T>, JoinError>`
+        // map JoinError into a DataFusion error so the async block returns
+        // `datafusion::common::Result<T>` (i.e. Result<T, DataFusionError>)
+        match handle.await {
+            Ok(inner) => inner,
+            Err(join_err) => Err(to_datafusion_err(join_err)),
+        }
+    })?; // converts PyErr -> PyDataFusionError
+
+    // `inner_result` is `datafusion::common::Result<T>`; use `?` to convert
+    // the inner DataFusion error into `PyDataFusionError` via `From` and
+    // return the inner `T` on success.
+    Ok(inner_result?)
 }
 
-pub(crate) fn parse_volatility(value: &str) -> Result<Volatility, DataFusionError> {
+pub(crate) fn parse_volatility(value: &str) -> PyDataFusionResult<Volatility> {
     Ok(match value {
         "immutable" => Volatility::Immutable,
         "stable" => Volatility::Stable,
         "volatile" => Volatility::Volatile,
         value => {
-            return Err(DataFusionError::Common(format!(
-                "Unsupportad volatility type: `{value}`, supported \
+            return Err(PyDataFusionError::Common(format!(
+                "Unsupported volatility type: `{value}`, supported \
                  values are: immutable, stable and volatile."
-            )))
+            )));
         }
     })
 }
+
+pub(crate) fn validate_pycapsule(capsule: &Bound<PyCapsule>, name: &str) -> PyResult<()> {
+    let capsule_name = capsule.name()?;
+    if capsule_name.is_none() {
+        return Err(PyValueError::new_err(format!(
+            "Expected {name} PyCapsule to have name set."
+        )));
+    }
+
+    let capsule_name = unsafe { capsule_name.unwrap().as_cstr().to_str()? };
+    if capsule_name != name {
+        return Err(PyValueError::new_err(format!(
+            "Expected name '{name}' in PyCapsule, instead got '{capsule_name}'"
+        )));
+    }
+
+    Ok(())
+}
+
+pub(crate) fn table_provider_from_pycapsule<'py>(
+    mut obj: Bound<'py, PyAny>,
+    session: Bound<'py, PyAny>,
+) -> PyResult<Option<Arc<dyn TableProvider>>> {
+    if obj.hasattr("__datafusion_table_provider__")? {
+        obj = obj
+            .getattr("__datafusion_table_provider__")?
+            .call1((session,)).map_err(|err| {
+            let py = obj.py();
+            if err.get_type(py).is(PyType::new::<PyTypeError>(py)) {
+                PyImportError::new_err("Incompatible libraries. DataFusion 52.0.0 introduced an incompatible signature change for table providers. Either downgrade DataFusion or upgrade your function library.")
+            } else {
+                err
+            }
+        })?;
+    }
+
+    if let Ok(capsule) = obj.cast::<PyCapsule>().map_err(py_datafusion_err) {
+        validate_pycapsule(capsule, "datafusion_table_provider")?;
+
+        let data: NonNull<FFI_TableProvider> = capsule
+            .pointer_checked(Some(c_str!("datafusion_table_provider")))?
+            .cast();
+        let provider = unsafe { data.as_ref() };
+        let provider: Arc<dyn TableProvider> = provider.into();
+
+        Ok(Some(provider))
+    } else {
+        Ok(None)
+    }
+}
+
+pub(crate) fn extract_logical_extension_codec(
+    py: Python,
+    obj: Option<Bound<PyAny>>,
+) -> PyResult<Arc<FFI_LogicalExtensionCodec>> {
+    let obj = match obj {
+        Some(obj) => obj,
+        None => PySessionContext::global_ctx()?.into_bound_py_any(py)?,
+    };
+    let capsule = if obj.hasattr("__datafusion_logical_extension_codec__")? {
+        obj.getattr("__datafusion_logical_extension_codec__")?
+            .call0()?
+    } else {
+        obj
+    };
+    let capsule = capsule.cast::<PyCapsule>().map_err(py_datafusion_err)?;
+
+    validate_pycapsule(capsule, "datafusion_logical_extension_codec")?;
+
+    let data: NonNull<FFI_LogicalExtensionCodec> = capsule
+        .pointer_checked(Some(c_str!("datafusion_logical_extension_codec")))?
+        .cast();
+    let codec = unsafe { data.as_ref() };
+    Ok(Arc::new(codec.clone()))
+}
+
+pub(crate) fn create_logical_extension_capsule<'py>(
+    py: Python<'py>,
+    codec: &FFI_LogicalExtensionCodec,
+) -> PyResult<Bound<'py, PyCapsule>> {
+    let name = cr"datafusion_logical_extension_codec".into();
+    let codec = codec.clone();
+
+    PyCapsule::new(py, codec, Some(name))
+}
diff --git a/uv.lock b/uv.lock
new file mode 100644
index 000000000..f4926521b
--- /dev/null
+++ b/uv.lock
@@ -0,0 +1,1671 @@
+version = 1
+revision = 3
+requires-python = ">=3.10"
+resolution-markers = [
+    "python_full_version >= '3.14'",
+    "python_full_version >= '3.12' and python_full_version < '3.14'",
+    "python_full_version == '3.11.*'",
+    "python_full_version < '3.11'",
+]
+
+[[package]]
+name = "alabaster"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/f8/d9c74d0daf3f742840fd818d69cfae176fa332022fd44e3469487d5a9420/alabaster-1.0.0.tar.gz", hash = "sha256:c00dca57bca26fa62a6d7d0a9fcce65f3e026e9bfe33e9c538fd3fbb2144fd9e", size = 24210, upload-time = "2024-07-26T18:15:03.762Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", size = 13929, upload-time = "2024-07-26T18:15:02.05Z" },
+]
+
+[[package]]
+name = "arro3-core"
+version = "0.6.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", marker = "python_full_version < '3.12'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2a/01/f06342d2eb822153f63d188153e41fbeabb29b48247f7a11ce76c538f7d1/arro3_core-0.6.5.tar.gz", hash = "sha256:768078887cd7ac82de4736f94bbd91f6d660f10779848bd5b019f511badd9d75", size = 107522, upload-time = "2025-10-13T23:12:38.872Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7a/8a/24b35cf01a68621f5f07e3191ca96f70a145022ca367347266901eb504a7/arro3_core-0.6.5-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:da193dc2fb8c2005d0b3887b09d1a90d42cec1f59f17a8a1a5791f0de90946ae", size = 2678116, upload-time = "2025-10-13T23:09:04.198Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/7a/4398bb0582fb22d575f256f2b9ac7be735c765222cc61fb214d606bdb77c/arro3_core-0.6.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ed1a760ec39fe19c65e98f45515582408002d0212df5db227a5959ffeb07ad4a", size = 2383214, upload-time = "2025-10-13T23:09:06.841Z" },
+    { url = "https://files.pythonhosted.org/packages/82/3f/a321501c5da4bf3ff7438c3e5eb6e63bcecb5630c0f4a89a017cbfa8e4a0/arro3_core-0.6.5-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6584a3d28007740afcef1e301332876e2b785bd8edd59a458a6bc9b051bce052", size = 2883536, upload-time = "2025-10-13T23:09:08.877Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/50/1d1e55b9a8c4cf2fdeb954947aa135010554a3333b709e8cad3d5d084be2/arro3_core-0.6.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8e0af4789618f02bead4a0cd4d0a54abd9c8aa4fcedf9872b4891d2e3e984161", size = 2908828, upload-time = "2025-10-13T23:09:10.958Z" },
+    { url = "https://files.pythonhosted.org/packages/12/75/b4b1de1ccb17890bada9a3f4131cf3137f145d5d10490db51de6b8799926/arro3_core-0.6.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c73f212e549e9b6d11cfe3f14bbf3fba9d0891426afb5916688d16d0df724085", size = 3145458, upload-time = "2025-10-13T23:09:13.275Z" },
+    { url = "https://files.pythonhosted.org/packages/08/4f/f42ce1840490fd0863bfbc56f28eaaec3bcb4eb322079af9c070111657e5/arro3_core-0.6.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:89f88f62e4e276a9e84f250722d2e5ffc078af9a3f67ac691f572a0e05dd6095", size = 2775793, upload-time = "2025-10-13T23:09:15.342Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/aa/9637efc8d8733c34bedef44e5b2c170dea14d15ab56b3566d8d7963c2616/arro3_core-0.6.5-cp310-cp310-manylinux_2_24_aarch64.whl", hash = "sha256:b2635e4c227f25ff8784dc8efb38cb7c1674646cfdc68ded53f2426289885f0e", size = 2516697, upload-time = "2025-10-13T23:09:17.584Z" },
+    { url = "https://files.pythonhosted.org/packages/60/84/1fcfadf956bc25eb5251b1ea7a7099f05198a55764635d2fc9ceafdbdbd1/arro3_core-0.6.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a5f3e936686bcd8542fafc94c68fdb23ec42d1d51a4777967ae815c90aff7296", size = 3023625, upload-time = "2025-10-13T23:09:21.556Z" },
+    { url = "https://files.pythonhosted.org/packages/58/d0/52d0cb3c0dfa8e94ba2118b7e91a70da76d6ede9de4e70374f831f38cfdf/arro3_core-0.6.5-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:705c32fec03dadc08f807d69ce557882005d43eb20ec62699f7036340f0d580f", size = 2701346, upload-time = "2025-10-13T23:09:25.031Z" },
+    { url = "https://files.pythonhosted.org/packages/69/bf/42a6f6501805c31cb65d8a6e3379eeec4fa6c26dc07c9ce894f363ccad1c/arro3_core-0.6.5-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:56d8166235a4c54e4f7ba082ec76890c820fa8c1b6c995ec59cead62a9698e59", size = 3153207, upload-time = "2025-10-13T23:09:28.254Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/e5/41fdee468b33759b42958347c2d70b0461bf8f70ba1762a94cdf2e9b0142/arro3_core-0.6.5-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:1ba43ba9081c00767083195222b6be74913de668296f55599658c4b0bb7cd327", size = 3105033, upload-time = "2025-10-13T23:09:31.545Z" },
+    { url = "https://files.pythonhosted.org/packages/03/e0/b6d733b4540c05bac546162e045b547031f4d88c67b7c864929d9bce29ad/arro3_core-0.6.5-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:4f5df13c6742e3f0b494cfe9025dccdc8426a74cc9e3e5a1239311e07a4b24e0", size = 2954793, upload-time = "2025-10-13T23:09:34.988Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/34/8353ba79c8d0498eaacc077d58b384ef785e0b69c9cbff7c2580136b8fe3/arro3_core-0.6.5-cp310-cp310-win_amd64.whl", hash = "sha256:34676b728178236df63c9ea10b21432392d4b5bb51e2030e77c68eed4dede2ad", size = 2837495, upload-time = "2025-10-13T23:09:38.539Z" },
+    { url = "https://files.pythonhosted.org/packages/78/85/20e46d3ed59d2f93be4a4d1abea4f6bef3e96acd59bf5a50726f84303c51/arro3_core-0.6.5-cp311-abi3-macosx_10_12_x86_64.whl", hash = "sha256:9d5999506daec1ab31096b3deb1e3573041d6ecadb4ca99c96f7ab26720c592c", size = 2685615, upload-time = "2025-10-13T23:09:41.793Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/9c/427d578f7d2bf3149515a8b75217e7189e7b1d74e5c5609e1a7e7f0f8d3c/arro3_core-0.6.5-cp311-abi3-macosx_11_0_arm64.whl", hash = "sha256:bd3e251184c2dd6ade81c5613256b6d85ab3ddbd5af838b1de657e0ddec017f8", size = 2391944, upload-time = "2025-10-13T23:09:45.266Z" },
+    { url = "https://files.pythonhosted.org/packages/90/24/7e4af478eb889bfa401e1c1b8868048ca692e6205affbf81cf3666347852/arro3_core-0.6.5-cp311-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7cadb29349960d3821b0515d9df80f2725cea155ad966c699f6084de32e313cb", size = 2888376, upload-time = "2025-10-13T23:09:48.737Z" },
+    { url = "https://files.pythonhosted.org/packages/70/3b/01006a96bc980275aa4d2eb759c5f10afb7c85fcdce3c36ddb18635ad23b/arro3_core-0.6.5-cp311-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a922e560ed2ccee3293d51b39e013b51cc233895d25ddafcacfb83c540a19e6f", size = 2916568, upload-time = "2025-10-13T23:09:51.95Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/2f/4e04c7f5687de6fb6f88aa7590b16bcf507ba17ddbd268525f27b70b7a68/arro3_core-0.6.5-cp311-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:68fe6672bf51f039b12046a209cba0a9405e10ae44e5a0d557f091b356a62051", size = 3144223, upload-time = "2025-10-13T23:09:55.387Z" },
+    { url = "https://files.pythonhosted.org/packages/31/4a/72dc383d1a0d14f1d453e334e3461e229762edb1bf3f75b3ab977e9386ed/arro3_core-0.6.5-cp311-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c3ee95603e375401a58ff763ce2c8aa858e0c4f757c1fb719f48fb070f540b2", size = 2781862, upload-time = "2025-10-13T23:09:59.035Z" },
+    { url = "https://files.pythonhosted.org/packages/14/dc/0df7684b683114eaf8e57989b4230edb359cbfb6e98b8770d69128b27572/arro3_core-0.6.5-cp311-abi3-manylinux_2_24_aarch64.whl", hash = "sha256:fbaf6b65213630007b798b565e0701c2092a330deeba16bd3d896d401f7e9f28", size = 2522442, upload-time = "2025-10-13T23:10:02.134Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/04/75f8627cd7fe4d103eca51760d50269cfbc0bf6beaf83a3cdefb4ebd37c7/arro3_core-0.6.5-cp311-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:20679f874558bb2113e96325522625ec64a72687000b7a9578031a4d082c6ef5", size = 3033454, upload-time = "2025-10-13T23:10:05.192Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/19/f2d54985da65bf6d3da76218bee56383285035541c8d0cadb53095845b3e/arro3_core-0.6.5-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:d82d6ec32d5c7c73057fb9c528390289fd5bc94b8d8f28fca9c56fc8e41c412c", size = 2705984, upload-time = "2025-10-13T23:10:08.518Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/53/b1d7742d6db7b4aa44d3785956955d651b3ac36db321625fd15466be1aca/arro3_core-0.6.5-cp311-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:4cba4db0a4203a3ccf131c3fb7804d77f0740d6165ec9efa3aa3acbca87c43a3", size = 3157472, upload-time = "2025-10-13T23:10:11.976Z" },
+    { url = "https://files.pythonhosted.org/packages/05/31/68711327dbdd480aed54158fc1c46ab245e860ab0286e0916ce788f9889e/arro3_core-0.6.5-cp311-abi3-musllinux_1_2_i686.whl", hash = "sha256:e358affc4a0fe5c1b5dccf4f92c43a836aaa4c4eab0906c83b00b60275de3b6d", size = 3117099, upload-time = "2025-10-13T23:10:15.374Z" },
+    { url = "https://files.pythonhosted.org/packages/31/e3/15ffca0797d9500b23759ae4477cf052fde8dd47a3890f4e4e1d04639016/arro3_core-0.6.5-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:324e43f07b7681846d00a8995b78bdc4b4a719047aa0d34426b462b8f208ee98", size = 2963677, upload-time = "2025-10-13T23:10:18.828Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/02/69e60dbe3bbe2bfc8b6dfa4f4bfcb8d1dd240a137bf2a5f7bcc84703f05c/arro3_core-0.6.5-cp311-abi3-win_amd64.whl", hash = "sha256:285f802c8a42fe29ecb84584d1700bc4c4f974552b75f805e1f4362d28b97080", size = 2850445, upload-time = "2025-10-13T23:10:22.345Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/29/2e5b091f6b5cffb6489dbe7ed353841568dde8ac4d1232c77321da1d0925/arro3_core-0.6.5-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:8c20e69c3b3411fd6ed56091f388e699072651e880e682be5bd14f3a392ed3e8", size = 2671985, upload-time = "2025-10-13T23:10:25.515Z" },
+    { url = "https://files.pythonhosted.org/packages/30/74/764ac4b58fef3fdfc655416c42349206156db5c687fa24a0674acaeaadbb/arro3_core-0.6.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:92211f1d03221ff74d0b535a576b39601083d8e98e9d47228314573f9d4f9ae2", size = 2382931, upload-time = "2025-10-13T23:10:29.893Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/07/bd8c92e218240ae8a30150a5d7a2dab359b452ab54a8bb7b90effe806e3d/arro3_core-0.6.5-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:280d933b75f2649779d76e32a07f91d2352a952f2c97ddf7b320e267f440cd42", size = 2879900, upload-time = "2025-10-13T23:10:33.238Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/d4/253725019fe2ae5f5fde87928118ffa568cc59f07b2d6a0e90620938c537/arro3_core-0.6.5-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bfc3f6b93b924f43fb7985b06202343c30b43da6bd5055ba8b84eda431e494d4", size = 2904149, upload-time = "2025-10-13T23:10:36.547Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/b0/7a3dea641ac8de041c1a34859a2f2a82d3cdf3c3360872101c1d198a1e24/arro3_core-0.6.5-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a5963635eb698ebc7da689e641f68b3998864bab894cf0ca84bd058b8c60d97f", size = 3143477, upload-time = "2025-10-13T23:10:40.232Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/05/1a50575be33fe9240898a1b5a8574658a905b5675865285585e070dcf7e2/arro3_core-0.6.5-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac291b3e74b57e56e03373d57530540cbbbfd92e4219fe2778ea531006673fe9", size = 2776522, upload-time = "2025-10-13T23:10:43.413Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/bd/e7b03207e7906e94e327cd4190fdb2d26ae52bc4ee1edeb057fed760796b/arro3_core-0.6.5-cp313-cp313t-manylinux_2_24_aarch64.whl", hash = "sha256:5d3f4cc58a654037d61f61ba230419da2c8f88a0ac82b9d41fe307f7cf9fda97", size = 2515426, upload-time = "2025-10-13T23:10:46.926Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/ed/82d1febd5c104eccdfb82434e3619125c328c36da143e19dfa3c86de4a81/arro3_core-0.6.5-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:93cddac90238d64451f5e66c630ded89d0b5fd6d2c099bf3a5151dde2c1ddf1d", size = 3024759, upload-time = "2025-10-13T23:10:50.281Z" },
+    { url = "https://files.pythonhosted.org/packages/da/cd/00e06907e42e404c21eb08282dee94ac7a1961facfa9a96d116829031721/arro3_core-0.6.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:1fa7ac10db5846c33f4e8b66a6eaa705d84998e38575a835acac9a6a6649933d", size = 2700191, upload-time = "2025-10-13T23:10:53.776Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/11/a4bb9a900f456a6905d481bd2289f7a2371dcde024de56779621fd6a92c3/arro3_core-0.6.5-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:ca69f698a065cdbf845d59d412bc204e8f8af12f93737d82e6a18f3cff812349", size = 3149963, upload-time = "2025-10-13T23:10:57.163Z" },
+    { url = "https://files.pythonhosted.org/packages/28/8a/79c76ad88b16f2fac25684f7313593738f353355eb1af2307e43efd7b1ca/arro3_core-0.6.5-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:de74a2512e2e2366d4b064c498c38672bf6ddea38acec8b1999b4e66182dd001", size = 3104663, upload-time = "2025-10-13T23:11:00.582Z" },
+    { url = "https://files.pythonhosted.org/packages/20/66/9152feaa87f851a37c1a2bd74fb89d7e82e4c76447ee590bf8e6fff5e9d8/arro3_core-0.6.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:806ca8e20507675b2de68b3d009f76e898cc3c3e441c834ea5220866f68aac50", size = 2956440, upload-time = "2025-10-13T23:11:03.769Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/66/f4179ef64d5c18fe76ec93cfbff42c0f401438ef771c6766b880044d7e13/arro3_core-0.6.5-cp313-cp313t-win_amd64.whl", hash = "sha256:8f6f0cc78877ade7ad6e678a4671b191406547e7b407bc9637436869c017ed47", size = 2845345, upload-time = "2025-10-13T23:11:07.447Z" },
+    { url = "https://files.pythonhosted.org/packages/10/ca/b2139dbb25f9fefb9b1cdce8a73785615de6763af6a16bf6ff96a3b630f2/arro3_core-0.6.5-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:26d5b50139f1a96727fa1760b4d70393acf5ee0fba45346ad2d4f69824d3bdc2", size = 2676788, upload-time = "2025-10-13T23:11:56.965Z" },
+    { url = "https://files.pythonhosted.org/packages/34/a1/c68dde2944f493c8ccfcb91bf6da6d27a27c3674316dd09c9560f9e6ab1a/arro3_core-0.6.5-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:b65b3d8d7f65f2f3c36002dc467380d7a31ea771132986dddc6341c5a9dc726f", size = 2382809, upload-time = "2025-10-13T23:12:00.175Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/fc/2fb81d42a3cecd632deace97dc23ac74083d60d158106440c783bae4ff01/arro3_core-0.6.5-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6c3442a79a757ed3fbd7793de180019ae3201f04237537c2e2e3f1e3dd99b31c", size = 2882818, upload-time = "2025-10-13T23:12:03.721Z" },
+    { url = "https://files.pythonhosted.org/packages/58/7f/16f741e1d49ba5c5a893ce6f8eb0283d64bc68d6cc9e07ac62f96eaadfae/arro3_core-0.6.5-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:def7b0065a684d6f903a658d2567da47e2fcecde716e0b34eff4d899c6468c8d", size = 2907503, upload-time = "2025-10-13T23:12:07.066Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/45/2eb7972e0bbec0ee0ab22b0f166ec1ea74b53bd76c93a18ced434713e495/arro3_core-0.6.5-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cbfe2f2d4d0d393833cd6a4bd9c15266a02307a3028f159155a1c536469c3ae7", size = 3143706, upload-time = "2025-10-13T23:12:10.492Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/af/b78e28842faa675e4e6c4d82e861accf21ac08bbab80a65fa80c578f80a1/arro3_core-0.6.5-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a191a3e4f72c34f7ace7724a94f2d90b06c804a6cbece4ae0f18d36325479cf3", size = 2775462, upload-time = "2025-10-13T23:12:14.026Z" },
+    { url = "https://files.pythonhosted.org/packages/45/df/950e57e4915e0457acadaaca13c4423d5e2652e403135eb7606d5e6e5443/arro3_core-0.6.5-pp310-pypy310_pp73-manylinux_2_24_aarch64.whl", hash = "sha256:e3f6ab4c6ea96c451eff72aa6c5b9835a0ea8a9847cfe3995c88cce0c7701fb5", size = 2516212, upload-time = "2025-10-13T23:12:17.548Z" },
+    { url = "https://files.pythonhosted.org/packages/07/73/821640d0827a829ed2565c2d4812080ab7fb86f0d271b462f9b37e6d946e/arro3_core-0.6.5-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:27df5239835330299636a02977f2cb34d5c460cc03b2ae1d6ab6a03d28051b08", size = 3023342, upload-time = "2025-10-13T23:12:21.308Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/30/51302d2f4d1b627dd11e2be979f2c48550b782d8d58d0378316342e284a8/arro3_core-0.6.5-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:71dce89c0e91be4cfb42591f03809235bbc374c396e08acdf93c4d85b09e40f5", size = 2700740, upload-time = "2025-10-13T23:12:24.968Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/e8/0c8a345a013bb64abea60b4864bacc01e43b8699b8874794baec9c8a7e76/arro3_core-0.6.5-pp310-pypy310_pp73-musllinux_1_2_armv7l.whl", hash = "sha256:d380c28f85568ed99c1686fb9d64b5a811d76d569f367cbec8ef7e58f6e2fdf9", size = 3152749, upload-time = "2025-10-13T23:12:28.393Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/42/003b30c4da394366d5967a5b993f7471a74182c983d8f757891b3dd5d594/arro3_core-0.6.5-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:8e359c0c4fe9992f5a863a4a31502ea58eb2f92988fc2e501850540b3eff0328", size = 3104676, upload-time = "2025-10-13T23:12:31.711Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/fd/4f8dac58ea17e05978bf35cb9a3e485b1ff3cdd6e2cc29deb08f54080de4/arro3_core-0.6.5-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:9a58acbc61480b533aa84d735db04b1e68fc7f6807ab694d606c03b5e694d83d", size = 2954405, upload-time = "2025-10-13T23:12:35.328Z" },
+]
+
+[[package]]
+name = "astroid"
+version = "3.3.8"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/80/c5/5c83c48bbf547f3dd8b587529db7cf5a265a3368b33e85e76af8ff6061d3/astroid-3.3.8.tar.gz", hash = "sha256:a88c7994f914a4ea8572fac479459f4955eeccc877be3f2d959a33273b0cf40b", size = 398196, upload-time = "2024-12-24T01:13:05.59Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/07/28/0bc8a17d6cd4cc3c79ae41b7105a2b9a327c110e5ddd37a8a27b29a5c8a2/astroid-3.3.8-py3-none-any.whl", hash = "sha256:187ccc0c248bfbba564826c26f070494f7bc964fd286b6d9fff4420e55de828c", size = 275153, upload-time = "2024-12-24T01:13:02.726Z" },
+]
+
+[[package]]
+name = "asttokens"
+version = "3.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4a/e7/82da0a03e7ba5141f05cce0d302e6eed121ae055e0456ca228bf693984bc/asttokens-3.0.0.tar.gz", hash = "sha256:0dcd8baa8d62b0c1d118b399b2ddba3c4aff271d0d7a9e0d4c1681c79035bbc7", size = 61978, upload-time = "2024-11-30T04:30:14.439Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/25/8a/c46dcc25341b5bce5472c718902eb3d38600a903b14fa6aeecef3f21a46f/asttokens-3.0.0-py3-none-any.whl", hash = "sha256:e3078351a059199dd5138cb1c706e6430c05eff2ff136af5eb4790f9d28932e2", size = 26918, upload-time = "2024-11-30T04:30:10.946Z" },
+]
+
+[[package]]
+name = "babel"
+version = "2.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2a/74/f1bc80f23eeba13393b7222b11d95ca3af2c1e28edca18af487137eefed9/babel-2.16.0.tar.gz", hash = "sha256:d1f3554ca26605fe173f3de0c65f750f5a42f924499bf134de6423582298e316", size = 9348104, upload-time = "2024-08-08T14:25:45.459Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ed/20/bc79bc575ba2e2a7f70e8a1155618bb1301eaa5132a8271373a6903f73f8/babel-2.16.0-py3-none-any.whl", hash = "sha256:368b5b98b37c06b7daf6696391c3240c938b37767d4584413e8438c5c435fa8b", size = 9587599, upload-time = "2024-08-08T14:25:42.686Z" },
+]
+
+[[package]]
+name = "beautifulsoup4"
+version = "4.12.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "soupsieve" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b3/ca/824b1195773ce6166d388573fc106ce56d4a805bd7427b624e063596ec58/beautifulsoup4-4.12.3.tar.gz", hash = "sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051", size = 581181, upload-time = "2024-01-17T16:53:17.902Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b1/fe/e8c672695b37eecc5cbf43e1d0638d88d66ba3a44c4d321c796f4e59167f/beautifulsoup4-4.12.3-py3-none-any.whl", hash = "sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed", size = 147925, upload-time = "2024-01-17T16:53:12.779Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2024.12.14"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0f/bd/1d41ee578ce09523c81a15426705dd20969f5abf006d1afe8aeff0dd776a/certifi-2024.12.14.tar.gz", hash = "sha256:b650d30f370c2b724812bee08008be0c4163b163ddaec3f2546c1caf65f191db", size = 166010, upload-time = "2024-12-14T13:52:38.02Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a5/32/8f6669fc4798494966bf446c8c4a162e0b5d893dff088afddf76414f70e1/certifi-2024.12.14-py3-none-any.whl", hash = "sha256:1275f7a45be9464efc1173084eaa30f866fe2e47d389406136d332ed4967ec56", size = 164927, upload-time = "2024-12-14T13:52:36.114Z" },
+]
+
+[[package]]
+name = "cffi"
+version = "1.17.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pycparser" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621, upload-time = "2024-09-04T20:45:21.852Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/90/07/f44ca684db4e4f08a3fdc6eeb9a0d15dc6883efc7b8c90357fdbf74e186c/cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14", size = 182191, upload-time = "2024-09-04T20:43:30.027Z" },
+    { url = "https://files.pythonhosted.org/packages/08/fd/cc2fedbd887223f9f5d170c96e57cbf655df9831a6546c1727ae13fa977a/cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67", size = 178592, upload-time = "2024-09-04T20:43:32.108Z" },
+    { url = "https://files.pythonhosted.org/packages/de/cc/4635c320081c78d6ffc2cab0a76025b691a91204f4aa317d568ff9280a2d/cffi-1.17.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382", size = 426024, upload-time = "2024-09-04T20:43:34.186Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/7b/3b2b250f3aab91abe5f8a51ada1b717935fdaec53f790ad4100fe2ec64d1/cffi-1.17.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702", size = 448188, upload-time = "2024-09-04T20:43:36.286Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/48/1b9283ebbf0ec065148d8de05d647a986c5f22586b18120020452fff8f5d/cffi-1.17.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3", size = 455571, upload-time = "2024-09-04T20:43:38.586Z" },
+    { url = "https://files.pythonhosted.org/packages/40/87/3b8452525437b40f39ca7ff70276679772ee7e8b394934ff60e63b7b090c/cffi-1.17.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6", size = 436687, upload-time = "2024-09-04T20:43:40.084Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/fb/4da72871d177d63649ac449aec2e8a29efe0274035880c7af59101ca2232/cffi-1.17.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17", size = 446211, upload-time = "2024-09-04T20:43:41.526Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/a0/62f00bcb411332106c02b663b26f3545a9ef136f80d5df746c05878f8c4b/cffi-1.17.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8", size = 461325, upload-time = "2024-09-04T20:43:43.117Z" },
+    { url = "https://files.pythonhosted.org/packages/36/83/76127035ed2e7e27b0787604d99da630ac3123bfb02d8e80c633f218a11d/cffi-1.17.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e", size = 438784, upload-time = "2024-09-04T20:43:45.256Z" },
+    { url = "https://files.pythonhosted.org/packages/21/81/a6cd025db2f08ac88b901b745c163d884641909641f9b826e8cb87645942/cffi-1.17.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be", size = 461564, upload-time = "2024-09-04T20:43:46.779Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/fe/4d41c2f200c4a457933dbd98d3cf4e911870877bd94d9656cc0fcb390681/cffi-1.17.1-cp310-cp310-win32.whl", hash = "sha256:c9c3d058ebabb74db66e431095118094d06abf53284d9c81f27300d0e0d8bc7c", size = 171804, upload-time = "2024-09-04T20:43:48.186Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/b6/0b0f5ab93b0df4acc49cae758c81fe4e5ef26c3ae2e10cc69249dfd8b3ab/cffi-1.17.1-cp310-cp310-win_amd64.whl", hash = "sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15", size = 181299, upload-time = "2024-09-04T20:43:49.812Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/f4/927e3a8899e52a27fa57a48607ff7dc91a9ebe97399b357b85a0c7892e00/cffi-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401", size = 182264, upload-time = "2024-09-04T20:43:51.124Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/f5/6c3a8efe5f503175aaddcbea6ad0d2c96dad6f5abb205750d1b3df44ef29/cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf", size = 178651, upload-time = "2024-09-04T20:43:52.872Z" },
+    { url = "https://files.pythonhosted.org/packages/94/dd/a3f0118e688d1b1a57553da23b16bdade96d2f9bcda4d32e7d2838047ff7/cffi-1.17.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4", size = 445259, upload-time = "2024-09-04T20:43:56.123Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/ea/70ce63780f096e16ce8588efe039d3c4f91deb1dc01e9c73a287939c79a6/cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41", size = 469200, upload-time = "2024-09-04T20:43:57.891Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/a0/a4fa9f4f781bda074c3ddd57a572b060fa0df7655d2a4247bbe277200146/cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1", size = 477235, upload-time = "2024-09-04T20:44:00.18Z" },
+    { url = "https://files.pythonhosted.org/packages/62/12/ce8710b5b8affbcdd5c6e367217c242524ad17a02fe5beec3ee339f69f85/cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6", size = 459721, upload-time = "2024-09-04T20:44:01.585Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/6b/d45873c5e0242196f042d555526f92aa9e0c32355a1be1ff8c27f077fd37/cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d", size = 467242, upload-time = "2024-09-04T20:44:03.467Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/52/d9a0e523a572fbccf2955f5abe883cfa8bcc570d7faeee06336fbd50c9fc/cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6", size = 477999, upload-time = "2024-09-04T20:44:05.023Z" },
+    { url = "https://files.pythonhosted.org/packages/44/74/f2a2460684a1a2d00ca799ad880d54652841a780c4c97b87754f660c7603/cffi-1.17.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f", size = 454242, upload-time = "2024-09-04T20:44:06.444Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/4a/34599cac7dfcd888ff54e801afe06a19c17787dfd94495ab0c8d35fe99fb/cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b", size = 478604, upload-time = "2024-09-04T20:44:08.206Z" },
+    { url = "https://files.pythonhosted.org/packages/34/33/e1b8a1ba29025adbdcda5fb3a36f94c03d771c1b7b12f726ff7fef2ebe36/cffi-1.17.1-cp311-cp311-win32.whl", hash = "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655", size = 171727, upload-time = "2024-09-04T20:44:09.481Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/97/50228be003bb2802627d28ec0627837ac0bf35c90cf769812056f235b2d1/cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0", size = 181400, upload-time = "2024-09-04T20:44:10.873Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/84/e94227139ee5fb4d600a7a4927f322e1d4aea6fdc50bd3fca8493caba23f/cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4", size = 183178, upload-time = "2024-09-04T20:44:12.232Z" },
+    { url = "https://files.pythonhosted.org/packages/da/ee/fb72c2b48656111c4ef27f0f91da355e130a923473bf5ee75c5643d00cca/cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c", size = 178840, upload-time = "2024-09-04T20:44:13.739Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/b6/db007700f67d151abadf508cbfd6a1884f57eab90b1bb985c4c8c02b0f28/cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36", size = 454803, upload-time = "2024-09-04T20:44:15.231Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/df/f8d151540d8c200eb1c6fba8cd0dfd40904f1b0682ea705c36e6c2e97ab3/cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5", size = 478850, upload-time = "2024-09-04T20:44:17.188Z" },
+    { url = "https://files.pythonhosted.org/packages/28/c0/b31116332a547fd2677ae5b78a2ef662dfc8023d67f41b2a83f7c2aa78b1/cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff", size = 485729, upload-time = "2024-09-04T20:44:18.688Z" },
+    { url = "https://files.pythonhosted.org/packages/91/2b/9a1ddfa5c7f13cab007a2c9cc295b70fbbda7cb10a286aa6810338e60ea1/cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99", size = 471256, upload-time = "2024-09-04T20:44:20.248Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/d5/da47df7004cb17e4955df6a43d14b3b4ae77737dff8bf7f8f333196717bf/cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93", size = 479424, upload-time = "2024-09-04T20:44:21.673Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/ac/2a28bcf513e93a219c8a4e8e125534f4f6db03e3179ba1c45e949b76212c/cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3", size = 484568, upload-time = "2024-09-04T20:44:23.245Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/38/ca8a4f639065f14ae0f1d9751e70447a261f1a30fa7547a828ae08142465/cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8", size = 488736, upload-time = "2024-09-04T20:44:24.757Z" },
+    { url = "https://files.pythonhosted.org/packages/86/c5/28b2d6f799ec0bdecf44dced2ec5ed43e0eb63097b0f58c293583b406582/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65", size = 172448, upload-time = "2024-09-04T20:44:26.208Z" },
+    { url = "https://files.pythonhosted.org/packages/50/b9/db34c4755a7bd1cb2d1603ac3863f22bcecbd1ba29e5ee841a4bc510b294/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903", size = 181976, upload-time = "2024-09-04T20:44:27.578Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/f8/dd6c246b148639254dad4d6803eb6a54e8c85c6e11ec9df2cffa87571dbe/cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e", size = 182989, upload-time = "2024-09-04T20:44:28.956Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/f1/672d303ddf17c24fc83afd712316fda78dc6fce1cd53011b839483e1ecc8/cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2", size = 178802, upload-time = "2024-09-04T20:44:30.289Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/2d/eab2e858a91fdff70533cab61dcff4a1f55ec60425832ddfdc9cd36bc8af/cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3", size = 454792, upload-time = "2024-09-04T20:44:32.01Z" },
+    { url = "https://files.pythonhosted.org/packages/75/b2/fbaec7c4455c604e29388d55599b99ebcc250a60050610fadde58932b7ee/cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683", size = 478893, upload-time = "2024-09-04T20:44:33.606Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/b7/6e4a2162178bf1935c336d4da8a9352cccab4d3a5d7914065490f08c0690/cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5", size = 485810, upload-time = "2024-09-04T20:44:35.191Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/8a/1d0e4a9c26e54746dc08c2c6c037889124d4f59dffd853a659fa545f1b40/cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4", size = 471200, upload-time = "2024-09-04T20:44:36.743Z" },
+    { url = "https://files.pythonhosted.org/packages/26/9f/1aab65a6c0db35f43c4d1b4f580e8df53914310afc10ae0397d29d697af4/cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd", size = 479447, upload-time = "2024-09-04T20:44:38.492Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/e4/fb8b3dd8dc0e98edf1135ff067ae070bb32ef9d509d6cb0f538cd6f7483f/cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed", size = 484358, upload-time = "2024-09-04T20:44:40.046Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/47/d7145bf2dc04684935d57d67dff9d6d795b2ba2796806bb109864be3a151/cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9", size = 488469, upload-time = "2024-09-04T20:44:41.616Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/ee/f94057fa6426481d663b88637a9a10e859e492c73d0384514a17d78ee205/cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d", size = 172475, upload-time = "2024-09-04T20:44:43.733Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/fc/6a8cb64e5f0324877d503c854da15d76c1e50eb722e320b15345c4d0c6de/cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a", size = 182009, upload-time = "2024-09-04T20:44:45.309Z" },
+]
+
+[[package]]
+name = "cfgv"
+version = "3.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/11/74/539e56497d9bd1d484fd863dd69cbbfa653cd2aa27abfe35653494d85e94/cfgv-3.4.0.tar.gz", hash = "sha256:e52591d4c5f5dead8e0f673fb16db7949d2cfb3f7da4582893288f0ded8fe560", size = 7114, upload-time = "2023-08-12T20:38:17.776Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c5/55/51844dd50c4fc7a33b653bfaba4c2456f06955289ca770a5dbd5fd267374/cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9", size = 7249, upload-time = "2023-08-12T20:38:16.269Z" },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/16/b0/572805e227f01586461c80e0fd25d65a2115599cc9dad142fee4b747c357/charset_normalizer-3.4.1.tar.gz", hash = "sha256:44251f18cd68a75b56585dd00dae26183e102cd5e0f9f1466e6df5da2ed64ea3", size = 123188, upload-time = "2024-12-24T18:12:35.43Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0d/58/5580c1716040bc89206c77d8f74418caf82ce519aae06450393ca73475d1/charset_normalizer-3.4.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:91b36a978b5ae0ee86c394f5a54d6ef44db1de0815eb43de826d41d21e4af3de", size = 198013, upload-time = "2024-12-24T18:09:43.671Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/11/00341177ae71c6f5159a08168bcb98c6e6d196d372c94511f9f6c9afe0c6/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7461baadb4dc00fd9e0acbe254e3d7d2112e7f92ced2adc96e54ef6501c5f176", size = 141285, upload-time = "2024-12-24T18:09:48.113Z" },
+    { url = "https://files.pythonhosted.org/packages/01/09/11d684ea5819e5a8f5100fb0b38cf8d02b514746607934134d31233e02c8/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e218488cd232553829be0664c2292d3af2eeeb94b32bea483cf79ac6a694e037", size = 151449, upload-time = "2024-12-24T18:09:50.845Z" },
+    { url = "https://files.pythonhosted.org/packages/08/06/9f5a12939db324d905dc1f70591ae7d7898d030d7662f0d426e2286f68c9/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:80ed5e856eb7f30115aaf94e4a08114ccc8813e6ed1b5efa74f9f82e8509858f", size = 143892, upload-time = "2024-12-24T18:09:52.078Z" },
+    { url = "https://files.pythonhosted.org/packages/93/62/5e89cdfe04584cb7f4d36003ffa2936681b03ecc0754f8e969c2becb7e24/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b010a7a4fd316c3c484d482922d13044979e78d1861f0e0650423144c616a46a", size = 146123, upload-time = "2024-12-24T18:09:54.575Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/ac/ab729a15c516da2ab70a05f8722ecfccc3f04ed7a18e45c75bbbaa347d61/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4532bff1b8421fd0a320463030c7520f56a79c9024a4e88f01c537316019005a", size = 147943, upload-time = "2024-12-24T18:09:57.324Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d2/3f392f23f042615689456e9a274640c1d2e5dd1d52de36ab8f7955f8f050/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d973f03c0cb71c5ed99037b870f2be986c3c05e63622c017ea9816881d2dd247", size = 142063, upload-time = "2024-12-24T18:09:59.794Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/e3/e20aae5e1039a2cd9b08d9205f52142329f887f8cf70da3650326670bddf/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3a3bd0dcd373514dcec91c411ddb9632c0d7d92aed7093b8c3bbb6d69ca74408", size = 150578, upload-time = "2024-12-24T18:10:02.357Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/af/779ad72a4da0aed925e1139d458adc486e61076d7ecdcc09e610ea8678db/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d9c3cdf5390dcd29aa8056d13e8e99526cda0305acc038b96b30352aff5ff2bb", size = 153629, upload-time = "2024-12-24T18:10:03.678Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/b6/7aa450b278e7aa92cf7732140bfd8be21f5f29d5bf334ae987c945276639/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:2bdfe3ac2e1bbe5b59a1a63721eb3b95fc9b6817ae4a46debbb4e11f6232428d", size = 150778, upload-time = "2024-12-24T18:10:06.197Z" },
+    { url = "https://files.pythonhosted.org/packages/39/f4/d9f4f712d0951dcbfd42920d3db81b00dd23b6ab520419626f4023334056/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:eab677309cdb30d047996b36d34caeda1dc91149e4fdca0b1a039b3f79d9a807", size = 146453, upload-time = "2024-12-24T18:10:08.848Z" },
+    { url = "https://files.pythonhosted.org/packages/49/2b/999d0314e4ee0cff3cb83e6bc9aeddd397eeed693edb4facb901eb8fbb69/charset_normalizer-3.4.1-cp310-cp310-win32.whl", hash = "sha256:c0429126cf75e16c4f0ad00ee0eae4242dc652290f940152ca8c75c3a4b6ee8f", size = 95479, upload-time = "2024-12-24T18:10:10.044Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/ce/3cbed41cff67e455a386fb5e5dd8906cdda2ed92fbc6297921f2e4419309/charset_normalizer-3.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:9f0b8b1c6d84c8034a44893aba5e767bf9c7a211e313a9605d9c617d7083829f", size = 102790, upload-time = "2024-12-24T18:10:11.323Z" },
+    { url = "https://files.pythonhosted.org/packages/72/80/41ef5d5a7935d2d3a773e3eaebf0a9350542f2cab4eac59a7a4741fbbbbe/charset_normalizer-3.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8bfa33f4f2672964266e940dd22a195989ba31669bd84629f05fab3ef4e2d125", size = 194995, upload-time = "2024-12-24T18:10:12.838Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/28/0b9fefa7b8b080ec492110af6d88aa3dea91c464b17d53474b6e9ba5d2c5/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:28bf57629c75e810b6ae989f03c0828d64d6b26a5e205535585f96093e405ed1", size = 139471, upload-time = "2024-12-24T18:10:14.101Z" },
+    { url = "https://files.pythonhosted.org/packages/71/64/d24ab1a997efb06402e3fc07317e94da358e2585165930d9d59ad45fcae2/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f08ff5e948271dc7e18a35641d2f11a4cd8dfd5634f55228b691e62b37125eb3", size = 149831, upload-time = "2024-12-24T18:10:15.512Z" },
+    { url = "https://files.pythonhosted.org/packages/37/ed/be39e5258e198655240db5e19e0b11379163ad7070962d6b0c87ed2c4d39/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:234ac59ea147c59ee4da87a0c0f098e9c8d169f4dc2a159ef720f1a61bbe27cd", size = 142335, upload-time = "2024-12-24T18:10:18.369Z" },
+    { url = "https://files.pythonhosted.org/packages/88/83/489e9504711fa05d8dde1574996408026bdbdbd938f23be67deebb5eca92/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd4ec41f914fa74ad1b8304bbc634b3de73d2a0889bd32076342a573e0779e00", size = 143862, upload-time = "2024-12-24T18:10:19.743Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/c7/32da20821cf387b759ad24627a9aca289d2822de929b8a41b6241767b461/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eea6ee1db730b3483adf394ea72f808b6e18cf3cb6454b4d86e04fa8c4327a12", size = 145673, upload-time = "2024-12-24T18:10:21.139Z" },
+    { url = "https://files.pythonhosted.org/packages/68/85/f4288e96039abdd5aeb5c546fa20a37b50da71b5cf01e75e87f16cd43304/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c96836c97b1238e9c9e3fe90844c947d5afbf4f4c92762679acfe19927d81d77", size = 140211, upload-time = "2024-12-24T18:10:22.382Z" },
+    { url = "https://files.pythonhosted.org/packages/28/a3/a42e70d03cbdabc18997baf4f0227c73591a08041c149e710045c281f97b/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4d86f7aff21ee58f26dcf5ae81a9addbd914115cdebcbb2217e4f0ed8982e146", size = 148039, upload-time = "2024-12-24T18:10:24.802Z" },
+    { url = "https://files.pythonhosted.org/packages/85/e4/65699e8ab3014ecbe6f5c71d1a55d810fb716bbfd74f6283d5c2aa87febf/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:09b5e6733cbd160dcc09589227187e242a30a49ca5cefa5a7edd3f9d19ed53fd", size = 151939, upload-time = "2024-12-24T18:10:26.124Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/82/8e9fe624cc5374193de6860aba3ea8070f584c8565ee77c168ec13274bd2/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:5777ee0881f9499ed0f71cc82cf873d9a0ca8af166dfa0af8ec4e675b7df48e6", size = 149075, upload-time = "2024-12-24T18:10:30.027Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/7b/82865ba54c765560c8433f65e8acb9217cb839a9e32b42af4aa8e945870f/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:237bdbe6159cff53b4f24f397d43c6336c6b0b42affbe857970cefbb620911c8", size = 144340, upload-time = "2024-12-24T18:10:32.679Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/b6/9674a4b7d4d99a0d2df9b215da766ee682718f88055751e1e5e753c82db0/charset_normalizer-3.4.1-cp311-cp311-win32.whl", hash = "sha256:8417cb1f36cc0bc7eaba8ccb0e04d55f0ee52df06df3ad55259b9a323555fc8b", size = 95205, upload-time = "2024-12-24T18:10:34.724Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/ab/45b180e175de4402dcf7547e4fb617283bae54ce35c27930a6f35b6bef15/charset_normalizer-3.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7f50a1f8c450f3925cb367d011448c39239bb3eb4117c36a6d354794de4ce76", size = 102441, upload-time = "2024-12-24T18:10:37.574Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/9a/dd1e1cdceb841925b7798369a09279bd1cf183cef0f9ddf15a3a6502ee45/charset_normalizer-3.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:73d94b58ec7fecbc7366247d3b0b10a21681004153238750bb67bd9012414545", size = 196105, upload-time = "2024-12-24T18:10:38.83Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/8c/90bfabf8c4809ecb648f39794cf2a84ff2e7d2a6cf159fe68d9a26160467/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dad3e487649f498dd991eeb901125411559b22e8d7ab25d3aeb1af367df5efd7", size = 140404, upload-time = "2024-12-24T18:10:44.272Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/8f/e410d57c721945ea3b4f1a04b74f70ce8fa800d393d72899f0a40526401f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c30197aa96e8eed02200a83fba2657b4c3acd0f0aa4bdc9f6c1af8e8962e0757", size = 150423, upload-time = "2024-12-24T18:10:45.492Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/b8/e6825e25deb691ff98cf5c9072ee0605dc2acfca98af70c2d1b1bc75190d/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2369eea1ee4a7610a860d88f268eb39b95cb588acd7235e02fd5a5601773d4fa", size = 143184, upload-time = "2024-12-24T18:10:47.898Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/a2/513f6cbe752421f16d969e32f3583762bfd583848b763913ddab8d9bfd4f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc2722592d8998c870fa4e290c2eec2c1569b87fe58618e67d38b4665dfa680d", size = 145268, upload-time = "2024-12-24T18:10:50.589Z" },
+    { url = "https://files.pythonhosted.org/packages/74/94/8a5277664f27c3c438546f3eb53b33f5b19568eb7424736bdc440a88a31f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffc9202a29ab3920fa812879e95a9e78b2465fd10be7fcbd042899695d75e616", size = 147601, upload-time = "2024-12-24T18:10:52.541Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/5f/6d352c51ee763623a98e31194823518e09bfa48be2a7e8383cf691bbb3d0/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:804a4d582ba6e5b747c625bf1255e6b1507465494a40a2130978bda7b932c90b", size = 141098, upload-time = "2024-12-24T18:10:53.789Z" },
+    { url = "https://files.pythonhosted.org/packages/78/d4/f5704cb629ba5ab16d1d3d741396aec6dc3ca2b67757c45b0599bb010478/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0f55e69f030f7163dffe9fd0752b32f070566451afe180f99dbeeb81f511ad8d", size = 149520, upload-time = "2024-12-24T18:10:55.048Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/96/64120b1d02b81785f222b976c0fb79a35875457fa9bb40827678e54d1bc8/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c4c3e6da02df6fa1410a7680bd3f63d4f710232d3139089536310d027950696a", size = 152852, upload-time = "2024-12-24T18:10:57.647Z" },
+    { url = "https://files.pythonhosted.org/packages/84/c9/98e3732278a99f47d487fd3468bc60b882920cef29d1fa6ca460a1fdf4e6/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:5df196eb874dae23dcfb968c83d4f8fdccb333330fe1fc278ac5ceeb101003a9", size = 150488, upload-time = "2024-12-24T18:10:59.43Z" },
+    { url = "https://files.pythonhosted.org/packages/13/0e/9c8d4cb99c98c1007cc11eda969ebfe837bbbd0acdb4736d228ccaabcd22/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e358e64305fe12299a08e08978f51fc21fac060dcfcddd95453eabe5b93ed0e1", size = 146192, upload-time = "2024-12-24T18:11:00.676Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/21/2b6b5b860781a0b49427309cb8670785aa543fb2178de875b87b9cc97746/charset_normalizer-3.4.1-cp312-cp312-win32.whl", hash = "sha256:9b23ca7ef998bc739bf6ffc077c2116917eabcc901f88da1b9856b210ef63f35", size = 95550, upload-time = "2024-12-24T18:11:01.952Z" },
+    { url = "https://files.pythonhosted.org/packages/21/5b/1b390b03b1d16c7e382b561c5329f83cc06623916aab983e8ab9239c7d5c/charset_normalizer-3.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:6ff8a4a60c227ad87030d76e99cd1698345d4491638dfa6673027c48b3cd395f", size = 102785, upload-time = "2024-12-24T18:11:03.142Z" },
+    { url = "https://files.pythonhosted.org/packages/38/94/ce8e6f63d18049672c76d07d119304e1e2d7c6098f0841b51c666e9f44a0/charset_normalizer-3.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:aabfa34badd18f1da5ec1bc2715cadc8dca465868a4e73a0173466b688f29dda", size = 195698, upload-time = "2024-12-24T18:11:05.834Z" },
+    { url = "https://files.pythonhosted.org/packages/24/2e/dfdd9770664aae179a96561cc6952ff08f9a8cd09a908f259a9dfa063568/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22e14b5d70560b8dd51ec22863f370d1e595ac3d024cb8ad7d308b4cd95f8313", size = 140162, upload-time = "2024-12-24T18:11:07.064Z" },
+    { url = "https://files.pythonhosted.org/packages/24/4e/f646b9093cff8fc86f2d60af2de4dc17c759de9d554f130b140ea4738ca6/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8436c508b408b82d87dc5f62496973a1805cd46727c34440b0d29d8a2f50a6c9", size = 150263, upload-time = "2024-12-24T18:11:08.374Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/67/2937f8d548c3ef6e2f9aab0f6e21001056f692d43282b165e7c56023e6dd/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2d074908e1aecee37a7635990b2c6d504cd4766c7bc9fc86d63f9c09af3fa11b", size = 142966, upload-time = "2024-12-24T18:11:09.831Z" },
+    { url = "https://files.pythonhosted.org/packages/52/ed/b7f4f07de100bdb95c1756d3a4d17b90c1a3c53715c1a476f8738058e0fa/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:955f8851919303c92343d2f66165294848d57e9bba6cf6e3625485a70a038d11", size = 144992, upload-time = "2024-12-24T18:11:12.03Z" },
+    { url = "https://files.pythonhosted.org/packages/96/2c/d49710a6dbcd3776265f4c923bb73ebe83933dfbaa841c5da850fe0fd20b/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:44ecbf16649486d4aebafeaa7ec4c9fed8b88101f4dd612dcaf65d5e815f837f", size = 147162, upload-time = "2024-12-24T18:11:13.372Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/41/35ff1f9a6bd380303dea55e44c4933b4cc3c4850988927d4082ada230273/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0924e81d3d5e70f8126529951dac65c1010cdf117bb75eb02dd12339b57749dd", size = 140972, upload-time = "2024-12-24T18:11:14.628Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/43/c6a0b685fe6910d08ba971f62cd9c3e862a85770395ba5d9cad4fede33ab/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2967f74ad52c3b98de4c3b32e1a44e32975e008a9cd2a8cc8966d6a5218c5cb2", size = 149095, upload-time = "2024-12-24T18:11:17.672Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/ff/a9a504662452e2d2878512115638966e75633519ec11f25fca3d2049a94a/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c75cb2a3e389853835e84a2d8fb2b81a10645b503eca9bcb98df6b5a43eb8886", size = 152668, upload-time = "2024-12-24T18:11:18.989Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/71/189996b6d9a4b932564701628af5cee6716733e9165af1d5e1b285c530ed/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:09b26ae6b1abf0d27570633b2b078a2a20419c99d66fb2823173d73f188ce601", size = 150073, upload-time = "2024-12-24T18:11:21.507Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/93/946a86ce20790e11312c87c75ba68d5f6ad2208cfb52b2d6a2c32840d922/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fa88b843d6e211393a37219e6a1c1df99d35e8fd90446f1118f4216e307e48cd", size = 145732, upload-time = "2024-12-24T18:11:22.774Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/e5/131d2fb1b0dddafc37be4f3a2fa79aa4c037368be9423061dccadfd90091/charset_normalizer-3.4.1-cp313-cp313-win32.whl", hash = "sha256:eb8178fe3dba6450a3e024e95ac49ed3400e506fd4e9e5c32d30adda88cbd407", size = 95391, upload-time = "2024-12-24T18:11:24.139Z" },
+    { url = "https://files.pythonhosted.org/packages/27/f2/4f9a69cc7712b9b5ad8fdb87039fd89abba997ad5cbe690d1835d40405b0/charset_normalizer-3.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:b1ac5992a838106edb89654e0aebfc24f5848ae2547d22c2c3f66454daa11971", size = 102702, upload-time = "2024-12-24T18:11:26.535Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/f6/65ecc6878a89bb1c23a086ea335ad4bf21a588990c3f535a227b9eea9108/charset_normalizer-3.4.1-py3-none-any.whl", hash = "sha256:d98b1668f06378c6dbefec3b92299716b931cd4e6061f3c875a71ced1780ab85", size = 49767, upload-time = "2024-12-24T18:12:32.852Z" },
+]
+
+[[package]]
+name = "codespell"
+version = "2.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/15/e0/709453393c0ea77d007d907dd436b3ee262e28b30995ea1aa36c6ffbccaf/codespell-2.4.1.tar.gz", hash = "sha256:299fcdcb09d23e81e35a671bbe746d5ad7e8385972e65dbb833a2eaac33c01e5", size = 344740, upload-time = "2025-01-28T18:52:39.411Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/20/01/b394922252051e97aab231d416c86da3d8a6d781eeadcdca1082867de64e/codespell-2.4.1-py3-none-any.whl", hash = "sha256:3dadafa67df7e4a3dbf51e0d7315061b80d265f9552ebd699b3dd6834b47e425", size = 344501, upload-time = "2025-01-28T18:52:37.057Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "cryptography"
+version = "44.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/91/4c/45dfa6829acffa344e3967d6006ee4ae8be57af746ae2eba1c431949b32c/cryptography-44.0.0.tar.gz", hash = "sha256:cd4e834f340b4293430701e772ec543b0fbe6c2dea510a5286fe0acabe153a02", size = 710657, upload-time = "2024-11-27T18:07:10.168Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/55/09/8cc67f9b84730ad330b3b72cf867150744bf07ff113cda21a15a1c6d2c7c/cryptography-44.0.0-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:84111ad4ff3f6253820e6d3e58be2cc2a00adb29335d4cacb5ab4d4d34f2a123", size = 6541833, upload-time = "2024-11-27T18:05:55.475Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/5b/3759e30a103144e29632e7cb72aec28cedc79e514b2ea8896bb17163c19b/cryptography-44.0.0-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b15492a11f9e1b62ba9d73c210e2416724633167de94607ec6069ef724fad092", size = 3922710, upload-time = "2024-11-27T18:05:58.621Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/58/3b14bf39f1a0cfd679e753e8647ada56cddbf5acebffe7db90e184c76168/cryptography-44.0.0-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:831c3c4d0774e488fdc83a1923b49b9957d33287de923d58ebd3cec47a0ae43f", size = 4137546, upload-time = "2024-11-27T18:06:01.062Z" },
+    { url = "https://files.pythonhosted.org/packages/98/65/13d9e76ca19b0ba5603d71ac8424b5694415b348e719db277b5edc985ff5/cryptography-44.0.0-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:761817a3377ef15ac23cd7834715081791d4ec77f9297ee694ca1ee9c2c7e5eb", size = 3915420, upload-time = "2024-11-27T18:06:03.487Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/07/40fe09ce96b91fc9276a9ad272832ead0fddedcba87f1190372af8e3039c/cryptography-44.0.0-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3c672a53c0fb4725a29c303be906d3c1fa99c32f58abe008a82705f9ee96f40b", size = 4154498, upload-time = "2024-11-27T18:06:05.763Z" },
+    { url = "https://files.pythonhosted.org/packages/75/ea/af65619c800ec0a7e4034207aec543acdf248d9bffba0533342d1bd435e1/cryptography-44.0.0-cp37-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:4ac4c9f37eba52cb6fbeaf5b59c152ea976726b865bd4cf87883a7e7006cc543", size = 3932569, upload-time = "2024-11-27T18:06:07.489Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/af/d1deb0c04d59612e3d5e54203159e284d3e7a6921e565bb0eeb6269bdd8a/cryptography-44.0.0-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ed3534eb1090483c96178fcb0f8893719d96d5274dfde98aa6add34614e97c8e", size = 4016721, upload-time = "2024-11-27T18:06:11.57Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/69/7ca326c55698d0688db867795134bdfac87136b80ef373aaa42b225d6dd5/cryptography-44.0.0-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f3f6fdfa89ee2d9d496e2c087cebef9d4fcbb0ad63c40e821b39f74bf48d9c5e", size = 4240915, upload-time = "2024-11-27T18:06:13.515Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/d4/cae11bf68c0f981e0413906c6dd03ae7fa864347ed5fac40021df1ef467c/cryptography-44.0.0-cp37-abi3-win32.whl", hash = "sha256:eb33480f1bad5b78233b0ad3e1b0be21e8ef1da745d8d2aecbb20671658b9053", size = 2757925, upload-time = "2024-11-27T18:06:16.019Z" },
+    { url = "https://files.pythonhosted.org/packages/64/b1/50d7739254d2002acae64eed4fc43b24ac0cc44bf0a0d388d1ca06ec5bb1/cryptography-44.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:abc998e0c0eee3c8a1904221d3f67dcfa76422b23620173e28c11d3e626c21bd", size = 3202055, upload-time = "2024-11-27T18:06:19.113Z" },
+    { url = "https://files.pythonhosted.org/packages/11/18/61e52a3d28fc1514a43b0ac291177acd1b4de00e9301aaf7ef867076ff8a/cryptography-44.0.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:660cb7312a08bc38be15b696462fa7cc7cd85c3ed9c576e81f4dc4d8b2b31591", size = 6542801, upload-time = "2024-11-27T18:06:21.431Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/07/5f165b6c65696ef75601b781a280fc3b33f1e0cd6aa5a92d9fb96c410e97/cryptography-44.0.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1923cb251c04be85eec9fda837661c67c1049063305d6be5721643c22dd4e2b7", size = 3922613, upload-time = "2024-11-27T18:06:24.314Z" },
+    { url = "https://files.pythonhosted.org/packages/28/34/6b3ac1d80fc174812486561cf25194338151780f27e438526f9c64e16869/cryptography-44.0.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:404fdc66ee5f83a1388be54300ae978b2efd538018de18556dde92575e05defc", size = 4137925, upload-time = "2024-11-27T18:06:27.079Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/c7/c656eb08fd22255d21bc3129625ed9cd5ee305f33752ef2278711b3fa98b/cryptography-44.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:c5eb858beed7835e5ad1faba59e865109f3e52b3783b9ac21e7e47dc5554e289", size = 3915417, upload-time = "2024-11-27T18:06:28.959Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/82/72403624f197af0db6bac4e58153bc9ac0e6020e57234115db9596eee85d/cryptography-44.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:f53c2c87e0fb4b0c00fa9571082a057e37690a8f12233306161c8f4b819960b7", size = 4155160, upload-time = "2024-11-27T18:06:30.866Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/cd/2f3c440913d4329ade49b146d74f2e9766422e1732613f57097fea61f344/cryptography-44.0.0-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:9e6fc8a08e116fb7c7dd1f040074c9d7b51d74a8ea40d4df2fc7aa08b76b9e6c", size = 3932331, upload-time = "2024-11-27T18:06:33.432Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/df/8be88797f0a1cca6e255189a57bb49237402b1880d6e8721690c5603ac23/cryptography-44.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:d2436114e46b36d00f8b72ff57e598978b37399d2786fd39793c36c6d5cb1c64", size = 4017372, upload-time = "2024-11-27T18:06:38.343Z" },
+    { url = "https://files.pythonhosted.org/packages/af/36/5ccc376f025a834e72b8e52e18746b927f34e4520487098e283a719c205e/cryptography-44.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a01956ddfa0a6790d594f5b34fc1bfa6098aca434696a03cfdbe469b8ed79285", size = 4239657, upload-time = "2024-11-27T18:06:41.045Z" },
+    { url = "https://files.pythonhosted.org/packages/46/b0/f4f7d0d0bcfbc8dd6296c1449be326d04217c57afb8b2594f017eed95533/cryptography-44.0.0-cp39-abi3-win32.whl", hash = "sha256:eca27345e1214d1b9f9490d200f9db5a874479be914199194e746c893788d417", size = 2758672, upload-time = "2024-11-27T18:06:43.566Z" },
+    { url = "https://files.pythonhosted.org/packages/97/9b/443270b9210f13f6ef240eff73fd32e02d381e7103969dc66ce8e89ee901/cryptography-44.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:708ee5f1bafe76d041b53a4f95eb28cdeb8d18da17e597d46d7833ee59b97ede", size = 3202071, upload-time = "2024-11-27T18:06:45.586Z" },
+    { url = "https://files.pythonhosted.org/packages/77/d4/fea74422326388bbac0c37b7489a0fcb1681a698c3b875959430ba550daa/cryptography-44.0.0-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:37d76e6863da3774cd9db5b409a9ecfd2c71c981c38788d3fcfaf177f447b731", size = 3338857, upload-time = "2024-11-27T18:06:48.88Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/aa/ba8a7467c206cb7b62f09b4168da541b5109838627f582843bbbe0235e8e/cryptography-44.0.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:f677e1268c4e23420c3acade68fac427fffcb8d19d7df95ed7ad17cdef8404f4", size = 3850615, upload-time = "2024-11-27T18:06:50.774Z" },
+    { url = "https://files.pythonhosted.org/packages/89/fa/b160e10a64cc395d090105be14f399b94e617c879efd401188ce0fea39ee/cryptography-44.0.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:f5e7cb1e5e56ca0933b4873c0220a78b773b24d40d186b6738080b73d3d0a756", size = 4081622, upload-time = "2024-11-27T18:06:55.126Z" },
+    { url = "https://files.pythonhosted.org/packages/47/8f/20ff0656bb0cf7af26ec1d01f780c5cfbaa7666736063378c5f48558b515/cryptography-44.0.0-pp310-pypy310_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:8b3e6eae66cf54701ee7d9c83c30ac0a1e3fa17be486033000f2a73a12ab507c", size = 3867546, upload-time = "2024-11-27T18:06:57.694Z" },
+    { url = "https://files.pythonhosted.org/packages/38/d9/28edf32ee2fcdca587146bcde90102a7319b2f2c690edfa627e46d586050/cryptography-44.0.0-pp310-pypy310_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:be4ce505894d15d5c5037167ffb7f0ae90b7be6f2a98f9a5c3442395501c32fa", size = 4090937, upload-time = "2024-11-27T18:07:00.338Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/9d/37e5da7519de7b0b070a3fedd4230fe76d50d2a21403e0f2153d70ac4163/cryptography-44.0.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:62901fb618f74d7d81bf408c8719e9ec14d863086efe4185afd07c352aee1d2c", size = 3128774, upload-time = "2024-11-27T18:07:02.157Z" },
+]
+
+[[package]]
+name = "datafusion"
+source = { editable = "." }
+dependencies = [
+    { name = "pyarrow" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "arro3-core" },
+    { name = "codespell" },
+    { name = "maturin" },
+    { name = "nanoarrow" },
+    { name = "numpy", version = "2.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.14'" },
+    { name = "numpy", version = "2.3.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.14'" },
+    { name = "pre-commit" },
+    { name = "pyarrow" },
+    { name = "pygithub" },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "pyyaml" },
+    { name = "ruff" },
+    { name = "toml" },
+]
+docs = [
+    { name = "ipython" },
+    { name = "jinja2" },
+    { name = "myst-parser" },
+    { name = "pandas" },
+    { name = "pickleshare" },
+    { name = "pydata-sphinx-theme" },
+    { name = "setuptools" },
+    { name = "sphinx" },
+    { name = "sphinx-autoapi" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "pyarrow", marker = "python_full_version < '3.14'", specifier = ">=16.0.0" },
+    { name = "pyarrow", marker = "python_full_version >= '3.14'", specifier = ">=22.0.0" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "arro3-core", specifier = "==0.6.5" },
+    { name = "codespell", specifier = "==2.4.1" },
+    { name = "maturin", specifier = ">=1.8.1" },
+    { name = "nanoarrow", specifier = "==0.8.0" },
+    { name = "numpy", marker = "python_full_version < '3.14'", specifier = ">1.25.0" },
+    { name = "numpy", marker = "python_full_version >= '3.14'", specifier = ">=2.3.2" },
+    { name = "pre-commit", specifier = ">=4.3.0" },
+    { name = "pyarrow", specifier = ">=19.0.0" },
+    { name = "pygithub", specifier = "==2.5.0" },
+    { name = "pytest", specifier = ">=7.4.4" },
+    { name = "pytest-asyncio", specifier = ">=0.23.3" },
+    { name = "pyyaml", specifier = ">=6.0.3" },
+    { name = "ruff", specifier = ">=0.9.1" },
+    { name = "toml", specifier = ">=0.10.2" },
+]
+docs = [
+    { name = "ipython", specifier = ">=8.12.3" },
+    { name = "jinja2", specifier = ">=3.1.5" },
+    { name = "myst-parser", specifier = ">=3.0.1" },
+    { name = "pandas", specifier = ">=2.0.3" },
+    { name = "pickleshare", specifier = ">=0.7.5" },
+    { name = "pydata-sphinx-theme", specifier = "==0.8.0" },
+    { name = "setuptools", specifier = ">=75.3.0" },
+    { name = "sphinx", specifier = ">=7.1.2" },
+    { name = "sphinx-autoapi", specifier = ">=3.4.0" },
+]
+
+[[package]]
+name = "decorator"
+version = "5.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/66/0c/8d907af351aa16b42caae42f9d6aa37b900c67308052d10fdce809f8d952/decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330", size = 35016, upload-time = "2022-01-07T08:20:05.666Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d5/50/83c593b07763e1161326b3b8c6686f0f4b0f24d5526546bee538c89837d6/decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186", size = 9073, upload-time = "2022-01-07T08:20:03.734Z" },
+]
+
+[[package]]
+name = "deprecated"
+version = "1.2.18"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/98/97/06afe62762c9a8a86af0cfb7bfdab22a43ad17138b07af5b1a58442690a2/deprecated-1.2.18.tar.gz", hash = "sha256:422b6f6d859da6f2ef57857761bfb392480502a64c3028ca9bbe86085d72115d", size = 2928744, upload-time = "2025-01-27T10:46:25.7Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6e/c6/ac0b6c1e2d138f1002bcf799d330bd6d85084fece321e662a14223794041/Deprecated-1.2.18-py2.py3-none-any.whl", hash = "sha256:bd5011788200372a32418f888e326a09ff80d0214bd961147cfed01b5c018eec", size = 9998, upload-time = "2025-01-27T10:46:09.186Z" },
+]
+
+[[package]]
+name = "distlib"
+version = "0.3.9"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0d/dd/1bec4c5ddb504ca60fc29472f3d27e8d4da1257a854e1d96742f15c1d02d/distlib-0.3.9.tar.gz", hash = "sha256:a60f20dea646b8a33f3e7772f74dc0b2d0772d2837ee1342a00645c81edf9403", size = 613923, upload-time = "2024-10-09T18:35:47.551Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/91/a1/cf2472db20f7ce4a6be1253a81cfdf85ad9c7885ffbed7047fb72c24cf87/distlib-0.3.9-py2.py3-none-any.whl", hash = "sha256:47f8c22fd27c27e25a65601af709b38e4f0a45ea4fc2e710f65755fa8caaaf87", size = 468973, upload-time = "2024-10-09T18:35:44.272Z" },
+]
+
+[[package]]
+name = "docutils"
+version = "0.21.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ae/ed/aefcc8cd0ba62a0560c3c18c33925362d46c6075480bfa4df87b28e169a9/docutils-0.21.2.tar.gz", hash = "sha256:3a6b18732edf182daa3cd12775bbb338cf5691468f91eeeb109deff6ebfa986f", size = 2204444, upload-time = "2024-04-23T18:57:18.24Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8f/d7/9322c609343d929e75e7e5e6255e614fcc67572cfd083959cdef3b7aad79/docutils-0.21.2-py3-none-any.whl", hash = "sha256:dafca5b9e384f0e419294eb4d2ff9fa826435bf15f15b7bd45723e8ad76811b2", size = 587408, upload-time = "2024-04-23T18:57:14.835Z" },
+]
+
+[[package]]
+name = "exceptiongroup"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/09/35/2495c4ac46b980e4ca1f6ad6db102322ef3ad2410b79fdde159a4b0f3b92/exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc", size = 28883, upload-time = "2024-07-12T22:26:00.161Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/02/cc/b7e31358aac6ed1ef2bb790a9746ac2c69bcb3c8588b41616914eb106eaf/exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b", size = 16453, upload-time = "2024-07-12T22:25:58.476Z" },
+]
+
+[[package]]
+name = "executing"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/e3/7d45f492c2c4a0e8e0fad57d081a7c8a0286cdd86372b070cca1ec0caa1e/executing-2.1.0.tar.gz", hash = "sha256:8ea27ddd260da8150fa5a708269c4a10e76161e2496ec3e587da9e3c0fe4b9ab", size = 977485, upload-time = "2024-09-01T12:37:35.708Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b5/fd/afcd0496feca3276f509df3dbd5dae726fcc756f1a08d9e25abe1733f962/executing-2.1.0-py2.py3-none-any.whl", hash = "sha256:8d63781349375b5ebccc3142f4b30350c0cd9c79f921cde38be2be4637e98eaf", size = 25805, upload-time = "2024-09-01T12:37:33.007Z" },
+]
+
+[[package]]
+name = "filelock"
+version = "3.18.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0a/10/c23352565a6544bdc5353e0b15fc1c563352101f30e24bf500207a54df9a/filelock-3.18.0.tar.gz", hash = "sha256:adbc88eabb99d2fec8c9c1b229b171f18afa655400173ddc653d5d01501fb9f2", size = 18075, upload-time = "2025-03-14T07:11:40.47Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4d/36/2a115987e2d8c300a974597416d9de88f2444426de9571f4b59b2cca3acc/filelock-3.18.0-py3-none-any.whl", hash = "sha256:c401f4f8377c4464e6db25fff06205fd89bdd83b65eb0488ed1b160f780e21de", size = 16215, upload-time = "2025-03-14T07:11:39.145Z" },
+]
+
+[[package]]
+name = "identify"
+version = "2.6.12"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/88/d193a27416618628a5eea64e3223acd800b40749a96ffb322a9b55a49ed1/identify-2.6.12.tar.gz", hash = "sha256:d8de45749f1efb108badef65ee8386f0f7bb19a7f26185f74de6367bffbaf0e6", size = 99254, upload-time = "2025-05-23T20:37:53.3Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7a/cd/18f8da995b658420625f7ef13f037be53ae04ec5ad33f9b718240dcfd48c/identify-2.6.12-py2.py3-none-any.whl", hash = "sha256:ad9672d5a72e0d2ff7c5c8809b62dfa60458626352fb0eb7b55e69bdc45334a2", size = 99145, upload-time = "2025-05-23T20:37:51.495Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490, upload-time = "2024-09-15T18:07:39.745Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442, upload-time = "2024-09-15T18:07:37.964Z" },
+]
+
+[[package]]
+name = "imagesize"
+version = "1.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a7/84/62473fb57d61e31fef6e36d64a179c8781605429fd927b5dd608c997be31/imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a", size = 1280026, upload-time = "2022-07-01T12:21:05.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ff/62/85c4c919272577931d407be5ba5d71c20f0b616d31a0befe0ae45bb79abd/imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b", size = 8769, upload-time = "2022-07-01T12:21:02.467Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/4b/cbd8e699e64a6f16ca3a8220661b5f83792b3017d0f79807cb8708d33913/iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3", size = 4646, upload-time = "2023-01-07T11:08:11.254Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/a6/62565a6e1cf69e10f5727360368e451d4b7f58beeac6173dc9db836a5b46/iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374", size = 5892, upload-time = "2023-01-07T11:08:09.864Z" },
+]
+
+[[package]]
+name = "ipython"
+version = "8.31.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "decorator" },
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+    { name = "jedi" },
+    { name = "matplotlib-inline" },
+    { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" },
+    { name = "prompt-toolkit" },
+    { name = "pygments" },
+    { name = "stack-data" },
+    { name = "traitlets" },
+    { name = "typing-extensions", marker = "python_full_version < '3.12'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/01/35/6f90fdddff7a08b7b715fccbd2427b5212c9525cd043d26fdc45bee0708d/ipython-8.31.0.tar.gz", hash = "sha256:b6a2274606bec6166405ff05e54932ed6e5cfecaca1fc05f2cacde7bb074d70b", size = 5501011, upload-time = "2024-12-20T12:34:22.61Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/60/d0feb6b6d9fe4ab89fe8fe5b47cbf6cd936bfd9f1e7ffa9d0015425aeed6/ipython-8.31.0-py3-none-any.whl", hash = "sha256:46ec58f8d3d076a61d128fe517a51eb730e3aaf0c184ea8c17d16e366660c6a6", size = 821583, upload-time = "2024-12-20T12:34:17.106Z" },
+]
+
+[[package]]
+name = "jedi"
+version = "0.19.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "parso" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287, upload-time = "2024-11-11T01:41:42.873Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278, upload-time = "2024-11-11T01:41:40.175Z" },
+]
+
+[[package]]
+name = "jinja2"
+version = "3.1.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/af/92/b3130cbbf5591acf9ade8708c365f3238046ac7cb8ccba6e81abccb0ccff/jinja2-3.1.5.tar.gz", hash = "sha256:8fefff8dc3034e27bb80d67c671eb8a9bc424c0ef4c0826edbff304cceff43bb", size = 244674, upload-time = "2024-12-21T18:30:22.828Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bd/0f/2ba5fbcd631e3e88689309dbe978c5769e883e4b84ebfe7da30b43275c5a/jinja2-3.1.5-py3-none-any.whl", hash = "sha256:aba0f4dc9ed8013c424088f68a5c226f7d6097ed89b246d7749c2ec4175c6adb", size = 134596, upload-time = "2024-12-21T18:30:19.133Z" },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "3.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596, upload-time = "2023-06-03T06:41:14.443Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528, upload-time = "2023-06-03T06:41:11.019Z" },
+]
+
+[[package]]
+name = "markupsafe"
+version = "3.0.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b2/97/5d42485e71dfc078108a86d6de8fa46db44a1a9295e89c5d6d4a06e23a62/markupsafe-3.0.2.tar.gz", hash = "sha256:ee55d3edf80167e48ea11a923c7386f4669df67d7994554387f84e7d8b0a2bf0", size = 20537, upload-time = "2024-10-18T15:21:54.129Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/90/d08277ce111dd22f77149fd1a5d4653eeb3b3eaacbdfcbae5afb2600eebd/MarkupSafe-3.0.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7e94c425039cde14257288fd61dcfb01963e658efbc0ff54f5306b06054700f8", size = 14357, upload-time = "2024-10-18T15:20:51.44Z" },
+    { url = "https://files.pythonhosted.org/packages/04/e1/6e2194baeae0bca1fae6629dc0cbbb968d4d941469cbab11a3872edff374/MarkupSafe-3.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e2d922824181480953426608b81967de705c3cef4d1af983af849d7bd619158", size = 12393, upload-time = "2024-10-18T15:20:52.426Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/69/35fa85a8ece0a437493dc61ce0bb6d459dcba482c34197e3efc829aa357f/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:38a9ef736c01fccdd6600705b09dc574584b89bea478200c5fbf112a6b0d5579", size = 21732, upload-time = "2024-10-18T15:20:53.578Z" },
+    { url = "https://files.pythonhosted.org/packages/22/35/137da042dfb4720b638d2937c38a9c2df83fe32d20e8c8f3185dbfef05f7/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bbcb445fa71794da8f178f0f6d66789a28d7319071af7a496d4d507ed566270d", size = 20866, upload-time = "2024-10-18T15:20:55.06Z" },
+    { url = "https://files.pythonhosted.org/packages/29/28/6d029a903727a1b62edb51863232152fd335d602def598dade38996887f0/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:57cb5a3cf367aeb1d316576250f65edec5bb3be939e9247ae594b4bcbc317dfb", size = 20964, upload-time = "2024-10-18T15:20:55.906Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/cd/07438f95f83e8bc028279909d9c9bd39e24149b0d60053a97b2bc4f8aa51/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3809ede931876f5b2ec92eef964286840ed3540dadf803dd570c3b7e13141a3b", size = 21977, upload-time = "2024-10-18T15:20:57.189Z" },
+    { url = "https://files.pythonhosted.org/packages/29/01/84b57395b4cc062f9c4c55ce0df7d3108ca32397299d9df00fedd9117d3d/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e07c3764494e3776c602c1e78e298937c3315ccc9043ead7e685b7f2b8d47b3c", size = 21366, upload-time = "2024-10-18T15:20:58.235Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/6e/61ebf08d8940553afff20d1fb1ba7294b6f8d279df9fd0c0db911b4bbcfd/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b424c77b206d63d500bcb69fa55ed8d0e6a3774056bdc4839fc9298a7edca171", size = 21091, upload-time = "2024-10-18T15:20:59.235Z" },
+    { url = "https://files.pythonhosted.org/packages/11/23/ffbf53694e8c94ebd1e7e491de185124277964344733c45481f32ede2499/MarkupSafe-3.0.2-cp310-cp310-win32.whl", hash = "sha256:fcabf5ff6eea076f859677f5f0b6b5c1a51e70a376b0579e0eadef8db48c6b50", size = 15065, upload-time = "2024-10-18T15:21:00.307Z" },
+    { url = "https://files.pythonhosted.org/packages/44/06/e7175d06dd6e9172d4a69a72592cb3f7a996a9c396eee29082826449bbc3/MarkupSafe-3.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:6af100e168aa82a50e186c82875a5893c5597a0c1ccdb0d8b40240b1f28b969a", size = 15514, upload-time = "2024-10-18T15:21:01.122Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/28/bbf83e3f76936960b850435576dd5e67034e200469571be53f69174a2dfd/MarkupSafe-3.0.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9025b4018f3a1314059769c7bf15441064b2207cb3f065e6ea1e7359cb46db9d", size = 14353, upload-time = "2024-10-18T15:21:02.187Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/30/316d194b093cde57d448a4c3209f22e3046c5bb2fb0820b118292b334be7/MarkupSafe-3.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:93335ca3812df2f366e80509ae119189886b0f3c2b81325d39efdb84a1e2ae93", size = 12392, upload-time = "2024-10-18T15:21:02.941Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/96/9cdafba8445d3a53cae530aaf83c38ec64c4d5427d975c974084af5bc5d2/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2cb8438c3cbb25e220c2ab33bb226559e7afb3baec11c4f218ffa7308603c832", size = 23984, upload-time = "2024-10-18T15:21:03.953Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/a4/aefb044a2cd8d7334c8a47d3fb2c9f328ac48cb349468cc31c20b539305f/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a123e330ef0853c6e822384873bef7507557d8e4a082961e1defa947aa59ba84", size = 23120, upload-time = "2024-10-18T15:21:06.495Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/21/5e4851379f88f3fad1de30361db501300d4f07bcad047d3cb0449fc51f8c/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e084f686b92e5b83186b07e8a17fc09e38fff551f3602b249881fec658d3eca", size = 23032, upload-time = "2024-10-18T15:21:07.295Z" },
+    { url = "https://files.pythonhosted.org/packages/00/7b/e92c64e079b2d0d7ddf69899c98842f3f9a60a1ae72657c89ce2655c999d/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8213e09c917a951de9d09ecee036d5c7d36cb6cb7dbaece4c71a60d79fb9798", size = 24057, upload-time = "2024-10-18T15:21:08.073Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/ac/46f960ca323037caa0a10662ef97d0a4728e890334fc156b9f9e52bcc4ca/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:5b02fb34468b6aaa40dfc198d813a641e3a63b98c2b05a16b9f80b7ec314185e", size = 23359, upload-time = "2024-10-18T15:21:09.318Z" },
+    { url = "https://files.pythonhosted.org/packages/69/84/83439e16197337b8b14b6a5b9c2105fff81d42c2a7c5b58ac7b62ee2c3b1/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0bff5e0ae4ef2e1ae4fdf2dfd5b76c75e5c2fa4132d05fc1b0dabcd20c7e28c4", size = 23306, upload-time = "2024-10-18T15:21:10.185Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/34/a15aa69f01e2181ed8d2b685c0d2f6655d5cca2c4db0ddea775e631918cd/MarkupSafe-3.0.2-cp311-cp311-win32.whl", hash = "sha256:6c89876f41da747c8d3677a2b540fb32ef5715f97b66eeb0c6b66f5e3ef6f59d", size = 15094, upload-time = "2024-10-18T15:21:11.005Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b8/3a3bd761922d416f3dc5d00bfbed11f66b1ab89a0c2b6e887240a30b0f6b/MarkupSafe-3.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:70a87b411535ccad5ef2f1df5136506a10775d267e197e4cf531ced10537bd6b", size = 15521, upload-time = "2024-10-18T15:21:12.911Z" },
+    { url = "https://files.pythonhosted.org/packages/22/09/d1f21434c97fc42f09d290cbb6350d44eb12f09cc62c9476effdb33a18aa/MarkupSafe-3.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9778bd8ab0a994ebf6f84c2b949e65736d5575320a17ae8984a77fab08db94cf", size = 14274, upload-time = "2024-10-18T15:21:13.777Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/b0/18f76bba336fa5aecf79d45dcd6c806c280ec44538b3c13671d49099fdd0/MarkupSafe-3.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:846ade7b71e3536c4e56b386c2a47adf5741d2d8b94ec9dc3e92e5e1ee1e2225", size = 12348, upload-time = "2024-10-18T15:21:14.822Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/25/dd5c0f6ac1311e9b40f4af06c78efde0f3b5cbf02502f8ef9501294c425b/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c99d261bd2d5f6b59325c92c73df481e05e57f19837bdca8413b9eac4bd8028", size = 24149, upload-time = "2024-10-18T15:21:15.642Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/f0/89e7aadfb3749d0f52234a0c8c7867877876e0a20b60e2188e9850794c17/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e17c96c14e19278594aa4841ec148115f9c7615a47382ecb6b82bd8fea3ab0c8", size = 23118, upload-time = "2024-10-18T15:21:17.133Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/da/f2eeb64c723f5e3777bc081da884b414671982008c47dcc1873d81f625b6/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88416bd1e65dcea10bc7569faacb2c20ce071dd1f87539ca2ab364bf6231393c", size = 22993, upload-time = "2024-10-18T15:21:18.064Z" },
+    { url = "https://files.pythonhosted.org/packages/da/0e/1f32af846df486dce7c227fe0f2398dc7e2e51d4a370508281f3c1c5cddc/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2181e67807fc2fa785d0592dc2d6206c019b9502410671cc905d132a92866557", size = 24178, upload-time = "2024-10-18T15:21:18.859Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/f6/bb3ca0532de8086cbff5f06d137064c8410d10779c4c127e0e47d17c0b71/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:52305740fe773d09cffb16f8ed0427942901f00adedac82ec8b67752f58a1b22", size = 23319, upload-time = "2024-10-18T15:21:19.671Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/82/8be4c96ffee03c5b4a034e60a31294daf481e12c7c43ab8e34a1453ee48b/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad10d3ded218f1039f11a75f8091880239651b52e9bb592ca27de44eed242a48", size = 23352, upload-time = "2024-10-18T15:21:20.971Z" },
+    { url = "https://files.pythonhosted.org/packages/51/ae/97827349d3fcffee7e184bdf7f41cd6b88d9919c80f0263ba7acd1bbcb18/MarkupSafe-3.0.2-cp312-cp312-win32.whl", hash = "sha256:0f4ca02bea9a23221c0182836703cbf8930c5e9454bacce27e767509fa286a30", size = 15097, upload-time = "2024-10-18T15:21:22.646Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/80/a61f99dc3a936413c3ee4e1eecac96c0da5ed07ad56fd975f1a9da5bc630/MarkupSafe-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:8e06879fc22a25ca47312fbe7c8264eb0b662f6db27cb2d3bbbc74b1df4b9b87", size = 15601, upload-time = "2024-10-18T15:21:23.499Z" },
+    { url = "https://files.pythonhosted.org/packages/83/0e/67eb10a7ecc77a0c2bbe2b0235765b98d164d81600746914bebada795e97/MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ba9527cdd4c926ed0760bc301f6728ef34d841f405abf9d4f959c478421e4efd", size = 14274, upload-time = "2024-10-18T15:21:24.577Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/6d/9409f3684d3335375d04e5f05744dfe7e9f120062c9857df4ab490a1031a/MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8b3d067f2e40fe93e1ccdd6b2e1d16c43140e76f02fb1319a05cf2b79d99430", size = 12352, upload-time = "2024-10-18T15:21:25.382Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/f5/6eadfcd3885ea85fe2a7c128315cc1bb7241e1987443d78c8fe712d03091/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:569511d3b58c8791ab4c2e1285575265991e6d8f8700c7be0e88f86cb0672094", size = 24122, upload-time = "2024-10-18T15:21:26.199Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/91/96cf928db8236f1bfab6ce15ad070dfdd02ed88261c2afafd4b43575e9e9/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15ab75ef81add55874e7ab7055e9c397312385bd9ced94920f2802310c930396", size = 23085, upload-time = "2024-10-18T15:21:27.029Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/cf/c9d56af24d56ea04daae7ac0940232d31d5a8354f2b457c6d856b2057d69/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3818cb119498c0678015754eba762e0d61e5b52d34c8b13d770f0719f7b1d79", size = 22978, upload-time = "2024-10-18T15:21:27.846Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/9f/8619835cd6a711d6272d62abb78c033bda638fdc54c4e7f4272cf1c0962b/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cdb82a876c47801bb54a690c5ae105a46b392ac6099881cdfb9f6e95e4014c6a", size = 24208, upload-time = "2024-10-18T15:21:28.744Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/bf/176950a1792b2cd2102b8ffeb5133e1ed984547b75db47c25a67d3359f77/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cabc348d87e913db6ab4aa100f01b08f481097838bdddf7c7a84b7575b7309ca", size = 23357, upload-time = "2024-10-18T15:21:29.545Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/4f/9a02c1d335caabe5c4efb90e1b6e8ee944aa245c1aaaab8e8a618987d816/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:444dcda765c8a838eaae23112db52f1efaf750daddb2d9ca300bcae1039adc5c", size = 23344, upload-time = "2024-10-18T15:21:30.366Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/55/c271b57db36f748f0e04a759ace9f8f759ccf22b4960c270c78a394f58be/MarkupSafe-3.0.2-cp313-cp313-win32.whl", hash = "sha256:bcf3e58998965654fdaff38e58584d8937aa3096ab5354d493c77d1fdd66d7a1", size = 15101, upload-time = "2024-10-18T15:21:31.207Z" },
+    { url = "https://files.pythonhosted.org/packages/29/88/07df22d2dd4df40aba9f3e402e6dc1b8ee86297dddbad4872bd5e7b0094f/MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:e6a2a455bd412959b57a172ce6328d2dd1f01cb2135efda2e4576e8a23fa3b0f", size = 15603, upload-time = "2024-10-18T15:21:32.032Z" },
+    { url = "https://files.pythonhosted.org/packages/62/6a/8b89d24db2d32d433dffcd6a8779159da109842434f1dd2f6e71f32f738c/MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b5a6b3ada725cea8a5e634536b1b01c30bcdcd7f9c6fff4151548d5bf6b3a36c", size = 14510, upload-time = "2024-10-18T15:21:33.625Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/06/a10f955f70a2e5a9bf78d11a161029d278eeacbd35ef806c3fd17b13060d/MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a904af0a6162c73e3edcb969eeeb53a63ceeb5d8cf642fade7d39e7963a22ddb", size = 12486, upload-time = "2024-10-18T15:21:34.611Z" },
+    { url = "https://files.pythonhosted.org/packages/34/cf/65d4a571869a1a9078198ca28f39fba5fbb910f952f9dbc5220afff9f5e6/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aa4e5faecf353ed117801a068ebab7b7e09ffb6e1d5e412dc852e0da018126c", size = 25480, upload-time = "2024-10-18T15:21:35.398Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/e3/90e9651924c430b885468b56b3d597cabf6d72be4b24a0acd1fa0e12af67/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0ef13eaeee5b615fb07c9a7dadb38eac06a0608b41570d8ade51c56539e509d", size = 23914, upload-time = "2024-10-18T15:21:36.231Z" },
+    { url = "https://files.pythonhosted.org/packages/66/8c/6c7cf61f95d63bb866db39085150df1f2a5bd3335298f14a66b48e92659c/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d16a81a06776313e817c951135cf7340a3e91e8c1ff2fac444cfd75fffa04afe", size = 23796, upload-time = "2024-10-18T15:21:37.073Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/35/cbe9238ec3f47ac9a7c8b3df7a808e7cb50fe149dc7039f5f454b3fba218/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6381026f158fdb7c72a168278597a5e3a5222e83ea18f543112b2662a9b699c5", size = 25473, upload-time = "2024-10-18T15:21:37.932Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/32/7621a4382488aa283cc05e8984a9c219abad3bca087be9ec77e89939ded9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:3d79d162e7be8f996986c064d1c7c817f6df3a77fe3d6859f6f9e7be4b8c213a", size = 24114, upload-time = "2024-10-18T15:21:39.799Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/80/0985960e4b89922cb5a0bac0ed39c5b96cbc1a536a99f30e8c220a996ed9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:131a3c7689c85f5ad20f9f6fb1b866f402c445b220c19fe4308c0b147ccd2ad9", size = 24098, upload-time = "2024-10-18T15:21:40.813Z" },
+    { url = "https://files.pythonhosted.org/packages/82/78/fedb03c7d5380df2427038ec8d973587e90561b2d90cd472ce9254cf348b/MarkupSafe-3.0.2-cp313-cp313t-win32.whl", hash = "sha256:ba8062ed2cf21c07a9e295d5b8a2a5ce678b913b45fdf68c32d95d6c1291e0b6", size = 15208, upload-time = "2024-10-18T15:21:41.814Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/65/6079a46068dfceaeabb5dcad6d674f5f5c61a6fa5673746f42a9f4c233b3/MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:e444a31f8db13eb18ada366ab3cf45fd4b31e4db1236a4448f68778c1d1a5a2f", size = 15739, upload-time = "2024-10-18T15:21:42.784Z" },
+]
+
+[[package]]
+name = "matplotlib-inline"
+version = "0.1.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "traitlets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/99/5b/a36a337438a14116b16480db471ad061c36c3694df7c2084a0da7ba538b7/matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90", size = 8159, upload-time = "2024-04-15T13:44:44.803Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8f/8e/9ad090d3553c280a8060fbf6e24dc1c0c29704ee7d1c372f0c174aa59285/matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca", size = 9899, upload-time = "2024-04-15T13:44:43.265Z" },
+]
+
+[[package]]
+name = "maturin"
+version = "1.8.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9a/08/ccb0f917722a35ab0d758be9bb5edaf645c3a3d6170061f10d396ecd273f/maturin-1.8.1.tar.gz", hash = "sha256:49cd964aabf59f8b0a6969f9860d2cdf194ac331529caae14c884f5659568857", size = 197397, upload-time = "2024-12-30T14:03:48.109Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4c/00/f34077315f34db8ad2ccf6bfe11b864ca27baab3a1320634da8e3cf89a48/maturin-1.8.1-py3-none-linux_armv6l.whl", hash = "sha256:7e590a23d9076b8a994f2e67bc63dc9a2d1c9a41b1e7b45ac354ba8275254e89", size = 7568415, upload-time = "2024-12-30T14:03:07.939Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/07/9219976135ce0cb32d2fa6ea5c6d0ad709013d9a17967312e149b98153a6/maturin-1.8.1-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:8d8251a95682c83ea60988c804b620c181911cd824aa107b4a49ac5333c92968", size = 14527816, upload-time = "2024-12-30T14:03:13.851Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/04/fa009a00903acdd1785d58322193140bfe358595347c39f315112dabdf9e/maturin-1.8.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:b9fc1a4354cac5e32c190410208039812ea88c4a36bd2b6499268ec49ef5de00", size = 7580446, upload-time = "2024-12-30T14:03:17.64Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/d4/414b2aab9bbfe88182b734d3aa1b4fef7d7701e50f6be48500378b8c8721/maturin-1.8.1-py3-none-manylinux_2_12_i686.manylinux2010_i686.musllinux_1_1_i686.whl", hash = "sha256:621e171c6b39f95f1d0df69a118416034fbd59c0f89dcaea8c2ea62019deecba", size = 7650535, upload-time = "2024-12-30T14:03:21.115Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/64/879418a8a0196013ec1fb19eada0781c04a30e8d6d9227e80f91275a4f5b/maturin-1.8.1-py3-none-manylinux_2_12_x86_64.manylinux2010_x86_64.musllinux_1_1_x86_64.whl", hash = "sha256:98f638739a5132962347871b85c91f525c9246ef4d99796ae98a2031e3df029f", size = 8006702, upload-time = "2024-12-30T14:03:24.318Z" },
+    { url = "https://files.pythonhosted.org/packages/39/c2/605829324f8371294f70303aca130682df75318958efed246873d3d604ab/maturin-1.8.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:f9f5c47521924b6e515cbc652a042fe5f17f8747445be9d931048e5d8ddb50a4", size = 7368164, upload-time = "2024-12-30T14:03:26.582Z" },
+    { url = "https://files.pythonhosted.org/packages/be/6c/30e136d397bb146b94b628c0ef7f17708281611b97849e2cf37847025ac7/maturin-1.8.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l.whl", hash = "sha256:0f4407c7353c31bfbb8cdeb82bc2170e474cbfb97b5ba27568f440c9d6c1fdd4", size = 7450889, upload-time = "2024-12-30T14:03:28.893Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/50/e1f5023512696d4e56096f702e2f68d6d9a30afe0a4eec82b0e27b8eb4e4/maturin-1.8.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.musllinux_1_1_ppc64le.whl", hash = "sha256:ec49cd70cad3c389946c6e2bc0bd50772a7fcb463040dd800720345897eec9bf", size = 9585819, upload-time = "2024-12-30T14:03:31.125Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/80/b24b5248d89d2e5982553900237a337ea098ca9297b8369ca2aa95549e0f/maturin-1.8.1-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c08767d794de8f8a11c5c8b1b47a4ff9fb6ae2d2d97679e27030f2f509c8c2a0", size = 10920801, upload-time = "2024-12-30T14:03:35.127Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/f4/8ede7a662fabf93456b44390a5ad22630e25fb5ddaecf787251071b2e143/maturin-1.8.1-py3-none-win32.whl", hash = "sha256:d678407713f3e10df33c5b3d7a343ec0551eb7f14d8ad9ba6febeb96f4e4c75c", size = 6873556, upload-time = "2024-12-30T14:03:37.913Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/22/757f093ed0e319e9648155b8c9d716765442bea5bc98ebc58ad4ad5b0524/maturin-1.8.1-py3-none-win_amd64.whl", hash = "sha256:a526f90fe0e5cb59ffb81f4ff547ddc42e823bbdeae4a31012c0893ca6dcaf46", size = 7823153, upload-time = "2024-12-30T14:03:40.33Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/f5/051413e04f6da25069db5e76759ecdb8cd2a8ab4a94045b5a3bf548c66fa/maturin-1.8.1-py3-none-win_arm64.whl", hash = "sha256:e95f077fd2ddd2f048182880eed458c308571a534be3eb2add4d3dac55bf57f4", size = 6552131, upload-time = "2024-12-30T14:03:45.203Z" },
+]
+
+[[package]]
+name = "mdit-py-plugins"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/03/a2ecab526543b152300717cf232bb4bb8605b6edb946c845016fa9c9c9fd/mdit_py_plugins-0.4.2.tar.gz", hash = "sha256:5f2cd1fdb606ddf152d37ec30e46101a60512bc0e5fa1a7002c36647b09e26b5", size = 43542, upload-time = "2024-09-09T20:27:49.564Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a7/f7/7782a043553ee469c1ff49cfa1cdace2d6bf99a1f333cf38676b3ddf30da/mdit_py_plugins-0.4.2-py3-none-any.whl", hash = "sha256:0c673c3f889399a33b95e88d2f0d111b4447bdfea7f237dab2d488f459835636", size = 55316, upload-time = "2024-09-09T20:27:48.397Z" },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
+]
+
+[[package]]
+name = "myst-parser"
+version = "4.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "docutils" },
+    { name = "jinja2" },
+    { name = "markdown-it-py" },
+    { name = "mdit-py-plugins" },
+    { name = "pyyaml" },
+    { name = "sphinx" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/85/55/6d1741a1780e5e65038b74bce6689da15f620261c490c3511eb4c12bac4b/myst_parser-4.0.0.tar.gz", hash = "sha256:851c9dfb44e36e56d15d05e72f02b80da21a9e0d07cba96baf5e2d476bb91531", size = 93858, upload-time = "2024-08-05T14:02:45.798Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ca/b4/b036f8fdb667587bb37df29dc6644681dd78b7a2a6321a34684b79412b28/myst_parser-4.0.0-py3-none-any.whl", hash = "sha256:b9317997552424448c6096c2558872fdb6f81d3ecb3a40ce84a7518798f3f28d", size = 84563, upload-time = "2024-08-05T14:02:43.767Z" },
+]
+
+[[package]]
+name = "nanoarrow"
+version = "0.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/70/29/7b1ab53ed83fb70c80571a2487070113881b54067bda72cd87affc360ccc/nanoarrow-0.8.0.tar.gz", hash = "sha256:aa63e01e799380ec4f8adab88f4faac8d27bfb725fe1009fe73d7ce4efd9f7f6", size = 3508214, upload-time = "2026-02-10T03:36:02.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/27/7aece654f60453026fe36985291853243485ac41dfb9a69e421cdd2271fe/nanoarrow-0.8.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c5ea89651e49afa2674557005938963cb849d3c65f2f22ac6701c281a7e0244d", size = 834242, upload-time = "2026-02-10T03:33:40.25Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/63/2960ea0b1bfeec0381f01e6f7652c104683444b7c9902f42907c911630e9/nanoarrow-0.8.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:7861371960d09adb377d05da73190103178410dc014369779734f2dbff0ac0ad", size = 741604, upload-time = "2026-02-10T03:33:29.29Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/6d/9de1da912da0356169836af8ccecac1664ee4d603b65b7067a27b85ebaf2/nanoarrow-0.8.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:db62ea708c873980eeb0e711fa6162120d1e372b2404bb79ead69f9aa0560192", size = 970784, upload-time = "2026-02-10T03:32:30.293Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/a9/5e62e7f1b9b41ff86d6025c57636246e1e8702b0cba322fab0272c3cc0f8/nanoarrow-0.8.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:178cc6d097b988d13354c6a48a873b4496c7bcedce43c55c6770186b6d1b4845", size = 1018693, upload-time = "2026-02-10T03:32:51.819Z" },
+    { url = "https://files.pythonhosted.org/packages/68/4d/70eb2a672ca81d4385069eb6fc70fa6ab44a029d18df4da48e6691e6d8ba/nanoarrow-0.8.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f5715e68cc17ccec23e1fcb9e828281bdf6afa11d78c8b0cd9a343c1ac48fb1d", size = 1145087, upload-time = "2026-02-10T03:32:52.801Z" },
+    { url = "https://files.pythonhosted.org/packages/83/0e/02698dc0a4af10670822b949cdf0999134152347138d553d440b8f14f471/nanoarrow-0.8.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:958572c48d53f79693f30070fd4531f4d9643aa62e03ea1336ea2fc69e9e964d", size = 989528, upload-time = "2026-02-10T03:32:31.632Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/b4/1a5f3c10ad667ac9f0dfbde2416124025bdaf963d3915968b1ae6f5f9e85/nanoarrow-0.8.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:dc1a1fe64c6b1177314eb4c36d9037268257d6699b052f9462a99e056703f4cb", size = 1159183, upload-time = "2026-02-10T03:32:54.157Z" },
+    { url = "https://files.pythonhosted.org/packages/22/28/8c314b5f0bb5c27d1c6164fd8f90d52f02e08defc2d8880466610ecfefdc/nanoarrow-0.8.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:feae14c938fe2192f1bea1d0f8e87be9446703d2997bbd555c949df36eed6d32", size = 1031646, upload-time = "2026-02-10T03:32:55.228Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/98/3314109e7064f84e25cfc6b7d460177d92dab7eabd149a5b78c1463ad797/nanoarrow-0.8.0-cp310-cp310-win32.whl", hash = "sha256:491a8aedbbbe4dd06660d641762ad9cb9743c39b96259f7795a4ac22cc046f18", size = 566048, upload-time = "2026-02-10T03:35:53.806Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/f1/602c7be675383f725382f4eed0019ba840a8354d2eb732e56e336245182f/nanoarrow-0.8.0-cp310-cp310-win_amd64.whl", hash = "sha256:1c3b2c6ff46c9cd37350b9855829c0eed1256311e4fea0fcbc8aa9c2080b80ca", size = 658209, upload-time = "2026-02-10T03:33:50.792Z" },
+    { url = "https://files.pythonhosted.org/packages/22/89/3ba932b982d26c7f38c1c54cf97dde05ad141045c106b6f1664151c22387/nanoarrow-0.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:31445b4cb891f77cb0261a0790222c9584c122f6d851e5818bc50a2678ae7bc4", size = 832763, upload-time = "2026-02-10T03:33:41.41Z" },
+    { url = "https://files.pythonhosted.org/packages/91/1e/70ff64e9ecbf2744aa7527f721bed8f5e549dabbe1c02ceb6afafa651ba5/nanoarrow-0.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5a579bd43011d2f5cb5a9ba3a7352bd4e3783f3adedb59b93540af71949433cf", size = 739843, upload-time = "2026-02-10T03:33:30.318Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/06/3d88f0fb29b7343426b035f21d90d61c872b83243895e9548d880e08f60a/nanoarrow-0.8.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1a910eaae1c60838ea9d11d247aba88cb17c02b67430ec88569a1ae68a7bb25", size = 969064, upload-time = "2026-02-10T03:32:32.669Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/aa/e5655fd8d8a6defb0bed22e2de695f974a759798f10775de19f5a924156a/nanoarrow-0.8.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8520fe9ab310d855376e4faed742f683390bbab7b5dd230da398cb79f3deb29", size = 1018919, upload-time = "2026-02-10T03:32:56.317Z" },
+    { url = "https://files.pythonhosted.org/packages/94/16/db9fedc1d916ba6f66537a992144fb08ddc2495dd5b61a4a2710e5518ec4/nanoarrow-0.8.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:78a5cbd6f3664e552280688dcae765424587d7392577774f7cd7191f654e71ab", size = 1133563, upload-time = "2026-02-10T03:32:58.884Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/10/68374d91b1a55f38e4f96ef0f32ed6fd72826aeae6e3c7de45b635937244/nanoarrow-0.8.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8412b5594cef5e86f35a4a3eb05c25842c38f357926d13610b54dc1d99ffa2df", size = 991138, upload-time = "2026-02-10T03:32:34.182Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/eb/ec98442b8b03ce2e9c3150b6ead5c2475253c462ab2b54808be52f6596bd/nanoarrow-0.8.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:d6adfdc1129d3351e6a64e09749c2460270a49eea46a9badff16a15f31104e59", size = 1153814, upload-time = "2026-02-10T03:33:00.013Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/74/a3573db8c4b1de39b2ccca439479e408d0b40fd411c501299c3836f43c95/nanoarrow-0.8.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ebe2b9a7a25b3cc0f86f215e12f67bdfe8925a112ceda86c82d7633fc14fc52d", size = 1032100, upload-time = "2026-02-10T03:33:01.048Z" },
+    { url = "https://files.pythonhosted.org/packages/24/29/df629c41d2246fb7d0ad5f191296e5957389774a83f8097357e3073cc0cf/nanoarrow-0.8.0-cp311-cp311-win32.whl", hash = "sha256:196b561557a26295862b181f204790c9fd308bdc78df30247b0e4c0b775b4a48", size = 563662, upload-time = "2026-02-10T03:35:56.048Z" },
+    { url = "https://files.pythonhosted.org/packages/17/b8/54001df497f4fdbf7121db2d61090bf9986298a9eba4ed2cbfc9aad414f0/nanoarrow-0.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:2cc015aa3905c3f0b798570975297730d1428a23768805a23202bc48d0eaabcd", size = 658770, upload-time = "2026-02-10T03:33:51.924Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/20/02ef20b340c7f765192309b87685e56c88cda203a4effac04b5d9347626a/nanoarrow-0.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c5f27749e2b5218e69b484e01f4c08007386e1333fbb110f400354bde0612799", size = 840224, upload-time = "2026-02-10T03:33:42.615Z" },
+    { url = "https://files.pythonhosted.org/packages/94/84/b1b5d807483f882b7309799d96ec122daaa69890d80c2994f476d4e07c51/nanoarrow-0.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c84efa8efba413a1cecee7d10d9e5dfbf7651026538449c5d554c1af19932791", size = 732615, upload-time = "2026-02-10T03:33:31.79Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/9e/51a6b437cf173728e03e16e32aee865b36f2043478f4e2688ea2187f63ad/nanoarrow-0.8.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0548987b4d32536768e092478e3fe8968f35f9624354e30efa622e32c5d87944", size = 955080, upload-time = "2026-02-10T03:32:35.741Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/12/9fed89e0d76ad8c376fe74d12b7e1a7cbcb75ff8ebb242264a1d980f5529/nanoarrow-0.8.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ae9d43a358cd6f13e9569c010de36e7e3e98b7da059bdf83438d5e7ce2f77f4", size = 1009196, upload-time = "2026-02-10T03:33:02.057Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/1a/eb1a7036f2dbb30748eda66d479319cfe165eea6e6748c94488c484be7f4/nanoarrow-0.8.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cc83b0b5636a3e558588c0eb6e3c32e295d0296909a08f3b4af17c81a2db8bf6", size = 1119470, upload-time = "2026-02-10T03:33:03.696Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/c4/d2178bccb12aaeef5843c90e671faf1a6247bdb8b4d64454fc471e97eb71/nanoarrow-0.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:29e0783f9ff2b802cd883a41f5cc009f70efea519efcc710db7d143819d1d315", size = 979664, upload-time = "2026-02-10T03:32:37.594Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/34/f52319f9304659a5ed5db125b635316ce6d042767cde257fcf9c6a7f80e1/nanoarrow-0.8.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:20d07a0ac666e9563e132a2097de5e9fa26b4781c0f8edfbdce0da866c22faba", size = 1144197, upload-time = "2026-02-10T03:33:04.824Z" },
+    { url = "https://files.pythonhosted.org/packages/76/45/3b56702078b7515ff9b74b215ea983358df11140a6c3b7056f55551828da/nanoarrow-0.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3706258dc89231ef27dee50a26d53ec96dba85dbafa8d6637276bd212be4bc1b", size = 1026594, upload-time = "2026-02-10T03:33:06.055Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/f6/fe382bf2770a7e522f132e5310350fb0aecc3023f876d02265a7f40c7c79/nanoarrow-0.8.0-cp312-cp312-win32.whl", hash = "sha256:6ab8bd2db59388c6bd131c4d9e2649a6626ffe7434084cee6c22fdfbedfeda1b", size = 569212, upload-time = "2026-02-10T03:35:57.767Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/38/589e3c41490a742c639221eea655cf5d0a5972242efab8040a0c904a7dba/nanoarrow-0.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:22c3443ebc0b988dff06cb88d03cf9accbf85fdde905fb7d76b6e001561855a8", size = 645746, upload-time = "2026-02-10T03:33:53.147Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/af/b7df299b87348d396d049ef9fab6bef76d29c63288e5b54f752b97f7b3df/nanoarrow-0.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:605c7af9130599c40264d14c295dcc2a779402183c13f4189e7475b9dc52613a", size = 838886, upload-time = "2026-02-10T03:33:43.624Z" },
+    { url = "https://files.pythonhosted.org/packages/07/ec/02fd6979c35e347e6d5cf57757616a6d599d4ac6808bf0a37ca334639d07/nanoarrow-0.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:64d49118b5477bef8af5fba0b66ad032e1f9861f70d210c262b5393e5b62f47d", size = 730110, upload-time = "2026-02-10T03:33:32.771Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/04/64beb88b036a9d20d0f8be0846d9db7912c3332f3969ecd66144a4fd2021/nanoarrow-0.8.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c1b64aa3739efbe85e775ba5733e37713521386d3014c866f9065815b7387114", size = 951234, upload-time = "2026-02-10T03:32:39.119Z" },
+    { url = "https://files.pythonhosted.org/packages/53/3d/1850ef02a632fa5d65319c1155c326982896828ffbfd88c8fc44ee1a23aa/nanoarrow-0.8.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9b4a363e697b3e852fd1f374840df22aaac0323fb8d0ab24a50c3ea1090b4594", size = 1005525, upload-time = "2026-02-10T03:33:07.588Z" },
+    { url = "https://files.pythonhosted.org/packages/94/4b/3c671773e6dcce1784b4e42d0e5f5942fee49f6ddf7ae2567d36b3b4248e/nanoarrow-0.8.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:381a2a65b0bcfe36b267d506072a3a5c83b8326dfbb50dff2d7f55ac25159f69", size = 1120370, upload-time = "2026-02-10T03:33:08.715Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/79/bc49e7518ba9e5b377ca3670ceba5949cb3e20363ba7f091df62d84c4edd/nanoarrow-0.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cbca73fcb5c2c753ddac3695774e47cbed3b3bc64dba34866f3056e33a2a0ac2", size = 977504, upload-time = "2026-02-10T03:32:40.349Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/cb/bb57665133351b042b4c25d549b21fc9bb9f56a3c5f4e5d561c41f5d705c/nanoarrow-0.8.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:a4539c5767723cf0c0a21b401acc7d706ca7fd84302b6be514eeb5b8ee230903", size = 1141114, upload-time = "2026-02-10T03:33:10.575Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/a0/2792c5e160d56b5abe782228a963ae3d7477727bf950f6b990ebcfed8f49/nanoarrow-0.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:be0899058f66d3b7e4e4b7cfe125e95625e109b4513a81fd9bc098abef55a381", size = 1025080, upload-time = "2026-02-10T03:33:11.661Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/45/5209dad8a3e4f460ca7d7d314ff34ef6426ced873655df1a469b0f91e01d/nanoarrow-0.8.0-cp313-cp313-win32.whl", hash = "sha256:7c227e1e68926b0ccde7336211dd7a11f8983098b3698ee548756bdb778b016d", size = 568315, upload-time = "2026-02-10T03:35:58.998Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/41/b2ad2b541b94422e4091a96192deb5c98d5a6b4c44ade37f5bd6d3efd83f/nanoarrow-0.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:1730cb374739459a925c590c32e07e213c9c6ddd2e12f44547e2bd70d29a7a9b", size = 644676, upload-time = "2026-02-10T03:33:54.301Z" },
+    { url = "https://files.pythonhosted.org/packages/87/7a/5e2d1005f98cca18ebb289cffbb55fe0895465349affbe4cfb1321de9ad0/nanoarrow-0.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:dfa96964d2ccd762a5cb8e28eb0439b6c05b4f5090c4ca2d0207c32d8093cda5", size = 863391, upload-time = "2026-02-10T03:33:44.864Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/63/e45fd81a0a35bc782161801e2bec03794184504eedc7760fa79b33e333ca/nanoarrow-0.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:714b21daefe495d7cdd6dad34d3409ae42a77f4ef6bf648f4688d0abef8924c1", size = 779228, upload-time = "2026-02-10T03:33:33.9Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/a0/f8173511a74b48d2c3b88f7a337faaca8c01b3255a53b065db171e63fa85/nanoarrow-0.8.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3777298c348b268b3490504d9ba099dc6eede702bb9f337360dec6412944a187", size = 967376, upload-time = "2026-02-10T03:32:41.885Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/cf/4c885fb3a605a17607cfd8cc9f7b23aba19f9826c3bfe4dcf300b0a8e48c/nanoarrow-0.8.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1e31ee3e3b1e94eccc4cc034f02956ecd15b4ae33ae8a1f999704871ea3b6dec", size = 1014554, upload-time = "2026-02-10T03:33:12.916Z" },
+    { url = "https://files.pythonhosted.org/packages/43/07/190f7b4746b0d691dbea0f4c36c34012d916d3579af7ae83254a1d9f6f26/nanoarrow-0.8.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7bda72e24dd8e2abb3f445f129a422809d788db9cfbbfd247c32f5620e03128c", size = 1115168, upload-time = "2026-02-10T03:33:14.533Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/58/abd834fc30abcb053642e5935911be9a442c6c5d48c7c6f855c8de2f329d/nanoarrow-0.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:d2ee1a27a7210c8eba6ac6e8ab70b598da238348b125b53b16d9e1ae0313addc", size = 984855, upload-time = "2026-02-10T03:32:43.422Z" },
+    { url = "https://files.pythonhosted.org/packages/18/62/ca4977054d7267ce3756409425b82fe1ea916871555f2512872ec8f7e0d4/nanoarrow-0.8.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:91466de52617b25dff7349dbf18cc612ce5ec35d09f025b37ea60be819808be8", size = 1122634, upload-time = "2026-02-10T03:33:15.699Z" },
+    { url = "https://files.pythonhosted.org/packages/16/b3/75b71c46a3950b06ae3f63cb426ba92a9ebfe2aaa216845c8a4cc56b1bb7/nanoarrow-0.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4204e2b5f9cf895bcecfe432b03c346ec2bdadfda0174c8ab195acc6b4794986", size = 1022700, upload-time = "2026-02-10T03:33:16.802Z" },
+    { url = "https://files.pythonhosted.org/packages/89/12/3a3337b17de7c3c3ff1bfc09a01c75d8f463e40e6850c8f5e42d4240c9a7/nanoarrow-0.8.0-cp313-cp313t-win32.whl", hash = "sha256:1fdc0c2508b53a83c9814fdcd2d4bac6d98ea989fb363e0d88d329a8cddd7d50", size = 624159, upload-time = "2026-02-10T03:36:00.135Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/a8/80c9ed4718e253e7f19320fcd69ca8c7c9ed87d32848d3da97afee3d8b6b/nanoarrow-0.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:b73748e0f39cd8dc1ce33eaad3215f2aff6aebb03e659c26d2a8df9277e7e509", size = 712076, upload-time = "2026-02-10T03:33:55.345Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/6f/167cbe632266e8e84d8965262a5e3121e073f593140701bc9be06062f8da/nanoarrow-0.8.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:51e9609efad27191e6506b9c224c90ae49a0c72f641c8094f168d4694b45a3ff", size = 775361, upload-time = "2026-02-10T03:33:47.176Z" },
+    { url = "https://files.pythonhosted.org/packages/32/94/762f77b6b0fa7a6787316af297a239b59b1f36e37122b0770ff3cfe61e3d/nanoarrow-0.8.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:185726c467211592ba47933949cb62bc6e1797eefdd760a145b241c44377fba9", size = 692089, upload-time = "2026-02-10T03:33:36.46Z" },
+    { url = "https://files.pythonhosted.org/packages/27/c3/75ac260a7e5cd00b72c35248897bc6f899d4e65457141160978ce6258601/nanoarrow-0.8.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c11edd20949a874afb0e50f08402ea3f5c5206d70ec7ed2c27d8064a36222038", size = 903435, upload-time = "2026-02-10T03:32:47.413Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ce/26d6673123afe22ad04b68ca90f800133f75c55792355959037e81ddc8a2/nanoarrow-0.8.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c2b31fdab6b5fb3d3c10f7597e16698c9d3db1bac4c645341e6e36320b78642", size = 948741, upload-time = "2026-02-10T03:33:22.331Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/ad/f3b7b205ff1a2e755dcc90e7df4ede0f2a7eb6d217f2ab626ef2b00ee0e3/nanoarrow-0.8.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:df0f118c7ba1036adf032d909674cb925a37ceeed83756c43d27ff9ad225b9e1", size = 1055379, upload-time = "2026-02-10T03:33:23.481Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/13/623183d5df76a4e3835af9e42a6d63dcc46d3d3e22d846d48b4458cf5cfb/nanoarrow-0.8.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:827b3e3f8ba81c3b2a9de72dd6cddd74afc7e4cf03aacb0b7f6f2ac06747ae88", size = 591477, upload-time = "2026-02-10T03:33:57.652Z" },
+    { url = "https://files.pythonhosted.org/packages/96/97/6265c84c3c865d2fc1fd56954c60a9386e03ab9c9db11c5f2d57fafa1077/nanoarrow-0.8.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:a765f955a6bfb989af1d37fa3d0c4f89c242fe12088b5e787748f995a5fa13fc", size = 775344, upload-time = "2026-02-10T03:33:48.237Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/f2/daaf03224b88cb66b1a6a19da371386f875e95208a42c73b109f1d273166/nanoarrow-0.8.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:b2023fa0d5d6992fd8a5a04452c559817c9805aea7391fa46291aaf381a6aa19", size = 692002, upload-time = "2026-02-10T03:33:37.991Z" },
+    { url = "https://files.pythonhosted.org/packages/55/53/c058976db13e18106737a1fddf192e45022375628a38c2caaa51a9934ada/nanoarrow-0.8.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:96c7d723b5615e2e9c5f7ba7b5af8d80ba90ecf9871ba005941ac80355ef556a", size = 904133, upload-time = "2026-02-10T03:32:49.155Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/3f/002a228af17ecba07ca9ff47628e97c73e336a72fd18ad5d78534a6497d8/nanoarrow-0.8.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c22b03d1ceca21aace2c8053ed43cac5566e69dd1660708783fe0e84dd35693e", size = 949714, upload-time = "2026-02-10T03:33:24.542Z" },
+    { url = "https://files.pythonhosted.org/packages/28/5e/3bad2cfeb03d0682b93f13640ede98eb59cf15b4d868d5c9745118f59eb2/nanoarrow-0.8.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:999f906c297203b5430dc4e79e662301f5ab02a793b6fc67973ee3c0518fb936", size = 1056467, upload-time = "2026-02-10T03:33:25.617Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/e5/c740ea047b5ada76175327360d0406ae283159cb1745cbcb51443d90d53b/nanoarrow-0.8.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:8c5529abc4e75b7764ffc6d2fbabd0c676f75ca2ece71a8671c4724207cfb697", size = 591889, upload-time = "2026-02-10T03:33:58.891Z" },
+]
+
+[[package]]
+name = "nodeenv"
+version = "1.9.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/16/fc88b08840de0e0a72a2f9d8c6bae36be573e475a6326ae854bcc549fc45/nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f", size = 47437, upload-time = "2024-06-04T18:44:11.171Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d2/1d/1b658dbd2b9fa9c4c9f32accbfc0205d532c8c6194dc0f2a4c0428e7128a/nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9", size = 22314, upload-time = "2024-06-04T18:44:08.352Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.2.1"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.12' and python_full_version < '3.14'",
+    "python_full_version == '3.11.*'",
+    "python_full_version < '3.11'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f2/a5/fdbf6a7871703df6160b5cf3dd774074b086d278172285c52c2758b76305/numpy-2.2.1.tar.gz", hash = "sha256:45681fd7128c8ad1c379f0ca0776a8b0c6583d2f69889ddac01559dfe4390918", size = 20227662, upload-time = "2024-12-21T22:49:36.523Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/c4/5588367dc9f91e1a813beb77de46ea8cab13f778e1b3a0e661ab031aba44/numpy-2.2.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5edb4e4caf751c1518e6a26a83501fda79bff41cc59dac48d70e6d65d4ec4440", size = 21213214, upload-time = "2024-12-21T20:29:57.832Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/8b/32dd9f08419023a4cf856c5ad0b4eba9b830da85eafdef841a104c4fc05a/numpy-2.2.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:aa3017c40d513ccac9621a2364f939d39e550c542eb2a894b4c8da92b38896ab", size = 14352248, upload-time = "2024-12-21T20:30:32.954Z" },
+    { url = "https://files.pythonhosted.org/packages/84/2d/0e895d02940ba6e12389f0ab5cac5afcf8dc2dc0ade4e8cad33288a721bd/numpy-2.2.1-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:61048b4a49b1c93fe13426e04e04fdf5a03f456616f6e98c7576144677598675", size = 5391007, upload-time = "2024-12-21T20:30:46.067Z" },
+    { url = "https://files.pythonhosted.org/packages/11/b9/7f1e64a0d46d9c2af6d17966f641fb12d5b8ea3003f31b2308f3e3b9a6aa/numpy-2.2.1-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:7671dc19c7019103ca44e8d94917eba8534c76133523ca8406822efdd19c9308", size = 6926174, upload-time = "2024-12-21T20:31:07.682Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/8c/043fa4418bc9364e364ab7aba8ff6ef5f6b9171ade22de8fbcf0e2fa4165/numpy-2.2.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4250888bcb96617e00bfa28ac24850a83c9f3a16db471eca2ee1f1714df0f957", size = 14330914, upload-time = "2024-12-21T20:31:31.641Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/b6/d8110985501ca8912dfc1c3bbef99d66e62d487f72e46b2337494df77364/numpy-2.2.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a7746f235c47abc72b102d3bce9977714c2444bdfaea7888d241b4c4bb6a78bf", size = 16379607, upload-time = "2024-12-21T20:32:06.43Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/57/bdca9fb8bdaa810c3a4ff2eb3231379b77f618a7c0d24be9f7070db50775/numpy-2.2.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:059e6a747ae84fce488c3ee397cee7e5f905fd1bda5fb18c66bc41807ff119b2", size = 15541760, upload-time = "2024-12-21T20:32:46.421Z" },
+    { url = "https://files.pythonhosted.org/packages/97/55/3b9147b3cbc3b6b1abc2a411dec5337a46c873deca0dd0bf5bef9d0579cc/numpy-2.2.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f62aa6ee4eb43b024b0e5a01cf65a0bb078ef8c395e8713c6e8a12a697144528", size = 18168476, upload-time = "2024-12-21T22:25:15.062Z" },
+    { url = "https://files.pythonhosted.org/packages/00/e7/7c2cde16c9b87a8e14fdd262ca7849c4681cf48c8a774505f7e6f5e3b643/numpy-2.2.1-cp310-cp310-win32.whl", hash = "sha256:48fd472630715e1c1c89bf1feab55c29098cb403cc184b4859f9c86d4fcb6a95", size = 6570985, upload-time = "2024-12-21T22:25:31.2Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/a8/554b0e99fc4ac11ec481254781a10da180d0559c2ebf2c324232317349ee/numpy-2.2.1-cp310-cp310-win_amd64.whl", hash = "sha256:b541032178a718c165a49638d28272b771053f628382d5e9d1c93df23ff58dbf", size = 12913384, upload-time = "2024-12-21T22:25:54.717Z" },
+    { url = "https://files.pythonhosted.org/packages/59/14/645887347124e101d983e1daf95b48dc3e136bf8525cb4257bf9eab1b768/numpy-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:40f9e544c1c56ba8f1cf7686a8c9b5bb249e665d40d626a23899ba6d5d9e1484", size = 21217379, upload-time = "2024-12-21T22:26:52.153Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/fd/2279000cf29f58ccfd3778cbf4670dfe3f7ce772df5e198c5abe9e88b7d7/numpy-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f9b57eaa3b0cd8db52049ed0330747b0364e899e8a606a624813452b8203d5f7", size = 14388520, upload-time = "2024-12-21T22:27:29.302Z" },
+    { url = "https://files.pythonhosted.org/packages/58/b0/034eb5d5ba12d66ab658ff3455a31f20add0b78df8203c6a7451bd1bee21/numpy-2.2.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:bc8a37ad5b22c08e2dbd27df2b3ef7e5c0864235805b1e718a235bcb200cf1cb", size = 5389286, upload-time = "2024-12-21T22:27:42.369Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/69/6f3cccde92e82e7835fdb475c2bf439761cbf8a1daa7c07338e1e132dfec/numpy-2.2.1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:9036d6365d13b6cbe8f27a0eaf73ddcc070cae584e5ff94bb45e3e9d729feab5", size = 6930345, upload-time = "2024-12-21T22:28:02.349Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/72/1cd38e91ab563e67f584293fcc6aca855c9ae46dba42e6b5ff4600022899/numpy-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:51faf345324db860b515d3f364eaa93d0e0551a88d6218a7d61286554d190d73", size = 14335748, upload-time = "2024-12-21T22:28:33.546Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/d4/f999444e86986f3533e7151c272bd8186c55dda554284def18557e013a2a/numpy-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:38efc1e56b73cc9b182fe55e56e63b044dd26a72128fd2fbd502f75555d92591", size = 16391057, upload-time = "2024-12-21T22:29:06.549Z" },
+    { url = "https://files.pythonhosted.org/packages/99/7b/85cef6a3ae1b19542b7afd97d0b296526b6ef9e3c43ea0c4d9c4404fb2d0/numpy-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:31b89fa67a8042e96715c68e071a1200c4e172f93b0fbe01a14c0ff3ff820fc8", size = 15556943, upload-time = "2024-12-21T22:30:03.919Z" },
+    { url = "https://files.pythonhosted.org/packages/69/7e/b83cc884c3508e91af78760f6b17ab46ad649831b1fa35acb3eb26d9e6d2/numpy-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4c86e2a209199ead7ee0af65e1d9992d1dce7e1f63c4b9a616500f93820658d0", size = 18180785, upload-time = "2024-12-21T22:30:41.924Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/9f/eb4a9a38867de059dcd4b6e18d47c3867fbd3795d4c9557bb49278f94087/numpy-2.2.1-cp311-cp311-win32.whl", hash = "sha256:b34d87e8a3090ea626003f87f9392b3929a7bbf4104a05b6667348b6bd4bf1cd", size = 6568983, upload-time = "2024-12-21T22:30:56.619Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/1e/be3b9f3073da2f8c7fa361fcdc231b548266b0781029fdbaf75eeab997fd/numpy-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:360137f8fb1b753c5cde3ac388597ad680eccbbbb3865ab65efea062c4a1fd16", size = 12917260, upload-time = "2024-12-21T22:31:22.151Z" },
+    { url = "https://files.pythonhosted.org/packages/62/12/b928871c570d4a87ab13d2cc19f8817f17e340d5481621930e76b80ffb7d/numpy-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:694f9e921a0c8f252980e85bce61ebbd07ed2b7d4fa72d0e4246f2f8aa6642ab", size = 20909861, upload-time = "2024-12-21T22:32:05.145Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/c3/59df91ae1d8ad7c5e03efd63fd785dec62d96b0fe56d1f9ab600b55009af/numpy-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3683a8d166f2692664262fd4900f207791d005fb088d7fdb973cc8d663626faa", size = 14095776, upload-time = "2024-12-21T22:32:37.312Z" },
+    { url = "https://files.pythonhosted.org/packages/af/4e/8ed5868efc8e601fb69419644a280e9c482b75691466b73bfaab7d86922c/numpy-2.2.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:780077d95eafc2ccc3ced969db22377b3864e5b9a0ea5eb347cc93b3ea900315", size = 5126239, upload-time = "2024-12-21T22:32:59.288Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/74/dd0bbe650d7bc0014b051f092f2de65e34a8155aabb1287698919d124d7f/numpy-2.2.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:55ba24ebe208344aa7a00e4482f65742969a039c2acfcb910bc6fcd776eb4355", size = 6659296, upload-time = "2024-12-21T22:33:11.456Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/11/4ebd7a3f4a655764dc98481f97bd0a662fb340d1001be6050606be13e162/numpy-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b1d07b53b78bf84a96898c1bc139ad7f10fda7423f5fd158fd0f47ec5e01ac7", size = 14047121, upload-time = "2024-12-21T22:33:47.216Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/a7/c1f1d978166eb6b98ad009503e4d93a8c1962d0eb14a885c352ee0276a54/numpy-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5062dc1a4e32a10dc2b8b13cedd58988261416e811c1dc4dbdea4f57eea61b0d", size = 16096599, upload-time = "2024-12-21T22:34:27.868Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/6d/0e22afd5fcbb4d8d0091f3f46bf4e8906399c458d4293da23292c0ba5022/numpy-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:fce4f615f8ca31b2e61aa0eb5865a21e14f5629515c9151850aa936c02a1ee51", size = 15243932, upload-time = "2024-12-21T22:35:05.318Z" },
+    { url = "https://files.pythonhosted.org/packages/03/39/e4e5832820131ba424092b9610d996b37e5557180f8e2d6aebb05c31ae54/numpy-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:67d4cda6fa6ffa073b08c8372aa5fa767ceb10c9a0587c707505a6d426f4e046", size = 17861032, upload-time = "2024-12-21T22:35:37.77Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/8a/3794313acbf5e70df2d5c7d2aba8718676f8d054a05abe59e48417fb2981/numpy-2.2.1-cp312-cp312-win32.whl", hash = "sha256:32cb94448be47c500d2c7a95f93e2f21a01f1fd05dd2beea1ccd049bb6001cd2", size = 6274018, upload-time = "2024-12-21T22:35:51.117Z" },
+    { url = "https://files.pythonhosted.org/packages/17/c1/c31d3637f2641e25c7a19adf2ae822fdaf4ddd198b05d79a92a9ce7cb63e/numpy-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:ba5511d8f31c033a5fcbda22dd5c813630af98c70b2661f2d2c654ae3cdfcfc8", size = 12613843, upload-time = "2024-12-21T22:36:22.816Z" },
+    { url = "https://files.pythonhosted.org/packages/20/d6/91a26e671c396e0c10e327b763485ee295f5a5a7a48c553f18417e5a0ed5/numpy-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f1d09e520217618e76396377c81fba6f290d5f926f50c35f3a5f72b01a0da780", size = 20896464, upload-time = "2024-12-21T22:37:01.393Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/40/5792ccccd91d45e87d9e00033abc4f6ca8a828467b193f711139ff1f1cd9/numpy-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3ecc47cd7f6ea0336042be87d9e7da378e5c7e9b3c8ad0f7c966f714fc10d821", size = 14111350, upload-time = "2024-12-21T22:37:35.152Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/2a/fb0a27f846cb857cef0c4c92bef89f133a3a1abb4e16bba1c4dace2e9b49/numpy-2.2.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f419290bc8968a46c4933158c91a0012b7a99bb2e465d5ef5293879742f8797e", size = 5111629, upload-time = "2024-12-21T22:37:51.291Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/e5/8e81bb9d84db88b047baf4e8b681a3e48d6390bc4d4e4453eca428ecbb49/numpy-2.2.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:5b6c390bfaef8c45a260554888966618328d30e72173697e5cabe6b285fb2348", size = 6645865, upload-time = "2024-12-21T22:38:03.738Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1a/a90ceb191dd2f9e2897c69dde93ccc2d57dd21ce2acbd7b0333e8eea4e8d/numpy-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:526fc406ab991a340744aad7e25251dd47a6720a685fa3331e5c59fef5282a59", size = 14043508, upload-time = "2024-12-21T22:38:41.854Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/5a/e572284c86a59dec0871a49cd4e5351e20b9c751399d5f1d79628c0542cb/numpy-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f74e6fdeb9a265624ec3a3918430205dff1df7e95a230779746a6af78bc615af", size = 16094100, upload-time = "2024-12-21T22:39:12.904Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/2c/a79d24f364788386d85899dd280a94f30b0950be4b4a545f4fa4ed1d4ca7/numpy-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:53c09385ff0b72ba79d8715683c1168c12e0b6e84fb0372e97553d1ea91efe51", size = 15239691, upload-time = "2024-12-21T22:39:48.32Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/79/1e20fd1c9ce5a932111f964b544facc5bb9bde7865f5b42f00b4a6a9192b/numpy-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f3eac17d9ec51be534685ba877b6ab5edc3ab7ec95c8f163e5d7b39859524716", size = 17856571, upload-time = "2024-12-21T22:40:22.575Z" },
+    { url = "https://files.pythonhosted.org/packages/be/5b/cc155e107f75d694f562bdc84a26cc930569f3dfdfbccb3420b626065777/numpy-2.2.1-cp313-cp313-win32.whl", hash = "sha256:9ad014faa93dbb52c80d8f4d3dcf855865c876c9660cb9bd7553843dd03a4b1e", size = 6270841, upload-time = "2024-12-21T22:45:15.101Z" },
+    { url = "https://files.pythonhosted.org/packages/44/be/0e5cd009d2162e4138d79a5afb3b5d2341f0fe4777ab6e675aa3d4a42e21/numpy-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:164a829b6aacf79ca47ba4814b130c4020b202522a93d7bff2202bfb33b61c60", size = 12606618, upload-time = "2024-12-21T22:45:47.227Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/87/04ddf02dd86fb17c7485a5f87b605c4437966d53de1e3745d450343a6f56/numpy-2.2.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4dfda918a13cc4f81e9118dea249e192ab167a0bb1966272d5503e39234d694e", size = 20921004, upload-time = "2024-12-21T22:40:58.532Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/3e/d0e9e32ab14005425d180ef950badf31b862f3839c5b927796648b11f88a/numpy-2.2.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:733585f9f4b62e9b3528dd1070ec4f52b8acf64215b60a845fa13ebd73cd0712", size = 14119910, upload-time = "2024-12-21T22:41:41.298Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/5b/aa2d1905b04a8fb681e08742bb79a7bddfc160c7ce8e1ff6d5c821be0236/numpy-2.2.1-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:89b16a18e7bba224ce5114db863e7029803c179979e1af6ad6a6b11f70545008", size = 5153612, upload-time = "2024-12-21T22:41:52.23Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/35/6831808028df0648d9b43c5df7e1051129aa0d562525bacb70019c5f5030/numpy-2.2.1-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:676f4eebf6b2d430300f1f4f4c2461685f8269f94c89698d832cdf9277f30b84", size = 6668401, upload-time = "2024-12-21T22:42:05.378Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/38/10ef509ad63a5946cc042f98d838daebfe7eaf45b9daaf13df2086b15ff9/numpy-2.2.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:27f5cdf9f493b35f7e41e8368e7d7b4bbafaf9660cba53fb21d2cd174ec09631", size = 14014198, upload-time = "2024-12-21T22:42:36.414Z" },
+    { url = "https://files.pythonhosted.org/packages/df/f8/c80968ae01df23e249ee0a4487fae55a4c0fe2f838dfe9cc907aa8aea0fa/numpy-2.2.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c1ad395cf254c4fbb5b2132fee391f361a6e8c1adbd28f2cd8e79308a615fe9d", size = 16076211, upload-time = "2024-12-21T22:43:10.125Z" },
+    { url = "https://files.pythonhosted.org/packages/09/69/05c169376016a0b614b432967ac46ff14269eaffab80040ec03ae1ae8e2c/numpy-2.2.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:08ef779aed40dbc52729d6ffe7dd51df85796a702afbf68a4f4e41fafdc8bda5", size = 15220266, upload-time = "2024-12-21T22:43:44.16Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/ff/94a4ce67ea909f41cf7ea712aebbe832dc67decad22944a1020bb398a5ee/numpy-2.2.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:26c9c4382b19fcfbbed3238a14abf7ff223890ea1936b8890f058e7ba35e8d71", size = 17852844, upload-time = "2024-12-21T22:44:19.029Z" },
+    { url = "https://files.pythonhosted.org/packages/46/72/8a5dbce4020dfc595592333ef2fbb0a187d084ca243b67766d29d03e0096/numpy-2.2.1-cp313-cp313t-win32.whl", hash = "sha256:93cf4e045bae74c90ca833cba583c14b62cb4ba2cba0abd2b141ab52548247e2", size = 6326007, upload-time = "2024-12-21T22:44:34.097Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/9c/4fce9cf39dde2562584e4cfd351a0140240f82c0e3569ce25a250f47037d/numpy-2.2.1-cp313-cp313t-win_amd64.whl", hash = "sha256:bff7d8ec20f5f42607599f9994770fa65d76edca264a87b5e4ea5629bce12268", size = 12693107, upload-time = "2024-12-21T22:44:57.542Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/65/d36a76b811ffe0a4515e290cb05cb0e22171b1b0f0db6bee9141cf023545/numpy-2.2.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7ba9cc93a91d86365a5d270dee221fdc04fb68d7478e6bf6af650de78a8339e3", size = 21044672, upload-time = "2024-12-21T22:46:49.317Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/3f/b644199f165063154df486d95198d814578f13dd4d8c1651e075bf1cb8af/numpy-2.2.1-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:3d03883435a19794e41f147612a77a8f56d4e52822337844fff3d4040a142964", size = 6789873, upload-time = "2024-12-21T22:47:10.519Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/df/2adb0bb98a3cbe8a6c3c6d1019aede1f1d8b83927ced228a46cc56c7a206/numpy-2.2.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4511d9e6071452b944207c8ce46ad2f897307910b402ea5fa975da32e0102800", size = 16194933, upload-time = "2024-12-21T22:47:47.113Z" },
+    { url = "https://files.pythonhosted.org/packages/13/3e/1959d5219a9e6d200638d924cedda6a606392f7186a4ed56478252e70d55/numpy-2.2.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:5c5cc0cbabe9452038ed984d05ac87910f89370b9242371bd9079cb4af61811e", size = 12820057, upload-time = "2024-12-21T22:48:36.421Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.3.4"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.14'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b5/f4/098d2270d52b41f1bd7db9fc288aaa0400cb48c2a3e2af6fa365d9720947/numpy-2.3.4.tar.gz", hash = "sha256:a7d018bfedb375a8d979ac758b120ba846a7fe764911a64465fd87b8729f4a6a", size = 20582187, upload-time = "2025-10-15T16:18:11.77Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/60/e7/0e07379944aa8afb49a556a2b54587b828eb41dc9adc56fb7615b678ca53/numpy-2.3.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e78aecd2800b32e8347ce49316d3eaf04aed849cd5b38e0af39f829a4e59f5eb", size = 21259519, upload-time = "2025-10-15T16:15:19.012Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/cb/5a69293561e8819b09e34ed9e873b9a82b5f2ade23dce4c51dc507f6cfe1/numpy-2.3.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7fd09cc5d65bda1e79432859c40978010622112e9194e581e3415a3eccc7f43f", size = 14452796, upload-time = "2025-10-15T16:15:23.094Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/04/ff11611200acd602a1e5129e36cfd25bf01ad8e5cf927baf2e90236eb02e/numpy-2.3.4-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:1b219560ae2c1de48ead517d085bc2d05b9433f8e49d0955c82e8cd37bd7bf36", size = 5381639, upload-time = "2025-10-15T16:15:25.572Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/77/e95c757a6fe7a48d28a009267408e8aa382630cc1ad1db7451b3bc21dbb4/numpy-2.3.4-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:bafa7d87d4c99752d07815ed7a2c0964f8ab311eb8168f41b910bd01d15b6032", size = 6914296, upload-time = "2025-10-15T16:15:27.079Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/d2/137c7b6841c942124eae921279e5c41b1c34bab0e6fc60c7348e69afd165/numpy-2.3.4-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:36dc13af226aeab72b7abad501d370d606326a0029b9f435eacb3b8c94b8a8b7", size = 14591904, upload-time = "2025-10-15T16:15:29.044Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/32/67e3b0f07b0aba57a078c4ab777a9e8e6bc62f24fb53a2337f75f9691699/numpy-2.3.4-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a7b2f9a18b5ff9824a6af80de4f37f4ec3c2aab05ef08f51c77a093f5b89adda", size = 16939602, upload-time = "2025-10-15T16:15:31.106Z" },
+    { url = "https://files.pythonhosted.org/packages/95/22/9639c30e32c93c4cee3ccdb4b09c2d0fbff4dcd06d36b357da06146530fb/numpy-2.3.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9984bd645a8db6ca15d850ff996856d8762c51a2239225288f08f9050ca240a0", size = 16372661, upload-time = "2025-10-15T16:15:33.546Z" },
+    { url = "https://files.pythonhosted.org/packages/12/e9/a685079529be2b0156ae0c11b13d6be647743095bb51d46589e95be88086/numpy-2.3.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:64c5825affc76942973a70acf438a8ab618dbd692b84cd5ec40a0a0509edc09a", size = 18884682, upload-time = "2025-10-15T16:15:36.105Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/85/f6f00d019b0cc741e64b4e00ce865a57b6bed945d1bbeb1ccadbc647959b/numpy-2.3.4-cp311-cp311-win32.whl", hash = "sha256:ed759bf7a70342f7817d88376eb7142fab9fef8320d6019ef87fae05a99874e1", size = 6570076, upload-time = "2025-10-15T16:15:38.225Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/10/f8850982021cb90e2ec31990291f9e830ce7d94eef432b15066e7cbe0bec/numpy-2.3.4-cp311-cp311-win_amd64.whl", hash = "sha256:faba246fb30ea2a526c2e9645f61612341de1a83fb1e0c5edf4ddda5a9c10996", size = 13089358, upload-time = "2025-10-15T16:15:40.404Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/ad/afdd8351385edf0b3445f9e24210a9c3971ef4de8fd85155462fc4321d79/numpy-2.3.4-cp311-cp311-win_arm64.whl", hash = "sha256:4c01835e718bcebe80394fd0ac66c07cbb90147ebbdad3dcecd3f25de2ae7e2c", size = 10462292, upload-time = "2025-10-15T16:15:42.896Z" },
+    { url = "https://files.pythonhosted.org/packages/96/7a/02420400b736f84317e759291b8edaeee9dc921f72b045475a9cbdb26b17/numpy-2.3.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ef1b5a3e808bc40827b5fa2c8196151a4c5abe110e1726949d7abddfe5c7ae11", size = 20957727, upload-time = "2025-10-15T16:15:44.9Z" },
+    { url = "https://files.pythonhosted.org/packages/18/90/a014805d627aa5750f6f0e878172afb6454552da929144b3c07fcae1bb13/numpy-2.3.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c2f91f496a87235c6aaf6d3f3d89b17dba64996abadccb289f48456cff931ca9", size = 14187262, upload-time = "2025-10-15T16:15:47.761Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/e4/0a94b09abe89e500dc748e7515f21a13e30c5c3fe3396e6d4ac108c25fca/numpy-2.3.4-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:f77e5b3d3da652b474cc80a14084927a5e86a5eccf54ca8ca5cbd697bf7f2667", size = 5115992, upload-time = "2025-10-15T16:15:50.144Z" },
+    { url = "https://files.pythonhosted.org/packages/88/dd/db77c75b055c6157cbd4f9c92c4458daef0dd9cbe6d8d2fe7f803cb64c37/numpy-2.3.4-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:8ab1c5f5ee40d6e01cbe96de5863e39b215a4d24e7d007cad56c7184fdf4aeef", size = 6648672, upload-time = "2025-10-15T16:15:52.442Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/e6/e31b0d713719610e406c0ea3ae0d90760465b086da8783e2fd835ad59027/numpy-2.3.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77b84453f3adcb994ddbd0d1c5d11db2d6bda1a2b7fd5ac5bd4649d6f5dc682e", size = 14284156, upload-time = "2025-10-15T16:15:54.351Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/58/30a85127bfee6f108282107caf8e06a1f0cc997cb6b52cdee699276fcce4/numpy-2.3.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4121c5beb58a7f9e6dfdee612cb24f4df5cd4db6e8261d7f4d7450a997a65d6a", size = 16641271, upload-time = "2025-10-15T16:15:56.67Z" },
+    { url = "https://files.pythonhosted.org/packages/06/f2/2e06a0f2adf23e3ae29283ad96959267938d0efd20a2e25353b70065bfec/numpy-2.3.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:65611ecbb00ac9846efe04db15cbe6186f562f6bb7e5e05f077e53a599225d16", size = 16059531, upload-time = "2025-10-15T16:15:59.412Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/e7/b106253c7c0d5dc352b9c8fab91afd76a93950998167fa3e5afe4ef3a18f/numpy-2.3.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dabc42f9c6577bcc13001b8810d300fe814b4cfbe8a92c873f269484594f9786", size = 18578983, upload-time = "2025-10-15T16:16:01.804Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e3/04ecc41e71462276ee867ccbef26a4448638eadecf1bc56772c9ed6d0255/numpy-2.3.4-cp312-cp312-win32.whl", hash = "sha256:a49d797192a8d950ca59ee2d0337a4d804f713bb5c3c50e8db26d49666e351dc", size = 6291380, upload-time = "2025-10-15T16:16:03.938Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/a8/566578b10d8d0e9955b1b6cd5db4e9d4592dd0026a941ff7994cedda030a/numpy-2.3.4-cp312-cp312-win_amd64.whl", hash = "sha256:985f1e46358f06c2a09921e8921e2c98168ed4ae12ccd6e5e87a4f1857923f32", size = 12787999, upload-time = "2025-10-15T16:16:05.801Z" },
+    { url = "https://files.pythonhosted.org/packages/58/22/9c903a957d0a8071b607f5b1bff0761d6e608b9a965945411f867d515db1/numpy-2.3.4-cp312-cp312-win_arm64.whl", hash = "sha256:4635239814149e06e2cb9db3dd584b2fa64316c96f10656983b8026a82e6e4db", size = 10197412, upload-time = "2025-10-15T16:16:07.854Z" },
+    { url = "https://files.pythonhosted.org/packages/57/7e/b72610cc91edf138bc588df5150957a4937221ca6058b825b4725c27be62/numpy-2.3.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c090d4860032b857d94144d1a9976b8e36709e40386db289aaf6672de2a81966", size = 20950335, upload-time = "2025-10-15T16:16:10.304Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/46/bdd3370dcea2f95ef14af79dbf81e6927102ddf1cc54adc0024d61252fd9/numpy-2.3.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a13fc473b6db0be619e45f11f9e81260f7302f8d180c49a22b6e6120022596b3", size = 14179878, upload-time = "2025-10-15T16:16:12.595Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/01/5a67cb785bda60f45415d09c2bc245433f1c68dd82eef9c9002c508b5a65/numpy-2.3.4-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:3634093d0b428e6c32c3a69b78e554f0cd20ee420dcad5a9f3b2a63762ce4197", size = 5108673, upload-time = "2025-10-15T16:16:14.877Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/cd/8428e23a9fcebd33988f4cb61208fda832800ca03781f471f3727a820704/numpy-2.3.4-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:043885b4f7e6e232d7df4f51ffdef8c36320ee9d5f227b380ea636722c7ed12e", size = 6641438, upload-time = "2025-10-15T16:16:16.805Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/d1/913fe563820f3c6b079f992458f7331278dcd7ba8427e8e745af37ddb44f/numpy-2.3.4-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4ee6a571d1e4f0ea6d5f22d6e5fbd6ed1dc2b18542848e1e7301bd190500c9d7", size = 14281290, upload-time = "2025-10-15T16:16:18.764Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/7e/7d306ff7cb143e6d975cfa7eb98a93e73495c4deabb7d1b5ecf09ea0fd69/numpy-2.3.4-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fc8a63918b04b8571789688b2780ab2b4a33ab44bfe8ccea36d3eba51228c953", size = 16636543, upload-time = "2025-10-15T16:16:21.072Z" },
+    { url = "https://files.pythonhosted.org/packages/47/6a/8cfc486237e56ccfb0db234945552a557ca266f022d281a2f577b98e955c/numpy-2.3.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:40cc556d5abbc54aabe2b1ae287042d7bdb80c08edede19f0c0afb36ae586f37", size = 16056117, upload-time = "2025-10-15T16:16:23.369Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/0e/42cb5e69ea901e06ce24bfcc4b5664a56f950a70efdcf221f30d9615f3f3/numpy-2.3.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ecb63014bb7f4ce653f8be7f1df8cbc6093a5a2811211770f6606cc92b5a78fd", size = 18577788, upload-time = "2025-10-15T16:16:27.496Z" },
+    { url = "https://files.pythonhosted.org/packages/86/92/41c3d5157d3177559ef0a35da50f0cda7fa071f4ba2306dd36818591a5bc/numpy-2.3.4-cp313-cp313-win32.whl", hash = "sha256:e8370eb6925bb8c1c4264fec52b0384b44f675f191df91cbe0140ec9f0955646", size = 6282620, upload-time = "2025-10-15T16:16:29.811Z" },
+    { url = "https://files.pythonhosted.org/packages/09/97/fd421e8bc50766665ad35536c2bb4ef916533ba1fdd053a62d96cc7c8b95/numpy-2.3.4-cp313-cp313-win_amd64.whl", hash = "sha256:56209416e81a7893036eea03abcb91c130643eb14233b2515c90dcac963fe99d", size = 12784672, upload-time = "2025-10-15T16:16:31.589Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/df/5474fb2f74970ca8eb978093969b125a84cc3d30e47f82191f981f13a8a0/numpy-2.3.4-cp313-cp313-win_arm64.whl", hash = "sha256:a700a4031bc0fd6936e78a752eefb79092cecad2599ea9c8039c548bc097f9bc", size = 10196702, upload-time = "2025-10-15T16:16:33.902Z" },
+    { url = "https://files.pythonhosted.org/packages/11/83/66ac031464ec1767ea3ed48ce40f615eb441072945e98693bec0bcd056cc/numpy-2.3.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:86966db35c4040fdca64f0816a1c1dd8dbd027d90fca5a57e00e1ca4cd41b879", size = 21049003, upload-time = "2025-10-15T16:16:36.101Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/99/5b14e0e686e61371659a1d5bebd04596b1d72227ce36eed121bb0aeab798/numpy-2.3.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:838f045478638b26c375ee96ea89464d38428c69170360b23a1a50fa4baa3562", size = 14302980, upload-time = "2025-10-15T16:16:39.124Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/44/e9486649cd087d9fc6920e3fc3ac2aba10838d10804b1e179fb7cbc4e634/numpy-2.3.4-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:d7315ed1dab0286adca467377c8381cd748f3dc92235f22a7dfc42745644a96a", size = 5231472, upload-time = "2025-10-15T16:16:41.168Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/51/902b24fa8887e5fe2063fd61b1895a476d0bbf46811ab0c7fdf4bd127345/numpy-2.3.4-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:84f01a4d18b2cc4ade1814a08e5f3c907b079c847051d720fad15ce37aa930b6", size = 6739342, upload-time = "2025-10-15T16:16:43.777Z" },
+    { url = "https://files.pythonhosted.org/packages/34/f1/4de9586d05b1962acdcdb1dc4af6646361a643f8c864cef7c852bf509740/numpy-2.3.4-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:817e719a868f0dacde4abdfc5c1910b301877970195db9ab6a5e2c4bd5b121f7", size = 14354338, upload-time = "2025-10-15T16:16:46.081Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/06/1c16103b425de7969d5a76bdf5ada0804b476fed05d5f9e17b777f1cbefd/numpy-2.3.4-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:85e071da78d92a214212cacea81c6da557cab307f2c34b5f85b628e94803f9c0", size = 16702392, upload-time = "2025-10-15T16:16:48.455Z" },
+    { url = "https://files.pythonhosted.org/packages/34/b2/65f4dc1b89b5322093572b6e55161bb42e3e0487067af73627f795cc9d47/numpy-2.3.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:2ec646892819370cf3558f518797f16597b4e4669894a2ba712caccc9da53f1f", size = 16134998, upload-time = "2025-10-15T16:16:51.114Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/11/94ec578896cdb973aaf56425d6c7f2aff4186a5c00fac15ff2ec46998b46/numpy-2.3.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:035796aaaddfe2f9664b9a9372f089cfc88bd795a67bd1bfe15e6e770934cf64", size = 18651574, upload-time = "2025-10-15T16:16:53.429Z" },
+    { url = "https://files.pythonhosted.org/packages/62/b7/7efa763ab33dbccf56dade36938a77345ce8e8192d6b39e470ca25ff3cd0/numpy-2.3.4-cp313-cp313t-win32.whl", hash = "sha256:fea80f4f4cf83b54c3a051f2f727870ee51e22f0248d3114b8e755d160b38cfb", size = 6413135, upload-time = "2025-10-15T16:16:55.992Z" },
+    { url = "https://files.pythonhosted.org/packages/43/70/aba4c38e8400abcc2f345e13d972fb36c26409b3e644366db7649015f291/numpy-2.3.4-cp313-cp313t-win_amd64.whl", hash = "sha256:15eea9f306b98e0be91eb344a94c0e630689ef302e10c2ce5f7e11905c704f9c", size = 12928582, upload-time = "2025-10-15T16:16:57.943Z" },
+    { url = "https://files.pythonhosted.org/packages/67/63/871fad5f0073fc00fbbdd7232962ea1ac40eeaae2bba66c76214f7954236/numpy-2.3.4-cp313-cp313t-win_arm64.whl", hash = "sha256:b6c231c9c2fadbae4011ca5e7e83e12dc4a5072f1a1d85a0a7b3ed754d145a40", size = 10266691, upload-time = "2025-10-15T16:17:00.048Z" },
+    { url = "https://files.pythonhosted.org/packages/72/71/ae6170143c115732470ae3a2d01512870dd16e0953f8a6dc89525696069b/numpy-2.3.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:81c3e6d8c97295a7360d367f9f8553973651b76907988bb6066376bc2252f24e", size = 20955580, upload-time = "2025-10-15T16:17:02.509Z" },
+    { url = "https://files.pythonhosted.org/packages/af/39/4be9222ffd6ca8a30eda033d5f753276a9c3426c397bb137d8e19dedd200/numpy-2.3.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7c26b0b2bf58009ed1f38a641f3db4be8d960a417ca96d14e5b06df1506d41ff", size = 14188056, upload-time = "2025-10-15T16:17:04.873Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/3d/d85f6700d0a4aa4f9491030e1021c2b2b7421b2b38d01acd16734a2bfdc7/numpy-2.3.4-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:62b2198c438058a20b6704351b35a1d7db881812d8512d67a69c9de1f18ca05f", size = 5116555, upload-time = "2025-10-15T16:17:07.499Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/04/82c1467d86f47eee8a19a464c92f90a9bb68ccf14a54c5224d7031241ffb/numpy-2.3.4-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:9d729d60f8d53a7361707f4b68a9663c968882dd4f09e0d58c044c8bf5faee7b", size = 6643581, upload-time = "2025-10-15T16:17:09.774Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/d3/c79841741b837e293f48bd7db89d0ac7a4f2503b382b78a790ef1dc778a5/numpy-2.3.4-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bd0c630cf256b0a7fd9d0a11c9413b42fef5101219ce6ed5a09624f5a65392c7", size = 14299186, upload-time = "2025-10-15T16:17:11.937Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/7e/4a14a769741fbf237eec5a12a2cbc7a4c4e061852b6533bcb9e9a796c908/numpy-2.3.4-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5e081bc082825f8b139f9e9fe42942cb4054524598aaeb177ff476cc76d09d2", size = 16638601, upload-time = "2025-10-15T16:17:14.391Z" },
+    { url = "https://files.pythonhosted.org/packages/93/87/1c1de269f002ff0a41173fe01dcc925f4ecff59264cd8f96cf3b60d12c9b/numpy-2.3.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:15fb27364ed84114438fff8aaf998c9e19adbeba08c0b75409f8c452a8692c52", size = 16074219, upload-time = "2025-10-15T16:17:17.058Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/28/18f72ee77408e40a76d691001ae599e712ca2a47ddd2c4f695b16c65f077/numpy-2.3.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:85d9fb2d8cd998c84d13a79a09cc0c1091648e848e4e6249b0ccd7f6b487fa26", size = 18576702, upload-time = "2025-10-15T16:17:19.379Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/76/95650169b465ececa8cf4b2e8f6df255d4bf662775e797ade2025cc51ae6/numpy-2.3.4-cp314-cp314-win32.whl", hash = "sha256:e73d63fd04e3a9d6bc187f5455d81abfad05660b212c8804bf3b407e984cd2bc", size = 6337136, upload-time = "2025-10-15T16:17:22.886Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/89/a231a5c43ede5d6f77ba4a91e915a87dea4aeea76560ba4d2bf185c683f0/numpy-2.3.4-cp314-cp314-win_amd64.whl", hash = "sha256:3da3491cee49cf16157e70f607c03a217ea6647b1cea4819c4f48e53d49139b9", size = 12920542, upload-time = "2025-10-15T16:17:24.783Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/0c/ae9434a888f717c5ed2ff2393b3f344f0ff6f1c793519fa0c540461dc530/numpy-2.3.4-cp314-cp314-win_arm64.whl", hash = "sha256:6d9cd732068e8288dbe2717177320723ccec4fb064123f0caf9bbd90ab5be868", size = 10480213, upload-time = "2025-10-15T16:17:26.935Z" },
+    { url = "https://files.pythonhosted.org/packages/83/4b/c4a5f0841f92536f6b9592694a5b5f68c9ab37b775ff342649eadf9055d3/numpy-2.3.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:22758999b256b595cf0b1d102b133bb61866ba5ceecf15f759623b64c020c9ec", size = 21052280, upload-time = "2025-10-15T16:17:29.638Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/80/90308845fc93b984d2cc96d83e2324ce8ad1fd6efea81b324cba4b673854/numpy-2.3.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:9cb177bc55b010b19798dc5497d540dea67fd13a8d9e882b2dae71de0cf09eb3", size = 14302930, upload-time = "2025-10-15T16:17:32.384Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/4e/07439f22f2a3b247cec4d63a713faae55e1141a36e77fb212881f7cda3fb/numpy-2.3.4-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:0f2bcc76f1e05e5ab58893407c63d90b2029908fa41f9f1cc51eecce936c3365", size = 5231504, upload-time = "2025-10-15T16:17:34.515Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/de/1e11f2547e2fe3d00482b19721855348b94ada8359aef5d40dd57bfae9df/numpy-2.3.4-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:8dc20bde86802df2ed8397a08d793da0ad7a5fd4ea3ac85d757bf5dd4ad7c252", size = 6739405, upload-time = "2025-10-15T16:17:36.128Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/40/8cd57393a26cebe2e923005db5134a946c62fa56a1087dc7c478f3e30837/numpy-2.3.4-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5e199c087e2aa71c8f9ce1cb7a8e10677dc12457e7cc1be4798632da37c3e86e", size = 14354866, upload-time = "2025-10-15T16:17:38.884Z" },
+    { url = "https://files.pythonhosted.org/packages/93/39/5b3510f023f96874ee6fea2e40dfa99313a00bf3ab779f3c92978f34aace/numpy-2.3.4-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:85597b2d25ddf655495e2363fe044b0ae999b75bc4d630dc0d886484b03a5eb0", size = 16703296, upload-time = "2025-10-15T16:17:41.564Z" },
+    { url = "https://files.pythonhosted.org/packages/41/0d/19bb163617c8045209c1996c4e427bccbc4bbff1e2c711f39203c8ddbb4a/numpy-2.3.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:04a69abe45b49c5955923cf2c407843d1c85013b424ae8a560bba16c92fe44a0", size = 16136046, upload-time = "2025-10-15T16:17:43.901Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/c1/6dba12fdf68b02a21ac411c9df19afa66bed2540f467150ca64d246b463d/numpy-2.3.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e1708fac43ef8b419c975926ce1eaf793b0c13b7356cfab6ab0dc34c0a02ac0f", size = 18652691, upload-time = "2025-10-15T16:17:46.247Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/73/f85056701dbbbb910c51d846c58d29fd46b30eecd2b6ba760fc8b8a1641b/numpy-2.3.4-cp314-cp314t-win32.whl", hash = "sha256:863e3b5f4d9915aaf1b8ec79ae560ad21f0b8d5e3adc31e73126491bb86dee1d", size = 6485782, upload-time = "2025-10-15T16:17:48.872Z" },
+    { url = "https://files.pythonhosted.org/packages/17/90/28fa6f9865181cb817c2471ee65678afa8a7e2a1fb16141473d5fa6bacc3/numpy-2.3.4-cp314-cp314t-win_amd64.whl", hash = "sha256:962064de37b9aef801d33bc579690f8bfe6c5e70e29b61783f60bcba838a14d6", size = 13113301, upload-time = "2025-10-15T16:17:50.938Z" },
+    { url = "https://files.pythonhosted.org/packages/54/23/08c002201a8e7e1f9afba93b97deceb813252d9cfd0d3351caed123dcf97/numpy-2.3.4-cp314-cp314t-win_arm64.whl", hash = "sha256:8b5a9a39c45d852b62693d9b3f3e0fe052541f804296ff401a72a1b60edafb29", size = 10547532, upload-time = "2025-10-15T16:17:53.48Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/b6/64898f51a86ec88ca1257a59c1d7fd077b60082a119affefcdf1dd0df8ca/numpy-2.3.4-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:6e274603039f924c0fe5cb73438fa9246699c78a6df1bd3decef9ae592ae1c05", size = 21131552, upload-time = "2025-10-15T16:17:55.845Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/4c/f135dc6ebe2b6a3c77f4e4838fa63d350f85c99462012306ada1bd4bc460/numpy-2.3.4-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d149aee5c72176d9ddbc6803aef9c0f6d2ceeea7626574fc68518da5476fa346", size = 14377796, upload-time = "2025-10-15T16:17:58.308Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/a4/f33f9c23fcc13dd8412fc8614559b5b797e0aba9d8e01dfa8bae10c84004/numpy-2.3.4-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:6d34ed9db9e6395bb6cd33286035f73a59b058169733a9db9f85e650b88df37e", size = 5306904, upload-time = "2025-10-15T16:18:00.596Z" },
+    { url = "https://files.pythonhosted.org/packages/28/af/c44097f25f834360f9fb960fa082863e0bad14a42f36527b2a121abdec56/numpy-2.3.4-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:fdebe771ca06bb8d6abce84e51dca9f7921fe6ad34a0c914541b063e9a68928b", size = 6819682, upload-time = "2025-10-15T16:18:02.32Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/8c/cd283b54c3c2b77e188f63e23039844f56b23bba1712318288c13fe86baf/numpy-2.3.4-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:957e92defe6c08211eb77902253b14fe5b480ebc5112bc741fd5e9cd0608f847", size = 14422300, upload-time = "2025-10-15T16:18:04.271Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/f0/8404db5098d92446b3e3695cf41c6f0ecb703d701cb0b7566ee2177f2eee/numpy-2.3.4-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:13b9062e4f5c7ee5c7e5be96f29ba71bc5a37fed3d1d77c37390ae00724d296d", size = 16760806, upload-time = "2025-10-15T16:18:06.668Z" },
+    { url = "https://files.pythonhosted.org/packages/95/8e/2844c3959ce9a63acc7c8e50881133d86666f0420bcde695e115ced0920f/numpy-2.3.4-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:81b3a59793523e552c4a96109dde028aa4448ae06ccac5a76ff6532a85558a7f", size = 12973130, upload-time = "2025-10-15T16:18:09.397Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "24.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950, upload-time = "2024-11-08T09:47:47.202Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451, upload-time = "2024-11-08T09:47:44.722Z" },
+]
+
+[[package]]
+name = "pandas"
+version = "2.2.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy", version = "2.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.14'" },
+    { name = "numpy", version = "2.3.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.14'" },
+    { name = "python-dateutil" },
+    { name = "pytz" },
+    { name = "tzdata" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9c/d6/9f8431bacc2e19dca897724cd097b1bb224a6ad5433784a44b587c7c13af/pandas-2.2.3.tar.gz", hash = "sha256:4f18ba62b61d7e192368b84517265a99b4d7ee8912f8708660fb4a366cc82667", size = 4399213, upload-time = "2024-09-20T13:10:04.827Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/aa/70/c853aec59839bceed032d52010ff5f1b8d87dc3114b762e4ba2727661a3b/pandas-2.2.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1948ddde24197a0f7add2bdc4ca83bf2b1ef84a1bc8ccffd95eda17fd836ecb5", size = 12580827, upload-time = "2024-09-20T13:08:42.347Z" },
+    { url = "https://files.pythonhosted.org/packages/99/f2/c4527768739ffa4469b2b4fff05aa3768a478aed89a2f271a79a40eee984/pandas-2.2.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:381175499d3802cde0eabbaf6324cce0c4f5d52ca6f8c377c29ad442f50f6348", size = 11303897, upload-time = "2024-09-20T13:08:45.807Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/12/86c1747ea27989d7a4064f806ce2bae2c6d575b950be087837bdfcabacc9/pandas-2.2.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d9c45366def9a3dd85a6454c0e7908f2b3b8e9c138f5dc38fed7ce720d8453ed", size = 66480908, upload-time = "2024-09-20T18:37:13.513Z" },
+    { url = "https://files.pythonhosted.org/packages/44/50/7db2cd5e6373ae796f0ddad3675268c8d59fb6076e66f0c339d61cea886b/pandas-2.2.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86976a1c5b25ae3f8ccae3a5306e443569ee3c3faf444dfd0f41cda24667ad57", size = 13064210, upload-time = "2024-09-20T13:08:48.325Z" },
+    { url = "https://files.pythonhosted.org/packages/61/61/a89015a6d5536cb0d6c3ba02cebed51a95538cf83472975275e28ebf7d0c/pandas-2.2.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b8661b0238a69d7aafe156b7fa86c44b881387509653fdf857bebc5e4008ad42", size = 16754292, upload-time = "2024-09-20T19:01:54.443Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/0d/4cc7b69ce37fac07645a94e1d4b0880b15999494372c1523508511b09e40/pandas-2.2.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:37e0aced3e8f539eccf2e099f65cdb9c8aa85109b0be6e93e2baff94264bdc6f", size = 14416379, upload-time = "2024-09-20T13:08:50.882Z" },
+    { url = "https://files.pythonhosted.org/packages/31/9e/6ebb433de864a6cd45716af52a4d7a8c3c9aaf3a98368e61db9e69e69a9c/pandas-2.2.3-cp310-cp310-win_amd64.whl", hash = "sha256:56534ce0746a58afaf7942ba4863e0ef81c9c50d3f0ae93e9497d6a41a057645", size = 11598471, upload-time = "2024-09-20T13:08:53.332Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/44/d9502bf0ed197ba9bf1103c9867d5904ddcaf869e52329787fc54ed70cc8/pandas-2.2.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66108071e1b935240e74525006034333f98bcdb87ea116de573a6a0dccb6c039", size = 12602222, upload-time = "2024-09-20T13:08:56.254Z" },
+    { url = "https://files.pythonhosted.org/packages/52/11/9eac327a38834f162b8250aab32a6781339c69afe7574368fffe46387edf/pandas-2.2.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7c2875855b0ff77b2a64a0365e24455d9990730d6431b9e0ee18ad8acee13dbd", size = 11321274, upload-time = "2024-09-20T13:08:58.645Z" },
+    { url = "https://files.pythonhosted.org/packages/45/fb/c4beeb084718598ba19aa9f5abbc8aed8b42f90930da861fcb1acdb54c3a/pandas-2.2.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cd8d0c3be0515c12fed0bdbae072551c8b54b7192c7b1fda0ba56059a0179698", size = 15579836, upload-time = "2024-09-20T19:01:57.571Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/5f/4dba1d39bb9c38d574a9a22548c540177f78ea47b32f99c0ff2ec499fac5/pandas-2.2.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c124333816c3a9b03fbeef3a9f230ba9a737e9e5bb4060aa2107a86cc0a497fc", size = 13058505, upload-time = "2024-09-20T13:09:01.501Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/57/708135b90391995361636634df1f1130d03ba456e95bcf576fada459115a/pandas-2.2.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:63cc132e40a2e084cf01adf0775b15ac515ba905d7dcca47e9a251819c575ef3", size = 16744420, upload-time = "2024-09-20T19:02:00.678Z" },
+    { url = "https://files.pythonhosted.org/packages/86/4a/03ed6b7ee323cf30404265c284cee9c65c56a212e0a08d9ee06984ba2240/pandas-2.2.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:29401dbfa9ad77319367d36940cd8a0b3a11aba16063e39632d98b0e931ddf32", size = 14440457, upload-time = "2024-09-20T13:09:04.105Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/8c/87ddf1fcb55d11f9f847e3c69bb1c6f8e46e2f40ab1a2d2abadb2401b007/pandas-2.2.3-cp311-cp311-win_amd64.whl", hash = "sha256:3fc6873a41186404dad67245896a6e440baacc92f5b716ccd1bc9ed2995ab2c5", size = 11617166, upload-time = "2024-09-20T13:09:06.917Z" },
+    { url = "https://files.pythonhosted.org/packages/17/a3/fb2734118db0af37ea7433f57f722c0a56687e14b14690edff0cdb4b7e58/pandas-2.2.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b1d432e8d08679a40e2a6d8b2f9770a5c21793a6f9f47fdd52c5ce1948a5a8a9", size = 12529893, upload-time = "2024-09-20T13:09:09.655Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/0c/ad295fd74bfac85358fd579e271cded3ac969de81f62dd0142c426b9da91/pandas-2.2.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a5a1595fe639f5988ba6a8e5bc9649af3baf26df3998a0abe56c02609392e0a4", size = 11363475, upload-time = "2024-09-20T13:09:14.718Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/2a/4bba3f03f7d07207481fed47f5b35f556c7441acddc368ec43d6643c5777/pandas-2.2.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5de54125a92bb4d1c051c0659e6fcb75256bf799a732a87184e5ea503965bce3", size = 15188645, upload-time = "2024-09-20T19:02:03.88Z" },
+    { url = "https://files.pythonhosted.org/packages/38/f8/d8fddee9ed0d0c0f4a2132c1dfcf0e3e53265055da8df952a53e7eaf178c/pandas-2.2.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fffb8ae78d8af97f849404f21411c95062db1496aeb3e56f146f0355c9989319", size = 12739445, upload-time = "2024-09-20T13:09:17.621Z" },
+    { url = "https://files.pythonhosted.org/packages/20/e8/45a05d9c39d2cea61ab175dbe6a2de1d05b679e8de2011da4ee190d7e748/pandas-2.2.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6dfcb5ee8d4d50c06a51c2fffa6cff6272098ad6540aed1a76d15fb9318194d8", size = 16359235, upload-time = "2024-09-20T19:02:07.094Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/99/617d07a6a5e429ff90c90da64d428516605a1ec7d7bea494235e1c3882de/pandas-2.2.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:062309c1b9ea12a50e8ce661145c6aab431b1e99530d3cd60640e255778bd43a", size = 14056756, upload-time = "2024-09-20T13:09:20.474Z" },
+    { url = "https://files.pythonhosted.org/packages/29/d4/1244ab8edf173a10fd601f7e13b9566c1b525c4f365d6bee918e68381889/pandas-2.2.3-cp312-cp312-win_amd64.whl", hash = "sha256:59ef3764d0fe818125a5097d2ae867ca3fa64df032331b7e0917cf5d7bf66b13", size = 11504248, upload-time = "2024-09-20T13:09:23.137Z" },
+    { url = "https://files.pythonhosted.org/packages/64/22/3b8f4e0ed70644e85cfdcd57454686b9057c6c38d2f74fe4b8bc2527214a/pandas-2.2.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f00d1345d84d8c86a63e476bb4955e46458b304b9575dcf71102b5c705320015", size = 12477643, upload-time = "2024-09-20T13:09:25.522Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/93/b3f5d1838500e22c8d793625da672f3eec046b1a99257666c94446969282/pandas-2.2.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3508d914817e153ad359d7e069d752cdd736a247c322d932eb89e6bc84217f28", size = 11281573, upload-time = "2024-09-20T13:09:28.012Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/94/6c79b07f0e5aab1dcfa35a75f4817f5c4f677931d4234afcd75f0e6a66ca/pandas-2.2.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22a9d949bfc9a502d320aa04e5d02feab689d61da4e7764b62c30b991c42c5f0", size = 15196085, upload-time = "2024-09-20T19:02:10.451Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/31/aa8da88ca0eadbabd0a639788a6da13bb2ff6edbbb9f29aa786450a30a91/pandas-2.2.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3a255b2c19987fbbe62a9dfd6cff7ff2aa9ccab3fc75218fd4b7530f01efa24", size = 12711809, upload-time = "2024-09-20T13:09:30.814Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/7c/c6dbdb0cb2a4344cacfb8de1c5808ca885b2e4dcfde8008266608f9372af/pandas-2.2.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:800250ecdadb6d9c78eae4990da62743b857b470883fa27f652db8bdde7f6659", size = 16356316, upload-time = "2024-09-20T19:02:13.825Z" },
+    { url = "https://files.pythonhosted.org/packages/57/b7/8b757e7d92023b832869fa8881a992696a0bfe2e26f72c9ae9f255988d42/pandas-2.2.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6374c452ff3ec675a8f46fd9ab25c4ad0ba590b71cf0656f8b6daa5202bca3fb", size = 14022055, upload-time = "2024-09-20T13:09:33.462Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/bc/4b18e2b8c002572c5a441a64826252ce5da2aa738855747247a971988043/pandas-2.2.3-cp313-cp313-win_amd64.whl", hash = "sha256:61c5ad4043f791b61dd4752191d9f07f0ae412515d59ba8f005832a532f8736d", size = 11481175, upload-time = "2024-09-20T13:09:35.871Z" },
+    { url = "https://files.pythonhosted.org/packages/76/a3/a5d88146815e972d40d19247b2c162e88213ef51c7c25993942c39dbf41d/pandas-2.2.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3b71f27954685ee685317063bf13c7709a7ba74fc996b84fc6821c59b0f06468", size = 12615650, upload-time = "2024-09-20T13:09:38.685Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/8c/f0fd18f6140ddafc0c24122c8a964e48294acc579d47def376fef12bcb4a/pandas-2.2.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:38cf8125c40dae9d5acc10fa66af8ea6fdf760b2714ee482ca691fc66e6fcb18", size = 11290177, upload-time = "2024-09-20T13:09:41.141Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/f9/e995754eab9c0f14c6777401f7eece0943840b7a9fc932221c19d1abee9f/pandas-2.2.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ba96630bc17c875161df3818780af30e43be9b166ce51c9a18c1feae342906c2", size = 14651526, upload-time = "2024-09-20T19:02:16.905Z" },
+    { url = "https://files.pythonhosted.org/packages/25/b0/98d6ae2e1abac4f35230aa756005e8654649d305df9a28b16b9ae4353bff/pandas-2.2.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db71525a1538b30142094edb9adc10be3f3e176748cd7acc2240c2f2e5aa3a4", size = 11871013, upload-time = "2024-09-20T13:09:44.39Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/57/0f72a10f9db6a4628744c8e8f0df4e6e21de01212c7c981d31e50ffc8328/pandas-2.2.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:15c0e1e02e93116177d29ff83e8b1619c93ddc9c49083f237d4312337a61165d", size = 15711620, upload-time = "2024-09-20T19:02:20.639Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/5f/b38085618b950b79d2d9164a711c52b10aefc0ae6833b96f626b7021b2ed/pandas-2.2.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ad5b65698ab28ed8d7f18790a0dc58005c7629f227be9ecc1072aa74c0c1d43a", size = 13098436, upload-time = "2024-09-20T13:09:48.112Z" },
+]
+
+[[package]]
+name = "parso"
+version = "0.8.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/66/94/68e2e17afaa9169cf6412ab0f28623903be73d1b32e208d9e8e541bb086d/parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d", size = 400609, upload-time = "2024-04-05T09:43:55.897Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c6/ac/dac4a63f978e4dcb3c6d3a78c4d8e0192a113d288502a1216950c41b1027/parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18", size = 103650, upload-time = "2024-04-05T09:43:53.299Z" },
+]
+
+[[package]]
+name = "pexpect"
+version = "4.9.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ptyprocess" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" },
+]
+
+[[package]]
+name = "pickleshare"
+version = "0.7.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/b6/df3c1c9b616e9c0edbc4fbab6ddd09df9535849c64ba51fcb6531c32d4d8/pickleshare-0.7.5.tar.gz", hash = "sha256:87683d47965c1da65cdacaf31c8441d12b8044cdec9aca500cd78fc2c683afca", size = 6161, upload-time = "2018-09-25T19:17:37.249Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/41/220f49aaea88bc6fa6cba8d05ecf24676326156c23b991e80b3f2fc24c77/pickleshare-0.7.5-py2.py3-none-any.whl", hash = "sha256:9649af414d74d4df115d5d718f82acb59c9d418196b7b4290ed47a12ce62df56", size = 6877, upload-time = "2018-09-25T19:17:35.817Z" },
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.3.8"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fe/8b/3c73abc9c759ecd3f1f7ceff6685840859e8070c4d947c93fae71f6a0bf2/platformdirs-4.3.8.tar.gz", hash = "sha256:3d512d96e16bcb959a814c9f348431070822a6496326a4be0911c40b5a74c2bc", size = 21362, upload-time = "2025-05-07T22:47:42.121Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fe/39/979e8e21520d4e47a0bbe349e2713c0aac6f3d853d0e5b34d76206c439aa/platformdirs-4.3.8-py3-none-any.whl", hash = "sha256:ff7059bb7eb1179e2685604f4aaf157cfd9535242bd23742eadc3c13542139b4", size = 18567, upload-time = "2025-05-07T22:47:40.376Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/96/2d/02d4312c973c6050a18b314a5ad0b3210edb65a906f868e31c111dede4a6/pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1", size = 67955, upload-time = "2024-04-20T21:34:42.531Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556, upload-time = "2024-04-20T21:34:40.434Z" },
+]
+
+[[package]]
+name = "pre-commit"
+version = "4.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cfgv" },
+    { name = "identify" },
+    { name = "nodeenv" },
+    { name = "pyyaml" },
+    { name = "virtualenv" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ff/29/7cf5bbc236333876e4b41f56e06857a87937ce4bf91e117a6991a2dbb02a/pre_commit-4.3.0.tar.gz", hash = "sha256:499fe450cc9d42e9d58e606262795ecb64dd05438943c62b66f6a8673da30b16", size = 193792, upload-time = "2025-08-09T18:56:14.651Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5b/a5/987a405322d78a73b66e39e4a90e4ef156fd7141bf71df987e50717c321b/pre_commit-4.3.0-py2.py3-none-any.whl", hash = "sha256:2b0747ad7e6e967169136edffee14c16e148a778a54e4f967921aa1ebf2308d8", size = 220965, upload-time = "2025-08-09T18:56:13.192Z" },
+]
+
+[[package]]
+name = "prompt-toolkit"
+version = "3.0.48"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wcwidth" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2d/4f/feb5e137aff82f7c7f3248267b97451da3644f6cdc218edfe549fb354127/prompt_toolkit-3.0.48.tar.gz", hash = "sha256:d6623ab0477a80df74e646bdbc93621143f5caf104206aa29294d53de1a03d90", size = 424684, upload-time = "2024-09-25T10:20:57.609Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a9/6a/fd08d94654f7e67c52ca30523a178b3f8ccc4237fce4be90d39c938a831a/prompt_toolkit-3.0.48-py3-none-any.whl", hash = "sha256:f49a827f90062e411f1ce1f854f2aedb3c23353244f8108b89283587397ac10e", size = 386595, upload-time = "2024-09-25T10:20:53.932Z" },
+]
+
+[[package]]
+name = "ptyprocess"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" },
+]
+
+[[package]]
+name = "pure-eval"
+version = "0.2.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" },
+]
+
+[[package]]
+name = "pyarrow"
+version = "22.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/30/53/04a7fdc63e6056116c9ddc8b43bc28c12cdd181b85cbeadb79278475f3ae/pyarrow-22.0.0.tar.gz", hash = "sha256:3d600dc583260d845c7d8a6db540339dd883081925da2bd1c5cb808f720b3cd9", size = 1151151, upload-time = "2025-10-24T12:30:00.762Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d9/9b/cb3f7e0a345353def531ca879053e9ef6b9f38ed91aebcf68b09ba54dec0/pyarrow-22.0.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:77718810bd3066158db1e95a63c160ad7ce08c6b0710bc656055033e39cdad88", size = 34223968, upload-time = "2025-10-24T10:03:31.21Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/41/3184b8192a120306270c5307f105b70320fdaa592c99843c5ef78aaefdcf/pyarrow-22.0.0-cp310-cp310-macosx_12_0_x86_64.whl", hash = "sha256:44d2d26cda26d18f7af7db71453b7b783788322d756e81730acb98f24eb90ace", size = 35942085, upload-time = "2025-10-24T10:03:38.146Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/3d/a1eab2f6f08001f9fb714b8ed5cfb045e2fe3e3e3c0c221f2c9ed1e6d67d/pyarrow-22.0.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:b9d71701ce97c95480fecb0039ec5bb889e75f110da72005743451339262f4ce", size = 44964613, upload-time = "2025-10-24T10:03:46.516Z" },
+    { url = "https://files.pythonhosted.org/packages/46/46/a1d9c24baf21cfd9ce994ac820a24608decf2710521b29223d4334985127/pyarrow-22.0.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:710624ab925dc2b05a6229d47f6f0dac1c1155e6ed559be7109f684eba048a48", size = 47627059, upload-time = "2025-10-24T10:03:55.353Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/4c/f711acb13075c1391fd54bc17e078587672c575f8de2a6e62509af026dcf/pyarrow-22.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f963ba8c3b0199f9d6b794c90ec77545e05eadc83973897a4523c9e8d84e9340", size = 47947043, upload-time = "2025-10-24T10:04:05.408Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/70/1f3180dd7c2eab35c2aca2b29ace6c519f827dcd4cfeb8e0dca41612cf7a/pyarrow-22.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:bd0d42297ace400d8febe55f13fdf46e86754842b860c978dfec16f081e5c653", size = 50206505, upload-time = "2025-10-24T10:04:15.786Z" },
+    { url = "https://files.pythonhosted.org/packages/80/07/fea6578112c8c60ffde55883a571e4c4c6bc7049f119d6b09333b5cc6f73/pyarrow-22.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:00626d9dc0f5ef3a75fe63fd68b9c7c8302d2b5bbc7f74ecaedba83447a24f84", size = 28101641, upload-time = "2025-10-24T10:04:22.57Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/b7/18f611a8cdc43417f9394a3ccd3eace2f32183c08b9eddc3d17681819f37/pyarrow-22.0.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:3e294c5eadfb93d78b0763e859a0c16d4051fc1c5231ae8956d61cb0b5666f5a", size = 34272022, upload-time = "2025-10-24T10:04:28.973Z" },
+    { url = "https://files.pythonhosted.org/packages/26/5c/f259e2526c67eb4b9e511741b19870a02363a47a35edbebc55c3178db22d/pyarrow-22.0.0-cp311-cp311-macosx_12_0_x86_64.whl", hash = "sha256:69763ab2445f632d90b504a815a2a033f74332997052b721002298ed6de40f2e", size = 35995834, upload-time = "2025-10-24T10:04:35.467Z" },
+    { url = "https://files.pythonhosted.org/packages/50/8d/281f0f9b9376d4b7f146913b26fac0aa2829cd1ee7e997f53a27411bbb92/pyarrow-22.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:b41f37cabfe2463232684de44bad753d6be08a7a072f6a83447eeaf0e4d2a215", size = 45030348, upload-time = "2025-10-24T10:04:43.366Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/e5/53c0a1c428f0976bf22f513d79c73000926cb00b9c138d8e02daf2102e18/pyarrow-22.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:35ad0f0378c9359b3f297299c3309778bb03b8612f987399a0333a560b43862d", size = 47699480, upload-time = "2025-10-24T10:04:51.486Z" },
+    { url = "https://files.pythonhosted.org/packages/95/e1/9dbe4c465c3365959d183e6345d0a8d1dc5b02ca3f8db4760b3bc834cf25/pyarrow-22.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8382ad21458075c2e66a82a29d650f963ce51c7708c7c0ff313a8c206c4fd5e8", size = 48011148, upload-time = "2025-10-24T10:04:59.585Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/b4/7caf5d21930061444c3cf4fa7535c82faf5263e22ce43af7c2759ceb5b8b/pyarrow-22.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1a812a5b727bc09c3d7ea072c4eebf657c2f7066155506ba31ebf4792f88f016", size = 50276964, upload-time = "2025-10-24T10:05:08.175Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/f3/cec89bd99fa3abf826f14d4e53d3d11340ce6f6af4d14bdcd54cd83b6576/pyarrow-22.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:ec5d40dd494882704fb876c16fa7261a69791e784ae34e6b5992e977bd2e238c", size = 28106517, upload-time = "2025-10-24T10:05:14.314Z" },
+    { url = "https://files.pythonhosted.org/packages/af/63/ba23862d69652f85b615ca14ad14f3bcfc5bf1b99ef3f0cd04ff93fdad5a/pyarrow-22.0.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:bea79263d55c24a32b0d79c00a1c58bb2ee5f0757ed95656b01c0fb310c5af3d", size = 34211578, upload-time = "2025-10-24T10:05:21.583Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/d0/f9ad86fe809efd2bcc8be32032fa72e8b0d112b01ae56a053006376c5930/pyarrow-22.0.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:12fe549c9b10ac98c91cf791d2945e878875d95508e1a5d14091a7aaa66d9cf8", size = 35989906, upload-time = "2025-10-24T10:05:29.485Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/a8/f910afcb14630e64d673f15904ec27dd31f1e009b77033c365c84e8c1e1d/pyarrow-22.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:334f900ff08ce0423407af97e6c26ad5d4e3b0763645559ece6fbf3747d6a8f5", size = 45021677, upload-time = "2025-10-24T10:05:38.274Z" },
+    { url = "https://files.pythonhosted.org/packages/13/95/aec81f781c75cd10554dc17a25849c720d54feafb6f7847690478dcf5ef8/pyarrow-22.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:c6c791b09c57ed76a18b03f2631753a4960eefbbca80f846da8baefc6491fcfe", size = 47726315, upload-time = "2025-10-24T10:05:47.314Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/d4/74ac9f7a54cfde12ee42734ea25d5a3c9a45db78f9def949307a92720d37/pyarrow-22.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c3200cb41cdbc65156e5f8c908d739b0dfed57e890329413da2748d1a2cd1a4e", size = 47990906, upload-time = "2025-10-24T10:05:58.254Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/71/fedf2499bf7a95062eafc989ace56572f3343432570e1c54e6599d5b88da/pyarrow-22.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ac93252226cf288753d8b46280f4edf3433bf9508b6977f8dd8526b521a1bbb9", size = 50306783, upload-time = "2025-10-24T10:06:08.08Z" },
+    { url = "https://files.pythonhosted.org/packages/68/ed/b202abd5a5b78f519722f3d29063dda03c114711093c1995a33b8e2e0f4b/pyarrow-22.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:44729980b6c50a5f2bfcc2668d36c569ce17f8b17bccaf470c4313dcbbf13c9d", size = 27972883, upload-time = "2025-10-24T10:06:14.204Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/d6/d0fac16a2963002fc22c8fa75180a838737203d558f0ed3b564c4a54eef5/pyarrow-22.0.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:e6e95176209257803a8b3d0394f21604e796dadb643d2f7ca21b66c9c0b30c9a", size = 34204629, upload-time = "2025-10-24T10:06:20.274Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/9c/1d6357347fbae062ad3f17082f9ebc29cc733321e892c0d2085f42a2212b/pyarrow-22.0.0-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:001ea83a58024818826a9e3f89bf9310a114f7e26dfe404a4c32686f97bd7901", size = 35985783, upload-time = "2025-10-24T10:06:27.301Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/c0/782344c2ce58afbea010150df07e3a2f5fdad299cd631697ae7bd3bac6e3/pyarrow-22.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:ce20fe000754f477c8a9125543f1936ea5b8867c5406757c224d745ed033e691", size = 45020999, upload-time = "2025-10-24T10:06:35.387Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/8b/5362443737a5307a7b67c1017c42cd104213189b4970bf607e05faf9c525/pyarrow-22.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:e0a15757fccb38c410947df156f9749ae4a3c89b2393741a50521f39a8cf202a", size = 47724601, upload-time = "2025-10-24T10:06:43.551Z" },
+    { url = "https://files.pythonhosted.org/packages/69/4d/76e567a4fc2e190ee6072967cb4672b7d9249ac59ae65af2d7e3047afa3b/pyarrow-22.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cedb9dd9358e4ea1d9bce3665ce0797f6adf97ff142c8e25b46ba9cdd508e9b6", size = 48001050, upload-time = "2025-10-24T10:06:52.284Z" },
+    { url = "https://files.pythonhosted.org/packages/01/5e/5653f0535d2a1aef8223cee9d92944cb6bccfee5cf1cd3f462d7cb022790/pyarrow-22.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:252be4a05f9d9185bb8c18e83764ebcfea7185076c07a7a662253af3a8c07941", size = 50307877, upload-time = "2025-10-24T10:07:02.405Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/f8/1d0bd75bf9328a3b826e24a16e5517cd7f9fbf8d34a3184a4566ef5a7f29/pyarrow-22.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:a4893d31e5ef780b6edcaf63122df0f8d321088bb0dee4c8c06eccb1ca28d145", size = 27977099, upload-time = "2025-10-24T10:08:07.259Z" },
+    { url = "https://files.pythonhosted.org/packages/90/81/db56870c997805bf2b0f6eeeb2d68458bf4654652dccdcf1bf7a42d80903/pyarrow-22.0.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:f7fe3dbe871294ba70d789be16b6e7e52b418311e166e0e3cba9522f0f437fb1", size = 34336685, upload-time = "2025-10-24T10:07:11.47Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/98/0727947f199aba8a120f47dfc229eeb05df15bcd7a6f1b669e9f882afc58/pyarrow-22.0.0-cp313-cp313t-macosx_12_0_x86_64.whl", hash = "sha256:ba95112d15fd4f1105fb2402c4eab9068f0554435e9b7085924bcfaac2cc306f", size = 36032158, upload-time = "2025-10-24T10:07:18.626Z" },
+    { url = "https://files.pythonhosted.org/packages/96/b4/9babdef9c01720a0785945c7cf550e4acd0ebcd7bdd2e6f0aa7981fa85e2/pyarrow-22.0.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:c064e28361c05d72eed8e744c9605cbd6d2bb7481a511c74071fd9b24bc65d7d", size = 44892060, upload-time = "2025-10-24T10:07:26.002Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ca/2f8804edd6279f78a37062d813de3f16f29183874447ef6d1aadbb4efa0f/pyarrow-22.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:6f9762274496c244d951c819348afbcf212714902742225f649cf02823a6a10f", size = 47504395, upload-time = "2025-10-24T10:07:34.09Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/f0/77aa5198fd3943682b2e4faaf179a674f0edea0d55d326d83cb2277d9363/pyarrow-22.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a9d9ffdc2ab696f6b15b4d1f7cec6658e1d788124418cb30030afbae31c64746", size = 48066216, upload-time = "2025-10-24T10:07:43.528Z" },
+    { url = "https://files.pythonhosted.org/packages/79/87/a1937b6e78b2aff18b706d738c9e46ade5bfcf11b294e39c87706a0089ac/pyarrow-22.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ec1a15968a9d80da01e1d30349b2b0d7cc91e96588ee324ce1b5228175043e95", size = 50288552, upload-time = "2025-10-24T10:07:53.519Z" },
+    { url = "https://files.pythonhosted.org/packages/60/ae/b5a5811e11f25788ccfdaa8f26b6791c9807119dffcf80514505527c384c/pyarrow-22.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:bba208d9c7decf9961998edf5c65e3ea4355d5818dd6cd0f6809bec1afb951cc", size = 28262504, upload-time = "2025-10-24T10:08:00.932Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/b0/0fa4d28a8edb42b0a7144edd20befd04173ac79819547216f8a9f36f9e50/pyarrow-22.0.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:9bddc2cade6561f6820d4cd73f99a0243532ad506bc510a75a5a65a522b2d74d", size = 34224062, upload-time = "2025-10-24T10:08:14.101Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/a8/7a719076b3c1be0acef56a07220c586f25cd24de0e3f3102b438d18ae5df/pyarrow-22.0.0-cp314-cp314-macosx_12_0_x86_64.whl", hash = "sha256:e70ff90c64419709d38c8932ea9fe1cc98415c4f87ea8da81719e43f02534bc9", size = 35990057, upload-time = "2025-10-24T10:08:21.842Z" },
+    { url = "https://files.pythonhosted.org/packages/89/3c/359ed54c93b47fb6fe30ed16cdf50e3f0e8b9ccfb11b86218c3619ae50a8/pyarrow-22.0.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:92843c305330aa94a36e706c16209cd4df274693e777ca47112617db7d0ef3d7", size = 45068002, upload-time = "2025-10-24T10:08:29.034Z" },
+    { url = "https://files.pythonhosted.org/packages/55/fc/4945896cc8638536ee787a3bd6ce7cec8ec9acf452d78ec39ab328efa0a1/pyarrow-22.0.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:6dda1ddac033d27421c20d7a7943eec60be44e0db4e079f33cc5af3b8280ccde", size = 47737765, upload-time = "2025-10-24T10:08:38.559Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/5e/7cb7edeb2abfaa1f79b5d5eb89432356155c8426f75d3753cbcb9592c0fd/pyarrow-22.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:84378110dd9a6c06323b41b56e129c504d157d1a983ce8f5443761eb5256bafc", size = 48048139, upload-time = "2025-10-24T10:08:46.784Z" },
+    { url = "https://files.pythonhosted.org/packages/88/c6/546baa7c48185f5e9d6e59277c4b19f30f48c94d9dd938c2a80d4d6b067c/pyarrow-22.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:854794239111d2b88b40b6ef92aa478024d1e5074f364033e73e21e3f76b25e0", size = 50314244, upload-time = "2025-10-24T10:08:55.771Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/79/755ff2d145aafec8d347bf18f95e4e81c00127f06d080135dfc86aea417c/pyarrow-22.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:b883fe6fd85adad7932b3271c38ac289c65b7337c2c132e9569f9d3940620730", size = 28757501, upload-time = "2025-10-24T10:09:59.891Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/d2/237d75ac28ced3147912954e3c1a174df43a95f4f88e467809118a8165e0/pyarrow-22.0.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:7a820d8ae11facf32585507c11f04e3f38343c1e784c9b5a8b1da5c930547fe2", size = 34355506, upload-time = "2025-10-24T10:09:02.953Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/2c/733dfffe6d3069740f98e57ff81007809067d68626c5faef293434d11bd6/pyarrow-22.0.0-cp314-cp314t-macosx_12_0_x86_64.whl", hash = "sha256:c6ec3675d98915bf1ec8b3c7986422682f7232ea76cad276f4c8abd5b7319b70", size = 36047312, upload-time = "2025-10-24T10:09:10.334Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/2b/29d6e3782dc1f299727462c1543af357a0f2c1d3c160ce199950d9ca51eb/pyarrow-22.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:3e739edd001b04f654b166204fc7a9de896cf6007eaff33409ee9e50ceaff754", size = 45081609, upload-time = "2025-10-24T10:09:18.61Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/42/aa9355ecc05997915af1b7b947a7f66c02dcaa927f3203b87871c114ba10/pyarrow-22.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:7388ac685cab5b279a41dfe0a6ccd99e4dbf322edfb63e02fc0443bf24134e91", size = 47703663, upload-time = "2025-10-24T10:09:27.369Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/62/45abedde480168e83a1de005b7b7043fd553321c1e8c5a9a114425f64842/pyarrow-22.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f633074f36dbc33d5c05b5dc75371e5660f1dbf9c8b1d95669def05e5425989c", size = 48066543, upload-time = "2025-10-24T10:09:34.908Z" },
+    { url = "https://files.pythonhosted.org/packages/84/e9/7878940a5b072e4f3bf998770acafeae13b267f9893af5f6d4ab3904b67e/pyarrow-22.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:4c19236ae2402a8663a2c8f21f1870a03cc57f0bef7e4b6eb3238cc82944de80", size = 50288838, upload-time = "2025-10-24T10:09:44.394Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/03/f335d6c52b4a4761bcc83499789a1e2e16d9d201a58c327a9b5cc9a41bd9/pyarrow-22.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:0c34fe18094686194f204a3b1787a27456897d8a2d62caf84b61e8dfbc0252ae", size = 29185594, upload-time = "2025-10-24T10:09:53.111Z" },
+]
+
+[[package]]
+name = "pycparser"
+version = "2.22"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", size = 172736, upload-time = "2024-03-30T13:22:22.564Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552, upload-time = "2024-03-30T13:22:20.476Z" },
+]
+
+[[package]]
+name = "pydata-sphinx-theme"
+version = "0.8.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "beautifulsoup4" },
+    { name = "docutils" },
+    { name = "sphinx" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fc/d6/3921de802cf1ee771f0e76c9068b52498aeb8eeec6b830ff931c81c7ecf3/pydata_sphinx_theme-0.8.0.tar.gz", hash = "sha256:9f72015d9c572ea92e3007ab221a8325767c426783b6b9941813e65fa988dc90", size = 1123746, upload-time = "2022-01-15T19:25:25.712Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/91/26/0694318d46c7d90ab602ae27b24431e939f1600f9a4c69d1e727ec57289f/pydata_sphinx_theme-0.8.0-py3-none-any.whl", hash = "sha256:fbcbb833a07d3ad8dd997dd40dc94da18d98b41c68123ab0182b58fe92271204", size = 3284997, upload-time = "2022-01-15T19:25:23.807Z" },
+]
+
+[[package]]
+name = "pygithub"
+version = "2.5.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "deprecated" },
+    { name = "pyjwt", extra = ["crypto"] },
+    { name = "pynacl" },
+    { name = "requests" },
+    { name = "typing-extensions" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/16/ce/aa91d30040d9552c274e7ea8bd10a977600d508d579a4bb262b95eccf961/pygithub-2.5.0.tar.gz", hash = "sha256:e1613ac508a9be710920d26eb18b1905ebd9926aa49398e88151c1b526aad3cf", size = 3552804, upload-time = "2024-11-06T20:50:07.168Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/37/05/bfbdbbc5d8aafd8dae9b3b6877edca561fccd8528ef5edc4e7b6d23721b5/PyGithub-2.5.0-py3-none-any.whl", hash = "sha256:b0b635999a658ab8e08720bdd3318893ff20e2275f6446fcf35bf3f44f2c0fd2", size = 375935, upload-time = "2024-11-06T20:50:04.931Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7c/2d/c3338d48ea6cc0feb8446d8e6937e1408088a72a39937982cc6111d17f84/pygments-2.19.1.tar.gz", hash = "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f", size = 4968581, upload-time = "2025-01-06T17:26:30.443Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8a/0b/9fcc47d19c48b59121088dd6da2488a49d5f72dacf8262e2790a1d2c7d15/pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c", size = 1225293, upload-time = "2025-01-06T17:26:25.553Z" },
+]
+
+[[package]]
+name = "pyjwt"
+version = "2.10.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/46/bd74733ff231675599650d3e47f361794b22ef3e3770998dda30d3b63726/pyjwt-2.10.1.tar.gz", hash = "sha256:3cc5772eb20009233caf06e9d8a0577824723b44e6648ee0a2aedb6cf9381953", size = 87785, upload-time = "2024-11-28T03:43:29.933Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/61/ad/689f02752eeec26aed679477e80e632ef1b682313be70793d798c1d5fc8f/PyJWT-2.10.1-py3-none-any.whl", hash = "sha256:dcdd193e30abefd5debf142f9adfcdd2b58004e644f25406ffaebd50bd98dacb", size = 22997, upload-time = "2024-11-28T03:43:27.893Z" },
+]
+
+[package.optional-dependencies]
+crypto = [
+    { name = "cryptography" },
+]
+
+[[package]]
+name = "pynacl"
+version = "1.5.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a7/22/27582568be639dfe22ddb3902225f91f2f17ceff88ce80e4db396c8986da/PyNaCl-1.5.0.tar.gz", hash = "sha256:8ac7448f09ab85811607bdd21ec2464495ac8b7c66d146bf545b0f08fb9220ba", size = 3392854, upload-time = "2022-01-07T22:05:41.134Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/75/0b8ede18506041c0bf23ac4d8e2971b4161cd6ce630b177d0a08eb0d8857/PyNaCl-1.5.0-cp36-abi3-macosx_10_10_universal2.whl", hash = "sha256:401002a4aaa07c9414132aaed7f6836ff98f59277a234704ff66878c2ee4a0d1", size = 349920, upload-time = "2022-01-07T22:05:49.156Z" },
+    { url = "https://files.pythonhosted.org/packages/59/bb/fddf10acd09637327a97ef89d2a9d621328850a72f1fdc8c08bdf72e385f/PyNaCl-1.5.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_24_aarch64.whl", hash = "sha256:52cb72a79269189d4e0dc537556f4740f7f0a9ec41c1322598799b0bdad4ef92", size = 601722, upload-time = "2022-01-07T22:05:50.989Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/70/87a065c37cca41a75f2ce113a5a2c2aa7533be648b184ade58971b5f7ccc/PyNaCl-1.5.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a36d4a9dda1f19ce6e03c9a784a2921a4b726b02e1c736600ca9c22029474394", size = 680087, upload-time = "2022-01-07T22:05:52.539Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/87/f1bb6a595f14a327e8285b9eb54d41fef76c585a0edef0a45f6fc95de125/PyNaCl-1.5.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:0c84947a22519e013607c9be43706dd42513f9e6ae5d39d3613ca1e142fba44d", size = 856678, upload-time = "2022-01-07T22:05:54.251Z" },
+    { url = "https://files.pythonhosted.org/packages/66/28/ca86676b69bf9f90e710571b67450508484388bfce09acf8a46f0b8c785f/PyNaCl-1.5.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:06b8f6fa7f5de8d5d2f7573fe8c863c051225a27b61e6860fd047b1775807858", size = 1133660, upload-time = "2022-01-07T22:05:56.056Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/85/c262db650e86812585e2bc59e497a8f59948a005325a11bbbc9ecd3fe26b/PyNaCl-1.5.0-cp36-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:a422368fc821589c228f4c49438a368831cb5bbc0eab5ebe1d7fac9dded6567b", size = 663824, upload-time = "2022-01-07T22:05:57.434Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/1a/cc308a884bd299b651f1633acb978e8596c71c33ca85e9dc9fa33a5399b9/PyNaCl-1.5.0-cp36-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:61f642bf2378713e2c2e1de73444a3778e5f0a38be6fee0fe532fe30060282ff", size = 1117912, upload-time = "2022-01-07T22:05:58.665Z" },
+    { url = "https://files.pythonhosted.org/packages/25/2d/b7df6ddb0c2a33afdb358f8af6ea3b8c4d1196ca45497dd37a56f0c122be/PyNaCl-1.5.0-cp36-abi3-win32.whl", hash = "sha256:e46dae94e34b085175f8abb3b0aaa7da40767865ac82c928eeb9e57e1ea8a543", size = 204624, upload-time = "2022-01-07T22:06:00.085Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/22/d3db169895faaf3e2eda892f005f433a62db2decbcfbc2f61e6517adfa87/PyNaCl-1.5.0-cp36-abi3-win_amd64.whl", hash = "sha256:20f42270d27e1b6a29f54032090b972d97f0a1b0948cc52392041ef7831fee93", size = 212141, upload-time = "2022-01-07T22:06:01.861Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "8.3.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/05/35/30e0d83068951d90a01852cb1cef56e5d8a09d20c7f511634cc2f7e0372a/pytest-8.3.4.tar.gz", hash = "sha256:965370d062bce11e73868e0335abac31b4d3de0e82f4007408d242b4f8610761", size = 1445919, upload-time = "2024-12-01T12:54:25.98Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/11/92/76a1c94d3afee238333bc0a42b82935dd8f9cf8ce9e336ff87ee14d9e1cf/pytest-8.3.4-py3-none-any.whl", hash = "sha256:50e16d954148559c9a74109af1eaf0c945ba2d8f30f0a3d3335edde19788b6f6", size = 343083, upload-time = "2024-12-01T12:54:19.735Z" },
+]
+
+[[package]]
+name = "pytest-asyncio"
+version = "0.25.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f2/a8/ecbc8ede70921dd2f544ab1cadd3ff3bf842af27f87bbdea774c7baa1d38/pytest_asyncio-0.25.3.tar.gz", hash = "sha256:fc1da2cf9f125ada7e710b4ddad05518d4cee187ae9412e9ac9271003497f07a", size = 54239, upload-time = "2025-01-28T18:37:58.729Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/67/17/3493c5624e48fd97156ebaec380dcaafee9506d7e2c46218ceebbb57d7de/pytest_asyncio-0.25.3-py3-none-any.whl", hash = "sha256:9e89518e0f9bd08928f97a3482fdc4e244df17529460bc038291ccaf8f85c7c3", size = 19467, upload-time = "2025-01-28T18:37:56.798Z" },
+]
+
+[[package]]
+name = "python-dateutil"
+version = "2.9.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
+]
+
+[[package]]
+name = "pytz"
+version = "2024.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/3a/31/3c70bf7603cc2dca0f19bdc53b4537a797747a58875b552c8c413d963a3f/pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a", size = 319692, upload-time = "2024-09-11T02:24:47.91Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/11/c3/005fcca25ce078d2cc29fd559379817424e94885510568bc1bc53d7d5846/pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725", size = 508002, upload-time = "2024-09-11T02:24:45.8Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" },
+    { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" },
+    { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },
+    { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },
+    { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },
+    { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },
+    { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
+    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
+    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
+]
+
+[[package]]
+name = "requests"
+version = "2.32.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218, upload-time = "2024-05-29T15:37:49.536Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928, upload-time = "2024-05-29T15:37:47.027Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.9.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/67/3e/e89f736f01aa9517a97e2e7e0ce8d34a4d8207087b3cfdec95133fee13b5/ruff-0.9.1.tar.gz", hash = "sha256:fd2b25ecaf907d6458fa842675382c8597b3c746a2dde6717fe3415425df0c17", size = 3498844, upload-time = "2025-01-10T18:57:53.896Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/05/c3a2e0feb3d5d394cdfd552de01df9d3ec8a3a3771bbff247fab7e668653/ruff-0.9.1-py3-none-linux_armv6l.whl", hash = "sha256:84330dda7abcc270e6055551aca93fdde1b0685fc4fd358f26410f9349cf1743", size = 10645241, upload-time = "2025-01-10T18:56:45.897Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/da/59f0a40e5f88ee5c054ad175caaa2319fc96571e1d29ab4730728f2aad4f/ruff-0.9.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:3cae39ba5d137054b0e5b472aee3b78a7c884e61591b100aeb544bcd1fc38d4f", size = 10391066, upload-time = "2025-01-10T18:56:52.224Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/fe/85e1c1acf0ba04a3f2d54ae61073da030f7a5dc386194f96f3c6ca444a78/ruff-0.9.1-py3-none-macosx_11_0_arm64.whl", hash = "sha256:50c647ff96f4ba288db0ad87048257753733763b409b2faf2ea78b45c8bb7fcb", size = 10012308, upload-time = "2025-01-10T18:56:55.426Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/9b/780aa5d4bdca8dcea4309264b8faa304bac30e1ce0bcc910422bfcadd203/ruff-0.9.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f0c8b149e9c7353cace7d698e1656ffcf1e36e50f8ea3b5d5f7f87ff9986a7ca", size = 10881960, upload-time = "2025-01-10T18:56:59.539Z" },
+    { url = "https://files.pythonhosted.org/packages/12/f4/dac4361afbfe520afa7186439e8094e4884ae3b15c8fc75fb2e759c1f267/ruff-0.9.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:beb3298604540c884d8b282fe7625651378e1986c25df51dec5b2f60cafc31ce", size = 10414803, upload-time = "2025-01-10T18:57:04.919Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/a2/057a3cb7999513cb78d6cb33a7d1cc6401c82d7332583786e4dad9e38e44/ruff-0.9.1-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:39d0174ccc45c439093971cc06ed3ac4dc545f5e8bdacf9f067adf879544d969", size = 11464929, upload-time = "2025-01-10T18:57:08.146Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/c6/1ccfcc209bee465ced4874dcfeaadc88aafcc1ea9c9f31ef66f063c187f0/ruff-0.9.1-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:69572926c0f0c9912288915214ca9b2809525ea263603370b9e00bed2ba56dbd", size = 12170717, upload-time = "2025-01-10T18:57:12.564Z" },
+    { url = "https://files.pythonhosted.org/packages/84/97/4a524027518525c7cf6931e9fd3b2382be5e4b75b2b61bec02681a7685a5/ruff-0.9.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:937267afce0c9170d6d29f01fcd1f4378172dec6760a9f4dface48cdabf9610a", size = 11708921, upload-time = "2025-01-10T18:57:17.216Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/a4/4e77cf6065c700d5593b25fca6cf725b1ab6d70674904f876254d0112ed0/ruff-0.9.1-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:186c2313de946f2c22bdf5954b8dd083e124bcfb685732cfb0beae0c47233d9b", size = 13058074, upload-time = "2025-01-10T18:57:20.57Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/d6/fcb78e0531e863d0a952c4c5600cc5cd317437f0e5f031cd2288b117bb37/ruff-0.9.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f94942a3bb767675d9a051867c036655fe9f6c8a491539156a6f7e6b5f31831", size = 11281093, upload-time = "2025-01-10T18:57:25.526Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/3b/7235bbeff00c95dc2d073cfdbf2b871b5bbf476754c5d277815d286b4328/ruff-0.9.1-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:728d791b769cc28c05f12c280f99e8896932e9833fef1dd8756a6af2261fd1ab", size = 10882610, upload-time = "2025-01-10T18:57:28.855Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/66/5599d23257c61cf038137f82999ca8f9d0080d9d5134440a461bef85b461/ruff-0.9.1-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:2f312c86fb40c5c02b44a29a750ee3b21002bd813b5233facdaf63a51d9a85e1", size = 10489273, upload-time = "2025-01-10T18:57:32.219Z" },
+    { url = "https://files.pythonhosted.org/packages/78/85/de4aa057e2532db0f9761e2c2c13834991e087787b93e4aeb5f1cb10d2df/ruff-0.9.1-py3-none-musllinux_1_2_i686.whl", hash = "sha256:ae017c3a29bee341ba584f3823f805abbe5fe9cd97f87ed07ecbf533c4c88366", size = 11003314, upload-time = "2025-01-10T18:57:35.431Z" },
+    { url = "https://files.pythonhosted.org/packages/00/42/afedcaa089116d81447347f76041ff46025849fedb0ed2b187d24cf70fca/ruff-0.9.1-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:5dc40a378a0e21b4cfe2b8a0f1812a6572fc7b230ef12cd9fac9161aa91d807f", size = 11342982, upload-time = "2025-01-10T18:57:38.642Z" },
+    { url = "https://files.pythonhosted.org/packages/39/c6/fe45f3eb27e3948b41a305d8b768e949bf6a39310e9df73f6c576d7f1d9f/ruff-0.9.1-py3-none-win32.whl", hash = "sha256:46ebf5cc106cf7e7378ca3c28ce4293b61b449cd121b98699be727d40b79ba72", size = 8819750, upload-time = "2025-01-10T18:57:41.93Z" },
+    { url = "https://files.pythonhosted.org/packages/38/8d/580db77c3b9d5c3d9479e55b0b832d279c30c8f00ab0190d4cd8fc67831c/ruff-0.9.1-py3-none-win_amd64.whl", hash = "sha256:342a824b46ddbcdddd3abfbb332fa7fcaac5488bf18073e841236aadf4ad5c19", size = 9701331, upload-time = "2025-01-10T18:57:46.334Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/94/0498cdb7316ed67a1928300dd87d659c933479f44dec51b4f62bfd1f8028/ruff-0.9.1-py3-none-win_arm64.whl", hash = "sha256:1cd76c7f9c679e6e8f2af8f778367dca82b95009bc7b1a85a47f1521ae524fa7", size = 9145708, upload-time = "2025-01-10T18:57:51.308Z" },
+]
+
+[[package]]
+name = "setuptools"
+version = "75.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/92/ec/089608b791d210aec4e7f97488e67ab0d33add3efccb83a056cbafe3a2a6/setuptools-75.8.0.tar.gz", hash = "sha256:c5afc8f407c626b8313a86e10311dd3f661c6cd9c09d4bf8c15c0e11f9f2b0e6", size = 1343222, upload-time = "2025-01-08T18:28:23.98Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/69/8a/b9dc7678803429e4a3bc9ba462fa3dd9066824d3c607490235c6a796be5a/setuptools-75.8.0-py3-none-any.whl", hash = "sha256:e3982f444617239225d675215d51f6ba05f845d4eec313da4418fdbb56fb27e3", size = 1228782, upload-time = "2025-01-08T18:28:20.912Z" },
+]
+
+[[package]]
+name = "six"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
+]
+
+[[package]]
+name = "snowballstemmer"
+version = "2.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/44/7b/af302bebf22c749c56c9c3e8ae13190b5b5db37a33d9068652e8f73b7089/snowballstemmer-2.2.0.tar.gz", hash = "sha256:09b16deb8547d3412ad7b590689584cd0fe25ec8db3be37788be3810cbf19cb1", size = 86699, upload-time = "2021-11-16T18:38:38.009Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ed/dc/c02e01294f7265e63a7315fe086dd1df7dacb9f840a804da846b96d01b96/snowballstemmer-2.2.0-py2.py3-none-any.whl", hash = "sha256:c8e1716e83cc398ae16824e5572ae04e0d9fc2c6b985fb0f900f5f0c96ecba1a", size = 93002, upload-time = "2021-11-16T18:38:34.792Z" },
+]
+
+[[package]]
+name = "soupsieve"
+version = "2.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/ce/fbaeed4f9fb8b2daa961f90591662df6a86c1abf25c548329a86920aedfb/soupsieve-2.6.tar.gz", hash = "sha256:e2e68417777af359ec65daac1057404a3c8a5455bb8abc36f1a9866ab1a51abb", size = 101569, upload-time = "2024-08-13T13:39:12.166Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/c2/fe97d779f3ef3b15f05c94a2f1e3d21732574ed441687474db9d342a7315/soupsieve-2.6-py3-none-any.whl", hash = "sha256:e72c4ff06e4fb6e4b5a9f0f55fe6e81514581fca1515028625d0f299c602ccc9", size = 36186, upload-time = "2024-08-13T13:39:10.986Z" },
+]
+
+[[package]]
+name = "sphinx"
+version = "8.1.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "alabaster" },
+    { name = "babel" },
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "docutils" },
+    { name = "imagesize" },
+    { name = "jinja2" },
+    { name = "packaging" },
+    { name = "pygments" },
+    { name = "requests" },
+    { name = "snowballstemmer" },
+    { name = "sphinxcontrib-applehelp" },
+    { name = "sphinxcontrib-devhelp" },
+    { name = "sphinxcontrib-htmlhelp" },
+    { name = "sphinxcontrib-jsmath" },
+    { name = "sphinxcontrib-qthelp" },
+    { name = "sphinxcontrib-serializinghtml" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/be0b61178fe2cdcb67e2a92fc9ebb488e3c51c4f74a36a7824c0adf23425/sphinx-8.1.3.tar.gz", hash = "sha256:43c1911eecb0d3e161ad78611bc905d1ad0e523e4ddc202a58a821773dc4c927", size = 8184611, upload-time = "2024-10-13T20:27:13.93Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/26/60/1ddff83a56d33aaf6f10ec8ce84b4c007d9368b21008876fceda7e7381ef/sphinx-8.1.3-py3-none-any.whl", hash = "sha256:09719015511837b76bf6e03e42eb7595ac8c2e41eeb9c29c5b755c6b677992a2", size = 3487125, upload-time = "2024-10-13T20:27:10.448Z" },
+]
+
+[[package]]
+name = "sphinx-autoapi"
+version = "3.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "astroid" },
+    { name = "jinja2" },
+    { name = "pyyaml" },
+    { name = "sphinx" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4a/eb/cc243583bb1d518ca3b10998c203d919a8ed90affd4831f2b61ad09043d2/sphinx_autoapi-3.4.0.tar.gz", hash = "sha256:e6d5371f9411bbb9fca358c00a9e57aef3ac94cbfc5df4bab285946462f69e0c", size = 29292, upload-time = "2024-11-30T01:09:40.956Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/d6/f2acdc2567337fd5f5dc091a4e58d8a0fb14927b9779fc1e5ecee96d9824/sphinx_autoapi-3.4.0-py3-none-any.whl", hash = "sha256:4027fef2875a22c5f2a57107c71641d82f6166bf55beb407a47aaf3ef14e7b92", size = 34095, upload-time = "2024-11-30T01:09:17.272Z" },
+]
+
+[[package]]
+name = "sphinxcontrib-applehelp"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ba/6e/b837e84a1a704953c62ef8776d45c3e8d759876b4a84fe14eba2859106fe/sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1", size = 20053, upload-time = "2024-07-29T01:09:00.465Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5d/85/9ebeae2f76e9e77b952f4b274c27238156eae7979c5421fba91a28f4970d/sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5", size = 119300, upload-time = "2024-07-29T01:08:58.99Z" },
+]
+
+[[package]]
+name = "sphinxcontrib-devhelp"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f6/d2/5beee64d3e4e747f316bae86b55943f51e82bb86ecd325883ef65741e7da/sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad", size = 12967, upload-time = "2024-07-29T01:09:23.417Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/35/7a/987e583882f985fe4d7323774889ec58049171828b58c2217e7f79cdf44e/sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2", size = 82530, upload-time = "2024-07-29T01:09:21.945Z" },
+]
+
+[[package]]
+name = "sphinxcontrib-htmlhelp"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/93/983afd9aa001e5201eab16b5a444ed5b9b0a7a010541e0ddfbbfd0b2470c/sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9", size = 22617, upload-time = "2024-07-29T01:09:37.889Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0a/7b/18a8c0bcec9182c05a0b3ec2a776bba4ead82750a55ff798e8d406dae604/sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8", size = 98705, upload-time = "2024-07-29T01:09:36.407Z" },
+]
+
+[[package]]
+name = "sphinxcontrib-jsmath"
+version = "1.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b2/e8/9ed3830aeed71f17c026a07a5097edcf44b692850ef215b161b8ad875729/sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8", size = 5787, upload-time = "2019-01-21T16:10:16.347Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c2/42/4c8646762ee83602e3fb3fbe774c2fac12f317deb0b5dbeeedd2d3ba4b77/sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178", size = 5071, upload-time = "2019-01-21T16:10:14.333Z" },
+]
+
+[[package]]
+name = "sphinxcontrib-qthelp"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/68/bc/9104308fc285eb3e0b31b67688235db556cd5b0ef31d96f30e45f2e51cae/sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab", size = 17165, upload-time = "2024-07-29T01:09:56.435Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/27/83/859ecdd180cacc13b1f7e857abf8582a64552ea7a061057a6c716e790fce/sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb", size = 88743, upload-time = "2024-07-29T01:09:54.885Z" },
+]
+
+[[package]]
+name = "sphinxcontrib-serializinghtml"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/3b/44/6716b257b0aa6bfd51a1b31665d1c205fb12cb5ad56de752dfa15657de2f/sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d", size = 16080, upload-time = "2024-07-29T01:10:09.332Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", size = 92072, upload-time = "2024-07-29T01:10:08.203Z" },
+]
+
+[[package]]
+name = "stack-data"
+version = "0.6.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "asttokens" },
+    { name = "executing" },
+    { name = "pure-eval" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" },
+]
+
+[[package]]
+name = "toml"
+version = "0.10.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/be/ba/1f744cdc819428fc6b5084ec34d9b30660f6f9daaf70eead706e3203ec3c/toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f", size = 22253, upload-time = "2020-11-01T01:40:22.204Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/44/6f/7120676b6d73228c96e17f1f794d8ab046fc910d781c8d151120c3f1569e/toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b", size = 16588, upload-time = "2020-11-01T01:40:20.672Z" },
+]
+
+[[package]]
+name = "tomli"
+version = "2.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/18/87/302344fed471e44a87289cf4967697d07e532f2421fdaf868a303cbae4ff/tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff", size = 17175, upload-time = "2024-11-27T22:38:36.873Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/43/ca/75707e6efa2b37c77dadb324ae7d9571cb424e61ea73fad7c56c2d14527f/tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249", size = 131077, upload-time = "2024-11-27T22:37:54.956Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/16/51ae563a8615d472fdbffc43a3f3d46588c264ac4f024f63f01283becfbb/tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6", size = 123429, upload-time = "2024-11-27T22:37:56.698Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/dd/4f6cd1e7b160041db83c694abc78e100473c15d54620083dbd5aae7b990e/tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a", size = 226067, upload-time = "2024-11-27T22:37:57.63Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/6b/c54ede5dc70d648cc6361eaf429304b02f2871a345bbdd51e993d6cdf550/tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee", size = 236030, upload-time = "2024-11-27T22:37:59.344Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/47/999514fa49cfaf7a92c805a86c3c43f4215621855d151b61c602abb38091/tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e", size = 240898, upload-time = "2024-11-27T22:38:00.429Z" },
+    { url = "https://files.pythonhosted.org/packages/73/41/0a01279a7ae09ee1573b423318e7934674ce06eb33f50936655071d81a24/tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4", size = 229894, upload-time = "2024-11-27T22:38:02.094Z" },
+    { url = "https://files.pythonhosted.org/packages/55/18/5d8bc5b0a0362311ce4d18830a5d28943667599a60d20118074ea1b01bb7/tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106", size = 245319, upload-time = "2024-11-27T22:38:03.206Z" },
+    { url = "https://files.pythonhosted.org/packages/92/a3/7ade0576d17f3cdf5ff44d61390d4b3febb8a9fc2b480c75c47ea048c646/tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8", size = 238273, upload-time = "2024-11-27T22:38:04.217Z" },
+    { url = "https://files.pythonhosted.org/packages/72/6f/fa64ef058ac1446a1e51110c375339b3ec6be245af9d14c87c4a6412dd32/tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff", size = 98310, upload-time = "2024-11-27T22:38:05.908Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/1c/4a2dcde4a51b81be3530565e92eda625d94dafb46dbeb15069df4caffc34/tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b", size = 108309, upload-time = "2024-11-27T22:38:06.812Z" },
+    { url = "https://files.pythonhosted.org/packages/52/e1/f8af4c2fcde17500422858155aeb0d7e93477a0d59a98e56cbfe75070fd0/tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea", size = 132762, upload-time = "2024-11-27T22:38:07.731Z" },
+    { url = "https://files.pythonhosted.org/packages/03/b8/152c68bb84fc00396b83e7bbddd5ec0bd3dd409db4195e2a9b3e398ad2e3/tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8", size = 123453, upload-time = "2024-11-27T22:38:09.384Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/d6/fc9267af9166f79ac528ff7e8c55c8181ded34eb4b0e93daa767b8841573/tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192", size = 233486, upload-time = "2024-11-27T22:38:10.329Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/51/51c3f2884d7bab89af25f678447ea7d297b53b5a3b5730a7cb2ef6069f07/tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222", size = 242349, upload-time = "2024-11-27T22:38:11.443Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/df/bfa89627d13a5cc22402e441e8a931ef2108403db390ff3345c05253935e/tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77", size = 252159, upload-time = "2024-11-27T22:38:13.099Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/6e/fa2b916dced65763a5168c6ccb91066f7639bdc88b48adda990db10c8c0b/tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6", size = 237243, upload-time = "2024-11-27T22:38:14.766Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/04/885d3b1f650e1153cbb93a6a9782c58a972b94ea4483ae4ac5cedd5e4a09/tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd", size = 259645, upload-time = "2024-11-27T22:38:15.843Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/de/6b432d66e986e501586da298e28ebeefd3edc2c780f3ad73d22566034239/tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e", size = 244584, upload-time = "2024-11-27T22:38:17.645Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/9a/47c0449b98e6e7d1be6cbac02f93dd79003234ddc4aaab6ba07a9a7482e2/tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98", size = 98875, upload-time = "2024-11-27T22:38:19.159Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/60/9b9638f081c6f1261e2688bd487625cd1e660d0a85bd469e91d8db969734/tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4", size = 109418, upload-time = "2024-11-27T22:38:20.064Z" },
+    { url = "https://files.pythonhosted.org/packages/04/90/2ee5f2e0362cb8a0b6499dc44f4d7d48f8fff06d28ba46e6f1eaa61a1388/tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7", size = 132708, upload-time = "2024-11-27T22:38:21.659Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/ec/46b4108816de6b385141f082ba99e315501ccd0a2ea23db4a100dd3990ea/tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c", size = 123582, upload-time = "2024-11-27T22:38:22.693Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/bd/b470466d0137b37b68d24556c38a0cc819e8febe392d5b199dcd7f578365/tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13", size = 232543, upload-time = "2024-11-27T22:38:24.367Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/e5/82e80ff3b751373f7cead2815bcbe2d51c895b3c990686741a8e56ec42ab/tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281", size = 241691, upload-time = "2024-11-27T22:38:26.081Z" },
+    { url = "https://files.pythonhosted.org/packages/05/7e/2a110bc2713557d6a1bfb06af23dd01e7dde52b6ee7dadc589868f9abfac/tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272", size = 251170, upload-time = "2024-11-27T22:38:27.921Z" },
+    { url = "https://files.pythonhosted.org/packages/64/7b/22d713946efe00e0adbcdfd6d1aa119ae03fd0b60ebed51ebb3fa9f5a2e5/tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140", size = 236530, upload-time = "2024-11-27T22:38:29.591Z" },
+    { url = "https://files.pythonhosted.org/packages/38/31/3a76f67da4b0cf37b742ca76beaf819dca0ebef26d78fc794a576e08accf/tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2", size = 258666, upload-time = "2024-11-27T22:38:30.639Z" },
+    { url = "https://files.pythonhosted.org/packages/07/10/5af1293da642aded87e8a988753945d0cf7e00a9452d3911dd3bb354c9e2/tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744", size = 243954, upload-time = "2024-11-27T22:38:31.702Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/b9/1ed31d167be802da0fc95020d04cd27b7d7065cc6fbefdd2f9186f60d7bd/tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec", size = 98724, upload-time = "2024-11-27T22:38:32.837Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/32/b0963458706accd9afcfeb867c0f9175a741bf7b19cd424230714d722198/tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69", size = 109383, upload-time = "2024-11-27T22:38:34.455Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257, upload-time = "2024-11-27T22:38:35.385Z" },
+]
+
+[[package]]
+name = "traitlets"
+version = "5.14.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621, upload-time = "2024-04-19T11:11:49.746Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359, upload-time = "2024-04-19T11:11:46.763Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.12.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321, upload-time = "2024-06-07T18:52:15.995Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438, upload-time = "2024-06-07T18:52:13.582Z" },
+]
+
+[[package]]
+name = "tzdata"
+version = "2024.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e1/34/943888654477a574a86a98e9896bae89c7aa15078ec29f490fef2f1e5384/tzdata-2024.2.tar.gz", hash = "sha256:7d85cc416e9382e69095b7bdf4afd9e3880418a2413feec7069d533d6b4e31cc", size = 193282, upload-time = "2024-09-23T18:56:46.89Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a6/ab/7e5f53c3b9d14972843a647d8d7a853969a58aecc7559cb3267302c94774/tzdata-2024.2-py2.py3-none-any.whl", hash = "sha256:a48093786cdcde33cad18c2555e8532f34422074448fbc874186f0abd79565cd", size = 346586, upload-time = "2024-09-23T18:56:45.478Z" },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/63/e53da845320b757bf29ef6a9062f5c669fe997973f966045cb019c3f4b66/urllib3-2.3.0.tar.gz", hash = "sha256:f8c5449b3cf0861679ce7e0503c7b44b5ec981bec0d1d3795a07f1ba96f0204d", size = 307268, upload-time = "2024-12-22T07:47:30.032Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c8/19/4ec628951a74043532ca2cf5d97b7b14863931476d117c471e8e2b1eb39f/urllib3-2.3.0-py3-none-any.whl", hash = "sha256:1cee9ad369867bfdbbb48b7dd50374c0967a0bb7710050facf0dd6911440e3df", size = 128369, upload-time = "2024-12-22T07:47:28.074Z" },
+]
+
+[[package]]
+name = "virtualenv"
+version = "20.31.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "distlib" },
+    { name = "filelock" },
+    { name = "platformdirs" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/56/2c/444f465fb2c65f40c3a104fd0c495184c4f2336d65baf398e3c75d72ea94/virtualenv-20.31.2.tar.gz", hash = "sha256:e10c0a9d02835e592521be48b332b6caee6887f332c111aa79a09b9e79efc2af", size = 6076316, upload-time = "2025-05-08T17:58:23.811Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f3/40/b1c265d4b2b62b58576588510fc4d1fe60a86319c8de99fd8e9fec617d2c/virtualenv-20.31.2-py3-none-any.whl", hash = "sha256:36efd0d9650ee985f0cad72065001e66d49a6f24eb44d98980f630686243cf11", size = 6057982, upload-time = "2025-05-08T17:58:21.15Z" },
+]
+
+[[package]]
+name = "wcwidth"
+version = "0.2.13"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6c/63/53559446a878410fc5a5974feb13d31d78d752eb18aeba59c7fef1af7598/wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5", size = 101301, upload-time = "2024-01-06T02:10:57.829Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fd/84/fd2ba7aafacbad3c4201d395674fc6348826569da3c0937e75505ead3528/wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859", size = 34166, upload-time = "2024-01-06T02:10:55.763Z" },
+]
+
+[[package]]
+name = "wrapt"
+version = "1.17.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/fc/e91cc220803d7bc4db93fb02facd8461c37364151b8494762cc88b0fbcef/wrapt-1.17.2.tar.gz", hash = "sha256:41388e9d4d1522446fe79d3213196bd9e3b301a336965b9e27ca2788ebd122f3", size = 55531, upload-time = "2025-01-14T10:35:45.465Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/d1/1daec934997e8b160040c78d7b31789f19b122110a75eca3d4e8da0049e1/wrapt-1.17.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:3d57c572081fed831ad2d26fd430d565b76aa277ed1d30ff4d40670b1c0dd984", size = 53307, upload-time = "2025-01-14T10:33:13.616Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/7b/13369d42651b809389c1a7153baa01d9700430576c81a2f5c5e460df0ed9/wrapt-1.17.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b5e251054542ae57ac7f3fba5d10bfff615b6c2fb09abeb37d2f1463f841ae22", size = 38486, upload-time = "2025-01-14T10:33:15.947Z" },
+    { url = "https://files.pythonhosted.org/packages/62/bf/e0105016f907c30b4bd9e377867c48c34dc9c6c0c104556c9c9126bd89ed/wrapt-1.17.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:80dd7db6a7cb57ffbc279c4394246414ec99537ae81ffd702443335a61dbf3a7", size = 38777, upload-time = "2025-01-14T10:33:17.462Z" },
+    { url = "https://files.pythonhosted.org/packages/27/70/0f6e0679845cbf8b165e027d43402a55494779295c4b08414097b258ac87/wrapt-1.17.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a6e821770cf99cc586d33833b2ff32faebdbe886bd6322395606cf55153246c", size = 83314, upload-time = "2025-01-14T10:33:21.282Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/77/0576d841bf84af8579124a93d216f55d6f74374e4445264cb378a6ed33eb/wrapt-1.17.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b60fb58b90c6d63779cb0c0c54eeb38941bae3ecf7a73c764c52c88c2dcb9d72", size = 74947, upload-time = "2025-01-14T10:33:24.414Z" },
+    { url = "https://files.pythonhosted.org/packages/90/ec/00759565518f268ed707dcc40f7eeec38637d46b098a1f5143bff488fe97/wrapt-1.17.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b870b5df5b71d8c3359d21be8f0d6c485fa0ebdb6477dda51a1ea54a9b558061", size = 82778, upload-time = "2025-01-14T10:33:26.152Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/5a/7cffd26b1c607b0b0c8a9ca9d75757ad7620c9c0a9b4a25d3f8a1480fafc/wrapt-1.17.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4011d137b9955791f9084749cba9a367c68d50ab8d11d64c50ba1688c9b457f2", size = 81716, upload-time = "2025-01-14T10:33:27.372Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/09/dccf68fa98e862df7e6a60a61d43d644b7d095a5fc36dbb591bbd4a1c7b2/wrapt-1.17.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:1473400e5b2733e58b396a04eb7f35f541e1fb976d0c0724d0223dd607e0f74c", size = 74548, upload-time = "2025-01-14T10:33:28.52Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/8e/067021fa3c8814952c5e228d916963c1115b983e21393289de15128e867e/wrapt-1.17.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3cedbfa9c940fdad3e6e941db7138e26ce8aad38ab5fe9dcfadfed9db7a54e62", size = 81334, upload-time = "2025-01-14T10:33:29.643Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/0d/9d4b5219ae4393f718699ca1c05f5ebc0c40d076f7e65fd48f5f693294fb/wrapt-1.17.2-cp310-cp310-win32.whl", hash = "sha256:582530701bff1dec6779efa00c516496968edd851fba224fbd86e46cc6b73563", size = 36427, upload-time = "2025-01-14T10:33:30.832Z" },
+    { url = "https://files.pythonhosted.org/packages/72/6a/c5a83e8f61aec1e1aeef939807602fb880e5872371e95df2137142f5c58e/wrapt-1.17.2-cp310-cp310-win_amd64.whl", hash = "sha256:58705da316756681ad3c9c73fd15499aa4d8c69f9fd38dc8a35e06c12468582f", size = 38774, upload-time = "2025-01-14T10:33:32.897Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/f7/a2aab2cbc7a665efab072344a8949a71081eed1d2f451f7f7d2b966594a2/wrapt-1.17.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:ff04ef6eec3eee8a5efef2401495967a916feaa353643defcc03fc74fe213b58", size = 53308, upload-time = "2025-01-14T10:33:33.992Z" },
+    { url = "https://files.pythonhosted.org/packages/50/ff/149aba8365fdacef52b31a258c4dc1c57c79759c335eff0b3316a2664a64/wrapt-1.17.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4db983e7bca53819efdbd64590ee96c9213894272c776966ca6306b73e4affda", size = 38488, upload-time = "2025-01-14T10:33:35.264Z" },
+    { url = "https://files.pythonhosted.org/packages/65/46/5a917ce85b5c3b490d35c02bf71aedaa9f2f63f2d15d9949cc4ba56e8ba9/wrapt-1.17.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9abc77a4ce4c6f2a3168ff34b1da9b0f311a8f1cfd694ec96b0603dff1c79438", size = 38776, upload-time = "2025-01-14T10:33:38.28Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/74/336c918d2915a4943501c77566db41d1bd6e9f4dbc317f356b9a244dfe83/wrapt-1.17.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0b929ac182f5ace000d459c59c2c9c33047e20e935f8e39371fa6e3b85d56f4a", size = 83776, upload-time = "2025-01-14T10:33:40.678Z" },
+    { url = "https://files.pythonhosted.org/packages/09/99/c0c844a5ccde0fe5761d4305485297f91d67cf2a1a824c5f282e661ec7ff/wrapt-1.17.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f09b286faeff3c750a879d336fb6d8713206fc97af3adc14def0cdd349df6000", size = 75420, upload-time = "2025-01-14T10:33:41.868Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/b0/9fc566b0fe08b282c850063591a756057c3247b2362b9286429ec5bf1721/wrapt-1.17.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1a7ed2d9d039bd41e889f6fb9364554052ca21ce823580f6a07c4ec245c1f5d6", size = 83199, upload-time = "2025-01-14T10:33:43.598Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/4b/71996e62d543b0a0bd95dda485219856def3347e3e9380cc0d6cf10cfb2f/wrapt-1.17.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:129a150f5c445165ff941fc02ee27df65940fcb8a22a61828b1853c98763a64b", size = 82307, upload-time = "2025-01-14T10:33:48.499Z" },
+    { url = "https://files.pythonhosted.org/packages/39/35/0282c0d8789c0dc9bcc738911776c762a701f95cfe113fb8f0b40e45c2b9/wrapt-1.17.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1fb5699e4464afe5c7e65fa51d4f99e0b2eadcc176e4aa33600a3df7801d6662", size = 75025, upload-time = "2025-01-14T10:33:51.191Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/6d/90c9fd2c3c6fee181feecb620d95105370198b6b98a0770cba090441a828/wrapt-1.17.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9a2bce789a5ea90e51a02dfcc39e31b7f1e662bc3317979aa7e5538e3a034f72", size = 81879, upload-time = "2025-01-14T10:33:52.328Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/fa/9fb6e594f2ce03ef03eddbdb5f4f90acb1452221a5351116c7c4708ac865/wrapt-1.17.2-cp311-cp311-win32.whl", hash = "sha256:4afd5814270fdf6380616b321fd31435a462019d834f83c8611a0ce7484c7317", size = 36419, upload-time = "2025-01-14T10:33:53.551Z" },
+    { url = "https://files.pythonhosted.org/packages/47/f8/fb1773491a253cbc123c5d5dc15c86041f746ed30416535f2a8df1f4a392/wrapt-1.17.2-cp311-cp311-win_amd64.whl", hash = "sha256:acc130bc0375999da18e3d19e5a86403667ac0c4042a094fefb7eec8ebac7cf3", size = 38773, upload-time = "2025-01-14T10:33:56.323Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/bd/ab55f849fd1f9a58ed7ea47f5559ff09741b25f00c191231f9f059c83949/wrapt-1.17.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d5e2439eecc762cd85e7bd37161d4714aa03a33c5ba884e26c81559817ca0925", size = 53799, upload-time = "2025-01-14T10:33:57.4Z" },
+    { url = "https://files.pythonhosted.org/packages/53/18/75ddc64c3f63988f5a1d7e10fb204ffe5762bc663f8023f18ecaf31a332e/wrapt-1.17.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fc7cb4c1c744f8c05cd5f9438a3caa6ab94ce8344e952d7c45a8ed59dd88392", size = 38821, upload-time = "2025-01-14T10:33:59.334Z" },
+    { url = "https://files.pythonhosted.org/packages/48/2a/97928387d6ed1c1ebbfd4efc4133a0633546bec8481a2dd5ec961313a1c7/wrapt-1.17.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8fdbdb757d5390f7c675e558fd3186d590973244fab0c5fe63d373ade3e99d40", size = 38919, upload-time = "2025-01-14T10:34:04.093Z" },
+    { url = "https://files.pythonhosted.org/packages/73/54/3bfe5a1febbbccb7a2f77de47b989c0b85ed3a6a41614b104204a788c20e/wrapt-1.17.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5bb1d0dbf99411f3d871deb6faa9aabb9d4e744d67dcaaa05399af89d847a91d", size = 88721, upload-time = "2025-01-14T10:34:07.163Z" },
+    { url = "https://files.pythonhosted.org/packages/25/cb/7262bc1b0300b4b64af50c2720ef958c2c1917525238d661c3e9a2b71b7b/wrapt-1.17.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d18a4865f46b8579d44e4fe1e2bcbc6472ad83d98e22a26c963d46e4c125ef0b", size = 80899, upload-time = "2025-01-14T10:34:09.82Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/5a/04cde32b07a7431d4ed0553a76fdb7a61270e78c5fd5a603e190ac389f14/wrapt-1.17.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc570b5f14a79734437cb7b0500376b6b791153314986074486e0b0fa8d71d98", size = 89222, upload-time = "2025-01-14T10:34:11.258Z" },
+    { url = "https://files.pythonhosted.org/packages/09/28/2e45a4f4771fcfb109e244d5dbe54259e970362a311b67a965555ba65026/wrapt-1.17.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6d9187b01bebc3875bac9b087948a2bccefe464a7d8f627cf6e48b1bbae30f82", size = 86707, upload-time = "2025-01-14T10:34:12.49Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/d2/dcb56bf5f32fcd4bd9aacc77b50a539abdd5b6536872413fd3f428b21bed/wrapt-1.17.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:9e8659775f1adf02eb1e6f109751268e493c73716ca5761f8acb695e52a756ae", size = 79685, upload-time = "2025-01-14T10:34:15.043Z" },
+    { url = "https://files.pythonhosted.org/packages/80/4e/eb8b353e36711347893f502ce91c770b0b0929f8f0bed2670a6856e667a9/wrapt-1.17.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e8b2816ebef96d83657b56306152a93909a83f23994f4b30ad4573b00bd11bb9", size = 87567, upload-time = "2025-01-14T10:34:16.563Z" },
+    { url = "https://files.pythonhosted.org/packages/17/27/4fe749a54e7fae6e7146f1c7d914d28ef599dacd4416566c055564080fe2/wrapt-1.17.2-cp312-cp312-win32.whl", hash = "sha256:468090021f391fe0056ad3e807e3d9034e0fd01adcd3bdfba977b6fdf4213ea9", size = 36672, upload-time = "2025-01-14T10:34:17.727Z" },
+    { url = "https://files.pythonhosted.org/packages/15/06/1dbf478ea45c03e78a6a8c4be4fdc3c3bddea5c8de8a93bc971415e47f0f/wrapt-1.17.2-cp312-cp312-win_amd64.whl", hash = "sha256:ec89ed91f2fa8e3f52ae53cd3cf640d6feff92ba90d62236a81e4e563ac0e991", size = 38865, upload-time = "2025-01-14T10:34:19.577Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/b9/0ffd557a92f3b11d4c5d5e0c5e4ad057bd9eb8586615cdaf901409920b14/wrapt-1.17.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6ed6ffac43aecfe6d86ec5b74b06a5be33d5bb9243d055141e8cabb12aa08125", size = 53800, upload-time = "2025-01-14T10:34:21.571Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/ef/8be90a0b7e73c32e550c73cfb2fa09db62234227ece47b0e80a05073b375/wrapt-1.17.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:35621ae4c00e056adb0009f8e86e28eb4a41a4bfa8f9bfa9fca7d343fe94f998", size = 38824, upload-time = "2025-01-14T10:34:22.999Z" },
+    { url = "https://files.pythonhosted.org/packages/36/89/0aae34c10fe524cce30fe5fc433210376bce94cf74d05b0d68344c8ba46e/wrapt-1.17.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a604bf7a053f8362d27eb9fefd2097f82600b856d5abe996d623babd067b1ab5", size = 38920, upload-time = "2025-01-14T10:34:25.386Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/24/11c4510de906d77e0cfb5197f1b1445d4fec42c9a39ea853d482698ac681/wrapt-1.17.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5cbabee4f083b6b4cd282f5b817a867cf0b1028c54d445b7ec7cfe6505057cf8", size = 88690, upload-time = "2025-01-14T10:34:28.058Z" },
+    { url = "https://files.pythonhosted.org/packages/71/d7/cfcf842291267bf455b3e266c0c29dcb675b5540ee8b50ba1699abf3af45/wrapt-1.17.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:49703ce2ddc220df165bd2962f8e03b84c89fee2d65e1c24a7defff6f988f4d6", size = 80861, upload-time = "2025-01-14T10:34:29.167Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/66/5d973e9f3e7370fd686fb47a9af3319418ed925c27d72ce16b791231576d/wrapt-1.17.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8112e52c5822fc4253f3901b676c55ddf288614dc7011634e2719718eaa187dc", size = 89174, upload-time = "2025-01-14T10:34:31.702Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/d3/8e17bb70f6ae25dabc1aaf990f86824e4fd98ee9cadf197054e068500d27/wrapt-1.17.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9fee687dce376205d9a494e9c121e27183b2a3df18037f89d69bd7b35bcf59e2", size = 86721, upload-time = "2025-01-14T10:34:32.91Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/54/f170dfb278fe1c30d0ff864513cff526d624ab8de3254b20abb9cffedc24/wrapt-1.17.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:18983c537e04d11cf027fbb60a1e8dfd5190e2b60cc27bc0808e653e7b218d1b", size = 79763, upload-time = "2025-01-14T10:34:34.903Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/98/de07243751f1c4a9b15c76019250210dd3486ce098c3d80d5f729cba029c/wrapt-1.17.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:703919b1633412ab54bcf920ab388735832fdcb9f9a00ae49387f0fe67dad504", size = 87585, upload-time = "2025-01-14T10:34:36.13Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/f0/13925f4bd6548013038cdeb11ee2cbd4e37c30f8bfd5db9e5a2a370d6e20/wrapt-1.17.2-cp313-cp313-win32.whl", hash = "sha256:abbb9e76177c35d4e8568e58650aa6926040d6a9f6f03435b7a522bf1c487f9a", size = 36676, upload-time = "2025-01-14T10:34:37.962Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/ae/743f16ef8c2e3628df3ddfd652b7d4c555d12c84b53f3d8218498f4ade9b/wrapt-1.17.2-cp313-cp313-win_amd64.whl", hash = "sha256:69606d7bb691b50a4240ce6b22ebb319c1cfb164e5f6569835058196e0f3a845", size = 38871, upload-time = "2025-01-14T10:34:39.13Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/bc/30f903f891a82d402ffb5fda27ec1d621cc97cb74c16fea0b6141f1d4e87/wrapt-1.17.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:4a721d3c943dae44f8e243b380cb645a709ba5bd35d3ad27bc2ed947e9c68192", size = 56312, upload-time = "2025-01-14T10:34:40.604Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/04/c97273eb491b5f1c918857cd26f314b74fc9b29224521f5b83f872253725/wrapt-1.17.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:766d8bbefcb9e00c3ac3b000d9acc51f1b399513f44d77dfe0eb026ad7c9a19b", size = 40062, upload-time = "2025-01-14T10:34:45.011Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/ca/3b7afa1eae3a9e7fefe499db9b96813f41828b9fdb016ee836c4c379dadb/wrapt-1.17.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e496a8ce2c256da1eb98bd15803a79bee00fc351f5dfb9ea82594a3f058309e0", size = 40155, upload-time = "2025-01-14T10:34:47.25Z" },
+    { url = "https://files.pythonhosted.org/packages/89/be/7c1baed43290775cb9030c774bc53c860db140397047cc49aedaf0a15477/wrapt-1.17.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40d615e4fe22f4ad3528448c193b218e077656ca9ccb22ce2cb20db730f8d306", size = 113471, upload-time = "2025-01-14T10:34:50.934Z" },
+    { url = "https://files.pythonhosted.org/packages/32/98/4ed894cf012b6d6aae5f5cc974006bdeb92f0241775addad3f8cd6ab71c8/wrapt-1.17.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a5aaeff38654462bc4b09023918b7f21790efb807f54c000a39d41d69cf552cb", size = 101208, upload-time = "2025-01-14T10:34:52.297Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/fd/0c30f2301ca94e655e5e057012e83284ce8c545df7661a78d8bfca2fac7a/wrapt-1.17.2-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9a7d15bbd2bc99e92e39f49a04653062ee6085c0e18b3b7512a4f2fe91f2d681", size = 109339, upload-time = "2025-01-14T10:34:53.489Z" },
+    { url = "https://files.pythonhosted.org/packages/75/56/05d000de894c4cfcb84bcd6b1df6214297b8089a7bd324c21a4765e49b14/wrapt-1.17.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e3890b508a23299083e065f435a492b5435eba6e304a7114d2f919d400888cc6", size = 110232, upload-time = "2025-01-14T10:34:55.327Z" },
+    { url = "https://files.pythonhosted.org/packages/53/f8/c3f6b2cf9b9277fb0813418e1503e68414cd036b3b099c823379c9575e6d/wrapt-1.17.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:8c8b293cd65ad716d13d8dd3624e42e5a19cc2a2f1acc74b30c2c13f15cb61a6", size = 100476, upload-time = "2025-01-14T10:34:58.055Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/b1/0bb11e29aa5139d90b770ebbfa167267b1fc548d2302c30c8f7572851738/wrapt-1.17.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4c82b8785d98cdd9fed4cac84d765d234ed3251bd6afe34cb7ac523cb93e8b4f", size = 106377, upload-time = "2025-01-14T10:34:59.3Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/e1/0122853035b40b3f333bbb25f1939fc1045e21dd518f7f0922b60c156f7c/wrapt-1.17.2-cp313-cp313t-win32.whl", hash = "sha256:13e6afb7fe71fe7485a4550a8844cc9ffbe263c0f1a1eea569bc7091d4898555", size = 37986, upload-time = "2025-01-14T10:35:00.498Z" },
+    { url = "https://files.pythonhosted.org/packages/09/5e/1655cf481e079c1f22d0cabdd4e51733679932718dc23bf2db175f329b76/wrapt-1.17.2-cp313-cp313t-win_amd64.whl", hash = "sha256:eaf675418ed6b3b31c7a989fd007fa7c3be66ce14e5c3b27336383604c9da85c", size = 40750, upload-time = "2025-01-14T10:35:03.378Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/82/f56956041adef78f849db6b289b282e72b55ab8045a75abad81898c28d19/wrapt-1.17.2-py3-none-any.whl", hash = "sha256:b18f2d1533a71f069c7f82d524a52599053d4c7166e9dd374ae2136b7f40f7c8", size = 23594, upload-time = "2025-01-14T10:35:44.018Z" },
+]