chatan 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

chatan/__init__.py

@@ -1,9 +1,11 @@
 """Minos: Create synthetic datasets with LLM generators and samplers."""
 
-__version__ = "0.1.1"
+__version__ = "0.1.3"
 
 from .dataset import dataset
 from .generator import generator
 from .sampler import sample
+from .viewer import generate_with_viewer
+from .evaluate import evaluate, eval
 
-__all__ = ["dataset", "generator", "sample"]
+__all__ = ["dataset", "generator", "sample", "generate_with_viewer", "evaluate", "eval"]

chatan/dataset.py

@@ -3,8 +3,10 @@
 from typing import Dict, Any, Union, Optional, List, Callable
 import pandas as pd
 from datasets import Dataset as HFDataset
+from tqdm import tqdm
 from .generator import GeneratorFunction
 from .sampler import SampleFunction
+from .evaluate import DatasetEvaluator, EvaluationFunction
 
 
 class Dataset:
@@ -26,18 +28,61 @@ class Dataset:
         self.schema = schema
         self.n = n
         self._data = None
+
+    @property
+    def eval(self):
+        """Get dataset evaluator for method chaining."""
+        if self._data is None:
+            raise ValueError("Dataset must be generated before evaluation")
+        return DatasetEvaluator(self)
+
+    def evaluate(self, eval_schema: Dict[str, EvaluationFunction]) -> Dict[str, float]:
+        """
+        Evaluate multiple metrics on this dataset.
+
+        Args:
+            eval_schema: Dictionary mapping metric names to evaluation function.
+
+        Returns:
+            Dictionary of metric names to computed scores
+        """
+        if self._data is None:
+            self.generate()
+
+        results = {}
+        for name, eval_function in eval_schema.items():
+            results[name] = eval_function(self._data)
+        return results
+
     
-    def generate(self, n: Optional[int] = None) -> pd.DataFrame:
-        """Generate the dataset."""
+    def generate(
+        self, n: Optional[int] = None, progress: bool = True
+    ) -> pd.DataFrame:
+        """Generate the dataset.
+
+        Parameters
+        ----------
+        n:
+            Number of samples to generate. Defaults to the value provided at
+            initialization.
+        progress:
+            Whether to display a progress bar. Defaults to ``True``. Pass
+            ``False`` to disable the progress output.
+        """
         num_samples = n or self.n
-        
+        show_progress = progress
+
         # Build dependency graph
         dependencies = self._build_dependency_graph()
         execution_order = self._topological_sort(dependencies)
-        
+
         # Generate data
         data = []
-        for i in range(num_samples):
+        iterator = range(num_samples)
+        if show_progress:
+            iterator = tqdm(iterator, desc="Generating", leave=False)
+
+        for _ in iterator:
             row = {}
             for column in execution_order:
                 value = self._generate_value(column, row)

chatan/evaluate.py

@@ -0,0 +1,320 @@
+"""Evaluation functions for synthetic data quality assessment."""
+
+from typing import Dict, Any, Union, List, Callable, Optional
+import numpy as np
+import pandas as pd
+from abc import ABC, abstractmethod
+
+
+class BaseEvaluator(ABC):
+    """Base class for evaluation metrics."""
+    
+    @abstractmethod
+    def compute(self, predictions: List[Any], targets: List[Any], **kwargs) -> float:
+        """Compute the evaluation metric."""
+        pass
+
+
+class ExactMatchEvaluator(BaseEvaluator):
+    """Exact string match evaluator."""
+    
+    def compute(self, predictions: List[str], targets: List[str], **kwargs) -> float:
+        """Compute exact match accuracy."""
+        if len(predictions) != len(targets):
+            raise ValueError("Predictions and targets must have same length")
+        
+        matches = sum(1 for p, t in zip(predictions, targets) if str(p) == str(t))
+        return matches / len(predictions)
+
+
+class SemanticSimilarityEvaluator(BaseEvaluator):
+    """Semantic similarity evaluator using sentence transformers."""
+    
+    def __init__(self, model: str = "all-MiniLM-L6-v2"):
+        self.model_name = model
+        self._model = None
+    
+    def _load_model(self):
+        """Lazy load the sentence transformer model."""
+        if self._model is None:
+            try:
+                from sentence_transformers import SentenceTransformer
+                self._model = SentenceTransformer(self.model_name)
+            except ImportError:
+                raise ImportError(
+                    "sentence-transformers is required for semantic similarity. "
+                    "Install with: pip install sentence-transformers"
+                )
+    
+    def compute(self, predictions: List[str], targets: List[str], **kwargs) -> float:
+        """Compute mean cosine similarity between predictions and targets."""
+        if len(predictions) != len(targets):
+            raise ValueError("Predictions and targets must have same length")
+        
+        self._load_model()
+        
+        pred_embeddings = self._model.encode(predictions)
+        target_embeddings = self._model.encode(targets)
+        
+        # Compute cosine similarities
+        from sklearn.metrics.pairwise import cosine_similarity
+        similarities = []
+        for pred_emb, target_emb in zip(pred_embeddings, target_embeddings):
+            sim = cosine_similarity([pred_emb], [target_emb])[0][0]
+            similarities.append(sim)
+        
+        return float(np.mean(similarities))
+
+
+class BLEUEvaluator(BaseEvaluator):
+    """BLEU score evaluator."""
+    
+    def compute(self, predictions: List[str], targets: List[str], **kwargs) -> float:
+        """Compute BLEU score."""
+        try:
+            from nltk.translate.bleu_score import sentence_bleu
+            from nltk.tokenize import word_tokenize
+            import nltk
+            
+            # Download required NLTK data
+            try:
+                nltk.data.find('tokenizers/punkt')
+            except LookupError:
+                nltk.download('punkt', quiet=True)
+                
+        except ImportError:
+            raise ImportError(
+                "nltk is required for BLEU score. "
+                "Install with: pip install nltk"
+            )
+        
+        if len(predictions) != len(targets):
+            raise ValueError("Predictions and targets must have same length")
+        
+        scores = []
+        for pred, target in zip(predictions, targets):
+            pred_tokens = word_tokenize(str(pred).lower())
+            target_tokens = [word_tokenize(str(target).lower())]
+            
+            if len(pred_tokens) == 0 or len(target_tokens[0]) == 0:
+                scores.append(0.0)
+            else:
+                score = sentence_bleu(target_tokens, pred_tokens)
+                scores.append(score)
+        
+        return float(np.mean(scores))
+
+
+class EditDistanceEvaluator(BaseEvaluator):
+    """Normalized edit distance evaluator."""
+    
+    def compute(self, predictions: List[str], targets: List[str], **kwargs) -> float:
+        """Compute normalized edit distance (lower is better, normalized to 0-1)."""
+        if len(predictions) != len(targets):
+            raise ValueError("Predictions and targets must have same length")
+        
+        distances = []
+        for pred, target in zip(predictions, targets):
+            pred_str, target_str = str(pred), str(target)
+            distance = self._levenshtein_distance(pred_str, target_str)
+            max_len = max(len(pred_str), len(target_str))
+            normalized_distance = distance / max_len if max_len > 0 else 0.0
+            # Convert to similarity (1 - distance)
+            similarity = 1.0 - normalized_distance
+            distances.append(similarity)
+        
+        return float(np.mean(distances))
+    
+    def _levenshtein_distance(self, s1: str, s2: str) -> int:
+        """Compute Levenshtein distance between two strings."""
+        if len(s1) < len(s2):
+            return self._levenshtein_distance(s2, s1)
+        
+        if len(s2) == 0:
+            return len(s1)
+        
+        previous_row = list(range(len(s2) + 1))
+        for i, c1 in enumerate(s1):
+            current_row = [i + 1]
+            for j, c2 in enumerate(s2):
+                insertions = previous_row[j + 1] + 1
+                deletions = current_row[j] + 1
+                substitutions = previous_row[j] + (c1 != c2)
+                current_row.append(min(insertions, deletions, substitutions))
+            previous_row = current_row
+        
+        return previous_row[-1]
+
+
+class LLMJudgeEvaluator(BaseEvaluator):
+    """LLM-as-a-judge evaluator."""
+    
+    def __init__(self, generator_client, prompt_template: str = None):
+        self.generator = generator_client
+        self.prompt_template = prompt_template or (
+            "Rate the quality of this response on a scale of 1-10:\n\n"
+            "Question: {question}\n"
+            "Response: {response}\n\n"
+            "Rating (1-10):"
+        )
+    
+    def compute(self, predictions: List[str], targets: List[str], 
+                questions: Optional[List[str]] = None, **kwargs) -> float:
+        """Compute LLM judge scores."""
+        if len(predictions) != len(targets):
+            raise ValueError("Predictions and targets must have same length")
+        
+        scores = []
+        for i, (pred, target) in enumerate(zip(predictions, targets)):
+            question = questions[i] if questions else f"Question {i+1}"
+            
+            prompt = self.prompt_template.format(
+                question=question,
+                response=pred,
+                target=target
+            )
+            
+            try:
+                response = self.generator._generator.generate(prompt)
+                # Extract numeric score from response
+                score = self._extract_score(response)
+                scores.append(score)
+            except Exception:
+                # If generation fails, assign neutral score
+                scores.append(0.5)
+        
+        return float(np.mean(scores))
+    
+    def _extract_score(self, response: str) -> float:
+        """Extract numeric score from LLM response."""
+        import re
+        
+        # Look for numbers in the response
+        numbers = re.findall(r'\b(\d+(?:\.\d+)?)\b', response)
+        
+        if numbers:
+            score = float(numbers[0])
+            # Normalize to 0-1 scale if it looks like 1-10 scale
+            if score > 1:
+                score = score / 10.0
+            return min(max(score, 0.0), 1.0)
+        
+        return 0.5  # Default neutral score
+
+
+class EvaluationFunction:
+    """Evaluation function for use in evaluation schemas."""
+    
+    def __init__(self, evaluator: BaseEvaluator, column_a: str, column_b: str, **kwargs):
+        self.evaluator = evaluator
+        self.column_a = column_a
+        self.column_b = column_b
+        self.kwargs = kwargs
+    
+    def __call__(self, data: pd.DataFrame) -> float:
+        """Compute evaluation metric on dataset."""
+        predictions = data[self.column_a].tolist()
+        targets = data[self.column_b].tolist()
+        return self.evaluator.compute(predictions, targets, **self.kwargs)
+
+
+class DatasetEvaluator:
+    """Dataset-specific evaluator for method chaining."""
+    
+    def __init__(self, dataset):
+        self.dataset = dataset
+    
+    def exact_match(self, column_a: str, column_b: str, **kwargs) -> EvaluationFunction:
+        """Create exact match evaluation function."""
+        return EvaluationFunction(ExactMatchEvaluator(), column_a, column_b, **kwargs)
+    
+    def semantic_similarity(self, column_a: str, column_b: str, 
+                          model: str = "all-MiniLM-L6-v2", **kwargs) -> EvaluationFunction:
+        """Create semantic similarity evaluation function."""
+        evaluator = SemanticSimilarityEvaluator(model)
+        return EvaluationFunction(evaluator, column_a, column_b, **kwargs)
+    
+    def bleu_score(self, column_a: str, column_b: str, **kwargs) -> EvaluationFunction:
+        """Create BLEU score evaluation function."""
+        return EvaluationFunction(BLEUEvaluator(), column_a, column_b, **kwargs)
+    
+    def edit_distance(self, column_a: str, column_b: str, **kwargs) -> EvaluationFunction:
+        """Create edit distance evaluation function."""
+        return EvaluationFunction(EditDistanceEvaluator(), column_a, column_b, **kwargs)
+    
+    def llm_judge(self, column_a: str, column_b: str, 
+                  generator_client, prompt_template: str = None, **kwargs) -> EvaluationFunction:
+        """Create LLM judge evaluation function."""
+        evaluator = LLMJudgeEvaluator(generator_client, prompt_template)
+        return EvaluationFunction(evaluator, column_a, column_b, **kwargs)
+
+
+# Standalone evaluation functions for schema use
+class EvalNamespace:
+    """Namespace for evaluation functions."""
+    
+    @staticmethod
+    def exact_match(column_a: str, column_b: str, **kwargs) -> Callable:
+        """Exact match evaluation for use in dataset schemas."""
+        def eval_func(context: Dict[str, Any]) -> float:
+            pred, target = context[column_a], context[column_b]
+            return 1.0 if str(pred) == str(target) else 0.0
+        return eval_func
+    
+    @staticmethod
+    def semantic_similarity(column_a: str, column_b: str, 
+                          model: str = "all-MiniLM-L6-v2") -> Callable:
+        """Semantic similarity evaluation for use in dataset schemas."""
+        evaluator = SemanticSimilarityEvaluator(model)
+        
+        def eval_func(context: Dict[str, Any]) -> float:
+            pred, target = context[column_a], context[column_b]
+            return evaluator.compute([str(pred)], [str(target)])
+        return eval_func
+    
+    @staticmethod
+    def bleu_score(column_a: str, column_b: str) -> Callable:
+        """BLEU score evaluation for use in dataset schemas."""
+        evaluator = BLEUEvaluator()
+        
+        def eval_func(context: Dict[str, Any]) -> float:
+            pred, target = context[column_a], context[column_b]
+            return evaluator.compute([str(pred)], [str(target)])
+        return eval_func
+    
+    @staticmethod
+    def edit_distance(column_a: str, column_b: str) -> Callable:
+        """Edit distance evaluation for use in dataset schemas."""
+        evaluator = EditDistanceEvaluator()
+        
+        def eval_func(context: Dict[str, Any]) -> float:
+            pred, target = context[column_a], context[column_b]
+            return evaluator.compute([str(pred)], [str(target)])
+        return eval_func
+
+
+def evaluate(eval_schema: Dict[str, Union[EvaluationFunction, Callable]]) -> Dict[str, float]:
+    """
+    Evaluate multiple metrics across datasets.
+    
+    Args:
+        eval_schema: Dictionary mapping metric names to evaluation functions or callables
+        
+    Returns:
+        Dictionary of metric names to computed scores
+    """
+    results = {}
+    for name, eval_func in eval_schema.items():
+        if isinstance(eval_func, EvaluationFunction):
+            # This shouldn't happen in normal usage - EvaluationFunction needs a dataset
+            raise ValueError(f"EvaluationFunction for '{name}' requires dataset context")
+        elif callable(eval_func):
+            # Should be a callable that returns the result
+            results[name] = eval_func()
+        else:
+            raise ValueError(f"Invalid evaluation function type for '{name}': {type(eval_func)}")
+    return results
+
+
+# Export the eval namespace
+eval = EvalNamespace()

chatan/generator.py

@@ -3,6 +3,7 @@
 from typing import Dict, Any, Optional, Union, List
 import openai
 import anthropic
+from transformers import pipeline
 from abc import ABC, abstractmethod
 
 
@@ -56,6 +57,17 @@ class AnthropicGenerator(BaseGenerator):
         return response.content[0].text.strip()
 
 
+class TransformersGenerator(BaseGenerator):
+    """Local HuggingFace/transformers generator."""
+
+    def __init__(self, model: str = "gpt2", **kwargs):
+        self.pipeline = pipeline("text-generation", model=model, **kwargs)
+
+    def generate(self, prompt: str, **kwargs) -> str:
+        result = self.pipeline(prompt, **kwargs)[0]["generated_text"]
+        return result.strip()
+
+
 class GeneratorFunction:
     """Callable generator function for use in dataset schemas."""
 
@@ -82,12 +94,19 @@ class GeneratorFunction:
 
 class GeneratorClient:
     """Main interface for creating generators."""
-    
-    def __init__(self, provider: str, api_key: str, **kwargs):
-        if provider.lower() == "openai":
+
+    def __init__(self, provider: str, api_key: Optional[str] = None, **kwargs):
+        provider_lower = provider.lower()
+        if provider_lower == "openai":
+            if api_key is None:
+                raise ValueError("API key is required for OpenAI")
             self._generator = OpenAIGenerator(api_key, **kwargs)
-        elif provider.lower() == "anthropic":
+        elif provider_lower == "anthropic":
+            if api_key is None:
+                raise ValueError("API key is required for Anthropic")
             self._generator = AnthropicGenerator(api_key, **kwargs)
+        elif provider_lower in {"huggingface", "transformers", "hf"}:
+            self._generator = TransformersGenerator(**kwargs)
         else:
             raise ValueError(f"Unsupported provider: {provider}")
     
@@ -109,6 +128,6 @@ class GeneratorClient:
 # Factory function
 def generator(provider: str = "openai", api_key: Optional[str] = None, **kwargs) -> GeneratorClient:
     """Create a generator client."""
-    if api_key is None:
+    if provider.lower() in {"openai", "anthropic"} and api_key is None:
         raise ValueError("API key is required")
     return GeneratorClient(provider, api_key, **kwargs)

chatan/viewer.py

@@ -0,0 +1,581 @@
+"""Live HTML viewer for dataset generation."""
+
+import json
+import os
+import tempfile
+import webbrowser
+from pathlib import Path
+from typing import Dict, Any, Optional, Callable
+import threading
+import time
+from http.server import HTTPServer, SimpleHTTPRequestHandler
+import atexit
+
+
+class LiveViewer:
+    """Live HTML viewer for streaming dataset generation results."""
+    
+    def __init__(self, title: str = "Dataset Generation", auto_open: bool = True):
+        self.title = title
+        self.auto_open = auto_open
+        self.temp_dir = None
+        self.html_file = None
+        self.data_file = None
+        self.server = None
+        self.server_thread = None
+        self.port = 8000
+        self._active = False
+        
+    def start(self, schema: Dict[str, Any]) -> str:
+        """Start the viewer and return the URL."""
+        self.temp_dir = tempfile.mkdtemp()
+        self.html_file = Path(self.temp_dir) / "viewer.html"
+        self.data_file = Path(self.temp_dir) / "data.json"
+        
+        # Initialize empty data file
+        with open(self.data_file, 'w') as f:
+            json.dump({"rows": [], "completed": False, "current_row": None}, f)
+        
+        # Create HTML file
+        html_content = self._generate_html(list(schema.keys()))
+        with open(self.html_file, 'w') as f:
+            f.write(html_content)
+        
+        # Start local server
+        self._start_server()
+        
+        # Open in browser
+        url = f"http://localhost:{self.port}/viewer.html"
+        if self.auto_open:
+            webbrowser.open(url)
+        
+        self._active = True
+        return url
+    
+    def add_row(self, row: Dict[str, Any]):
+        """Add a new row to the viewer."""
+        if not self._active or not self.data_file:
+            return
+            
+        try:
+            with open(self.data_file, 'r') as f:
+                data = json.load(f)
+        except:
+            data = {"rows": [], "completed": False, "current_row": None}
+        
+        data["rows"].append(row)
+        # Keep current_row so we can update the UI with final values
+        data["completed_row"] = {"index": len(data["rows"]) - 1, "data": row}
+        data["current_row"] = None  # Clear current row when row is complete
+        
+        with open(self.data_file, 'w') as f:
+            json.dump(data, f)
+    
+    def start_row(self, row_index: int):
+        """Start a new row with empty cells."""
+        if not self._active or not self.data_file:
+            return
+            
+        try:
+            with open(self.data_file, 'r') as f:
+                data = json.load(f)
+        except:
+            data = {"rows": [], "completed": False, "current_row": None}
+        
+        data["current_row"] = {"index": row_index, "cells": {}}
+        
+        with open(self.data_file, 'w') as f:
+            json.dump(data, f)
+    
+    def update_cell(self, column: str, value: Any):
+        """Update a single cell in the current row."""
+        if not self._active or not self.data_file:
+            return
+            
+        try:
+            with open(self.data_file, 'r') as f:
+                data = json.load(f)
+        except:
+            data = {"rows": [], "completed": False, "current_row": None}
+        
+        if data.get("current_row"):
+            data["current_row"]["cells"][column] = value
+            
+            with open(self.data_file, 'w') as f:
+                json.dump(data, f)
+    
+    def complete(self):
+        """Mark generation as complete."""
+        if not self._active or not self.data_file:
+            return
+            
+        try:
+            with open(self.data_file, 'r') as f:
+                data = json.load(f)
+        except:
+            data = {"rows": [], "completed": False, "current_row": None}
+        
+        data["completed"] = True
+        
+        with open(self.data_file, 'w') as f:
+            json.dump(data, f)
+    
+    def stop(self):
+        """Stop the viewer and cleanup resources."""
+        self._active = False
+        if self.server:
+            self.server.shutdown()
+            self.server.server_close()
+    
+    def _start_server(self):
+        """Start a local HTTP server."""
+        os.chdir(self.temp_dir)
+        
+        # Find available port
+        for port in range(8000, 8100):
+            try:
+                self.server = HTTPServer(("localhost", port), SimpleHTTPRequestHandler)
+                self.port = port
+                break
+            except OSError:
+                continue
+        
+        if self.server:
+            self.server_thread = threading.Thread(target=self.server.serve_forever, daemon=True)
+            self.server_thread.start()
+            
+            # Register cleanup on exit
+            atexit.register(self.stop)
+    
+    def _generate_html(self, columns) -> str:
+        """Generate the HTML content."""
+        return f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{self.title}</title>
+    <style>
+        body {{
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif;
+            margin: 0;
+            padding: 20px;
+            background: #f8fafc;
+            color: #1e293b;
+        }}
+        
+        .header {{
+            background: white;
+            padding: 20px;
+            border-radius: 12px;
+            box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+            margin-bottom: 20px;
+        }}
+        
+        .title {{
+            font-size: 24px;
+            font-weight: 600;
+            margin: 0 0 10px 0;
+        }}
+        
+        .status {{
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 14px;
+            color: #64748b;
+        }}
+        
+        .status-dot {{
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+            background: #10b981;
+            animation: pulse 1.5s infinite;
+        }}
+        
+        .status-dot.complete {{
+            background: #6366f1;
+            animation: none;
+        }}
+        
+        @keyframes pulse {{
+            0%, 100% {{ opacity: 1; }}
+            50% {{ opacity: 0.5; }}
+        }}
+        
+        .table-container {{
+            background: white;
+            border-radius: 12px;
+            box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+            overflow: hidden;
+            max-height: 70vh;
+            overflow-y: auto;
+        }}
+        
+        table {{
+            width: 100%;
+            border-collapse: collapse;
+            table-layout: fixed;
+        }}
+        
+        th {{
+            background: #f1f5f9;
+            padding: 16px;
+            text-align: left;
+            font-weight: 600;
+            border-bottom: 1px solid #e2e8f0;
+            position: sticky;
+            top: 0;
+            z-index: 10;
+            position: relative;
+        }}
+
+        th:not(:last-child), td:not(:last-child) {{
+            border-right: 1px solid #e2e8f0;
+        }}
+
+        .col-resizer {{
+            position: absolute;
+            right: 0;
+            top: 0;
+            height: 100%;
+            width: 5px;
+            cursor: col-resize;
+            user-select: none;
+        }}
+        
+        td {{
+            padding: 12px 16px;
+            border-bottom: 1px solid #f1f5f9;
+            vertical-align: top;
+        }}
+        
+        tr:hover {{
+            background: #f8fafc;
+        }}
+        
+        .row-number {{
+            color: #64748b;
+            font-size: 12px;
+            font-weight: 500;
+            width: 60px;
+        }}
+        
+        .cell-content {{
+            max-width: 300px;
+            word-wrap: break-word;
+            white-space: pre-wrap;
+        }}
+        
+        .cell-generating {{
+            background: linear-gradient(90deg, #f1f5f9, #e2e8f0, #f1f5f9);
+            background-size: 200% 200%;
+            animation: shimmer 1.5s ease-in-out infinite;
+        }}
+        
+        @keyframes shimmer {{
+            0% {{ background-position: -200% 0; }}
+            100% {{ background-position: 200% 0; }}
+        }}
+        
+        .new-row {{
+            animation: slideIn 0.3s ease-out;
+        }}
+        
+        @keyframes slideIn {{
+            from {{
+                opacity: 0;
+                transform: translateY(-10px);
+            }}
+            to {{
+                opacity: 1;
+                transform: translateY(0);
+            }}
+        }}
+        
+        .loading {{
+            text-align: center;
+            padding: 40px;
+            color: #64748b;
+        }}
+    </style>
+</head>
+<body>
+    <div class="header">
+        <div class="title">{self.title}</div>
+        <div class="status">
+            <div class="status-dot" id="statusDot"></div>
+            <span id="statusText">Generating...</span>
+            <span id="rowCount">0 rows</span>
+        </div>
+    </div>
+    
+    <div class="table-container">
+        <table>
+            <thead>
+                <tr>
+                    <th class="row-number">#</th>
+                    {' '.join(f'<th>{col}</th>' for col in columns)}
+                </tr>
+            </thead>
+            <tbody id="tableBody">
+                <tr>
+                    <td colspan="{len(columns) + 1}" class="loading">
+                        Waiting for data...
+                    </td>
+                </tr>
+            </tbody>
+        </table>
+    </div>
+
+    <script>
+        let rowCount = 0;
+        let currentRowElement = null;
+
+        function makeColumnsResizable(table) {{
+            const headers = table.querySelectorAll('th');
+            headers.forEach((th, index) => {{
+
+                if (index === headers.length - 1) return;
+                const resizer = document.createElement('div');
+                resizer.className = 'col-resizer';
+                th.appendChild(resizer);
+
+                let startX, startWidth;
+
+                resizer.addEventListener('mousedown', (e) => {{
+
+                    startX = e.clientX;
+                    startWidth = th.offsetWidth;
+                    document.addEventListener('mousemove', doDrag);
+                    document.addEventListener('mouseup', stopDrag);
+                }});
+
+                function doDrag(e) {{
+                    const width = startWidth + e.clientX - startX;
+                    th.style.width = width + 'px';
+                }}
+
+                function stopDrag() {{
+                    document.removeEventListener('mousemove', doDrag);
+                    document.removeEventListener('mouseup', stopDrag);
+                }}
+            }});
+        }}
+
+        
+        async function fetchData() {{
+            try {{
+                const response = await fetch('data.json?' + new Date().getTime());
+                const data = await response.json();
+                
+                // Handle current row updates
+                if (data.current_row) {{
+                    updateCurrentRow(data.current_row);
+                }}
+                
+                // Handle completed rows
+                if (data.completed_row) {{
+                    completeRow(data.completed_row);
+                }}
+                
+                if (data.rows.length > rowCount) {{
+                    rowCount = data.rows.length;
+                    updateStatus(data.completed);
+                }}
+                
+                if (data.completed) {{
+                    document.getElementById('statusDot').classList.add('complete');
+                    document.getElementById('statusText').textContent = 'Complete';
+                    return;
+                }}
+            }} catch (error) {{
+                console.error('Error fetching data:', error);
+            }}
+            
+            setTimeout(fetchData, 200); // Faster polling for cell updates
+        }}
+        
+        function updateCurrentRow(currentRow) {{
+            const tbody = document.getElementById('tableBody');
+            
+            // Remove loading message if present
+            if (tbody.children.length === 1 && tbody.children[0].cells.length === {len(columns) + 1}) {{
+                tbody.innerHTML = '';
+            }}
+            
+            // Create new row element only if we don't have one for this index
+            if (!currentRowElement || parseInt(currentRowElement.dataset.rowIndex) !== currentRow.index) {{
+                currentRowElement = document.createElement('tr');
+                currentRowElement.className = 'new-row';
+                currentRowElement.dataset.rowIndex = currentRow.index;
+                
+                // Row number
+                const numCell = document.createElement('td');
+                numCell.className = 'row-number';
+                numCell.textContent = currentRow.index + 1;
+                currentRowElement.appendChild(numCell);
+                
+                // Create empty cells for all columns
+                {json.dumps(columns)}.forEach(col => {{
+                    const td = document.createElement('td');
+                    td.className = 'cell-content cell-generating';
+                    td.textContent = '...';
+                    td.id = `cell-${{currentRow.index}}-${{col}}`;
+                    currentRowElement.appendChild(td);
+                }});
+                
+                tbody.appendChild(currentRowElement);
+            }}
+            
+            // Update cells with values
+            Object.entries(currentRow.cells).forEach(([col, value]) => {{
+                const cell = document.getElementById(`cell-${{currentRow.index}}-${{col}}`);
+                if (cell) {{
+                    cell.textContent = value || '';
+                    cell.classList.remove('cell-generating');
+                }}
+            }});
+        }}
+        
+        function completeRow(completedRow) {{
+            // Find the row element and update it with final data
+            const rowElement = document.querySelector(`tr[data-row-index="${{completedRow.index}}"]`);
+            if (rowElement) {{
+                {json.dumps(columns)}.forEach((col, colIndex) => {{
+                    const cell = rowElement.cells[colIndex + 1]; // +1 for row number column
+                    if (cell) {{
+                        cell.textContent = completedRow.data[col] || '';
+                        cell.classList.remove('cell-generating');
+                    }}
+                }});
+            }}
+            
+            // Clear current row if this was it
+            if (currentRowElement && parseInt(currentRowElement.dataset.rowIndex) === completedRow.index) {{
+                currentRowElement = null;
+            }}
+        }}
+        
+        function addRows(rows) {{
+            const tbody = document.getElementById('tableBody');
+            
+            rows.forEach((row, index) => {{
+                const tr = document.createElement('tr');
+                tr.className = 'new-row';
+                
+                const numCell = document.createElement('td');
+                numCell.className = 'row-number';
+                numCell.textContent = rowCount - rows.length + index + 1;
+                tr.appendChild(numCell);
+                
+                {json.dumps(columns)}.forEach(col => {{
+                    const td = document.createElement('td');
+                    td.className = 'cell-content';
+                    td.textContent = row[col] || '';
+                    tr.appendChild(td);
+                }});
+                
+                tbody.appendChild(tr);
+            }});
+        }}
+        
+        function updateStatus(completed) {{
+            document.getElementById('rowCount').textContent = `${{rowCount}} rows`;
+            if (completed) {{
+                document.getElementById('statusText').textContent = 'Complete';
+                document.getElementById('statusDot').classList.add('complete');
+            }}
+        }}
+        
+        makeColumnsResizable(document.querySelector('table'));
+        fetchData();
+    </script>
+</body>
+</html>"""
+
+
+def create_viewer_callback(viewer: LiveViewer) -> Callable[[Dict[str, Any]], None]:
+    """Create a callback function for dataset generation progress."""
+    def callback(row: Dict[str, Any]):
+        viewer.add_row(row)
+    return callback
+
+
+def generate_with_viewer(
+    dataset_instance,
+    n: Optional[int] = None,
+    progress: bool = True,
+    viewer_title: str = "Dataset Generation",
+    auto_open: bool = True,
+    stream_delay: float = 0.05,
+    cell_delay: float = 0.3
+):
+    """Generate dataset with live viewer showing cell-by-cell generation.
+    
+    Args:
+        dataset_instance: The Dataset instance
+        n: Number of samples to generate
+        progress: Show progress bar (ignored when using viewer)
+        viewer_title: Title for the HTML viewer
+        auto_open: Whether to auto-open browser
+        stream_delay: Delay between rows for streaming effect
+        cell_delay: Delay between individual cell generations
+    
+    Returns:
+        pd.DataFrame: Generated dataset
+    """
+    viewer = LiveViewer(title=viewer_title, auto_open=auto_open)
+    num_samples = n or dataset_instance.n
+    
+    try:
+        # Start viewer
+        url = viewer.start(dataset_instance.schema)
+        print(f"Live viewer started at: {url}")
+        
+        # Build dependency graph (copied from dataset logic)
+        dependencies = dataset_instance._build_dependency_graph()
+        execution_order = dataset_instance._topological_sort(dependencies)
+        
+        # Generate data with live updates
+        data = []
+        
+        for i in range(num_samples):
+            # Start new row
+            viewer.start_row(i)
+            
+            row = {}
+            for column in execution_order:
+                # Generate cell value
+                value = dataset_instance._generate_value(column, row)
+                row[column] = value
+                
+                # Update viewer with new cell value
+                viewer.update_cell(column, value)
+                
+                # Delay to show cell generation effect
+                if cell_delay > 0:
+                    time.sleep(cell_delay)
+            
+            # Complete the row
+            data.append(row)
+            viewer.add_row(row)
+            
+            # Small delay between rows
+            if stream_delay > 0:
+                time.sleep(stream_delay)
+        
+        viewer.complete()
+        
+        # Import pandas dynamically to avoid circular imports
+        import pandas as pd
+        dataset_instance._data = pd.DataFrame(data)
+        return dataset_instance._data
+        
+    except Exception as e:
+        viewer.stop()
+        raise e
+    finally:
+        # Keep server running for a bit so user can see final state
+        time.sleep(1)

chatan-0.1.3.dist-info/METADATA

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: chatan
+Version: 0.1.3
+Summary: Create synthetic datasets with LLM generators and samplers
+Project-URL: Documentation, https://github.com/cdreetz/chatan#readme
+Project-URL: Issues, https://github.com/cdreetz/chatan/issues
+Project-URL: Source, https://github.com/cdreetz/chatan
+Author-email: Christian Reetz <cdreetz@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: dataset generation,llm,machine learning,synthetic data
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Requires-Dist: anthropic>=0.7.0
+Requires-Dist: datasets>=2.0.0
+Requires-Dist: nltk>=3.9.1
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: scikit-learn>=1.3.2
+Requires-Dist: sentence-transformers>=3.2.1
+Requires-Dist: torch>=2.5.1
+Requires-Dist: tqdm>=4.0.0
+Requires-Dist: transformers>=4.0.0
+Description-Content-Type: text/markdown
+
+# Chatan
+
+Create diverse, synthetic datasets. Start from scratch or augment an existing dataset. Simple define your dataset schema as a set of generators, typically being LLMs with a prompt describing what kind of examples you want.
+
+## Installation
+
+```
+pip install chatan
+```
+
+## Getting Started
+
+```
+import chatan
+
+# Create a generator
+gen = chatan.generator("openai", "YOUR_API_KEY")
+
+# Define a dataset schema
+ds = chatan.dataset({
+    "topic": chatan.sample.choice(["Python", "JavaScript", "Rust"]),
+    "prompt": gen("write a programming question about {topic}"),
+    "response": gen("answer this question: {prompt}")
+})
+
+# Generate the data with a progress bar
+df = ds.generate(n=10)
+```
+
+## Examples
+
+Create Data Mixes
+
+```
+from chatan import dataset, generator, sample
+import uuid
+
+gen = generator("openai", "YOUR_API_KEY")
+
+mix = [
+    "san antonio, tx",
+    "marfa, tx",
+    "paris, fr"
+]
+
+ds = dataset({
+    "id": sample.uuid(),
+    "topic": sample.choice(mix),
+    "prompt": gen("write an example question about the history of {topic}"),
+    "response": gen("respond to: {prompt}"),
+})
+```
+
+Augment datasets
+
+```
+from chatan import generator, dataset, sample
+from datasets import load_dataset
+
+gen = generator("openai", "YOUR_API_KEY")
+hf_data = load_dataset("some/dataset")
+
+ds = dataset({
+    "original_prompt": sample.from_dataset(hf_data, "prompt"),
+    "variation": gen("rewrite this prompt: {original_prompt}"),
+    "response": gen("respond to: {variation}")
+})
+
+```
+
+## Citation
+
+If you use this code in your research, please cite:
+
+```
+@software{reetz2025chatan,
+  author = {Reetz, Christian},
+  title = {chatan: Create synthetic datasets with LLM generators.},
+  url = {https://github.com/cdreetz/chatan},
+  year = {2025}
+}
+```
+
+## Contributing
+
+Community contributions are more than welcome, bug reports, bug fixes, feature requests, feature additions, please refer to the Issues tab.

chatan-0.1.3.dist-info/RECORD

@@ -0,0 +1,10 @@
+chatan/__init__.py,sha256=AEW7uf7P7t_BAkKHEUl9Eq02R6C8VAFfYAc5zM4ECEc,355
+chatan/dataset.py,sha256=R0sa2m7LM_BABi2B1NJpGxiSFuh0h1cFMGUCw-9ZKhM,5716
+chatan/evaluate.py,sha256=m_2zTEJUNfA3Jqt195dd4LqOTTMZOUVtoNDjOhwtHHM,12543
+chatan/generator.py,sha256=syapQLWPvaLJ_Jw3Vn9egTvUzIkgotEFut1_qpqxHEk,4764
+chatan/sampler.py,sha256=0X6AVQK20py4SwKnsppZC2yAZnP_jBhRxt9MfT1e-k4,4812
+chatan/viewer.py,sha256=tnQPoOYz_c22BouPPC7zDjdjHox0SETlf9XeXYs82FA,18885
+chatan-0.1.3.dist-info/METADATA,sha256=30X5jEMcs7XjAvTqbYaH1flCZ-OaWmmXsTbQ9iL5vPQ,3445
+chatan-0.1.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+chatan-0.1.3.dist-info/licenses/LICENSE,sha256=QplUnrABTIgjBDFCKoGgdjnZndIBrRCS2WJr6gm9kX4,1072
+chatan-0.1.3.dist-info/RECORD,,

chatan-0.1.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Christian Reetz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

chatan-0.1.1.dist-info/METADATA

@@ -1,83 +0,0 @@
-Metadata-Version: 2.4
-Name: chatan
-Version: 0.1.1
-Summary: Create synthetic datasets with LLM generators and samplers
-Project-URL: Documentation, https://github.com/cdreetz/chatan#readme
-Project-URL: Issues, https://github.com/cdreetz/chatan/issues
-Project-URL: Source, https://github.com/cdreetz/chatan
-Author-email: Christian Reetz <cdreetz@gmail.com>
-License-Expression: MIT
-Keywords: dataset generation,llm,machine learning,synthetic data
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.8
-Requires-Dist: anthropic>=0.7.0
-Requires-Dist: datasets>=2.0.0
-Requires-Dist: numpy>=1.20.0
-Requires-Dist: openai>=1.0.0
-Requires-Dist: pandas>=1.3.0
-Requires-Dist: pydantic>=2.0.0
-Description-Content-Type: text/markdown
-
-## Examples
-
-Prompt a dataset
-
-```
-import chatan
-
-gen = chatan.generator.client("YOUR_OPENAI_API_KEY")
-ds = chatan.dataset("create a QA dataset for finetuning an LLM on pharmacology")
-```
-
-Creating datasets with different data mixes
-
-```
-import uuid
-from chatan import dataset, generator, mix
-
-gen = generator.client("YOUR_OPENAI_API_KEY")
-#generator.client("anthropic", "YOUR_ANTHROPIC_API_KEY")
-
-mix = {
-    "implementation": "Can you implement a matmul kernel in Triton",
-    "conversion": "Convert this pytorch model to Triton",
-    "explanation": "What memory access optimizations are being used here?"
-}
-
-ds = dataset({
-    "id": uuid,
-    "task": sample.choice(mix),
-    "prompt": gen("write a prompt for {task}"),
-    "response": gen("write a response to {prompt}"),
-)}
-```
-
-Augment datasets
-
-```
-import uuid
-from chatan import dataset, generator
-from dataset import load_dataset
-
-gen = generator.client("YOUR_OPENAI_API_KEY")
-hf_dataset = load_dataset("GPU_MODE/KernelBook")
-
-ds = dataset({
-    "id": sample.from_dataset(hf_data, "id", default=sample.uuid()),
-    "prompt": sample.from_dataset(hf_data, "prompt", aug=gen("provide a variation of this prompt")),
-    "response": gen("write a response to {prompt}")
-
-})
-
-```

chatan-0.1.1.dist-info/RECORD

@@ -1,7 +0,0 @@
-chatan/__init__.py,sha256=SebE8sKfiXl3FC0iwYi7ft9piJgOVdRXnj6g17z5rzo,233
-chatan/dataset.py,sha256=t6RrrQchsD2dROD886IfnlXWnn-F-IAWMcEIK0SS3xg,4358
-chatan/generator.py,sha256=zAOVxd2iY_KMK21dCMeFhvsJu2q8NEwch5jGJP-Me9s,3914
-chatan/sampler.py,sha256=0X6AVQK20py4SwKnsppZC2yAZnP_jBhRxt9MfT1e-k4,4812
-chatan-0.1.1.dist-info/METADATA,sha256=cCZgPzZaGvLWBDqDBj3dS7Fzh-l4HFFqGDoy01n5Sw8,2549
-chatan-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-chatan-0.1.1.dist-info/RECORD,,