## Inputs

URL: https://docs.atlan.com/product/capabilities/build-apps/sdks/application-sdk/references/inputs

> Complete reference for input classes that read data from various sources including SQL queries, Parquet files, JSON files, and Iceberg tables.

pd.DataFrame",
 purpose: "Returns a single pandas DataFrame with all data from the input source. Must be implemented by all input classes.",
 async: true,
 returns: {
 type: "pd.DataFrame",
 description: "Complete data as pandas DataFrame"
 }
 },
 {
 name: "get_batched_dataframe",
 signature: "async get_batched_dataframe(self) -> AsyncIterator[pd.DataFrame]",
 purpose: "Returns an async iterator of pandas DataFrames, yielding data in batches. Must be implemented by all input classes.",
 async: true,
 returns: {
 type: "AsyncIterator[pd.DataFrame]",
 description: "Iterator yielding batches of pandas DataFrames"
 }
 },
 {
 name: "get_daft_dataframe",
 signature: "async get_daft_dataframe(self) -> daft.DataFrame",
 purpose: "Returns a single daft DataFrame with all data from the input source. Must be implemented by all input classes.",
 async: true,
 returns: {
 type: "daft.DataFrame",
 description: "Complete data as daft DataFrame"
 }
 },
 {
 name: "get_batched_daft_dataframe",
 signature: "async get_batched_daft_dataframe(self) -> AsyncIterator[daft.DataFrame]",
 purpose: "Returns an async iterator of daft DataFrames, yielding data in batches. Must be implemented by all input classes.",
 async: true,
 returns: {
 type: "AsyncIterator[daft.DataFrame]",
 description: "Iterator yielding batches of daft DataFrames"
 }
 },
 {
 name: "download_files",
 signature: "async download_files(self) -> List[str]",
 purpose: "Automatically handles file retrieval from object stores when files are not available locally. Checks if files exist locally at the specified path, if not found attempts to download from object store, filters by file_names if provided, and returns list of file paths.",
 async: true,
 returns: {
 type: "List[str]",
 description: "List of file paths (local or downloaded)"
 }
 }
 ]}
/>

## Input implementations

The Application SDK provides four concrete implementations of the base `Input` class, each optimized for different data sources and formats. All implementations inherit the common functionality from the base class, including automatic file downloading from object stores, batch processing capabilities, and unified DataFrame interfaces.

 Reads data from SQL databases by executing SQL queries. Supports both SQLAlchemy engines and connection strings, with automatic handling of async and sync operations.

 Reads data from Parquet files, supporting both single files and directories containing multiple Parquet files. Automatically handles local and object store paths.

 Reads data from JSON files, supporting both single files and directories containing multiple JSON files. Supports JSONL (JSON Lines) format where each line is a separate JSON object.

 Reads data from Apache Iceberg tables using daft. Provides support for reading Iceberg table data as DataFrames with lazy evaluation.

## Usage patterns

### Read from object stores

All file-based inputs (ParquetInput, JsonInput) automatically handle downloading files from object stores when files aren't available locally:

```python
from application_sdk.inputs import ParquetInput

# Files will be automatically downloaded from S3 if not local

parquet_input = ParquetInput(
 path="s3://my-bucket/data/",
 file_names=["file1.parquet", "file2.parquet"]
)

# Files are downloaded automatically on first access

df = await parquet_input.get_dataframe()
```

### Process large datasets in batches

Use batched methods to process large datasets without loading everything into memory:

```python
from application_sdk.inputs import ParquetInput

parquet_input = ParquetInput(
 path="s3://bucket/large-dataset/",
 chunk_size=50000 # Process 50k rows at a time
)

# Process in batches to avoid memory issues

async for batch_df in parquet_input.get_batched_dataframe():
 # Process each batch
 processed = transform_data(batch_df)
 await save_results(processed)
```

### Combine multiple data sources

You can combine data from different input sources:

```python
from application_sdk.inputs import SQLQueryInput, ParquetInput

# Read from SQL

sql_input = SQLQueryInput(
 query="SELECT * FROM users",
 engine=db_engine
)
sql_df = await sql_input.get_dataframe()

# Read from Parquet

parquet_input = ParquetInput(path="data/additional.parquet")
parquet_df = await parquet_input.get_dataframe()

# Combine DataFrames

combined_df = pd.concat([sql_df, parquet_df], ignore_index=True)
```

### Error handling

All input methods raise exceptions on failure. Wrap calls in try-except blocks:

```python
from application_sdk.inputs import ParquetInput
from application_sdk.common.error_codes import IOError

try:
 parquet_input = ParquetInput(path="data/missing.parquet")
 df = await parquet_input.get_dataframe()
except IOError as e:
 print(f"Failed to read files: {e}")
except Exception as e:
 print(f"Unexpected error: {e}")
```

## See also

- [Outputs](https://docs.atlan.com/llms/platform/build-apps/outputs/llms.txt): Write data to various destinations including Parquet files, JSON files, and Iceberg tables
- [Application SDK README](https://docs.atlan.com/llms/platform/build-apps/application-sdk/llms.txt): Overview of the Application SDK and its components
- [App structure](https://docs.atlan.com/llms/platform/build-apps/app-structure/llms.txt): Standardized folder structure for Atlan applications
- [StateStore](https://docs.atlan.com/llms/platform/build-apps/statestore/llms.txt): Persistent state management for workflows and credentials

_Last updated: 10 August 2026._

---

> **AI agent?** Install the Atlan Docs MCP for direct access: https://docs.atlan.com/skills/install-docs-mcp.md