Fix linting issues in practical examples and documentation

- Fixed duplicate heading in migration-guide.md (Validation -> Post-Migration Validation)
- Removed specific notebook references from documentation to avoid link issues
- Fixed Jupyter notebook schema validation by adding missing outputs field
- Fixed import organization in notebooks by moving all imports to top cell
- Removed duplicate imports from cleanup cells
- Fixed end-of-file formatting issues

All linting checks now pass.

Generated with [Devin](https://cli.devin.ai/docs)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>

Author: nellaivijay

mkdocs/docs/migration-guide.md

@@ -29,6 +29,7 @@ This guide helps you migrate data from various formats and systems to Apache Ice
 ## Overview
 
 Migrating to Iceberg provides numerous benefits:
+
 - **Performance**: Columnar Parquet format with predicate pushdown
 - **Reliability**: ACID transactions with snapshot isolation
 - **Flexibility**: Schema evolution without breaking queries
@@ -66,6 +67,7 @@ table.append(csv_data)
 - **Data Validation**: Clean and validate data
 
 **Best Practices**:
+
 - Use PyArrow for efficient CSV reading
 - Handle missing values explicitly
 - Validate data ranges and types
@@ -245,7 +247,7 @@ table.append(table_data)
 3. **File size optimization**: Target appropriate Iceberg file sizes
 4. **Partitioning**: Design partition strategy based on query patterns
 
-### Validation
+### Data Quality Validation
 
 1. **Row count validation**: Ensure all rows migrated
 2. **Data sampling**: Compare sample data before and after
@@ -259,6 +261,7 @@ table.append(table_data)
 **Problem**: Source schema doesn't match Iceberg type system
 
 **Solution**:
+
 ```python
 # Explicit type conversion
 converted_schema = pa.schema([
@@ -274,6 +277,7 @@ converted_data = original_data.cast(converted_schema)
 **Problem**: Dataset too large for memory
 
 **Solution**:
+
 ```python
 # Process in batches
 batch_size = 100000
@@ -287,6 +291,7 @@ for i in range(0, len(data), batch_size):
 **Problem**: Incompatible data types between systems
 
 **Solution**:
+
 ```python
 # Custom type conversion
 def convert_type(value):
@@ -303,14 +308,15 @@ def convert_type(value):
 **Problem**: Optimal partitioning unclear
 
 **Solution**:
+
 - Analyze query patterns
 - Choose high-cardinality columns for partitioning
 - Consider date/time-based partitioning for time-series data
 - Test different partitioning strategies
 
 ## Post-Migration Steps
 
-### Validation
+### Post-Migration Validation
 
 1. **Data integrity**: Verify data accuracy
 2. **Query testing**: Test all critical queries
@@ -353,11 +359,9 @@ def convert_type(value):
 - **Trino**: SQL query engine with Iceberg support
 - **Pandas**: Data analysis with Iceberg integration
 
-### Example Notebooks
+### Additional Resources
 
-Example notebooks are available in the `notebooks/` directory of the repository:
-- `csv_migration_example.ipynb` - CSV to Iceberg migration
-- `time_travel_example.ipynb` - Time travel queries and snapshot management
+For detailed implementation examples and patterns, see the [practical examples guide](practical-examples.md).
 
 ## Getting Help
 
@@ -368,4 +372,4 @@ Example notebooks are available in the `notebooks/` directory of the repository:
 
 ## Conclusion
 
-Migrating to Iceberg provides significant benefits for data management and analytics. By following this guide and leveraging PyIceberg's capabilities, you can successfully migrate your data while minimizing disruption and maximizing the benefits of Iceberg's advanced features.
+Migrating to Iceberg provides significant benefits for data management and analytics. By following this guide and leveraging PyIceberg's capabilities, you can successfully migrate your data while minimizing disruption and maximizing the benefits of Iceberg's advanced features.

mkdocs/docs/practical-examples.md

@@ -24,83 +24,66 @@ hide:
 
 # Practical Examples
 
-This guide provides practical, real-world examples for common PyIceberg use cases. Each example is available as a Jupyter notebook that you can run and modify for your specific needs.
+This guide provides practical guidance for common PyIceberg use cases and implementation patterns.
 
-## Available Examples
+## Common Use Cases
 
-### 1. CSV to Iceberg Migration
-**Notebook**: `csv_migration_example.ipynb`
+### CSV Migration
 
-Migrate CSV data to Iceberg with various strategies:
+Migrating CSV files to Iceberg tables involves reading CSV data, converting it to Iceberg's schema, and writing it to Iceberg tables. This is one of the most common migration scenarios.
 
-- **Simple Migration**: Direct CSV to Iceberg conversion
-- **Schema Enhancement**: Add computed columns during migration
-- **Partitioned Migration**: Organize data for better performance
-- **Data Quality**: Validate and clean data during migration
-- **Best Practices**: Production migration considerations
+**Key Steps**:
 
-**When to use**: Transitioning from CSV to modern table formats, data lakehouse migration
+1. Read CSV files using PyArrow
+2. Convert data types appropriately
+3. Create Iceberg table with proper schema
+4. Write data to Iceberg table
+5. Validate migration success
 
-**Run the example**:
-```bash
-make notebook
-# Open csv_migration_example.ipynb in Jupyter
-```
+**Best Practices**:
 
-### 2. Time Travel Queries
-**Notebook**: `time_travel_example.ipynb`
+- Use PyArrow for efficient CSV reading
+- Handle missing values explicitly
+- Validate data ranges and types
+- Consider partitioning for large datasets
 
-Explore Iceberg's time travel capabilities:
+### Time Travel Queries
 
-- **Snapshots**: Understand Iceberg's snapshot mechanism
-- **Historical Queries**: Query data as it existed at specific times
-- **Rollback**: Revert to previous table states
-- **Audit Trail**: Track complete history of table changes
-- **Real-world Use Cases**: Debugging, compliance, ML, data recovery
+Iceberg's time travel feature allows you to query historical data and manage table versions through snapshots.
 
-**When to use**: Data debugging, compliance requirements, analytics, disaster recovery
+**Key Concepts**:
 
-**Run the example**:
-```bash
-make notebook
-# Open time_travel_example.ipynb in Jupyter
-```
+- **Snapshots**: Each commit creates a snapshot with unique ID and timestamp
+- **Historical Queries**: Query data as it existed at specific times
+- **Rollback**: Revert tables to previous states when needed
+- **Audit Trail**: Complete history of all table changes
 
-## Running the Examples
+**Common Patterns**:
 
-### Prerequisites
+- Query data as of a specific snapshot ID
+- Query data as of a specific timestamp
+- List table history to track changes
+- Rollback to known good states
 
-Install PyIceberg with required dependencies:
+### Data Quality Management
 
-```bash
-pip install pyiceberg[pyarrow]
-```
+Implementing data quality checks during and after migration ensures data integrity.
 
-### Using Make Commands
+**Validation Steps**:
 
-PyIceberg provides convenient Make commands for running notebooks:
+- Row count validation
+- Data sampling and comparison
+- Query validation with representative tests
+- Performance comparison
 
-```bash
-# Basic PyIceberg examples (no external infrastructure)
-make notebook
+**Common Issues**:
 
-# Spark integration examples (requires Docker infrastructure)
-make notebook-infra
-```
+- Schema mismatches between source and target
+- Missing or null values
+- Duplicate records
+- Data type conversion errors
 
-### Manual Setup
-
-If you prefer manual setup:
-
-```bash
-# Install Jupyter
-pip install jupyter
-
-# Start Jupyter Lab
-jupyter lab notebooks/
-```
-
-## Example Patterns
+## Implementation Patterns
 
 ### Data Migration Pattern
 
@@ -130,6 +113,51 @@ for snapshot in table.history():
     print(f"Snapshot: {snapshot.snapshot_id}, Time: {snapshot.timestamp_ms}")
 ```
 
+### Schema Evolution Pattern
+
+```python
+# Add new column to existing table
+with table.update_schema() as update_schema:
+    update_schema.add_column(
+        field_id=1000,
+        name="new_column",
+        field_type="string",
+        required=False
+    )
+```
+
+## Running Examples
+
+### Prerequisites
+
+Install PyIceberg with required dependencies:
+
+```bash
+pip install pyiceberg[pyarrow]
+```
+
+### Using Make Commands
+
+PyIceberg provides convenient Make commands:
+
+```bash
+# Basic PyIceberg examples (no external infrastructure)
+make notebook
+
+# Spark integration examples (requires Docker infrastructure)
+make notebook-infra
+```
+
+### Manual Setup
+
+```bash
+# Install Jupyter
+pip install jupyter
+
+# Start Jupyter Lab
+jupyter lab notebooks/
+```
+
 ## Best Practices
 
 ### Performance
@@ -153,48 +181,43 @@ for snapshot in table.history():
 - **Testing**: Test examples in non-production environments first
 - **Documentation**: Document your customizations and patterns
 
-## Troubleshooting
+## Common Issues
 
-### Common Issues
+### Import Errors
 
-**Import Errors**:
 ```bash
 # Ensure all dependencies are installed
 pip install pyiceberg[pyarrow,s3fs]
 ```
 
-**Permission Errors**:
+### Permission Errors
+
 ```bash
 # Check catalog credentials in .pyiceberg.yaml
 # Verify file system permissions for warehouse location
 ```
 
-**Memory Issues**:
+### Memory Issues
+
 ```bash
 # Process data in batches for large files
+# Use DuckDB for out-of-core processing
 ```
 
-### Getting Help
+## Getting Help
 
-- **Documentation**: Check the [main API documentation](api.md)
+- **Documentation**: Check the [API documentation](api.md)
 - **Community**: Join the [Apache Iceberg community](https://iceberg.apache.org/community/)
 - **Issues**: Report bugs on [GitHub Issues](https://github.com/apache/iceberg-python/issues)
 
 ## Contributing Examples
 
 We welcome contributions of additional practical examples! When contributing:
 
-1. **Follow the pattern**: Use the existing notebook structure
-2. **Include cleanup**: Clean up temporary resources
+1. **Follow the pattern**: Use existing code examples as templates
+2. **Include error handling**: Add appropriate error handling
 3. **Add documentation**: Explain the use case and when to use it
-4. **Test thoroughly**: Ensure examples run successfully
+4. **Test thoroughly**: Ensure examples work correctly
 5. **Document dependencies**: List all required packages
 
 See the [contributing guide](contributing.md) for more details.
-
-## Additional Resources
-
-- **API Documentation**: Comprehensive API reference
-- **Configuration Guide**: Catalog and table configuration options
-- **Expression DSL**: Query and filter expressions
-- **Community**: Connect with other users and contributors