sdg-hub 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

sdg_hub/core/blocks/deprecated_blocks/rename_columns.py

@@ -1,88 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""Deprecated RenameColumns for backwards compatibility.
-
-This module provides a deprecated wrapper around RenameColumnsBlock
-to maintain backwards compatibility with existing code and configurations.
-"""
-
-# Standard
-from typing import Any
-import warnings
-
-# Third Party
-from datasets import Dataset
-
-# Local
-from ...utils.logger_config import setup_logger
-from ..base import BaseBlock
-from ..registry import BlockRegistry
-from ..transform import RenameColumnsBlock
-
-logger = setup_logger(__name__)
-
-
-@BlockRegistry.register(
-    "RenameColumns",
-    "deprecated",
-    "DEPRECATED: Use RenameColumnsBlock instead. Renames columns in a dataset according to a mapping dictionary",
-)
-class RenameColumns(BaseBlock):
-    """DEPRECATED: Block for renaming columns in a dataset.
-
-    This block is deprecated and maintained only for backwards compatibility.
-    Please use RenameColumnsBlock instead.
-
-    This block renames columns in a dataset according to a mapping dictionary,
-    where keys are existing column names and values are new column names.
-    """
-
-    def __init__(
-        self,
-        block_name: str,
-        columns_map: dict[str, str],
-    ) -> None:
-        """Initialize the deprecated RenameColumns.
-
-        Parameters
-        ----------
-        block_name : str
-            Name of the block.
-        columns_map : Dict[str, str]
-            Dictionary mapping existing column names to new column names.
-            Keys are existing column names, values are new column names.
-        """
-        # Issue deprecation warning
-        warnings.warn(
-            "RenameColumns is deprecated and will be removed in a future version. "
-            "Please use RenameColumnsBlock instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-        # Map old signature to new signature
-        super().__init__(
-            block_name=block_name,
-            input_cols=columns_map,
-            output_cols=[],
-        )
-
-        # Create the new block instance with mapped parameters
-        self._new_block = RenameColumnsBlock(
-            block_name=block_name,
-            input_cols=columns_map,
-        )
-
-    def generate(self, samples: Dataset, **kwargs: Any) -> Dataset:
-        """Generate dataset with renamed columns using the new RenameColumnsBlock.
-
-        Parameters
-        ----------
-        samples : Dataset
-            The input dataset to rename columns in.
-
-        Returns
-        -------
-        Dataset
-            The dataset with renamed columns.
-        """
-        return self._new_block.generate(samples, **kwargs)

sdg_hub/core/blocks/deprecated_blocks/sample_populator.py

@@ -1,58 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""DEPRECATED: SamplePopulatorBlock for backward compatibility.
-
-This module provides a deprecated stub for SamplePopulatorBlock.
-This block is deprecated and will be replaced with a router block.
-"""
-
-# Standard
-from typing import Any
-import warnings
-
-# Third Party
-from datasets import Dataset
-
-# Local
-from ...utils.logger_config import setup_logger
-from ..base import BaseBlock
-from ..registry import BlockRegistry
-
-logger = setup_logger(__name__)
-
-
-@BlockRegistry.register(
-    "SamplePopulatorBlock",
-    "deprecated",
-    "DEPRECATED: Use a router block instead. Populates dataset with data from configuration files",
-)
-class SamplePopulatorBlock(BaseBlock):
-    """DEPRECATED: Block for populating dataset with data from configuration files.
-
-    .. deprecated::
-        This block is deprecated and will be replaced with a router block.
-    """
-
-    def __init__(
-        self,
-        block_name: str,
-        config_paths: list[str],
-        column_name: str,
-        post_fix: str = "",
-        **batch_kwargs: dict[str, Any],
-    ) -> None:
-        warnings.warn(
-            "SamplePopulatorBlock is deprecated and will be replaced with a router block.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-        # Initialize with dummy values for BaseBlock validation
-        super().__init__(
-            block_name=block_name, input_cols=[column_name], output_cols=[column_name]
-        )
-
-    def generate(self, samples: Dataset, **kwargs: Any) -> Dataset:
-        """Generate method - raises error as block is deprecated."""
-        raise NotImplementedError(
-            "SamplePopulatorBlock is deprecated and will be replaced with a router block."
-        )

sdg_hub/core/blocks/deprecated_blocks/selector.py

@@ -1,97 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""DEPRECATED: SelectorBlock for backward compatibility.
-
-This module provides a deprecated wrapper for the old SelectorBlock interface.
-Use transform.IndexBasedMapperBlock instead.
-"""
-
-# Standard
-from typing import Any
-import warnings
-
-# Third Party
-from datasets import Dataset
-
-# Local
-from ...utils.logger_config import setup_logger
-from ..base import BaseBlock
-from ..registry import BlockRegistry
-from ..transform.index_based_mapper import IndexBasedMapperBlock
-
-logger = setup_logger(__name__)
-
-
-@BlockRegistry.register(
-    "SelectorBlock",
-    "deprecated",
-    "DEPRECATED: Use IndexBasedMapperBlock instead. Selects and maps values from one column to another",
-)
-class SelectorBlock(BaseBlock):
-    """DEPRECATED: Block for selecting and mapping values from one column to another.
-
-    .. deprecated::
-        Use `sdg_hub.blocks.transform.IndexBasedMapperBlock` instead.
-        This class will be removed in a future version.
-
-    This block uses a mapping dictionary to select values from one column and
-    store them in a new output column based on a choice column's value.
-
-    Parameters
-    ----------
-    block_name : str
-        Name of the block.
-    choice_map : Dict[str, str]
-        Dictionary mapping choice values to column names.
-    choice_col : str
-        Name of the column containing choice values.
-    output_col : str
-        Name of the column to store selected values.
-    **batch_kwargs : Dict[str, Any]
-        Additional keyword arguments for batch processing.
-    """
-
-    def __init__(
-        self,
-        block_name: str,
-        choice_map: dict[str, str],
-        choice_col: str,
-        output_col: str,
-        **batch_kwargs: dict[str, Any],
-    ) -> None:
-        warnings.warn(
-            "SelectorBlock is deprecated. Use sdg_hub.blocks.transform.IndexBasedMapperBlock instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-        # Initialize with dummy values for BaseBlock validation
-        # We need all columns referenced in choice_map as input, plus the choice column
-        all_input_cols = list(choice_map.values()) + [choice_col]
-
-        super().__init__(
-            block_name=block_name, input_cols=all_input_cols, output_cols=[output_col]
-        )
-
-        # Create the new implementation
-        self._impl = IndexBasedMapperBlock(
-            block_name=block_name,
-            input_cols=all_input_cols,
-            output_cols=[output_col],
-            choice_map=choice_map,
-            choice_cols=[choice_col],
-        )
-
-    def generate(self, samples: Dataset, **kwargs) -> Dataset:
-        """Generate a new dataset with selected values.
-
-        Parameters
-        ----------
-        samples : Dataset
-            Input dataset to process.
-
-        Returns
-        -------
-        Dataset
-            Dataset with selected values stored in output column.
-        """
-        return self._impl.generate(samples)

sdg_hub/core/blocks/deprecated_blocks/set_to_majority_value.py

@@ -1,88 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""Deprecated SetToMajorityValue for backwards compatibility.
-
-This module provides a deprecated wrapper around UniformColumnValueSetter
-to maintain backwards compatibility with existing code and configurations.
-"""
-
-# Standard
-from typing import Any
-import warnings
-
-# Third Party
-from datasets import Dataset
-
-# Local
-from ...utils.logger_config import setup_logger
-from ..base import BaseBlock
-from ..registry import BlockRegistry
-from ..transform import UniformColumnValueSetter
-
-logger = setup_logger(__name__)
-
-
-@BlockRegistry.register(
-    "SetToMajorityValue",
-    "deprecated",
-    "DEPRECATED: Use UniformColumnValueSetter with reduction_strategy='mode' instead. Sets all values in a column to the most frequent value",
-)
-class SetToMajorityValue(BaseBlock):
-    """DEPRECATED: Block for setting all values in a column to the most frequent value.
-
-    This block is deprecated and maintained only for backwards compatibility.
-    Please use UniformColumnValueSetter with reduction_strategy='mode' instead.
-
-    This block finds the most common value (mode) in a specified column and
-    replaces all values in that column with this majority value.
-    """
-
-    def __init__(
-        self,
-        block_name: str,
-        col_name: str,
-    ) -> None:
-        """Initialize the deprecated SetToMajorityValue.
-
-        Parameters
-        ----------
-        block_name : str
-            Name of the block.
-        col_name : str
-            Name of the column to set to majority value.
-        """
-        # Issue deprecation warning
-        warnings.warn(
-            "SetToMajorityValue is deprecated and will be removed in a future version. "
-            "Please use UniformColumnValueSetter with reduction_strategy='mode' instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-        # Map old signature to new signature
-        super().__init__(
-            block_name=block_name,
-            input_cols=[col_name],
-            output_cols=[],
-        )
-
-        # Create the new block instance with mapped parameters
-        self._new_block = UniformColumnValueSetter(
-            block_name=block_name,
-            input_cols=[col_name],
-            reduction_strategy="mode",
-        )
-
-    def generate(self, samples: Dataset, **kwargs: Any) -> Dataset:
-        """Generate dataset with column set to majority value using UniformColumnValueSetter.
-
-        Parameters
-        ----------
-        samples : Dataset
-            The input dataset to process.
-
-        Returns
-        -------
-        Dataset
-            The dataset with specified column set to its majority value.
-        """
-        return self._new_block.generate(samples, **kwargs)

sdg_hub/core/flow/migration.py

@@ -1,198 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""Migration utilities for backward compatibility with old flow formats."""
-
-# Standard
-from pathlib import Path
-from typing import Any, Union
-
-# Local
-from ..utils.logger_config import setup_logger
-
-logger = setup_logger(__name__)
-
-
-class FlowMigration:
-    """Utility class for migrating old flow formats to new format."""
-
-    @staticmethod
-    def is_old_format(flow_config: Union[list[dict[str, Any]], dict[str, Any]]) -> bool:
-        """Detect if a flow configuration is in the old format.
-
-        Parameters
-        ----------
-        flow_config : Union[List[Dict[str, Any]], Dict[str, Any]]
-            The loaded YAML configuration.
-
-        Returns
-        -------
-        bool
-            True if the configuration is in old format, False otherwise.
-        """
-        # Old format: Direct array of blocks
-        # New format: Dictionary with 'metadata' and 'blocks' keys
-        if isinstance(flow_config, list):
-            return True
-
-        if isinstance(flow_config, dict):
-            # Check if it has the new format structure
-            has_metadata = "metadata" in flow_config
-            has_blocks = "blocks" in flow_config
-
-            # If it has both metadata and blocks, it's new format
-            if has_metadata and has_blocks:
-                return False
-
-            # If it doesn't have the expected new format structure but is a dict,
-            # check if it looks like old format (all keys are block configs)
-            if not has_metadata and not has_blocks:
-                # Check first few items to see if they look like old block configs
-                for value in flow_config.values():
-                    if isinstance(value, dict) and "block_type" in value:
-                        return True
-                # If it's a dict but doesn't look like blocks, assume new format
-                return False
-
-        # If we can't determine, assume new format
-        return False
-
-    @staticmethod
-    def migrate_to_new_format(
-        flow_config: list[dict[str, Any]], yaml_path: str
-    ) -> tuple[dict[str, Any], dict[str, dict[str, Any]]]:
-        """Migrate old format flow configuration to new format.
-
-        Parameters
-        ----------
-        flow_config : List[Dict[str, Any]]
-            Old format flow configuration (array of blocks).
-        yaml_path : str
-            Path to the original YAML file for generating metadata.
-
-        Returns
-        -------
-        tuple[Dict[str, Any], Dict[str, Dict[str, Any]]]
-            Tuple of (new format flow configuration, extracted runtime_params).
-        """
-        logger.info(f"Migrating old flow format from: {yaml_path}")
-
-        # Generate default metadata
-        flow_name = Path(yaml_path).stem
-        metadata = FlowMigration._generate_default_metadata(flow_name)
-
-        # Process blocks and extract runtime parameters
-        migrated_blocks = []
-        runtime_params = {}
-
-        for i, block_config in enumerate(flow_config):
-            try:
-                migrated_block, block_runtime_params = (
-                    FlowMigration._migrate_block_config(block_config)
-                )
-                migrated_blocks.append(migrated_block)
-
-                # Add block's runtime params if any
-                if block_runtime_params:
-                    block_name = migrated_block.get("block_config", {}).get(
-                        "block_name"
-                    )
-                    if block_name:
-                        runtime_params[block_name] = block_runtime_params
-
-            except Exception as exc:
-                logger.warning(f"Failed to migrate block at index {i}: {exc}")
-                # Keep original block config as fallback
-                migrated_blocks.append(block_config)
-
-        # Create new format structure
-        new_config = {"metadata": metadata, "blocks": migrated_blocks}
-
-        logger.info(f"Successfully migrated flow with {len(migrated_blocks)} blocks")
-        logger.info(f"Extracted runtime_params for {len(runtime_params)} blocks")
-
-        return new_config, runtime_params
-
-    @staticmethod
-    def _generate_default_metadata(flow_name: str) -> dict[str, Any]:
-        """Generate default metadata for migrated flows."""
-        # Import here to avoid circular import
-        from ..utils.flow_identifier import get_flow_identifier
-
-        metadata = {
-            "name": flow_name,
-            "description": f"Migrated flow: {flow_name}",
-            "version": "1.0.0",
-            "author": "SDG_Hub",
-            "tags": ["migrated"],
-            "recommended_models": {
-                "default": "meta-llama/Llama-3.3-70B-Instruct",
-                "compatible": [],
-                "experimental": [],
-            },
-        }
-
-        # Generate id for migrated flows
-        flow_id = get_flow_identifier(flow_name)
-        if flow_id:
-            metadata["id"] = flow_id
-            logger.debug(f"Generated id for migrated flow: {flow_id}")
-
-        return metadata
-
-    @staticmethod
-    def _migrate_block_config(
-        block_config: dict[str, Any],
-    ) -> tuple[dict[str, Any], dict[str, Any]]:
-        """Migrate individual block configuration from old to new format.
-
-        Parameters
-        ----------
-        block_config : Dict[str, Any]
-            Old format block configuration.
-
-        Returns
-        -------
-        tuple[Dict[str, Any], Dict[str, Any]]
-            Tuple of (migrated block configuration, extracted runtime_params).
-        """
-        if not isinstance(block_config, dict):
-            return block_config, {}
-
-        # Start with the original config
-        migrated_config = block_config.copy()
-        runtime_params = {}
-
-        # Extract gen_kwargs as runtime_params
-        if "gen_kwargs" in migrated_config:
-            runtime_params = migrated_config.pop("gen_kwargs")
-            logger.debug(f"Extracted gen_kwargs as runtime_params: {runtime_params}")
-
-        # Remove unsupported fields
-        for unsupported_field in ["drop_columns", "drop_duplicates", "batch_kwargs"]:
-            if unsupported_field in migrated_config:
-                migrated_config.pop(unsupported_field)
-                logger.debug(
-                    f"Ignoring {unsupported_field} as it's not supported in new flow format"
-                )
-
-        # Handle parser_kwargs for LLMBlock (keep in block_config)
-        if migrated_config.get("block_type") == "LLMBlock":
-            block_config_section = migrated_config.get("block_config", {})
-            if "parser_kwargs" in block_config_section:
-                parser_kwargs = block_config_section["parser_kwargs"]
-                logger.debug(f"Preserving parser_kwargs for LLMBlock: {parser_kwargs}")
-
-        # Handle operator string conversion for FilterByValueBlock
-        if migrated_config.get("block_type") == "FilterByValueBlock":
-            block_config_section = migrated_config.get("block_config", {})
-            if "operation" in block_config_section:
-                operation = block_config_section["operation"]
-                if isinstance(operation, str) and operation.startswith("operator."):
-                    # Convert "operator.eq" to "eq"
-                    block_config_section["operation"] = operation.replace(
-                        "operator.", ""
-                    )
-                    logger.debug(
-                        f"Converted operation from {operation} to {block_config_section['operation']}"
-                    )
-
-        return migrated_config, runtime_params