Upload folder using huggingface_hub

.claude/settings.local.json

@@ -0,0 +1,11 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(python3:*)",
+      "Bash(pip3 install:*)",
+      "Bash(/Library/Developer/CommandLineTools/usr/bin/python3:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

.gitignore

@@ -0,0 +1,31 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+.venv
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Jupyter
+.ipynb_checkpoints
+*.ipynb
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Temporary files
+*.tmp
+*.bak
+*.log

README.md

@@ -1,3 +1,273 @@
 ---
 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).

api_df.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5a83511908fded48f6446c5f7fd2479e5059c1c40df5ed57e98d8f943a584c0b
-size 465822
+oid sha256:fb9c090ba3e2377533f7ebee9e250cc5ea164962d29647a2a5180757886a26f6
+size 465818

fenic_api.py

@@ -0,0 +1,104 @@
+"""
+Dataset loading script for Fenic 0.4.0 API Documentation.
+
+This script can be used with the Hugging Face datasets library to load the dataset.
+"""
+
+import pandas as pd
+from datasets import Dataset, DatasetDict, Features, Value, Sequence
+
+
+def load_fenic_api_dataset(data_dir="."):
+    """
+    Load the Fenic API documentation dataset.
+    
+    Args:
+        data_dir: Directory containing the parquet files
+        
+    Returns:
+        DatasetDict with three splits: api, hierarchy, and summary
+    """
+    
+    # Load the parquet files
+    api_df = pd.read_parquet(f"{data_dir}/api_df.parquet")
+    hierarchy_df = pd.read_parquet(f"{data_dir}/hierarchy_df.parquet")
+    summary_df = pd.read_parquet(f"{data_dir}/fenic_summary.parquet")
+    
+    # Convert DataFrames to Hugging Face Datasets
+    api_dataset = Dataset.from_pandas(api_df)
+    hierarchy_dataset = Dataset.from_pandas(hierarchy_df)
+    summary_dataset = Dataset.from_pandas(summary_df)
+    
+    # Create a DatasetDict
+    dataset_dict = DatasetDict({
+        'api': api_dataset,
+        'hierarchy': hierarchy_dataset,
+        'summary': summary_dataset
+    })
+    
+    return dataset_dict
+
+
+def get_dataframe_methods(dataset):
+    """
+    Get all DataFrame methods from the dataset.
+    
+    Args:
+        dataset: The loaded Fenic API dataset
+        
+    Returns:
+        Filtered dataset containing only DataFrame methods
+    """
+    api_data = dataset['api']
+    
+    # Filter for DataFrame methods
+    df_methods = []
+    for item in api_data:
+        if (item['qualified_name'] and 
+            'fenic.api.dataframe.DataFrame.' in item['qualified_name'] and
+            item['type'] == 'method' and
+            item['is_public']):
+            df_methods.append(item)
+    
+    return Dataset.from_list(df_methods)
+
+
+def get_semantic_functions(dataset):
+    """
+    Get all semantic functions from the dataset.
+    
+    Args:
+        dataset: The loaded Fenic API dataset
+        
+    Returns:
+        Filtered dataset containing only semantic functions
+    """
+    api_data = dataset['api']
+    
+    # Filter for semantic functions
+    semantic_funcs = []
+    for item in api_data:
+        if (item['qualified_name'] and 
+            'fenic.api.functions.semantic.' in item['qualified_name'] and
+            item['type'] == 'function'):
+            semantic_funcs.append(item)
+    
+    return Dataset.from_list(semantic_funcs)
+
+
+if __name__ == "__main__":
+    # Example usage
+    dataset = load_fenic_api_dataset()
+    
+    print("Dataset loaded successfully!")
+    print(f"API entries: {len(dataset['api'])}")
+    print(f"Hierarchy entries: {len(dataset['hierarchy'])}")
+    print(f"Summary entries: {len(dataset['summary'])}")
+    
+    # Get DataFrame methods
+    df_methods = get_dataframe_methods(dataset)
+    print(f"\nDataFrame methods found: {len(df_methods)}")
+    
+    # Get semantic functions
+    semantic_funcs = get_semantic_functions(dataset)
+    print(f"Semantic functions found: {len(semantic_funcs)}")

fenic_summary.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8f38b7ee7b32748b2dc204503fe533347ccc426fdf9153f408cd5e10c4a582f5
-size 4313
+oid sha256:33595fbb42d0239e195216b149a653172bf08087f4b4f1086e177c32abfb68eb
+size 5195

hierarchy_df.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6777a4f867522ffb1d0b82deffd7e4df2a4365786ebade763578589653cf07e9
-size 499075
+oid sha256:00b47451e3caedc9ce486577edf27e75837cade7b21c1ec2f1ff76c18a38521c
+size 495178