How to work with OneLake files locally using Python

Last week I shared how you could use the  OneLake File Explorer to sync your Lakehouse tables to your local machine. It's a convenient way to get your Parquet and Delta Lake files off the cloud and onto disk — but what do you actually do with them once they're there?

In this post, I’ll walk you through how to interact with your locally synced OneLake files using Python. We'll cover four practical approaches, with real code you can drop straight into a notebook.

Where are your files?

When OneLake File Explorer syncs your files, they land in a path that looks something like this:

C:\Users\<you>\OneLake - <workspace name>\<lakehouse name>.Lakehouse\Tables\<table name>

Keep that path in mind— you'll be passing it into every example below. Delta Lake tables are stored as folders containing multiple Parquet files plus a _delta_log/ directory, so make sure you're pointing at the table's root folder, not an individual file.

Reading a parquet file using Pandas

If you just need to load a parquet file into a DataFrame for analysis or transformation, pandas is the fastest way to get started.

Make sure you have Aandas and PyArrow installed:

pip install pandas

pip install pyarrow

Now you can run the following Python code

import pandas as pd

# Read a single Parquet file
df = pd.read_parquet(r"C:\Users\you\OneLake - MyWorkspace\MyLakehouse.Lakehouse\Tables\orders\part-00001.parquet")

print(df.head())
print(df.dtypes)

Pandas uses PyArrow under the hood for Parquet reading, so you get solid type handling and decent performance for most workloads. For large tables, be mindful of memory — it loads everything into RAM.

Reading delta tables using delta-rs

If your table is in Delta format (which is the default in Fabric Lakehouses), you'll want delta-rs to take advantage of Delta-specific features like schema enforcement, versioning, and time travel.

First install deltalake:

pip install deltalake

Now you can use this library to query the delta table:

from deltalake import DeltaTable

table_path = r"C:\Users\you\OneLake - MyWorkspace\MyLakehouse.Lakehouse\Tables\orders"

# Load the latest version
dt = DeltaTable(table_path)
df = dt.to_pandas()

# Check table metadata
print(dt.schema())
print(f"Current version: {dt.version()}")

Where delta-rs really shines is time travel — you can read any historical version of your table:

# Read a specific version

dt_v2 = DeltaTable(table_path, version=2)
df_v2 = dt_v2.to_pandas()

# Or go back to a point in time
from datetime import datetime
dt_yesterday = DeltaTable(table_path, version=datetime(2026, 2, 22))
df_yesterday = dt_yesterday.to_pandas()

This is invaluable when you're debugging a pipeline and need to see what the data looked like before a bad write landed.

That’s it!