sdg-hub 0.1.4__py3-none-any.whl → 0.2.1__py3-none-any.whl

sdg_hub-0.2.1.dist-info/RECORD

@@ -0,0 +1,68 @@
+sdg_hub/__init__.py,sha256=Tw-6R5a8_W1kJcTAsW3R9ltBDP1dy5-fe7Tvt3cSyCQ,550
+sdg_hub/_version.py,sha256=UoNvMtd4wCG76RwoSpNCUtaFyTwakGcZolfjXzNVSMY,511
+sdg_hub/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sdg_hub/core/__init__.py,sha256=NwqB4fwhC29W50VW7QXZssLxx122YvgO9LHDLdgAnrI,496
+sdg_hub/core/blocks/__init__.py,sha256=9sCkCvDQzJGSedaePVlEIpbNwrkBz_K500VW_6FLhuE,1601
+sdg_hub/core/blocks/base.py,sha256=TrzUAkG7Tiquk0Z3SOFsb5mRnHd1IbHH6gFPVH1P7T8,10424
+sdg_hub/core/blocks/registry.py,sha256=U__75QrxFpRaJlt36mOd26dgOqBeePs-ZX0Rnutp6r0,9782
+sdg_hub/core/blocks/deprecated_blocks/__init__.py,sha256=RDu3MWFStDQko-TKkx8tGoB1UTatP_RSldZK43zHDvY,889
+sdg_hub/core/blocks/deprecated_blocks/combine_columns.py,sha256=HCvpaYsAwgx1Dm0vIshcWsKoVsRT0KrmKp9j4oqtByc,2757
+sdg_hub/core/blocks/deprecated_blocks/duplicate_columns.py,sha256=maCaaEs0EMMzt7L1xm7fAH3ylaFMHEkeC_dtOw3FrjU,2694
+sdg_hub/core/blocks/deprecated_blocks/filter_by_value.py,sha256=-fuuMKj2g2MrijMBTd0PWtYBbf9anQ2UkYXHigCxxJI,3328
+sdg_hub/core/blocks/deprecated_blocks/flatten_columns.py,sha256=IenCskrPEv09h2uT6aZKCQzaxgA_3kAzOeJSd-R_-EA,2839
+sdg_hub/core/blocks/deprecated_blocks/llmblock.py,sha256=34lzC43BODpMk5AwlWA1ctdYPmN7cA6WL5vMXaI0P0Y,20385
+sdg_hub/core/blocks/deprecated_blocks/rename_columns.py,sha256=thp-mHtkRmUw_nYKpldy_mLWR2AvC5YUhbqDETM6-T0,2620
+sdg_hub/core/blocks/deprecated_blocks/sample_populator.py,sha256=UdueMApxOmPWaxxMrw7b1v74fKJBfqqRATEBqgmVtNw,1737
+sdg_hub/core/blocks/deprecated_blocks/selector.py,sha256=ABcXZrqEMsgKfdGAkSo2plMp4LsZSqPhEQugoDEYm1I,2950
+sdg_hub/core/blocks/deprecated_blocks/set_to_majority_value.py,sha256=44TQu-rK5isia-otMVB1zHd8D-wWmu3C8CI1NLtfY5s,2729
+sdg_hub/core/blocks/evaluation/__init__.py,sha256=kFXee-vsVVdU2XtLio9qHgPx_a0zoB_rQr509EKBGJc,357
+sdg_hub/core/blocks/evaluation/evaluate_faithfulness_block.py,sha256=ZuQ8jq2JwTdslUJtFi1E9NXebCWFZS8isXOafcJ_CMU,23026
+sdg_hub/core/blocks/evaluation/evaluate_relevancy_block.py,sha256=ieQRwl4bx5EQ3m7Wa2P3pHLUPQY7HuwNWjHUCo98u6g,22832
+sdg_hub/core/blocks/evaluation/verify_question_block.py,sha256=fSNbW1KpdfVE0fQsm4Y8QfVk6A3J5H3C0dtGn49t8tM,22853
+sdg_hub/core/blocks/filtering/__init__.py,sha256=isxSVSvDqkMjG8dQSl3Q2M4g5c1t9fTjBSA21icf-yA,275
+sdg_hub/core/blocks/filtering/column_value_filter.py,sha256=H8Gif0q9Wc_d1TnVow8Zpsg7blJOFGN1EZmV6OPpkcg,5971
+sdg_hub/core/blocks/llm/__init__.py,sha256=N6-Prgd4X85oWbMQzhYMrq7OX-NTJm57cghowK-val0,844
+sdg_hub/core/blocks/llm/client_manager.py,sha256=vaoPoTITJ9IlooeVRfu6M4WBc08mp4aJZ5tvnl2fMv8,12309
+sdg_hub/core/blocks/llm/config.py,sha256=TmbfqxPHH3mShTK2EuCX2AGKtDvl0aSvihsaqgzABtM,11266
+sdg_hub/core/blocks/llm/error_handler.py,sha256=7T-019ZFB9qgZoX1ybIiXyaLjPzrF96qcKmUu6vmO6g,12178
+sdg_hub/core/blocks/llm/llm_chat_block.py,sha256=3o2oV_ecWsEHFp5FWPIpBT-yJ1imJmeZy2b9GZL-T54,20121
+sdg_hub/core/blocks/llm/llm_chat_with_parsing_retry_block.py,sha256=mMmifTC-sRUhdxuLRRtAMhQC7r7NOyTAfBx-xTzLzTc,19669
+sdg_hub/core/blocks/llm/prompt_builder_block.py,sha256=fkJd718X1oYlMY1cjo_8WCO16Gl8Tm0bUPWR78E_uws,13935
+sdg_hub/core/blocks/llm/text_parser_block.py,sha256=vQgUaeYJI9HuxDPRjII-NIOsR01JA-sBBGl05623L8I,14391
+sdg_hub/core/blocks/transform/__init__.py,sha256=Y_3izPCtgnMbFK-gBMeLHZspSrNLgbGheAJXU57XfFw,746
+sdg_hub/core/blocks/transform/duplicate_columns.py,sha256=SaP7rIF4ZFEFFa50aU2xGNIuddXaEZrKxdWfHjzFpVI,2833
+sdg_hub/core/blocks/transform/index_based_mapper.py,sha256=mGup5agvDf9kAFSvXE5X6Puo6CQc9UOdFdbhdFWJjwk,8225
+sdg_hub/core/blocks/transform/melt_columns.py,sha256=vaYa5Taq6GhNZYWFL4uPK3-SfN2BsKEm-wvjd2EYYoI,4382
+sdg_hub/core/blocks/transform/rename_columns.py,sha256=qeB5L2utqDQnutUetH1VKZSqDiJSH_yUp5EFCV-XCVI,1998
+sdg_hub/core/blocks/transform/text_concat.py,sha256=_-B__Hob1WwgwkILPIZvTnsDzuwtoX1hKviyzHlnnes,3149
+sdg_hub/core/blocks/transform/uniform_col_val_setter.py,sha256=XnjiT29z3PzIPy8M-mmE2w-Miab6Ed5ahy32SaxTCTE,3263
+sdg_hub/core/flow/__init__.py,sha256=N2NZGngvd7qpT5FI_knKukUFM0IkD9K5jdTi-gDeUI4,475
+sdg_hub/core/flow/base.py,sha256=Jm90xQ1ns0ArEiqkceSME6phzBtkw6nthjSJNTU3IkQ,45530
+sdg_hub/core/flow/checkpointer.py,sha256=stm5ZtjjEiLk9ZkAAnoQQn5Y8Yl_d7qCsQLZTrCXR48,11867
+sdg_hub/core/flow/metadata.py,sha256=h9jpvAzWsF5n4ztZMzwa9ZNgnzKTHmFWdn7YbyJLHCw,12977
+sdg_hub/core/flow/migration.py,sha256=6and-RBqV0t2gRipr1GiOOVnyBJdtyyjw1kO08Z--d4,7558
+sdg_hub/core/flow/registry.py,sha256=DzCqEEgwhvwnCBAGLogoMVdwXh4pCHrxOWqoxam7O8I,12162
+sdg_hub/core/flow/validation.py,sha256=pUJvgaUjLpKNwvW6djcqVOF-HShOjegEmGOnUnoX4BA,9722
+sdg_hub/core/utils/__init__.py,sha256=C2FzLn3dHprwGJDEgI4fyFS3aoCJR-9PhHsunxropJ8,351
+sdg_hub/core/utils/datautils.py,sha256=QnzMl7nOp0crNJEWgAqurOuuAyz0SnvAjLiKzvG0uds,1933
+sdg_hub/core/utils/error_handling.py,sha256=yku8cGj_nKCyXDsnb-mHCpgukkkAMucJ4iAUrIzqysc,5510
+sdg_hub/core/utils/flow_id_words.yaml,sha256=5QHpQdP7zwahRuooyAlJIwBY7WcDR7vtbJXxVJqujbg,2317
+sdg_hub/core/utils/flow_identifier.py,sha256=aAHfK_G9AwEtMglLRMdMpi_AI1dciub5UqBGm4yb2HE,2841
+sdg_hub/core/utils/logger_config.py,sha256=MPYdpyNXh_pxFUOAvSCHa98LGjxjaLXoUoqWekqTG4s,422
+sdg_hub/core/utils/path_resolution.py,sha256=yWof4kGNpQ5dKcrVHg0h9KfOKLZ6ROjdfsLAZsQT5rM,2000
+sdg_hub/core/utils/yaml_utils.py,sha256=tShCd-FFkp0xlKnLe7dXsMOR4AvT9d2qRUmu4ZnPSEY,1458
+sdg_hub/flows/qa_generation/document_grounded_qa/multi_summary_qa/instructlab/README.md,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sdg_hub/flows/qa_generation/document_grounded_qa/multi_summary_qa/instructlab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sdg_hub/flows/qa_generation/document_grounded_qa/multi_summary_qa/instructlab/atomic_facts.yaml,sha256=xgUNY793y4lcpdtuWm5Ah1CmbU2gvvPQCpZMMa6kPXU,2447
+sdg_hub/flows/qa_generation/document_grounded_qa/multi_summary_qa/instructlab/detailed_summary.yaml,sha256=_vF-AzjC8d6wqAle5pkQ103EW-BbAhNA0qllk3ojUZc,353
+sdg_hub/flows/qa_generation/document_grounded_qa/multi_summary_qa/instructlab/evaluate_faithfulness.yaml,sha256=GiIipXrjm7btghvpgFUoTZYAJRyu7yE-WEi5yDLxjY4,3032
+sdg_hub/flows/qa_generation/document_grounded_qa/multi_summary_qa/instructlab/evaluate_question.yaml,sha256=zwzklXup6khRkR88avgrJTcjaMcV1wnbeYaML5oPuNs,1767
+sdg_hub/flows/qa_generation/document_grounded_qa/multi_summary_qa/instructlab/evaluate_relevancy.yaml,sha256=cA8igo7jMrRXaWW6k0of6KOp7YnxLtPj0fP4DbrmZNQ,3647
+sdg_hub/flows/qa_generation/document_grounded_qa/multi_summary_qa/instructlab/extractive_summary.yaml,sha256=fcMV7LaCFZo4D29nwhGJXqFFuZMYVLo9XYjv8zcU6zs,364
+sdg_hub/flows/qa_generation/document_grounded_qa/multi_summary_qa/instructlab/flow.yaml,sha256=Rrl9eve9QsGLojAkflgKTHyUgUawKfvhEVAnAxBLZJ8,6307
+sdg_hub/flows/qa_generation/document_grounded_qa/multi_summary_qa/instructlab/generate_questions_responses.yaml,sha256=yX8aLY8dJSDML9ZJhnj9RzPbN8tH2xfcM4Gc6xZuwqQ,2596
+sdg_hub-0.2.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sdg_hub-0.2.1.dist-info/METADATA,sha256=0Si2PZotpwtUI2Pg2cc3uSZIJtS12jF4VInJSTyBngA,8606
+sdg_hub-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sdg_hub-0.2.1.dist-info/top_level.txt,sha256=TqI7d-HE1n6zkXFkU0nF3A1Ct0P0pBaqI675uFokhx4,8
+sdg_hub-0.2.1.dist-info/RECORD,,

sdg_hub/blocks/__init__.py

@@ -1,42 +0,0 @@
-"""Block implementations for SDG Hub.
-
-This package provides various block implementations for data generation, processing, and transformation.
-"""
-
-# Local
-from .block import Block
-from .llmblock import LLMBlock, ConditionalLLMBlock
-from .openaichatblock import (
-    OpenAIChatBlock,
-    OpenAIAsyncChatBlock
-)
-from .utilblocks import (
-    SamplePopulatorBlock,
-    SelectorBlock,
-    CombineColumnsBlock,
-    FlattenColumnsBlock,
-    DuplicateColumns,
-    RenameColumns,
-    SetToMajorityValue,
-    FilterByValueBlock,
-    IterBlock,
-)
-from ..registry import BlockRegistry
-
-__all__ = [
-    "Block",
-    "FilterByValueBlock",
-    "IterBlock",
-    "LLMBlock",
-    "ConditionalLLMBlock",
-    "SamplePopulatorBlock",
-    "SelectorBlock",
-    "CombineColumnsBlock",
-    "FlattenColumnsBlock",
-    "DuplicateColumns",
-    "RenameColumns",
-    "SetToMajorityValue",
-    "BlockRegistry",
-    "OpenAIChatBlock",
-    "OpenAIAsyncChatBlock"
-]

sdg_hub/blocks/block.py

@@ -1,96 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""Base block implementation for the SDG Hub system.
-
-This module provides the abstract base class for all blocks in the system,
-including functionality for template validation and configuration management.
-"""
-
-# Standard
-from abc import ABC
-from collections import ChainMap
-from typing import Any, Dict, Optional
-
-# Third Party
-from jinja2 import Template, UndefinedError
-import yaml
-
-# Local
-from ..registry import BlockRegistry
-from ..logger_config import setup_logger
-
-logger = setup_logger(__name__)
-
-
-@BlockRegistry.register("Block")
-class Block(ABC):
-    """Base abstract class for all blocks in the system.
-
-    This class provides common functionality for block validation and configuration loading.
-    All specific block implementations should inherit from this class.
-    """
-    
-    def __init__(self, block_name: str) -> None:
-        self.block_name = block_name
-
-    @staticmethod
-    def _validate(prompt_template: Template, input_dict: Dict[str, Any]) -> bool:
-        """Validate the input data for this block.
-
-        This method validates whether all required variables in the Jinja template are provided in the input_dict.
-
-        Parameters
-        ----------
-        prompt_template : Template
-            The Jinja2 template object.
-        input_dict : Dict[str, Any]
-            A dictionary of input values to check against the template.
-
-        Returns
-        -------
-        bool
-            True if the input data is valid (i.e., no missing variables), False otherwise.
-        """
-
-        class Default(dict):
-            def __missing__(self, key: str) -> None:
-                raise KeyError(key)
-
-        try:
-            # Try rendering the template with the input_dict
-            prompt_template.render(ChainMap(input_dict, Default()))
-            return True
-        except UndefinedError as e:
-            logger.error(f"Missing key: {e}")
-            return False
-
-    def _load_config(self, config_path: str) -> Optional[Dict[str, Any]]:
-        """Load the configuration file for this block.
-
-        Parameters
-        ----------
-        config_path : str
-            The path to the configuration file.
-
-        Returns
-        -------
-        Optional[Dict[str, Any]]
-            The loaded configuration. Returns None if file cannot be read or parsed.
-
-        Raises
-        ------
-        FileNotFoundError
-            If the configuration file does not exist.
-        """
-        try:
-            with open(config_path, "r", encoding="utf-8") as config_file:
-                try:
-                    return yaml.safe_load(config_file)
-                except yaml.YAMLError as e:
-                    logger.error(f"Error parsing YAML from {config_path}: {e}")
-                    return None
-        except FileNotFoundError:
-            logger.error(f"Configuration file not found: {config_path}")
-            raise
-        except Exception as e:
-            logger.error(f"Unexpected error reading config file {config_path}: {e}")
-            return None

sdg_hub/blocks/llmblock.py

@@ -1,375 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""LLM-based blocks for text generation and processing.
-
-This module provides blocks for interacting with language models.
-"""
-
-# Standard
-from typing import Any, Dict, List, Optional, Union
-import json
-import re
-
-# Third Party
-from datasets import Dataset
-from jinja2 import Template
-import openai
-
-# Local
-from .block import Block
-from ..logger_config import setup_logger
-from ..registry import BlockRegistry, PromptRegistry
-
-logger = setup_logger(__name__)
-
-
-def server_supports_batched(client: openai.OpenAI, model_id: str) -> bool:
-    """Check if the server supports batched inputs.
-
-    This function checks if the server supports batched inputs by making a test call to the server.
-
-    Parameters
-    ----------
-    client : openai.OpenAI
-        The client to use to make the test call.
-    model_id : str
-        The model ID to use for the test call.
-    """
-    supported = getattr(client, "server_supports_batched", None)
-    if supported is not None:
-        return supported
-    try:
-        # Make a test call to the server to determine whether it supports
-        # multiple input prompts per request and also the n parameter
-        response = client.completions.create(
-            model=model_id, prompt=["test1", "test2"], max_tokens=1, n=3
-        )
-        # Number outputs should be 2 * 3 = 6
-        supported = len(response.choices) == 6
-    except openai.InternalServerError:
-        supported = False
-    client.server_supports_batched = supported
-    logger.info(f"LLM server supports batched inputs: {client.server_supports_batched}")
-    return supported
-
-
-@BlockRegistry.register("LLMBlock")
-class LLMBlock(Block):
-    """Block for generating text using language models.
-
-    This block handles text generation, prompt formatting, and output parsing
-    for language model interactions.
-
-    Parameters
-    ----------
-    block_name : str
-        Name of the block.
-    config_path : str
-        Path to the configuration file.
-    client : openai.OpenAI
-        OpenAI client instance.
-    output_cols : List[str]
-        List of output column names.
-    parser_kwargs : Dict[str, Any], optional
-        Keyword arguments for the parser, by default {}.
-    model_prompt : str, optional
-        Template string for model prompt, by default "{prompt}".
-    model_id : Optional[str], optional
-        Model ID to use, by default None.
-    **batch_kwargs : Dict[str, Any]
-        Additional keyword arguments for batch processing.
-    """
-
-    # pylint: disable=too-many-instance-attributes
-    def __init__(
-        self,
-        block_name: str,
-        config_path: str,
-        client: openai.OpenAI,
-        output_cols: List[str],
-        parser_kwargs: Dict[str, Any] = {},
-        model_prompt: str = "{prompt}",
-        model_id: Optional[str] = None,
-        **batch_kwargs: Dict[str, Any],
-    ) -> None:
-        super().__init__(block_name)
-        self.block_config = self._load_config(config_path)
-        self.prompt_struct = (
-            """{system}\n{introduction}\n{principles}\n{examples}\n{generation}"""
-        )
-        filtered_config = {
-            k: (v if v is not None else "") for k, v in self.block_config.items()
-        }
-        self.prompt_template = Template(self.prompt_struct.format(**filtered_config))
-        self.client = client
-        if model_id:
-            self.model = model_id
-        else:
-            # get the default model id from client
-            self.model = self.client.models.list().data[0].id
-
-        self.model_prompt = model_prompt
-        self.output_cols = output_cols
-        self.batch_params = batch_kwargs.get("batch_kwargs", {})
-        self.parser_name = parser_kwargs.get("parser_name", None)
-        self.parsing_pattern = parser_kwargs.get("parsing_pattern", None)
-        self.parser_cleanup_tags = parser_kwargs.get("parser_cleanup_tags", None)
-        self.defaults = {
-            "model": self.model,
-            "temperature": 0,
-            "max_tokens": 4096,
-        }
-
-        # Whether the LLM server supports a list of input prompts
-        # and supports the n parameter to generate n outputs per input
-        self.server_supports_batched = server_supports_batched(client, self.model)
-
-    def _extract_matches(
-        self, text: str, start_tag: Optional[str], end_tag: Optional[str]
-    ) -> List[str]:
-        if not text:
-            return []
-        if not start_tag and not end_tag:
-            return [text.strip()]
-
-        pattern = ""
-        if start_tag:
-            pattern += re.escape(start_tag)
-        pattern += r"(.*?)"
-        if end_tag:
-            pattern += re.escape(end_tag)
-        elif start_tag:
-            # Enforce matching till end of string when only start_tag is provided.
-            pattern += "$"
-
-        return [match.strip() for match in re.findall(pattern, text, re.DOTALL)]
-
-    def _parse(self, generated_string: str) -> dict:
-        matches = {}
-
-        if self.parser_name is not None and self.parser_name == "custom":
-            pattern = re.compile(self.parsing_pattern, re.DOTALL)
-            all_matches = pattern.findall(generated_string)
-            matches = {column_name: [] for column_name in self.output_cols}
-            if all_matches and isinstance(all_matches[0], tuple):
-                for match in all_matches:
-                    for column_name, value in zip(self.output_cols, match):
-                        value = value.strip()
-                        for clean_tag in self.parser_cleanup_tags:
-                            value = value.replace(clean_tag, "")
-                        matches[column_name].append(value)
-            else:
-                matches[self.output_cols[0]] = (
-                    [match.strip() for match in all_matches] if all_matches else []
-                )
-        else:
-            for start_tag, end_tag, output_col in zip(
-                self.block_config.get("start_tags", []),
-                self.block_config.get("end_tags", []),
-                self.output_cols,
-            ):
-                matches[output_col] = self._extract_matches(
-                    generated_string, start_tag, end_tag
-                )
-
-        return matches
-
-    def _format_prompt(self, sample: Dict) -> str:
-        prompt_templated_str = self.prompt_template.render(sample).strip()
-        return PromptRegistry.render_template(
-            self.model_prompt, prompt_templated_str, add_generation_prompt=True
-        ).strip()
-
-    def _generate(self, samples: Dataset, **gen_kwargs: Dict[str, Any]) -> list:
-        prompts = [self._format_prompt(sample) for sample in samples]
-        logger.debug("Prompt: %s", prompts[0])
-        generate_args = {**self.defaults, **gen_kwargs}
-
-        if self.server_supports_batched:
-            response = self.client.completions.create(prompt=prompts, **generate_args)
-            # if stop is provided, then we need to add the stop token to the generated text,
-            # this is because the stop token is not included in the generated text - this is a limitation of the openai api
-            # we need to add the stop token to the generated text to make it consistent for the parser
-            if "stop" in generate_args:
-                return [
-                    choice.text.strip() + "".join(generate_args["stop"])
-                    for choice in response.choices
-                ]
-            return [choice.text.strip() for choice in response.choices]
-
-        n = gen_kwargs.get("n", 1)
-        results = []
-        for prompt in prompts:
-            for _ in range(n):
-                response = self.client.completions.create(
-                    prompt=prompt, **generate_args
-                )
-                if "stop" in generate_args:
-                    results.append(
-                        response.choices[0].text.strip()
-                        + "".join(generate_args["stop"])
-                    )
-                results.append(response.choices[0].text.strip())
-        return results
-
-    def generate(self, samples: Dataset, **gen_kwargs: Dict[str, Any]) -> Dataset:
-        """Generate the output from the block.
-
-        This method should first validate the input data,
-        then generate the output, and finally parse the generated output before returning it.
-
-        Returns
-        -------
-        Dataset
-            The parsed output after generation.
-        """
-        num_samples = self.block_config.get("num_samples", None)
-        logger.debug("Generating outputs for {} samples".format(len(samples)))
-
-        if (num_samples is not None) and ("num_samples" not in samples.column_names):
-            samples = samples.add_column("num_samples", [num_samples] * len(samples))
-
-        # validate each sample
-        # Log errors and remove invalid samples
-        valid_samples = []
-
-        for sample in samples:
-            if self._validate(self.prompt_template, sample):
-                valid_samples.append(sample)
-            else:
-                logger.warning(
-                    f"Sample failed validation: {sample}"
-                )  # Log details of the failed sample
-
-        samples = valid_samples
-
-        if len(samples) == 0:
-            logger.warning(
-                "No valid samples to generate outputs for, returning empty dataset"
-            )
-            return Dataset.from_list([])
-
-        # generate the output
-
-        outputs = self._generate(samples, **gen_kwargs)
-
-        logger.debug("Generated outputs: %s", outputs)
-
-        num_parallel_samples = gen_kwargs.get("n", 1)
-        extended_samples = []
-
-        # Duplicate each input sample n times, where n is the number
-        # of output sequences generated per input, so that we can
-        # pair up the inputs and outputs.
-        for item in samples:
-            extended_samples.extend([item] * num_parallel_samples)
-
-        new_data = []
-        for sample, output in zip(extended_samples, outputs):
-            parsed_outputs = self._parse(output)
-            max_length = max(len(value) for value in parsed_outputs.values())
-            for values in zip(*(lst[:max_length] for lst in parsed_outputs.values())):
-                new_data.append({**sample, **dict(zip(parsed_outputs.keys(), values))})
-
-        return Dataset.from_list(new_data)
-
-
-@BlockRegistry.register("ConditionalLLMBlock")
-class ConditionalLLMBlock(LLMBlock):
-    """Block for conditional text generation using language models.
-
-    This block selects different prompt templates based on a selector column value.
-
-    Parameters
-    ----------
-    block_name : str
-        Name of the block.
-    config_paths : Dict[str, str]
-        Dictionary mapping selector values to their config file paths.
-    client : openai.OpenAI
-        OpenAI client instance.
-    model_id : str
-        Model ID to use.
-    output_cols : List[str]
-        List of output column names.
-    selector_column_name : str
-        Name of the column used to select the prompt template.
-    model_prompt : str, optional
-        Template string for model prompt, by default "{prompt}".
-    **batch_kwargs : Dict[str, Any]
-        Additional keyword arguments for batch processing.
-    """
-
-    def __init__(
-        self,
-        block_name: str,
-        config_paths: Dict[str, str],
-        client: openai.OpenAI,
-        model_id: str,
-        output_cols: List[str],
-        selector_column_name: str,
-        model_prompt: str = "{prompt}",
-        **batch_kwargs: Dict[str, Any],
-    ) -> None:
-        super().__init__(
-            block_name=block_name,
-            config_path=list(config_paths.values())[0],
-            client=client,
-            model_id=model_id,
-            output_cols=output_cols,
-            model_prompt=model_prompt,
-            **batch_kwargs,
-        )
-        self.selector_column_name = selector_column_name
-        self.prompt_template = {}
-        if "All" in config_paths:
-            self.prompt_template = self.prompt_struct.format(**self.block_config)
-        else:
-            for config_key, config in config_paths.items():
-                filtered_config = {
-                    k: (v if v is not None else "")
-                    for k, v in self.block_config.items()
-                }
-                self.prompt_template[config_key] = Template(
-                    self.prompt_struct.format(**self._load_config(config))
-                )
-
-    def _format_prompt(self, sample: Dict[str, Any]) -> str:
-        """Format the prompt based on the selector column value.
-
-        Parameters
-        ----------
-        sample : Dict[str, Any]
-            Input sample containing the selector column.
-
-        Returns
-        -------
-        str
-            Formatted prompt string.
-        """
-        if isinstance(self.prompt_template, dict):
-            return (
-                self.prompt_template[sample[self.selector_column_name]]
-                .render(**sample)
-                .strip()
-            )
-
-        return self.prompt_template.render(**sample).strip()
-
-    def _validate(self, prompt_template: Union[str, Template], input_dict: Dict[str, Any]) -> bool:
-        """Validate the input data for this block.
-
-        Parameters
-        ----------
-        prompt_template : Union[str, Template]
-            The template to validate against.
-        input_dict : Dict[str, Any]
-            Input data to validate.
-
-        Returns
-        -------
-        bool
-            True if the input data is valid, False otherwise.
-        """
-        if isinstance(prompt_template, dict):
-            prompt_template = prompt_template[input_dict[self.selector_column_name]]
-        return super()._validate(prompt_template, input_dict)