sdg-hub 0.7.2__tar.gz → 0.8.0__tar.gz

sdg_hub-0.8.0/.github/actions/free-disk-space/action.yml

@@ -0,0 +1,26 @@
+name: 'Free Disk Space'
+description: 'Frees disk space on the runner for Python ML workloads'
+runs:
+  using: "composite"
+  steps:
+    - run: |
+        echo "Disk space before cleanup:"
+        df -h /
+
+        # Remove large pre-installed SDKs not needed for Python projects
+        sudo rm -rf \
+          /usr/share/dotnet \
+          /usr/local/lib/android \
+          /opt/ghc \
+          /usr/local/share/powershell \
+          /usr/share/swift \
+          /usr/local/.ghcup \
+          /usr/lib/jvm \
+          /opt/hostedtoolcache/CodeQL || true
+
+        # Remove docker images
+        docker image ls -aq | xargs -r sudo docker rmi >/dev/null 2>&1 || true
+
+        echo "Disk space after cleanup:"
+        df -h /
+      shell: bash

{sdg_hub-0.7.2 → sdg_hub-0.8.0}/.github/workflows/actionlint.dockerfile

@@ -1,3 +1,3 @@
 # Since dependabot cannot update workflows using docker,
 # we use this indirection since dependabot can update this file.
-FROM rhysd/actionlint:1.7.9@sha256:a0383f60d92601e2694e24b24d37df7b6a40bed7cedbc447611c50009bf02d94
+FROM rhysd/actionlint:1.7.10@sha256:ef8299f97635c4c30e2298f48f30763ab782a4ad2c95b744649439a039421e36

{sdg_hub-0.7.2 → sdg_hub-0.8.0}/.github/workflows/integration-test.yml

@@ -112,7 +112,7 @@ jobs:
 
 
       - name: Cache huggingface datasets
-        uses: actions/cache@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
+        uses: actions/cache@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
         with:
           path: ~/.cache/huggingface
           # Invalidate cache when any example notebook changes (may affect dataset downloads)

{sdg_hub-0.7.2 → sdg_hub-0.8.0}/CLAUDE.md

@@ -86,6 +86,7 @@ The framework is built around a modular block system with **composability at its
   - `transform/`: Data transformation blocks (column operations, text manipulation)
   - `filtering/`: Data filtering blocks with quality thresholds
   - `evaluation/`: Quality evaluation blocks (faithfulness, relevancy assessment)
+  - `agent/`: Agent framework integration blocks (Langflow, etc.)
 
 **Key Benefits**: Type-safe composition, automatic validation, rich logging, and high-performance async processing.
 
@@ -129,6 +130,39 @@ flows/qa_generation/document_grounded_qa/multi_summary_qa/instructlab/
 └── generate_questions_responses.yaml
 ```
 
+### Connector System
+Connectors handle communication with external agent frameworks:
+
+- **BaseConnector** (`src/sdg_hub/core/connectors/base.py`): Abstract base for all connectors
+- **ConnectorRegistry** (`src/sdg_hub/core/connectors/registry.py`): Auto-discovery for connectors
+- **BaseAgentConnector** (`src/sdg_hub/core/connectors/agent/base.py`): Base class for agent framework connectors
+
+**Supported Agent Frameworks:**
+- **Langflow** (`src/sdg_hub/core/connectors/agent/langflow.py`): Visual LLM app builder
+
+**Using AgentBlock:**
+```python
+from sdg_hub.core.blocks.agent import AgentBlock
+
+block = AgentBlock(
+    block_name="my_agent",
+    agent_framework="langflow",  # Connector name from registry
+    agent_url="http://localhost:7860/api/v1/run/my-flow",
+    agent_api_key="your-api-key",  # Optional
+    input_cols=["question"],
+    output_cols=["response"],
+    extract_response=True,  # Extract text from response (Langflow-specific)
+)
+
+result = block.generate(dataset)
+```
+
+**Adding New Connectors:**
+1. Create a new file in `src/sdg_hub/core/connectors/agent/`
+2. Inherit from `BaseAgentConnector`
+3. Implement `build_request()` and `parse_response()` methods
+4. Register with `@ConnectorRegistry.register("name")`
+
 ## Key Patterns
 
 ### Block Development

{sdg_hub-0.7.2 → sdg_hub-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdg_hub
-Version: 0.7.2
+Version: 0.8.0
 Summary: Synthetic Data Generation
 Author-email: Red Hat AI Innovation <abhandwa@redhat.com>
 License: Apache-2.0
@@ -26,7 +26,7 @@ Requires-Dist: click<9.0.0,>=8.1.7
 Requires-Dist: datasets>=4.0.0
 Requires-Dist: httpx<1.0.0,>=0.25.0
 Requires-Dist: jinja2
-Requires-Dist: litellm<1.75.0,>=1.73.0
+Requires-Dist: litellm<2.0.0,>=1.73.0
 Requires-Dist: rich
 Requires-Dist: pandas
 Requires-Dist: pydantic<3.0.0,>=2.0.0

{sdg_hub-0.7.2 → sdg_hub-0.8.0}/docs/blocks/llm-blocks.md

@@ -603,7 +603,7 @@ print(result["judgment"])     # ['YES']
 TextParserBlock is commonly used after LLMChatBlock to structure responses:
 
 ```python
-from sdg_hub.core.blocks import LLMChatBlock, LLMParserBlock, TextParserBlock
+from sdg_hub.core.blocks import LLMChatBlock, LLMResponseExtractorBlock, TextParserBlock
 
 # Step 1: Generate LLM response
 chat_block = LLMChatBlock(
@@ -615,7 +615,7 @@ chat_block = LLMChatBlock(
 
 # Step 2: Extract content from response object
 # Use field_prefix="" to get cleaner column names
-llm_parser = LLMParserBlock(
+llm_parser = LLMResponseExtractorBlock(
     block_name="extract_eval",
     input_cols=["eval_response"],
     extract_content=True,

{sdg_hub-0.7.2 → sdg_hub-0.8.0}/docs/flows/overview.md

@@ -316,7 +316,7 @@ blocks:
       output_cols: ["eval_response"]
       async_mode: true
 
-  - block_type: "LLMParserBlock"
+  - block_type: "LLMResponseExtractorBlock"
     block_config:
       block_name: "extract_eval_content"
       input_cols: ["eval_response"]
@@ -537,7 +537,7 @@ result = flow.generate(
 | | `top_p` | Nucleus sampling threshold | `0.0` - `1.0` |
 | | `frequency_penalty` | Penalize token repetition | `-2.0` - `2.0` |
 | | `presence_penalty` | Penalize new topics | `-2.0` - `2.0` |
-| **LLMParserBlock** | `extract_content` | Extract main content field | `True`, `False` |
+| **LLMResponseExtractorBlock** | `extract_content` | Extract main content field | `True`, `False` |
 | | `extract_reasoning_content` | Extract reasoning/thinking | `True`, `False` |
 | | `extract_tool_calls` | Extract tool call data | `True`, `False` |
 | | `field_prefix` | Prefix for output fields | `"llm_"`, `"parsed_"` |
@@ -752,7 +752,7 @@ result = flow.generate(dataset)
 │ │ generate_question    │ LLMChatBlock    │   45.30s │ 100 → 100    │ +1      │ ✓││
 │ │ generate_answer      │ LLMChatBlock    │   78.45s │ 100 → 100    │ +1      │ ✓││
 │ │ eval_faithfulness... │ LLMChatBlock    │   52.20s │ 100 → 100    │ +1      │ ✓││
-│ │ extract_eval_con...  │ LLMParserBlock  │    0.15s │ 100 → 100    │ +2      │ ✓││
+│ │ extract_eval_con...  │ LLMResponseExtractorBlock  │    0.15s │ 100 → 100    │ +2      │ ✓││
 │ │ parse_evaluation     │ TextParserBlock │    0.22s │ 100 → 100    │ +2      │ ✓││
 │ │ filter_faithful      │ ColumnValueF... │    0.08s │ 100 → 87     │ —       │ ✓││
 │ ├──────────────────────┼─────────────────┼──────────┼──────────────┼─────────┼──┤│

{sdg_hub-0.7.2 → sdg_hub-0.8.0}/examples/text_analysis/structured_insights_demo.ipynb

@@ -332,7 +332,7 @@
     "    LLMChatBlock,\n",
     "    PromptBuilderBlock,\n",
     "    TextParserBlock,\n",
-    "    LLMParserBlock,\n",
+    "    LLMResponseExtractorBlock,\n",
     ")\n",
     "from sdg_hub.core.blocks.transform import JSONStructureBlock\n",
     "\n",
@@ -355,7 +355,7 @@
     "    temperature=0.1,  # Low temperature for more consistent extraction\n",
     ")\n",
     "\n",
-    "ticker_llm_parser_block = LLMParserBlock(\n",
+    "ticker_llm_response_extractor_block = LLMResponseExtractorBlock(\n",
     "    block_name=\"extract_stock_tickers\",\n",
     "    input_cols=[\"raw_stock_tickers\"],\n",
     "    extract_content=True,\n",
@@ -406,7 +406,7 @@
     "ticker_blocks = [\n",
     "    ticker_prompt_block,\n",
     "    ticker_llm_block,\n",
-    "    ticker_llm_parser_block,\n",
+    "    ticker_llm_response_extractor_block,\n",
     "    ticker_parser_block,\n",
     "    enhanced_json_block,\n",
     "]\n",

{sdg_hub-0.7.2 → sdg_hub-0.8.0}/pyproject.toml

@@ -33,7 +33,7 @@ dependencies = [
     "datasets>=4.0.0",
     "httpx>=0.25.0,<1.0.0",
     "jinja2",
-    "litellm>=1.73.0,<1.75.0",
+    "litellm>=1.73.0,<2.0.0",         # raising cap since tests run without errors related to 'backoff' cap back to <1.75.0 if errors surface
     "rich",
     "pandas",
     "pydantic>=2.0.0,<3.0.0",         # cap before v3; adjust the lower bound to the minimum v2.x you’ve tested

{sdg_hub-0.7.2 → sdg_hub-0.8.0}/src/sdg_hub/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.7.2'
-__version_tuple__ = version_tuple = (0, 7, 2)
+__version__ = version = '0.8.0'
+__version_tuple__ = version_tuple = (0, 8, 0)
 
-__commit_id__ = commit_id = 'g99a40a268'
+__commit_id__ = commit_id = 'g280e2588b'

{sdg_hub-0.7.2 → sdg_hub-0.8.0}/src/sdg_hub/core/__init__.py

@@ -2,14 +2,26 @@
 """Core SDG Hub components."""
 
 # Local
-from .blocks import BaseBlock, BlockRegistry
+from .blocks import AgentBlock, BaseBlock, BlockRegistry
+from .connectors import (
+    BaseConnector,
+    ConnectorConfig,
+    ConnectorError,
+    ConnectorRegistry,
+)
 from .flow import Flow, FlowMetadata, FlowRegistry, FlowValidator
 from .utils import GenerateError, resolve_path
 
 __all__ = [
     # Block components
+    "AgentBlock",
     "BaseBlock",
     "BlockRegistry",
+    # Connector components
+    "BaseConnector",
+    "ConnectorConfig",
+    "ConnectorError",
+    "ConnectorRegistry",
     # Flow components
     "Flow",
     "FlowRegistry",

{sdg_hub-0.7.2 → sdg_hub-0.8.0}/src/sdg_hub/core/blocks/__init__.py

@@ -4,9 +4,16 @@ This package provides various block implementations for data generation, process
 """
 
 # Local
+from .agent import AgentBlock
 from .base import BaseBlock
 from .filtering import ColumnValueFilterBlock
-from .llm import LLMChatBlock, LLMParserBlock, PromptBuilderBlock, TextParserBlock
+from .llm import (
+    LLMChatBlock,
+    LLMParserBlock,
+    LLMResponseExtractorBlock,
+    PromptBuilderBlock,
+    TextParserBlock,
+)
 from .registry import BlockRegistry
 from .transform import (
     DuplicateColumnsBlock,
@@ -18,6 +25,7 @@ from .transform import (
 )
 
 __all__ = [
+    "AgentBlock",
     "BaseBlock",
     "BlockRegistry",
     "ColumnValueFilterBlock",
@@ -28,7 +36,8 @@ __all__ = [
     "TextConcatBlock",
     "UniformColumnValueSetter",
     "LLMChatBlock",
-    "LLMParserBlock",
+    "LLMParserBlock",  # Deprecated alias for LLMResponseExtractorBlock
+    "LLMResponseExtractorBlock",
     "TextParserBlock",
     "PromptBuilderBlock",
 ]

sdg_hub-0.8.0/src/sdg_hub/core/blocks/agent/__init__.py

@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Agent blocks for external agent framework integration."""
+
+from .agent_block import AgentBlock
+
+__all__ = ["AgentBlock"]

sdg_hub-0.8.0/src/sdg_hub/core/blocks/agent/agent_block.py

@@ -0,0 +1,397 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Agent block for integrating external agent frameworks."""
+
+from typing import Any, Optional
+import asyncio
+import uuid
+
+from pydantic import Field, PrivateAttr
+from tqdm import tqdm
+import pandas as pd
+
+from ...connectors.agent.base import BaseAgentConnector
+from ...connectors.base import ConnectorConfig
+from ...connectors.exceptions import ConnectorError
+from ...connectors.registry import ConnectorRegistry
+from ...utils.logger_config import setup_logger
+from ..base import BaseBlock
+from ..registry import BlockRegistry
+
+logger = setup_logger(__name__)
+
+
+@BlockRegistry.register(
+    "AgentBlock",
+    category="agent",
+    description="Execute agent frameworks (Langflow, etc.) on DataFrame rows",
+)
+class AgentBlock(BaseBlock):
+    """Block for executing external agent frameworks on DataFrame rows.
+
+    This block integrates with various agent frameworks through the connector
+    system. Each row in the DataFrame is processed by sending messages to the
+    agent and storing the response.
+
+    The block supports both sync and async execution modes for optimal
+    performance with large datasets.
+
+    Parameters
+    ----------
+    agent_framework : str
+        Name of the connector to use (e.g., 'langflow').
+    agent_url : str
+        API endpoint URL for the agent.
+    agent_api_key : str, optional
+        API key for authentication.
+    timeout : float
+        Request timeout in seconds. Default 120.0.
+    max_retries : int
+        Maximum retry attempts. Default 3.
+    session_id_col : str, optional
+        Column containing session IDs. If not provided, generates UUIDs.
+    async_mode : bool
+        Whether to use async execution. Default False.
+    max_concurrency : int
+        Maximum concurrent requests in async mode. Default 10.
+
+    Example YAML Configuration
+    --------------------------
+    ```yaml
+    - block_type: AgentBlock
+      block_config:
+        block_name: my_agent
+        agent_framework: langflow
+        agent_url: http://localhost:7860/api/v1/run/my-flow
+        agent_api_key: ${LANGFLOW_API_KEY}
+        input_cols:
+          messages: messages_col
+        output_cols:
+          - agent_response
+    ```
+
+    Example
+    -------
+    >>> block = AgentBlock(
+    ...     block_name="qa_agent",
+    ...     agent_framework="langflow",
+    ...     agent_url="http://localhost:7860/api/v1/run/qa-flow",
+    ...     input_cols={"messages": "question"},
+    ...     output_cols=["response"],
+    ... )
+    >>> result_df = block(df)
+    """
+
+    # Required configuration
+    agent_framework: str = Field(
+        ...,
+        description="Connector name (e.g., 'langflow')",
+    )
+    agent_url: str = Field(
+        ...,
+        description="Agent API endpoint URL",
+    )
+
+    # Optional configuration
+    agent_api_key: Optional[str] = Field(
+        None,
+        description="API key for authentication",
+    )
+    timeout: float = Field(
+        120.0,
+        description="Request timeout in seconds",
+        gt=0,
+    )
+    max_retries: int = Field(
+        3,
+        description="Maximum retry attempts",
+        ge=0,
+    )
+    session_id_col: Optional[str] = Field(
+        None,
+        description="Column containing session IDs",
+    )
+    async_mode: bool = Field(
+        False,
+        description="Use async execution for better throughput",
+    )
+    max_concurrency: int = Field(
+        10,
+        description="Maximum concurrent requests in async mode",
+        gt=0,
+    )
+    extract_response: bool = Field(
+        False,
+        description="Extract just the text content from agent response",
+    )
+
+    # Private attributes
+    _connector: Optional[BaseAgentConnector] = PrivateAttr(default=None)
+    _connector_config_key: Optional[tuple] = PrivateAttr(default=None)
+
+    def _get_connector(self) -> BaseAgentConnector:
+        """Get or create the connector instance.
+
+        Invalidates the cached connector if the config has changed (e.g., due
+        to runtime overrides).
+
+        Returns
+        -------
+        BaseAgentConnector
+            The configured connector instance.
+        """
+        config_key = (
+            self.agent_framework,
+            self.agent_url,
+            self.agent_api_key,
+            self.timeout,
+            self.max_retries,
+            self.extract_response,
+        )
+        if self._connector is None or self._connector_config_key != config_key:
+            connector_class = ConnectorRegistry.get(self.agent_framework)
+            config = ConnectorConfig(
+                url=self.agent_url,
+                api_key=self.agent_api_key,
+                timeout=self.timeout,
+                max_retries=self.max_retries,
+                extract_text=self.extract_response,
+            )
+            self._connector = connector_class(config=config)
+            self._connector_config_key = config_key
+        return self._connector
+
+    def _get_messages_col(self) -> str:
+        """Get the input column name for messages.
+
+        Returns
+        -------
+        str
+            Column name containing messages.
+        """
+        if isinstance(self.input_cols, dict):
+            if "messages" in self.input_cols:
+                return self.input_cols["messages"]
+            elif self.input_cols:
+                return list(self.input_cols.keys())[0]
+            else:
+                raise ConnectorError("input_cols must specify the messages column")
+        elif isinstance(self.input_cols, list) and len(self.input_cols) > 0:
+            return self.input_cols[0]
+        else:
+            raise ConnectorError("input_cols must specify the messages column")
+
+    def _get_output_col(self) -> str:
+        """Get the output column name for responses.
+
+        Returns
+        -------
+        str
+            Column name for storing responses.
+        """
+        if isinstance(self.output_cols, dict):
+            return list(self.output_cols.keys())[0]
+        elif isinstance(self.output_cols, list) and len(self.output_cols) > 0:
+            return self.output_cols[0]
+        else:
+            return "agent_response"
+
+    def _build_messages(self, content: Any) -> list[dict[str, Any]]:
+        """Build message list from row content.
+
+        Parameters
+        ----------
+        content : Any
+            Content from the DataFrame cell.
+
+        Returns
+        -------
+        list[dict]
+            List of messages in standard format.
+        """
+        if isinstance(content, list):
+            # Already a message list
+            return content
+        elif isinstance(content, dict):
+            # Single message dict
+            return [content]
+        else:
+            # Plain text - wrap as user message
+            return [{"role": "user", "content": str(content)}]
+
+    def _get_session_id(self, row: pd.Series, idx: int) -> str:
+        """Get session ID for a row.
+
+        Parameters
+        ----------
+        row : pd.Series
+            DataFrame row.
+        idx : int
+            Row index.
+
+        Returns
+        -------
+        str
+            Session ID.
+        """
+        if self.session_id_col and self.session_id_col in row:
+            return str(row[self.session_id_col])
+        return str(uuid.uuid4())
+
+    def _process_row_sync(
+        self,
+        row: pd.Series,
+        idx: int,
+        connector: BaseAgentConnector,
+        messages_col: str,
+    ) -> dict[str, Any]:
+        """Process a single row synchronously.
+
+        Parameters
+        ----------
+        row : pd.Series
+            DataFrame row.
+        idx : int
+            Row index.
+        connector : BaseAgentConnector
+            Connector instance.
+        messages_col : str
+            Column containing messages.
+
+        Returns
+        -------
+        dict
+            Response from the agent.
+        """
+        messages = self._build_messages(row[messages_col])
+        session_id = self._get_session_id(row, idx)
+        return connector.send(messages, session_id)
+
+    async def _process_row_async(
+        self,
+        row: pd.Series,
+        idx: int,
+        connector: BaseAgentConnector,
+        messages_col: str,
+        semaphore: asyncio.Semaphore,
+    ) -> tuple[int, dict[str, Any]]:
+        """Process a single row asynchronously.
+
+        Parameters
+        ----------
+        row : pd.Series
+            DataFrame row.
+        idx : int
+            Row index.
+        connector : BaseAgentConnector
+            Connector instance.
+        messages_col : str
+            Column containing messages.
+        semaphore : asyncio.Semaphore
+            Semaphore for concurrency control.
+
+        Returns
+        -------
+        tuple[int, dict]
+            Row index and response.
+        """
+        async with semaphore:
+            messages = self._build_messages(row[messages_col])
+            session_id = self._get_session_id(row, idx)
+            response = await connector.asend(messages, session_id)
+            return idx, response
+
+    async def _process_batch_async(
+        self,
+        df: pd.DataFrame,
+        connector: BaseAgentConnector,
+        messages_col: str,
+    ) -> dict[int, dict[str, Any]]:
+        """Process all rows asynchronously.
+
+        Parameters
+        ----------
+        df : pd.DataFrame
+            Input DataFrame.
+        connector : BaseAgentConnector
+            Connector instance.
+        messages_col : str
+            Column containing messages.
+
+        Returns
+        -------
+        dict[int, dict]
+            Mapping from row index to response.
+        """
+        semaphore = asyncio.Semaphore(self.max_concurrency)
+        tasks = [
+            self._process_row_async(row, idx, connector, messages_col, semaphore)
+            for idx, row in df.iterrows()
+        ]
+
+        results = {}
+        for coro in tqdm(
+            asyncio.as_completed(tasks),
+            total=len(tasks),
+            desc=f"{self.block_name} (async)",
+        ):
+            idx, response = await coro
+            results[idx] = response
+
+        return results
+
+    def generate(self, samples: pd.DataFrame, **kwargs: Any) -> pd.DataFrame:
+        """Process DataFrame rows through the agent.
+
+        Parameters
+        ----------
+        samples : pd.DataFrame
+            Input DataFrame with messages column.
+        **kwargs : Any
+            Runtime overrides.
+
+        Returns
+        -------
+        pd.DataFrame
+            DataFrame with agent responses added.
+        """
+        df = samples.copy()
+        connector = self._get_connector()
+        messages_col = self._get_messages_col()
+        output_col = self._get_output_col()
+
+        if self.async_mode:
+            # Async execution
+            try:
+                asyncio.get_running_loop()
+                # Already in async context - use thread executor
+                import concurrent.futures
+
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    future = executor.submit(
+                        asyncio.run,
+                        self._process_batch_async(df, connector, messages_col),
+                    )
+                    results = future.result()
+            except RuntimeError:
+                # No event loop - create one
+                results = asyncio.run(
+                    self._process_batch_async(df, connector, messages_col)
+                )
+
+            # Apply results
+            df[output_col] = df.index.map(results)
+        else:
+            # Sync execution with progress bar
+            responses = []
+            for idx, row in tqdm(
+                df.iterrows(),
+                total=len(df),
+                desc=self.block_name,
+            ):
+                response = self._process_row_sync(row, idx, connector, messages_col)
+                responses.append(response)
+
+            df[output_col] = responses
+
+        logger.info(f"Processed {len(df)} rows with {self.agent_framework} agent")
+        return df

{sdg_hub-0.7.2 → sdg_hub-0.8.0}/src/sdg_hub/core/blocks/base.py

@@ -49,6 +49,9 @@ class BaseBlock(BaseModel, ABC):
     block_name: str = Field(
         ..., description="Unique identifier for this block instance"
     )
+    block_type: Optional[str] = Field(
+        None, description="Block type (e.g., 'llm', 'transform', 'parser', 'filtering')"
+    )
     input_cols: Union[str, list[str], dict[str, Any], None] = Field(
         None, description="Input columns: str, list, or dict"
     )
@@ -366,5 +369,5 @@ class BaseBlock(BaseModel, ABC):
         Dict[str, Any]
         """
         config = self.get_config()
-        config["block_type"] = self.__class__.__name__
+        config["block_class"] = self.__class__.__name__
         return config