sdg-hub 0.7.2__py3-none-any.whl → 0.8.0__py3-none-any.whl

sdg_hub/core/blocks/transform/rename_columns.py

@@ -27,6 +27,8 @@ logger = setup_logger(__name__)
     "Renames columns in a dataset according to a mapping specification",
 )
 class RenameColumnsBlock(BaseBlock):
+    block_type: str = "transform"
+
     """Block for renaming columns in a dataset.
 
     This block renames columns in a dataset according to a mapping specification.
@@ -53,6 +55,16 @@ class RenameColumnsBlock(BaseBlock):
             )
         return v
 
+    def model_post_init(self, __context: Any) -> None:
+        """Initialize derived attributes after Pydantic validation."""
+        super().model_post_init(__context) if hasattr(
+            super(), "model_post_init"
+        ) else None
+
+        # Set output_cols to the new column names being created
+        if self.output_cols is None:
+            self.output_cols = list(self.input_cols.values())
+
     def generate(self, samples: pd.DataFrame, **kwargs: Any) -> pd.DataFrame:
         """Generate a dataset with renamed columns.
 

sdg_hub/core/blocks/transform/text_concat.py

@@ -27,6 +27,8 @@ logger = setup_logger(__name__)
     "Combines multiple columns into a single column using a specified separator",
 )
 class TextConcatBlock(BaseBlock):
+    block_type: str = "transform"
+
     """Block for combining multiple columns into a single column.
 
     This block concatenates values from multiple columns into a single output column,

sdg_hub/core/blocks/transform/uniform_col_val_setter.py

@@ -28,6 +28,8 @@ logger = setup_logger(__name__)
     "Replaces all values in a column with a single summary statistic (e.g., mode, mean, median)",
 )
 class UniformColumnValueSetter(BaseBlock):
+    block_type: str = "transform"
+
     """Block that replaces all values in a column with a single aggregate value.
 
     Supported strategies include: mode, min, max, mean, median.

sdg_hub/core/connectors/__init__.py

@@ -0,0 +1,46 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Connectors subsystem for external service integrations.
+
+Example
+-------
+>>> from sdg_hub.core.connectors import (
+...     ConnectorConfig,
+...     ConnectorRegistry,
+...     LangflowConnector,
+... )
+>>>
+>>> # Using the registry
+>>> connector_class = ConnectorRegistry.get("langflow")
+>>> config = ConnectorConfig(url="http://localhost:7860/api/v1/run/flow")
+>>> connector = connector_class(config=config)
+>>>
+>>> # Direct instantiation
+>>> connector = LangflowConnector(config=config)
+>>> response = connector.send(
+...     messages=[{"role": "user", "content": "Hello!"}],
+...     session_id="session-123",
+... )
+"""
+
+# Import agent module to register connectors
+from .agent import BaseAgentConnector, LangflowConnector
+from .base import BaseConnector, ConnectorConfig
+from .exceptions import ConnectorError, ConnectorHTTPError
+from .http import HttpClient
+from .registry import ConnectorRegistry
+
+__all__ = [
+    # Base classes
+    "BaseConnector",
+    "ConnectorConfig",
+    # Agent connectors
+    "BaseAgentConnector",
+    "LangflowConnector",
+    # Registry
+    "ConnectorRegistry",
+    # HTTP utilities
+    "HttpClient",
+    # Exceptions
+    "ConnectorError",
+    "ConnectorHTTPError",
+]

sdg_hub/core/connectors/agent/__init__.py

@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Agent connector implementations."""
+
+from .base import BaseAgentConnector
+from .langflow import LangflowConnector
+
+__all__ = [
+    "BaseAgentConnector",
+    "LangflowConnector",
+]

sdg_hub/core/connectors/agent/base.py

@@ -0,0 +1,233 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Base class for agent framework connectors."""
+
+from abc import abstractmethod
+from typing import Any, Optional
+import asyncio
+
+from pydantic import PrivateAttr
+
+from ...utils.logger_config import setup_logger
+from ..base import BaseConnector
+from ..exceptions import ConnectorError
+from ..http import HttpClient
+
+logger = setup_logger(__name__)
+
+
+class BaseAgentConnector(BaseConnector):
+    """Base class for agent framework connectors.
+
+    This class provides a common interface for communicating with
+    agent frameworks (Langflow, LangGraph, etc.). It uses an async-first
+    pattern where the core logic is implemented once in async, and sync
+    is derived automatically.
+
+    Subclasses must implement:
+    - build_request: Convert messages to framework-specific format
+    - parse_response: Convert framework response to standard format
+
+    Example
+    -------
+    >>> class MyAgentConnector(BaseAgentConnector):
+    ...     def build_request(self, messages, session_id):
+    ...         return {"input": messages[-1]["content"], "session": session_id}
+    ...
+    ...     def parse_response(self, response):
+    ...         return {"output": response["result"]}
+    ...
+    >>> connector = MyAgentConnector(config=ConnectorConfig(url="http://api"))
+    >>> response = connector.send([{"role": "user", "content": "Hello"}], "session1")
+    """
+
+    _http_client: Optional[HttpClient] = PrivateAttr(default=None)
+
+    def _get_http_client(self) -> HttpClient:
+        """Get or create the HTTP client."""
+        if self._http_client is None:
+            self._http_client = HttpClient(
+                timeout=self.config.timeout,
+                max_retries=self.config.max_retries,
+            )
+        return self._http_client
+
+    def _build_headers(self) -> dict[str, str]:
+        """Build HTTP headers for requests.
+
+        Override in subclasses for framework-specific headers.
+
+        Returns
+        -------
+        dict[str, str]
+            HTTP headers to include in requests.
+        """
+        headers = {"Content-Type": "application/json"}
+        if self.config.api_key:
+            headers["Authorization"] = f"Bearer {self.config.api_key}"
+        return headers
+
+    @abstractmethod
+    def build_request(
+        self,
+        messages: list[dict[str, Any]],
+        session_id: str,
+    ) -> dict[str, Any]:
+        """Build framework-specific request payload.
+
+        Parameters
+        ----------
+        messages : list[dict]
+            List of messages in standard format:
+            [{"role": "user", "content": "Hello"}, ...]
+        session_id : str
+            Session identifier for conversation tracking.
+
+        Returns
+        -------
+        dict
+            Framework-specific request payload.
+        """
+        pass
+
+    @abstractmethod
+    def parse_response(
+        self, response: dict[str, Any], extract_text: bool = False
+    ) -> Any:
+        """Parse and validate framework response.
+
+        Parameters
+        ----------
+        response : dict
+            Raw response from the framework.
+        extract_text : bool
+            If True, extract just the text content. Default False returns full response.
+
+        Returns
+        -------
+        dict or str
+            Full response dict, or just the text if extract_text=True.
+
+        Raises
+        ------
+        ConnectorError
+            If the response is invalid or cannot be parsed.
+        """
+        pass
+
+    async def _send_async(
+        self,
+        messages: list[dict[str, Any]],
+        session_id: str,
+    ) -> Any:
+        """Core async implementation.
+
+        Parameters
+        ----------
+        messages : list[dict]
+            Messages to send to the agent.
+        session_id : str
+            Session identifier.
+
+        Returns
+        -------
+        Any
+            Parsed response from the agent (dict or str if extract_text=True).
+        """
+        if not self.config.url:
+            raise ConnectorError("No URL configured for connector")
+
+        http_client = self._get_http_client()
+        request = self.build_request(messages, session_id)
+        headers = self._build_headers()
+
+        logger.debug(f"Sending request to {self.config.url}")
+        raw_response = await http_client.post(
+            url=self.config.url,
+            payload=request,
+            headers=headers,
+        )
+        logger.debug(f"Received response from {self.config.url}")
+
+        extract_text = getattr(self.config, "extract_text", False)
+        return self.parse_response(raw_response, extract_text=extract_text)
+
+    def send(
+        self,
+        messages: list[dict[str, Any]],
+        session_id: str,
+        async_mode: bool = False,
+    ):
+        """Send messages to the agent.
+
+        Parameters
+        ----------
+        messages : list[dict]
+            Messages to send, in format:
+            [{"role": "user", "content": "Hello"}, ...]
+        session_id : str
+            Session identifier for conversation tracking.
+        async_mode : bool, optional
+            If True, returns a coroutine. If False (default), runs synchronously.
+
+        Returns
+        -------
+        dict or Coroutine[dict]
+            Response dict, or coroutine if async_mode=True.
+        """
+        if async_mode:
+            return self._send_async(messages, session_id)
+
+        # Sync mode: run async code in event loop
+        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._send_async(messages, session_id),
+                )
+                return future.result()
+        except RuntimeError:
+            # No event loop - create one
+            return asyncio.run(self._send_async(messages, session_id))
+
+    async def asend(
+        self,
+        messages: list[dict[str, Any]],
+        session_id: str,
+    ) -> Any:
+        """Async send - convenience wrapper.
+
+        Parameters
+        ----------
+        messages : list[dict]
+            Messages to send.
+        session_id : str
+            Session identifier.
+
+        Returns
+        -------
+        Any
+            Response from the agent (dict or str if extract_text=True).
+        """
+        return await self._send_async(messages, session_id)
+
+    def execute(self, request: dict[str, Any]) -> dict[str, Any]:
+        """Execute a request (BaseConnector interface).
+
+        Parameters
+        ----------
+        request : dict
+            Request containing 'messages' and 'session_id' keys.
+
+        Returns
+        -------
+        dict
+            Response from the agent.
+        """
+        return self.send(
+            messages=request["messages"],
+            session_id=request.get("session_id", "default"),
+        )

sdg_hub/core/connectors/agent/langflow.py

@@ -0,0 +1,151 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Langflow agent framework connector."""
+
+from typing import Any
+
+from ...utils.logger_config import setup_logger
+from ..exceptions import ConnectorError
+from ..registry import ConnectorRegistry
+from .base import BaseAgentConnector
+
+logger = setup_logger(__name__)
+
+
+@ConnectorRegistry.register("langflow")
+class LangflowConnector(BaseAgentConnector):
+    """Connector for Langflow agent framework.
+
+    Langflow is a visual framework for building LLM-powered applications.
+    This connector handles the specific request/response format used by
+    Langflow's API.
+
+    Langflow expects:
+    - Single string input (not message array)
+    - Session ID for conversation tracking
+    - Returns structured response with outputs
+
+    Example
+    -------
+    >>> from sdg_hub.core.connectors import ConnectorConfig, LangflowConnector
+    >>>
+    >>> config = ConnectorConfig(
+    ...     url="http://localhost:7860/api/v1/run/my-flow",
+    ...     api_key="your-api-key",
+    ... )
+    >>> connector = LangflowConnector(config=config)
+    >>> response = connector.send(
+    ...     messages=[{"role": "user", "content": "Hello!"}],
+    ...     session_id="session-123",
+    ... )
+    """
+
+    def _build_headers(self) -> dict[str, str]:
+        """Build headers for Langflow API.
+
+        Langflow uses x-api-key header for authentication.
+
+        Returns
+        -------
+        dict[str, str]
+            HTTP headers.
+        """
+        headers = {"Content-Type": "application/json"}
+        if self.config.api_key:
+            # Langflow uses x-api-key header
+            headers["x-api-key"] = self.config.api_key
+        return headers
+
+    def build_request(
+        self,
+        messages: list[dict[str, Any]],
+        session_id: str,
+    ) -> dict[str, Any]:
+        """Build Langflow-specific request payload.
+
+        Langflow expects a single string input, not a message array.
+        We extract the last user message content.
+
+        Parameters
+        ----------
+        messages : list[dict]
+            Messages in standard format.
+        session_id : str
+            Session identifier.
+
+        Returns
+        -------
+        dict
+            Langflow API request payload.
+        """
+        input_value = self._extract_last_user_message(messages)
+
+        return {
+            "output_type": "chat",
+            "input_type": "chat",
+            "input_value": input_value,
+            "session_id": session_id,
+        }
+
+    def parse_response(
+        self, response: dict[str, Any], extract_text: bool = False
+    ) -> Any:
+        """Parse Langflow response.
+
+        Parameters
+        ----------
+        response : dict
+            Raw response from Langflow API.
+        extract_text : bool
+            If True, extract just the text content. Default False returns full response.
+
+        Returns
+        -------
+        dict or str
+            Full response dict, or just the text if extract_text=True.
+
+        Raises
+        ------
+        ConnectorError
+            If response is not a valid dict or text extraction fails.
+        """
+        if not isinstance(response, dict):
+            raise ConnectorError(
+                f"Expected dict response, got {type(response).__name__}"
+            )
+
+        if extract_text:
+            try:
+                return response["outputs"][0]["outputs"][0]["results"]["message"][
+                    "text"
+                ]
+            except (KeyError, IndexError, TypeError) as e:
+                raise ConnectorError(f"Failed to extract text from response: {e}")
+
+        return response
+
+    def _extract_last_user_message(self, messages: list[dict[str, Any]]) -> str:
+        """Extract the last user message content.
+
+        Parameters
+        ----------
+        messages : list[dict]
+            List of messages.
+
+        Returns
+        -------
+        str
+            Content of the last user message.
+
+        Raises
+        ------
+        ConnectorError
+            If no user message is found.
+        """
+        for msg in reversed(messages):
+            if msg.get("role") == "user" and msg.get("content"):
+                return msg["content"]
+
+        raise ConnectorError(
+            "No user message found in messages. "
+            "Expected at least one message with role='user' and content."
+        )

sdg_hub/core/connectors/base.py

@@ -0,0 +1,99 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Base connector classes for external service integrations."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from ..utils.logger_config import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class ConnectorConfig(BaseModel):
+    """Base configuration for all connectors.
+
+    Attributes
+    ----------
+    url : str, optional
+        The base URL for the external service.
+    api_key : str, optional
+        API key for authentication.
+    timeout : float
+        Request timeout in seconds. Default is 120.0.
+    max_retries : int
+        Maximum number of retry attempts. Default is 3.
+    """
+
+    url: Optional[str] = Field(None, description="Base URL for the service")
+    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)
+    extract_text: bool = Field(
+        False,
+        description="Extract just the text content from agent response",
+    )
+
+    model_config = ConfigDict(extra="allow")
+
+
+class BaseConnector(BaseModel, ABC):
+    """Abstract base class for all connectors.
+
+    Connectors handle communication with external services.
+
+    Attributes
+    ----------
+    config : ConnectorConfig
+        Configuration for the connector.
+
+    Example
+    -------
+    >>> class MyConnector(BaseConnector):
+    ...     def execute(self, request: dict) -> dict:
+    ...         return {"result": request.get("input")}
+    ...
+    >>> connector = MyConnector(config=ConnectorConfig(url="http://example.com"))
+    >>> result = connector.execute({"input": "test"})
+    """
+
+    config: ConnectorConfig = Field(..., description="Connector configuration")
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    @abstractmethod
+    def execute(self, request: Any) -> Any:
+        """Execute a synchronous request.
+
+        Parameters
+        ----------
+        request : Any
+            The request to execute (format depends on connector type).
+
+        Returns
+        -------
+        Any
+            The response from the external service.
+        """
+        pass
+
+    async def aexecute(self, request: Any) -> Any:
+        """Execute an asynchronous request.
+
+        Default implementation wraps sync execute in a thread.
+        Subclasses should override for true async support.
+
+        Parameters
+        ----------
+        request : Any
+            The request to execute.
+
+        Returns
+        -------
+        Any
+            The response from the external service.
+        """
+        import asyncio
+
+        return await asyncio.to_thread(self.execute, request)

sdg_hub/core/connectors/exceptions.py

@@ -0,0 +1,41 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Exception classes for the connectors subsystem."""
+
+from typing import Optional
+
+from ..utils.error_handling import SDGHubError
+
+
+class ConnectorError(SDGHubError):
+    """Base exception for all connector-related errors.
+
+    Use this for general connector errors including:
+    - Configuration errors
+    - Connection failures
+    - Timeout errors
+    - Response parsing errors
+    """
+
+    pass
+
+
+class ConnectorHTTPError(ConnectorError):
+    """Raised when an HTTP request returns an error status code.
+
+    Parameters
+    ----------
+    url : str
+        The URL that returned an error.
+    status_code : int
+        The HTTP status code.
+    message : str, optional
+        Additional error details (e.g., response body).
+    """
+
+    def __init__(self, url: str, status_code: int, message: Optional[str] = None):
+        self.url = url
+        self.status_code = status_code
+        error_msg = f"HTTP {status_code} error from '{url}'"
+        if message:
+            error_msg = f"{error_msg}: {message}"
+        super().__init__(error_msg)

sdg_hub/core/connectors/http/__init__.py

@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+"""HTTP utilities for connectors."""
+
+from .client import HttpClient
+
+__all__ = ["HttpClient"]