DeepFabric 4.5.1__py3-none-any.whl → 4.6.0__py3-none-any.whl

deepfabric/config.py

@@ -119,13 +119,13 @@ class TopicsConfig(BaseModel):
 class ConversationConfig(BaseModel):
     """Configuration for conversation structure in generation."""
 
-    type: Literal["basic", "chain_of_thought"] = Field(
+    type: Literal["basic", "cot"] = Field(
         default="basic",
-        description="Base conversation type: basic (simple chat), chain_of_thought (with reasoning)",
+        description="Base conversation type: basic (simple chat), cot (with reasoning)",
     )
     reasoning_style: Literal["freetext", "agent", "structured", "hybrid"] | None = Field(
         default=None,
-        description="Reasoning style for chain_of_thought: freetext or agent. Note: 'structured' and 'hybrid' are deprecated.",
+        description="Reasoning style for cot: freetext or agent. Note: 'structured' and 'hybrid' are deprecated.",
     )
     agent_mode: Literal["single_turn", "multi_turn"] | None = Field(
         default=None,
@@ -159,15 +159,14 @@ class ConversationConfig(BaseModel):
     @model_validator(mode="after")
     def validate_configuration(self):
         """Validate that configuration combinations are consistent."""
-        if self.reasoning_style is not None and self.type != "chain_of_thought":
+        if self.reasoning_style is not None and self.type != "cot":
             raise ValueError(
-                f"reasoning_style can only be set when type='chain_of_thought', "
-                f"got type='{self.type}'"
+                f"reasoning_style can only be set when type='cot', got type='{self.type}'"
             )
 
-        if self.type == "chain_of_thought" and self.reasoning_style is None:
+        if self.type == "cot" and self.reasoning_style is None:
             raise ValueError(
-                "reasoning_style must be specified when type='chain_of_thought'. "
+                "reasoning_style must be specified when type='cot'. "
                 "Choose from: 'freetext' or 'agent'"
             )
 
@@ -346,16 +345,37 @@ class KaggleConfig(BaseModel):
     version_notes: str | None = Field(None, description="Version notes for dataset update")
 
 
+class DeepFabricCloudConfig(BaseModel):
+    """Configuration for DeepFabric Cloud integration."""
+
+    graph: str | None = Field(
+        default=None,
+        description="DeepFabric Cloud graph handle (e.g., username/graph-name)",
+    )
+    dataset: str | None = Field(
+        default=None,
+        description="DeepFabric Cloud dataset handle (e.g., username/dataset-name)",
+    )
+    description: str | None = Field(
+        default=None,
+        description="Description for uploaded resources",
+    )
+    tags: list[str] = Field(
+        default_factory=list,
+        description="Tags for uploaded resources",
+    )
+
+
 class EvaluationConfig(BaseModel):
     """Configuration for model evaluation."""
 
-    conversation_type: Literal["basic", "chain_of_thought"] = Field(
+    conversation_type: Literal["basic", "cot"] = Field(
         ...,
         description="Conversation type (must match dataset generation)",
     )
     reasoning_style: Literal["freetext", "agent", "structured", "hybrid"] | None = Field(
         default=None,
-        description="Reasoning style for chain_of_thought type",
+        description="Reasoning style for cot type",
     )
 
     @field_validator("reasoning_style", mode="before")
@@ -419,15 +439,15 @@ class EvaluationConfig(BaseModel):
     @model_validator(mode="after")
     def validate_evaluation_config(self) -> "EvaluationConfig":
         """Validate evaluation configuration consistency."""
-        if self.reasoning_style is not None and self.conversation_type != "chain_of_thought":
+        if self.reasoning_style is not None and self.conversation_type != "cot":
             raise ValueError(
-                f"reasoning_style can only be set when conversation_type='chain_of_thought', "
+                f"reasoning_style can only be set when conversation_type='cot', "
                 f"got conversation_type='{self.conversation_type}'"
             )
 
-        if self.conversation_type == "chain_of_thought" and self.reasoning_style is None:
+        if self.conversation_type == "cot" and self.reasoning_style is None:
             raise ValueError(
-                "reasoning_style must be specified when conversation_type='chain_of_thought'. "
+                "reasoning_style must be specified when conversation_type='cot'. "
                 "Choose from: 'freetext' or 'agent'"
             )
 
@@ -457,6 +477,9 @@ class DeepFabricConfig(BaseModel):
     evaluation: EvaluationConfig | None = Field(None, description="Evaluation configuration")
     huggingface: HuggingFaceConfig | None = Field(None, description="Hugging Face configuration")
     kaggle: KaggleConfig | None = Field(None, description="Kaggle configuration")
+    deepfabric_cloud: DeepFabricCloudConfig | None = Field(
+        None, description="DeepFabric Cloud configuration"
+    )
 
     @classmethod
     def _detect_old_format(cls, config_dict: dict) -> bool:
@@ -663,6 +686,10 @@ See documentation for full examples.
         """Get Kaggle configuration."""
         return self.kaggle.model_dump() if self.kaggle else {}
 
+    def get_deepfabric_cloud_config(self) -> dict:
+        """Get DeepFabric Cloud configuration."""
+        return self.deepfabric_cloud.model_dump() if self.deepfabric_cloud else {}
+
     def get_configured_providers(self) -> set[str]:
         """Get the set of LLM providers configured in this config."""
         providers = set()
@@ -808,13 +835,13 @@ class DataEngineConfig(BaseModel):
         default=None,
         description="Rate limiting and retry configuration",
     )
-    conversation_type: Literal["basic", "chain_of_thought"] = Field(
+    conversation_type: Literal["basic", "cot"] = Field(
         default="basic",
         description="Base conversation type",
     )
     reasoning_style: Literal["freetext", "agent", "structured", "hybrid"] | None = Field(
         default=None,
-        description="Reasoning style for chain_of_thought type",
+        description="Reasoning style for cot type",
     )
 
     @field_validator("reasoning_style", mode="before")
@@ -839,15 +866,15 @@ class DataEngineConfig(BaseModel):
 
     @model_validator(mode="after")
     def validate_configuration(self):
-        if self.reasoning_style is not None and self.conversation_type != "chain_of_thought":
+        if self.reasoning_style is not None and self.conversation_type != "cot":
             raise ValueError(
-                f"reasoning_style can only be set when conversation_type='chain_of_thought', "
+                f"reasoning_style can only be set when conversation_type='cot', "
                 f"got conversation_type='{self.conversation_type}'"
             )
 
-        if self.conversation_type == "chain_of_thought" and self.reasoning_style is None:
+        if self.conversation_type == "cot" and self.reasoning_style is None:
             raise ValueError(
-                "reasoning_style must be specified when conversation_type='chain_of_thought'. "
+                "reasoning_style must be specified when conversation_type='cot'. "
                 "Choose from: 'freetext' or 'agent'"
             )
 

deepfabric/config_manager.py

@@ -63,8 +63,8 @@ def load_config(  # noqa: PLR0913
         output_save_as: Path to save dataset
         include_system_message: Include system message in dataset
         mode: Topic generation mode (tree or graph)
-        conversation_type: Base conversation type (basic, chain_of_thought)
-        reasoning_style: Reasoning style for chain_of_thought (freetext, agent)
+        conversation_type: Base conversation type (basic, cot)
+        reasoning_style: Reasoning style for cot (freetext, agent)
         agent_mode: Agent mode (single_turn, multi_turn)
 
     Returns:

deepfabric/dataset.py

@@ -0,0 +1,302 @@
+"""Native DeepFabric Dataset implementation.
+
+This module provides a simple, maintainable Dataset class with no external
+dependencies (beyond stdlib). It supports column-oriented access patterns
+similar to HuggingFace datasets.
+"""
+
+import json
+import random
+
+from collections.abc import Callable, Iterator
+from typing import Any, overload
+
+
+class Dataset:
+    """A simple, native dataset class that stores data as a list of dicts
+    with column-oriented access patterns.
+
+    Examples:
+        >>> ds = Dataset([{"text": "hello"}, {"text": "world"}])
+        >>> len(ds)
+        2
+        >>> ds["text"]
+        ['hello', 'world']
+        >>> ds[0]
+        {'text': 'hello'}
+        >>> ds[0:1]
+        Dataset with 1 samples
+    """
+
+    def __init__(self, data: list[dict[str, Any]], metadata: dict | None = None):
+        """Initialize dataset from list of sample dicts.
+
+        Args:
+            data: List of sample dictionaries
+            metadata: Optional metadata (source, path, etc.)
+        """
+        self._data = data
+        self._metadata = metadata or {}
+        self._columns: list[str] | None = None
+
+    @property
+    def column_names(self) -> list[str]:
+        """Return list of column names."""
+        if self._columns is None:
+            if self._data:
+                # Collect all unique keys across samples
+                all_keys: set[str] = set()
+                for sample in self._data:
+                    all_keys.update(sample.keys())
+                self._columns = sorted(all_keys)
+            else:
+                self._columns = []
+        return self._columns
+
+    @property
+    def num_rows(self) -> int:
+        """Return number of samples (alias for len)."""
+        return len(self._data)
+
+    def __len__(self) -> int:
+        """Return number of samples."""
+        return len(self._data)
+
+    @overload
+    def __getitem__(self, key: str) -> list[Any]: ...
+
+    @overload
+    def __getitem__(self, key: int) -> dict[str, Any]: ...
+
+    @overload
+    def __getitem__(self, key: slice) -> "Dataset": ...
+
+    def __getitem__(self, key: str | int | slice) -> Any:
+        """Access by column name, index, or slice.
+
+        Args:
+            key: Column name (str), row index (int), or slice
+
+        Returns:
+            - For str: list of values for that column
+            - For int: dict for that sample
+            - For slice: new Dataset with selected samples
+
+        Examples:
+            >>> ds["messages"]  # Get column as list
+            >>> ds[0]           # Get first sample as dict
+            >>> ds[0:10]        # Get first 10 samples as new Dataset
+        """
+        if isinstance(key, str):
+            # Column access - return list of values
+            return [sample.get(key) for sample in self._data]
+        if isinstance(key, int):
+            # Single sample access
+            if key < 0:
+                key = len(self._data) + key
+            if key < 0 or key >= len(self._data):
+                raise IndexError(
+                    f"Index {key} out of range for dataset with {len(self._data)} samples"
+                )
+            return self._data[key]
+        if isinstance(key, slice):
+            # Slice access - return new Dataset
+            return Dataset(self._data[key], self._metadata.copy())
+        raise TypeError(f"Invalid key type: {type(key)}. Expected str, int, or slice.")
+
+    def __iter__(self) -> Iterator[dict[str, Any]]:
+        """Iterate over samples."""
+        return iter(self._data)
+
+    def __repr__(self) -> str:
+        """Return string representation."""
+        cols = ", ".join(self.column_names[:5])
+        if len(self.column_names) > 5:  # noqa: PLR2004
+            cols += ", ..."
+        return f"Dataset(num_rows={len(self)}, columns=[{cols}])"
+
+    def split(
+        self,
+        test_size: float = 0.1,
+        seed: int | None = None,
+    ) -> dict[str, "Dataset"]:
+        """Split dataset into train and test sets.
+
+        Args:
+            test_size: Fraction of data for test set (0.0 to 1.0)
+            seed: Random seed for reproducibility
+
+        Returns:
+            Dict with "train" and "test" Dataset instances
+
+        Examples:
+            >>> splits = ds.split(test_size=0.1, seed=42)
+            >>> train_ds = splits["train"]
+            >>> test_ds = splits["test"]
+        """
+        if not 0.0 < test_size < 1.0:
+            raise ValueError("test_size must be between 0.0 and 1.0 (exclusive)")
+
+        # Use a local Random instance to avoid affecting global state
+        rng = random.Random(seed)  # noqa: S311 # nosec
+
+        # Create shuffled indices
+        indices = list(range(len(self._data)))
+        rng.shuffle(indices)
+
+        # Calculate split point
+        split_idx = int(len(indices) * (1 - test_size))
+
+        train_indices = indices[:split_idx]
+        test_indices = indices[split_idx:]
+
+        return {
+            "train": self.select(train_indices),
+            "test": self.select(test_indices),
+        }
+
+    def select(self, indices: list[int]) -> "Dataset":
+        """Select samples by indices.
+
+        Args:
+            indices: List of integer indices to select
+
+        Returns:
+            New Dataset with selected samples
+        """
+        return Dataset([self._data[i] for i in indices], self._metadata.copy())
+
+    def shuffle(self, seed: int | None = None) -> "Dataset":
+        """Return a shuffled copy of the dataset.
+
+        Args:
+            seed: Random seed for reproducibility
+
+        Returns:
+            New Dataset with shuffled samples
+        """
+        rng = random.Random(seed)  #  nosec  # noqa: S311
+        indices = list(range(len(self._data)))
+        rng.shuffle(indices)
+        return self.select(indices)
+
+    def map(self, fn: Callable[[dict[str, Any]], dict[str, Any]]) -> "Dataset":
+        """Apply function to each sample.
+
+        Args:
+            fn: Function that takes a sample dict and returns a new sample dict
+
+        Returns:
+            New Dataset with transformed samples
+
+        Examples:
+            >>> ds.map(lambda x: {"text": x["text"].upper()})
+        """
+        return Dataset([fn(sample) for sample in self._data], self._metadata.copy())
+
+    def filter(self, fn: Callable[[dict[str, Any]], bool]) -> "Dataset":
+        """Filter samples by predicate function.
+
+        Args:
+            fn: Function that takes a sample dict and returns True to keep
+
+        Returns:
+            New Dataset with filtered samples
+
+        Examples:
+            >>> ds.filter(lambda x: len(x["text"]) > 10)
+        """
+        return Dataset([s for s in self._data if fn(s)], self._metadata.copy())
+
+    def to_list(self) -> list[dict[str, Any]]:
+        """Return data as list of dicts.
+
+        Returns:
+            Copy of internal data as list of dictionaries
+        """
+        return self._data.copy()
+
+    def to_hf(self) -> Any:
+        """Convert to HuggingFace Dataset for use with TRL/transformers.
+
+        Returns:
+            A HuggingFace datasets.Dataset instance
+
+        Raises:
+            ImportError: If the 'datasets' package is not installed
+
+        Examples:
+            >>> from deepfabric import load_dataset
+            >>> ds = load_dataset("data.jsonl")
+            >>> hf_ds = ds.to_hf()
+            >>> trainer = SFTTrainer(train_dataset=hf_ds, ...)
+        """
+        try:
+            from datasets import Dataset as HFDataset  # noqa: PLC0415
+        except ImportError:
+            raise ImportError(
+                "The 'datasets' package is required for to_hf(). "
+                "Install it with: pip install datasets"
+            ) from None
+
+        return HFDataset.from_list(self._data)
+
+    def to_jsonl(self, path: str) -> None:
+        """Save dataset to JSONL file.
+
+        Args:
+            path: File path to save to
+        """
+        with open(path, "w", encoding="utf-8") as f:
+            for sample in self._data:
+                f.write(json.dumps(sample, ensure_ascii=False) + "\n")
+
+    @classmethod
+    def from_jsonl(cls, path: str) -> "Dataset":
+        """Load dataset from JSONL file.
+
+        Args:
+            path: File path to load from
+
+        Returns:
+            New Dataset loaded from file
+        """
+        data = []
+        with open(path, encoding="utf-8") as f:
+            for line in f:
+                if line.strip():
+                    data.append(json.loads(line))
+        return cls(data, metadata={"source": "jsonl", "path": path})
+
+    @classmethod
+    def from_list(cls, data: list[dict[str, Any]]) -> "Dataset":
+        """Create dataset from list of dicts.
+
+        Args:
+            data: List of sample dictionaries
+
+        Returns:
+            New Dataset from the provided data
+        """
+        return cls(data)
+
+
+class DatasetDict(dict):
+    """Dictionary of Dataset objects for train/test/validation splits.
+
+    A simple dict subclass that provides typed access to Dataset values.
+
+    Examples:
+        >>> dd = DatasetDict({"train": train_ds, "test": test_ds})
+        >>> dd["train"]
+        Dataset(num_rows=100, columns=[...])
+    """
+
+    def __getitem__(self, key: str) -> Dataset:
+        """Get Dataset by split name."""
+        return super().__getitem__(key)
+
+    def __repr__(self) -> str:
+        """Return string representation."""
+        splits = ", ".join(f"{k}: {len(v)} rows" for k, v in self.items())
+        return f"DatasetDict({{{splits}}})"

deepfabric/evaluation/parser.py

@@ -49,12 +49,12 @@ class GroundTruth(BaseModel):
         default=None,
         description="Expected final answer if available",
     )
-    conversation_type: Literal["basic", "chain_of_thought"] = Field(
+    conversation_type: Literal["basic", "cot"] = Field(
         description="Type of conversation",
     )
     reasoning_style: Literal["freetext", "agent", "structured", "hybrid"] | None = Field(
         default=None,
-        description="Reasoning style if chain_of_thought",
+        description="Reasoning style if cot",
     )
     agent_mode: Literal["single_turn", "multi_turn"] | None = Field(
         default=None,
@@ -75,18 +75,18 @@ class GroundTruthParser:
 
     def __init__(
         self,
-        conversation_type: Literal["basic", "chain_of_thought"],
+        conversation_type: Literal["basic", "cot"],
         reasoning_style: Literal["freetext", "agent", "structured", "hybrid"] | None = None,
         agent_mode: Literal["single_turn", "multi_turn"] | None = None,
     ):
         """Initialize parser with conversation configuration.
 
         Args:
-            conversation_type: Type of conversation (basic, chain_of_thought)
-            reasoning_style: Reasoning style for chain_of_thought
+            conversation_type: Type of conversation (basic, cot)
+            reasoning_style: Reasoning style for cot
             agent_mode: Agent mode if tools are used
         """
-        self.conversation_type: Literal["basic", "chain_of_thought"] = conversation_type
+        self.conversation_type: Literal["basic", "cot"] = conversation_type
         self.reasoning_style: Literal["freetext", "agent", "structured", "hybrid"] | None = (
             reasoning_style
         )
@@ -270,7 +270,7 @@ class GroundTruthParser:
 
 def parse_batch(
     conversations: list[Conversation],
-    conversation_type: Literal["basic", "chain_of_thought"],
+    conversation_type: Literal["basic", "cot"],
     reasoning_style: Literal["freetext", "agent", "structured", "hybrid"] | None = None,
     agent_mode: Literal["single_turn", "multi_turn"] | None = None,
 ) -> list[GroundTruth]:
@@ -279,7 +279,7 @@ def parse_batch(
     Args:
         conversations: List of Conversation objects
         conversation_type: Type of conversation
-        reasoning_style: Reasoning style if chain_of_thought
+        reasoning_style: Reasoning style if cot
         agent_mode: Agent mode if tools are used
 
     Returns:

deepfabric/evaluation/reporters/cloud_reporter.py

@@ -13,6 +13,7 @@ import httpx
 
 from rich.console import Console
 
+from ...utils import get_bool_env
 from .base import BaseReporter
 
 if TYPE_CHECKING:
@@ -45,7 +46,7 @@ class CloudReporter(BaseReporter):
 
         Args:
             config: Optional configuration with:
-                - api_url: DeepFabric API URL (default: https://api.deepfabric.dev")
+                - api_url: DeepFabric API URL (default: https://api.deepfabric.cloud")
                 - project_id: Project ID to associate results with
                 - auth_token: Authentication token (if not provided, will read from config file)
                 - enabled: Whether to enable cloud reporting (default: True if authenticated)
@@ -53,7 +54,7 @@ class CloudReporter(BaseReporter):
         super().__init__(config)
 
         # Get API URL from config or environment
-        self.api_url = os.getenv("DEEPFABRIC_API_URL", "https://api.deepfabric.dev")
+        self.api_url = os.getenv("DEEPFABRIC_API_URL", "https://api.deepfabric.cloud")
         if config and "api_url" in config:
             self.api_url = config["api_url"]
 
@@ -67,8 +68,9 @@ class CloudReporter(BaseReporter):
         # Get project ID from config
         self.project_id = config.get("project_id") if config else None
 
-        # Enable cloud reporting if authenticated
-        self.enabled = (
+        # Enable cloud reporting if authenticated AND experimental flag is set
+        is_experimental = get_bool_env("EXPERIMENTAL_DF")
+        self.enabled = is_experimental and (
             config.get("enabled", bool(self.auth_token)) if config else bool(self.auth_token)
         )
 
@@ -99,11 +101,22 @@ class CloudReporter(BaseReporter):
         try:
             console.print("[cyan]Uploading evaluation results to cloud...[/cyan]")
 
+            # Get model name as string (handle in-memory model objects)
+            model_value = result.config.inference_config.model
+            if isinstance(model_value, str):
+                model_name = model_value
+            else:
+                # For in-memory model objects, extract name from config
+                model_config = getattr(model_value, "config", None)
+                model_name = (
+                    getattr(model_config, "name_or_path", None) or type(model_value).__name__
+                )
+
             # Create evaluation run
             run_data = {
-                "project_id": self.project_id,
+                "pipeline_id": self.project_id,
                 "name": f"Evaluation - {datetime.now(UTC).strftime('%Y-%m-%d %H:%M')}",
-                "model_name": result.config.inference_config.model,
+                "model_name": model_name,
                 "model_provider": result.config.inference_config.backend,
                 "config": {
                     "evaluators": getattr(result.config, "evaluators", ["tool_calling"]),

deepfabric/exceptions.py

@@ -65,3 +65,17 @@ class RetryExhaustedError(ModelError):
     """Raised when maximum retries are exceeded."""
 
     pass
+
+
+class LoaderError(DeepFabricError):
+    """Raised when dataset loading fails.
+
+    Common causes:
+    - File not found
+    - Invalid file format (malformed JSON/JSONL)
+    - Cloud authentication failure
+    - Network errors
+    - Empty dataset
+    """
+
+    pass

deepfabric/generator.py

@@ -127,14 +127,14 @@ class DataSetGeneratorConfig(BaseModel):
     )
 
     # Modular conversation configuration
-    conversation_type: Literal["basic", "chain_of_thought"] = Field(
+    conversation_type: Literal["basic", "cot"] = Field(
         default="basic",
-        description="Base conversation type: basic (simple chat), chain_of_thought (with reasoning traces)",
+        description="Base conversation type: basic (simple chat), cot (with reasoning traces)",
     )
 
     reasoning_style: Literal["freetext", "agent", "structured", "hybrid"] | None = Field(
         default=None,
-        description="Reasoning style for chain_of_thought type: freetext (natural language) or agent (structured step-by-step for tool-calling). Note: 'structured' and 'hybrid' are deprecated.",
+        description="Reasoning style for cot type: freetext (natural language) or agent (structured step-by-step for tool-calling). Note: 'structured' and 'hybrid' are deprecated.",
     )
 
     @field_validator("reasoning_style", mode="before")
@@ -1045,7 +1045,7 @@ class DataSetGenerator:
             return CONVERSATION_GENERATION_PROMPT
 
         # Handle chain of thought conversations
-        if self.config.conversation_type == "chain_of_thought":
+        if self.config.conversation_type == "cot":
             # Agent mode with tools - use agent prompts
             if self.config.agent_mode == "single_turn" and self.tool_registry:
                 # Use agent prompt for single-turn tool calling