README.md

---

license: apache-2.0
task_categories:
- text-generation
- question-answering
language:
- en
tags:
- code
- api-documentation
- dataframe
- semantic-ai
- fenic
pretty_name: Fenic 0.4.0 API Documentation
size_categories:
- 1K<n<10K
configs:
- config_name: default
  data_files:
  - split: api
    path: "api_df.parquet"
  - split: hierarchy
    path: "hierarchy_df.parquet"
  - split: summary
    path: "fenic_summary.parquet"
---


# Fenic 0.4.0 API Documentation Dataset

## Dataset Description

This dataset contains comprehensive API documentation for [Fenic 0.4.0](https://github.com/typedef-ai/fenic), a PySpark-inspired DataFrame framework designed for building production AI and agentic applications. The dataset provides structured information about all public and private API elements, including modules, classes, functions, methods, and attributes.

### Dataset Summary

[Fenic](https://github.com/typedef-ai/fenic) is a DataFrame framework that combines traditional data processing capabilities with semantic/AI operations. It provides:
- A familiar DataFrame API similar to PySpark
- Semantic functions powered by LLMs (map, extract, classify, etc.)
- Integration with multiple AI model providers (Anthropic, OpenAI, Google, Cohere)
- Advanced features like semantic joins and clustering

The dataset captures the complete API surface of Fenic 0.4.0, making it valuable for:
- Code generation and understanding
- API documentation analysis
- Framework comparison studies
- Training models on DataFrame/data processing APIs

## Dataset Structure

The dataset consists of three Parquet files:

### 1. `api_df.parquet` (2,522 rows × 16 columns)

Main API documentation with detailed information about each API element.



**Columns:**

- `type`: Element type (module, class, function, method, attribute)

- `name`: Element name

- `qualified_name`: Fully qualified name (e.g., `fenic.api.dataframe.DataFrame`)
- `docstring`: Documentation string
- `filepath`: Source file path
- `is_public`: Whether the element is public
- `is_private`: Whether the element is private
- `line_start`: Starting line number in source
- `line_end`: Ending line number in source
- `annotation`: Type annotation
- `returns`: Return type annotation
- `parameters`: Function/method parameters
- `parent_class`: Parent class for methods
- `value`: Value for attributes
- `bases`: Base classes for class definitions
- `api_element_summary`: Formatted summary of the element

### 2. `hierarchy_df.parquet` (2,522 rows × 18 columns)

Same as api_df but with additional hierarchy information.

**Additional Columns:**
- `path_parts`: List showing the hierarchical path
- `depth`: Depth in the API hierarchy

### 3. `fenic_summary.parquet` (1 row × 1 column)

High-level project summary.



**Columns:**

- `project_summary`: Comprehensive description of the Fenic framework

## Key API Components

### Core DataFrame Operations
- Standard operations: `select`, `filter`, `join`, `group_by`, `agg`, `sort`
- Data conversion: `to_pandas()`, `to_polars()`, `to_arrow()`, `to_pydict()`, `to_pylist()`
- Lazy evaluation with logical query plans

### Semantic Functions (`fenic.api.functions.semantic`)
- `map`: Apply generation prompts to columns
- `extract`: Extract structured data using Pydantic models
- `classify`: Text classification
- `predicate`: Boolean filtering with natural language
- `reduce`: Aggregate strings using natural language instructions
- `analyze_sentiment`: Sentiment analysis
- `summarize`: Text summarization
- `embed`: Generate embeddings

### Advanced Features
- Semantic joins and clustering
- Model client integrations (Anthropic, OpenAI, Google, Cohere)
- Query optimization and execution planning
- MCP (Model-based Code Production) tool generation

## Usage

### Loading with Fenic (Recommended)

[Fenic](https://github.com/typedef-ai/fenic) natively supports loading datasets directly from Hugging Face using the `hf://` scheme:

```python

import fenic as fc



# Create a Fenic session

session = fc.Session.get_or_create(

    fc.SessionConfig(app_name="fenic_api_analysis")

)



# Load the API documentation split

api_df = session.read.parquet("hf://datasets/YOUR_USERNAME/fenic-api-0.4.0/api_df.parquet")



# Or load all splits at once

df = session.read.parquet("hf://datasets/YOUR_USERNAME/fenic-api-0.4.0/*.parquet")



# Explore the dataset

api_df.show(5)

print(f"Total API elements: {api_df.count()}")

print(f"Schema: {api_df.schema}")



# Example: Find all public DataFrame methods

dataframe_methods = api_df.filter(

    fc.col("qualified_name").contains("fenic.api.dataframe.DataFrame.") &

    (fc.col("type") == "method") &

    (fc.col("is_public") == True)

).select("name", "docstring", "parameters", "returns")



dataframe_methods.show(10)



# Example: Find all semantic functions

semantic_functions = api_df.filter(

    fc.col("qualified_name").contains("fenic.api.functions.semantic.") &

    (fc.col("type") == "function")

).select("name", "qualified_name", "docstring")



semantic_functions.show()



# Get statistics about the codebase

stats = api_df.group_by("type").agg(

    fc.count("*").alias("count")

).order_by(fc.col("count").desc())



print("\nAPI Element Statistics:")

stats.show()



# Search for specific functionality

embedding_apis = api_df.filter(

    fc.col("name").contains("embed") | 

    fc.col("docstring").contains("embedding")

).select("type", "qualified_name", "docstring")



print(f"\nFound {embedding_apis.count()} embedding-related APIs")

embedding_apis.show(5)

```

### Loading with Pandas

```python

import pandas as pd

from datasets import load_dataset



# Option 1: Using Hugging Face datasets library

dataset = load_dataset("YOUR_USERNAME/fenic-api-0.4.0")



# Access different splits and convert to pandas

api_df = dataset['api'].to_pandas()

hierarchy_df = dataset['hierarchy'].to_pandas()

summary_df = dataset['summary'].to_pandas()



# Option 2: Direct parquet loading

api_df = pd.read_parquet('hf://datasets/YOUR_USERNAME/fenic-api-0.4.0/api_df.parquet')

hierarchy_df = pd.read_parquet('hf://datasets/YOUR_USERNAME/fenic-api-0.4.0/hierarchy_df.parquet')

summary_df = pd.read_parquet('hf://datasets/YOUR_USERNAME/fenic-api-0.4.0/fenic_summary.parquet')



# Example: Find all public DataFrame methods

dataframe_methods = api_df[

    (api_df['qualified_name'].str.startswith('fenic.api.dataframe.DataFrame.')) &

    (api_df['type'] == 'method') &

    (api_df['is_public'] == True)

]



print(f"Found {len(dataframe_methods)} DataFrame methods")

print(dataframe_methods[['name', 'docstring']].head(10))



# Example: Analyze module structure

modules = api_df[api_df['type'] == 'module']

print(f"\nTotal modules: {len(modules)}")

print("Top-level modules:")

print(modules[modules['qualified_name'].str.count('\.') == 1]['name'].unique())



# Example: Find all semantic functions

semantic_functions = api_df[

    (api_df['qualified_name'].str.startswith('fenic.api.functions.semantic.')) &

    (api_df['type'] == 'function')

]



print(f"\nSemantic functions available:")

for _, func in semantic_functions.iterrows():

    doc_first_line = func['docstring'].split('\n')[0] if pd.notna(func['docstring']) else "No description"

    print(f"  • {func['name']}: {doc_first_line}")

```

### Authentication for Private Datasets

If you're using a private dataset, set your Hugging Face token:

```bash

export HF_TOKEN=your_token_here

```

Or in Python:
```python

import os

os.environ['HF_TOKEN'] = 'your_token_here'

```

## Dataset Creation

This dataset was automatically extracted from the Fenic 0.4.0 codebase using API documentation parsing tools. It captures the complete public and private API surface, including:
- All modules and submodules
- Classes with their methods and attributes
- Functions with their signatures
- Complete docstrings and type annotations

## Considerations for Using the Data

### Use Cases
- Training code generation models on DataFrame APIs
- Building API documentation search/retrieval systems
- Analyzing API design patterns in data processing frameworks
- Creating intelligent code completion for Fenic

### Limitations
- This dataset represents a snapshot of Fenic 0.4.0 and may not reflect newer versions
- Some internal/private APIs may change between versions
- Generated protobuf files are included but may be less useful for learning

## Additional Information

### Project Links
- **Fenic Framework**: [https://github.com/typedef-ai/fenic](https://github.com/typedef-ai/fenic)
- **Documentation**: See the official repository for the latest documentation
- **Issues**: Report issues with the dataset or framework on the GitHub repository

### Licensing
This dataset is released under the Apache 2.0 license, consistent with the Fenic framework's licensing.

### Citation
If you use this dataset, please cite:
```

@dataset{fenic_api_2025,

  title={Fenic 0.4.0 API Documentation Dataset},

  year={2025},

  publisher={Hugging Face},

  license={Apache-2.0}

}

```

### Maintenance
This dataset is a static snapshot of Fenic 0.4.0. For the latest API documentation and updates, refer to the official [Fenic repository](https://github.com/typedef-ai/fenic).