sdg-hub 0.1.0__py3-none-any.whl

sdg_hub/registry.py

@@ -0,0 +1,122 @@
+# Standard
+from typing import Union, List, Dict
+
+# Third Party
+from jinja2 import Template
+
+# Local
+from .logger_config import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class BlockRegistry:
+    """Registry for block classes to avoid manual additions to block type map."""
+
+    _registry: Dict[str, type] = {}
+
+    @classmethod
+    def register(cls, block_name: str):
+        """
+        Decorator to register a block class under a specified name.
+
+        :param block_name: Name under which to register the block.
+        """
+
+        def decorator(block_class):
+            cls._registry[block_name] = block_class
+            logger.debug(
+                f"Registered block '{block_name}' with class '{block_class.__name__}'"
+            )
+            return block_class
+
+        return decorator
+
+    @classmethod
+    def get_registry(cls):
+        """
+        Retrieve the current registry map of block types.
+
+        :return: Dictionary of registered block names and classes.
+        """
+        logger.debug("Fetching the block registry map.")
+        return cls._registry
+
+
+class PromptRegistry:
+    """Registry for managing Jinja2 prompt templates."""
+
+    _registry: Dict[str, Template] = {}
+
+    @classmethod
+    def register(cls, name: str):
+        """Decorator to register a Jinja2 template function by name.
+
+        :param name: Name of the template to register.
+        :return: A decorator that registers the Jinja2 template function.
+        """
+
+        def decorator(func):
+            template_str = func()
+            cls._registry[name] = Template(template_str)
+            logger.debug(f"Registered prompt template '{name}'")
+            return func
+
+        return decorator
+
+    @classmethod
+    def get_template(cls, name: str) -> Template:
+        """Retrieve a Jinja2 template by name.
+
+        :param name: Name of the template to retrieve.
+        :return: The Jinja2 template instance.
+        """
+        if name not in cls._registry:
+            raise KeyError(f"Template '{name}' not found.")
+        logger.debug(f"Retrieving prompt template '{name}'")
+        return cls._registry[name]
+
+    @classmethod
+    def get_registry(cls):
+        """
+        Retrieve the current registry map of block types.
+
+        :return: Dictionary of registered block names and classes.
+        """
+        logger.debug("Fetching the block registry map.")
+        return cls._registry
+
+    @classmethod
+    def render_template(
+        cls,
+        name: str,
+        messages: Union[str, List[Dict[str, str]]],
+        add_generation_prompt: bool = True,
+    ) -> str:
+        """Render the template with the provided messages or query.
+
+        :param name: Name of the template to render.
+        :param messages: Either a single query string or a list of messages (each as a dict with 'role' and 'content').
+        :param add_generation_prompt: Whether to add a generation prompt at the end.
+        :return: The rendered prompt as a string.
+        """
+
+        # Special handling for "blank" template
+        if name == "blank":
+            if not isinstance(messages, str):
+                raise ValueError(
+                    "The 'blank' template can only be used with a single query string, not a list of messages."
+                )
+            return messages  # Return the query as-is without templating
+
+        # Get the template
+        template = cls.get_template(name)
+
+        # If `messages` is a string, wrap it in a list with a default user role
+        if isinstance(messages, str):
+            messages = [{"role": "user", "content": messages}]
+
+        # Render the template with the `messages` list
+        return template.render(
+            messages=messages, add_generation_prompt=add_generation_prompt
+        )

sdg_hub/sdg.py

@@ -0,0 +1,206 @@
+# SPDX-License-Identifier: Apache-2.0
+
+"""Synthetic Data Generator (SDG) module for managing data generation flows."""
+
+# Standard
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import List, Optional, Tuple
+import traceback
+
+# Third Party
+from datasets import Dataset
+from tqdm import tqdm
+
+# Local
+from .checkpointer import Checkpointer
+from .flow import Flow
+from .logger_config import setup_logger
+from .utils.datautils import safe_concatenate_datasets
+
+logger = setup_logger(__name__)
+
+
+class SDG:
+    """Synthetic Data Generator class.
+
+    This class manages the generation of synthetic data using one or more
+    data generation flows.
+
+    Parameters
+    ----------
+    flows : List[Flow]
+        List of flows to execute.
+    num_workers : int, optional
+        Number of worker threads to use, by default 1
+    batch_size : Optional[int], optional
+        Size of batches to process, by default None
+    save_freq : Optional[int], optional
+        Frequency of checkpoint saves, by default None
+
+    Attributes
+    ----------
+    flows : List[Flow]
+        List of flows to execute.
+    num_workers : int
+        Number of worker threads to use.
+    batch_size : Optional[int]
+        Size of batches to process.
+    save_freq : Optional[int]
+        Frequency of checkpoint saves.
+    """
+
+    def __init__(
+        self,
+        flows: List[Flow],
+        num_workers: int = 1,
+        batch_size: Optional[int] = None,
+        save_freq: Optional[int] = None,
+    ) -> None:
+        self.flows = flows
+        self.num_workers = num_workers
+        self.batch_size = batch_size
+        self.save_freq = save_freq
+
+    def _split_dataset(
+        self, dataset: Dataset, batch_size: int
+    ) -> List[Tuple[int, int]]:
+        """Split the dataset into smaller batches.
+
+        Parameters
+        ----------
+        dataset : Dataset
+            The dataset to split.
+        batch_size : int
+            Size of each batch.
+
+        Returns
+        -------
+        List[Tuple[int, int]]
+            List of (start, end) indices for each batch.
+        """
+        total_size = len(dataset)
+        num_batches = (total_size + batch_size - 1) // batch_size
+
+        batches = [
+            (i * batch_size, min((i + 1) * batch_size, total_size))
+            for i in tqdm(range(num_batches))
+        ]
+
+        return batches
+
+    @staticmethod
+    def _generate_data(
+        flows: List[Flow],
+        input_split: Tuple[int, int],
+        ds: Dataset,
+        i: Optional[int] = None,
+    ) -> Optional[Dataset]:
+        """Generate data for a single split using the provided flows.
+
+        Parameters
+        ----------
+        flows : List[Flow]
+            List of flows to execute.
+        input_split : Tuple[int, int]
+            (start, end) indices for the current split.
+        ds : Dataset
+            The full input dataset.
+        i : Optional[int], optional
+            Split index for logging, by default None
+
+        Returns
+        -------
+        Optional[Dataset]
+            Generated dataset for the split, or None if generation failed.
+        """
+        logger.info(f"Processing split {i}")
+        input_split = ds.select(range(input_split[0], input_split[1]))
+        try:
+            for flow in flows:
+                input_split = flow.generate(input_split)
+            return input_split
+        except Exception as e:
+            logger.error(f"Error processing split {i}: {e}")
+            traceback.print_exc()
+            return None
+
+    def generate(
+        self, dataset: Dataset, checkpoint_dir: Optional[str] = None
+    ) -> Dataset:
+        """Generate synthetic data using the configured flows.
+
+        Parameters
+        ----------
+        dataset : Dataset
+            The input dataset to process.
+        checkpoint_dir : Optional[str], optional
+            Directory to save checkpoints, by default None
+
+        Returns
+        -------
+        Dataset
+            The generated dataset.
+
+        Notes
+        -----
+        If checkpoint_dir is provided, the generation process can be resumed
+        from the last checkpoint in case of interruption.
+        """
+        # Initialize checkpointer
+        checkpointer = Checkpointer(checkpoint_dir, self.save_freq)
+
+        # Load existing checkpoints and determine missing data
+        seed_data, pre_generated_data = checkpointer.load_existing_data(dataset)
+
+        # If all data has been generated, return the pre-generated data
+        if seed_data.num_rows == 0 and pre_generated_data is not None:
+            return pre_generated_data
+
+        if not self.batch_size:
+            # If batch size is not provided, generate the dataset in a single pass
+            generated_dataset = seed_data
+            # generated_data is initialized with seed_data, and it gets updated with each flow
+            for flow in self.flows:
+                generated_dataset = flow.generate(generated_dataset)
+            return generated_dataset
+
+        logger.info("Splitting the dataset into smaller batches")
+        input_splits = self._split_dataset(seed_data, self.batch_size)
+        logger.info(
+            f"Generating dataset with {len(input_splits)} splits, "
+            f"batch size {self.batch_size}, and {self.num_workers} workers"
+        )
+
+        generated_data = [pre_generated_data] if pre_generated_data else []
+        last_saved_split_index = 0  # To track the last saved split
+
+        with ThreadPoolExecutor(max_workers=self.num_workers) as executor:
+            futures = [
+                executor.submit(
+                    self._generate_data, self.flows, input_split, seed_data, i
+                )
+                for i, input_split in enumerate(input_splits)
+            ]
+
+            for i, future in enumerate(tqdm(as_completed(futures), total=len(futures))):
+                generated_data_split = future.result()  # Ensure each future completes
+
+                if generated_data_split:
+                    generated_data.append(generated_data_split)
+                    logger.info(f"Finished future processing split {i} \n\n")
+
+                    # Use checkpointer to handle intermediate saves
+                    if checkpointer.should_save_checkpoint(i):
+                        # Save only the new splits since the last checkpoint
+                        new_splits = generated_data[last_saved_split_index : i + 1]
+                        checkpoint_dataset = safe_concatenate_datasets(new_splits)
+                        # check if checkpoint_dataset is not None
+                        if checkpoint_dataset:
+                            checkpointer.save_intermediate_checkpoint(
+                                checkpoint_dataset
+                            )
+                            last_saved_split_index = i + 1
+
+        generated_dataset = safe_concatenate_datasets(generated_data)
+
+        return generated_dataset

sdg_hub/utils/__init__.py

@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: Apache-2.0
+
+# This is part of the public API, and used by instructlab
+class GenerateException(Exception):
+    """An exception raised during generate step."""

sdg_hub/utils/datautils.py

@@ -0,0 +1,14 @@
+# Third Party
+from datasets import concatenate_datasets
+
+
+def safe_concatenate_datasets(datasets: list):
+    """
+    Concatenate datasets safely, ignoring any datasets that are None or empty.
+    """
+    filtered_datasets = [ds for ds in datasets if ds is not None and ds.num_rows > 0]
+
+    if not filtered_datasets:
+        return None
+
+    return concatenate_datasets(filtered_datasets)

sdg_hub-0.1.0.dist-info/METADATA

@@ -0,0 +1,190 @@
+Metadata-Version: 2.4
+Name: sdg_hub
+Version: 0.1.0
+Summary: Synthetic Data Generation
+Author-email: Red Hat AI Innovation <abhandwa@redhat.com>
+License: Apache-2.0
+Project-URL: homepage, https://ai-innovation.team/
+Project-URL: source, https://github.com/Red-Hat-AI-Innovation-Team/sdg_hub
+Project-URL: issues, https://github.com/Red-Hat-AI-Innovation-Team/sdg_hub/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click<9.0.0,>=8.1.7
+Requires-Dist: datasets<4.0.0,>=2.18.0
+Requires-Dist: httpx<1.0.0,>=0.25.0
+Requires-Dist: jinja2
+Requires-Dist: openai<2.0.0,>=1.13.3
+Requires-Dist: rich
+Requires-Dist: tenacity!=8.4.0,>=8.3.0
+Requires-Dist: tqdm<5.0.0,>=4.66.2
+Provides-Extra: web-interface
+Requires-Dist: flask>=3.0.2; extra == "web-interface"
+Requires-Dist: pyyaml>=6.0.1; extra == "web-interface"
+Requires-Dist: flask-wtf>=1.2.2; extra == "web-interface"
+Provides-Extra: vllm
+Requires-Dist: vllm<0.8.4,>=0.8.0; extra == "vllm"
+Requires-Dist: torch>=2.0.0; extra == "vllm"
+Requires-Dist: transformers>=4.37.0; extra == "vllm"
+Requires-Dist: accelerate>=0.21.0; extra == "vllm"
+Requires-Dist: xformers>=0.0.22.post7; extra == "vllm"
+Provides-Extra: examples
+Requires-Dist: tabulate>=0.9.0; extra == "examples"
+Requires-Dist: transformers>=4.37.0; extra == "examples"
+Requires-Dist: langchain-text-splitters; extra == "examples"
+Requires-Dist: docling>=2.3.0; extra == "examples"
+Provides-Extra: dev
+Requires-Dist: pre-commit<4.0,>=3.0.4; extra == "dev"
+Requires-Dist: pylint<4.0,>=2.16.2; extra == "dev"
+Requires-Dist: pylint-pydantic; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-html; extra == "dev"
+Requires-Dist: tox<5,>=4.4.2; extra == "dev"
+Dynamic: license-file
+
+# SDG Hub: Synthetic Data Generation Toolkit
+
+[![Build](https://github.com/Red-Hat-AI-Innovation-Team/sdg_hub/actions/workflows/pypi.yaml/badge.svg?branch=main)](https://github.com/Red-Hat-AI-Innovation-Team/sdg_hub/actions/workflows/pypi.yaml)
+[![Release](https://img.shields.io/github/v/release/Red-Hat-AI-Innovation-Team/sdg_hub)](https://github.com/Red-Hat-AI-Innovation-Team/sdg_hub/releases)
+[![License](https://img.shields.io/github/license/Red-Hat-AI-Innovation-Team/sdg_hub)](https://github.com/Red-Hat-AI-Innovation-Team/sdg_hub/blob/main/LICENSE)
+[![Tests](https://github.com/Red-Hat-AI-Innovation-Team/sdg_hub/actions/workflows/test.yml/badge.svg)](https://github.com/Red-Hat-AI-Innovation-Team/sdg_hub/actions/workflows/test.yml)
+[![codecov](https://codecov.io/gh/Red-Hat-AI-Innovation-Team/sdg_hub/graph/badge.svg?token=SP75BCXWO2)](https://codecov.io/gh/Red-Hat-AI-Innovation-Team/sdg_hub)
+
+<html>
+    <h3 align="center">
+      A modular, scalable, and efficient solution for creating synthetic data generation flows in a "low-code" manner.
+    </h3>
+    <h3 align="center">
+      <a href="http://ai-innovation.team/sdg_hub">Documentation</a> |
+      <a href="examples/">Examples</a> |
+      <a href="https://www.youtube.com/watch?v=aGKCViWjAmA">Video Tutorial</a>
+    </h3>
+</html>
+
+SDG Hub is designed to simplify data creation for LLMs, allowing users to chain computational units and build powerful flows for generating data and processing tasks. Define complex workflows using nothing but YAML configuration files.
+
+**📖 Full documentation available at: [https://ai-innovation.team/sdg_hub](https://ai-innovation.team/sdg_hub)**
+
+---
+
+## ✨ Key Features
+
+- **Low-Code Flow Creation**: Build sophisticated data generation pipelines using
+  simple YAML configuration files without writing any code.
+
+- **Modular Block System**: Compose workflows from reusable, self-contained
+  blocks that handle LLM calls, data transformations, and filtering.
+
+- **LLM-Agnostic**: Works with any language model through configurable
+  prompt templates and generation parameters.
+
+- **Prompt Engineering Friendly**: Tune LLM behavior by editing declarative YAML prompts.
+
+## 🚀 Installation
+
+### Stable Release (Recommended)
+
+```bash
+pip install sdg-hub
+```
+
+### Development Version
+
+```bash
+pip install git+https://github.com/Red-Hat-AI-Innovation-Team/sdg_hub.git
+```
+
+## 🏁 Quick Start
+
+### Prerequisites
+
+Before getting started, make sure you have:
+- Python 3.8 or higher
+- LLM Inference Endpoint exposed through OpenAI API
+
+### Simple Example
+
+Here's the simplest way to get started:
+
+```python
+from sdg_hub.flow_runner import run_flow
+
+# Run a basic knowledge generation flow
+run_flow(
+    ds_path="my_data.jsonl",
+    save_path="output.jsonl", 
+    endpoint="http://0.0.0.0:8000/v1",
+    flow_path="flows/generation/knowledge/synth_knowledge.yaml"
+)
+```
+
+### Advanced Configuration
+You can invoke any built-in flow using run_flow:
+```python
+from sdg_hub.flow_runner import run_flow
+
+run_flow(
+    ds_path="path/to/dataset.jsonl",
+    save_path="path/to/output.jsonl",
+    endpoint="http://0.0.0.0:8000/v1",
+    flow_path="path/to/flow.yaml",
+    checkpoint_dir="path/to/checkpoints",
+    batch_size=8,
+    num_workers=32,
+    save_freq=2,
+)
+```
+
+### 📂 Available Built-in Flows
+
+You can start with any of these YAML flows out of the box:
+
+#### 🔎 **Knowledge Flows**
+
+| Flow | Description |
+|------|-------------|
+| `synth_knowledge.yaml` | Produces document-grounded questions and answers for factual memorization |
+| `synth_knowledge1.5.yaml` | Improved version that builds intermediate representations for better recall |
+
+#### 🧠 **Skills Flows**
+
+| Flow | Description |
+|------|-------------|
+| `synth_skills.yaml` | Freeform skills QA generation (eg: "Create a new github issue to add type hints") |
+| `synth_grounded_skills.yaml` | Domain-specific skill generation (eg: "From the given conversation create a table for feature requests") |
+| `improve_responses.yaml` | Uses planning and critique-based refinement to improve generated answers |
+
+All these can be found here: [flows](src/sdg_hub/flows)
+
+## 📺 Video Tutorial
+
+For a comprehensive walkthrough of sdg_hub:
+
+[![SDG Hub Tutorial](https://img.youtube.com/vi/aGKCViWjAmA/0.jpg)](https://www.youtube.com/watch?v=aGKCViWjAmA)
+
+## 🤝 Contributing
+
+We welcome contributions from the community! Whether it's bug reports, feature requests, documentation improvements, or code contributions, please check out our [contribution guidelines](CONTRIBUTING.md).
+
+## 📄 License
+
+This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.
+
+---
+
+Built with ❤️ by the Red Hat AI Innovation Team

sdg_hub-0.1.0.dist-info/RECORD

@@ -0,0 +1,82 @@
+sdg_hub/__init__.py,sha256=5Wa6onDndPvG4iwnjq2jK747t3-7XKdQn2WfHfq1sFc,67
+sdg_hub/_version.py,sha256=-LyU5F1uZDjn6Q8_Z6-_FJt_8RE4Kq9zcKdg1abSSps,511
+sdg_hub/checkpointer.py,sha256=R0pNKL_q7-BerxmIarY0w1nFYaq7fGnoRRkCVL6Z-Gw,5053
+sdg_hub/flow.py,sha256=YQNtI7KIqdr4zymUIiTe2pJf7xNVoHNs123W_nRimDo,10914
+sdg_hub/flow_runner.py,sha256=V2VY_gbSWXTujywtFLWr_hKZspkD_41oV5CRzRhKbRo,4829
+sdg_hub/logger_config.py,sha256=7uHEJVRfym1c4n95DOKHelLXqAus8uHsZYmzLsEjqpo,422
+sdg_hub/pipeline.py,sha256=mahktfoCMVnuBnvLNjAVOAoFKNQo-wb0Dz1_xdYhKDM,3852
+sdg_hub/prompts.py,sha256=rtiUS2IuaMAQVAy8aAwGxmk23sKC2Qqro7edymbENrk,8165
+sdg_hub/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sdg_hub/registry.py,sha256=Sc_HNxo4n0pgWMiEDd_sLjxaSXAMZFiHJIhQKqjywwk,3772
+sdg_hub/sdg.py,sha256=8SKrSnqyvJAwE2Muf9lXw9ONRcDzqmCtaEzFHCYW4CY,6914
+sdg_hub/blocks/__init__.py,sha256=pmxlv29ohPRdIVE9ojnBs3I58UwNMU0uTtGozOZuZzc,807
+sdg_hub/blocks/block.py,sha256=zdeyDyYiY0EdD3xS7kZR2hRZCRkbygQ4WONp_zv3X7w,3051
+sdg_hub/blocks/llmblock.py,sha256=nWslPFZSCiyL7MXQurOk6Jx29UOsgnVDMI3PTwje7kg,13678
+sdg_hub/blocks/utilblocks.py,sha256=U2PQk26cwHOgofk5IenHjrao08gbqPFOBNRy5QJ-EEY,18290
+sdg_hub/configs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sdg_hub/configs/annotations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sdg_hub/configs/annotations/cot_reflection.yaml,sha256=60EdsTe1y7GoUIAWYSGfMa3EKI3oLZKCvDuKU7wHgQU,1737
+sdg_hub/configs/annotations/detailed_annotations.yaml,sha256=in21xmlhxDJGEaWh1IgINh33tEyW9AuyG3k4pWBuKSM,1520
+sdg_hub/configs/annotations/detailed_description.yaml,sha256=FsGbQMBxf1MAOi0nhrQ4icxcwYMlRura_ji9Pmeh1AA,192
+sdg_hub/configs/annotations/detailed_description_icl.yaml,sha256=NDdwo5EShnYZjm1Fn80sZTAwfnwpPigixP2hvJ8--cU,679
+sdg_hub/configs/annotations/simple_annotations.yaml,sha256=e2F_Ow8EG_me4XJ2cnBTlKb9y1FmdX0DHKkiMqiwdUQ,188
+sdg_hub/configs/knowledge/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sdg_hub/configs/knowledge/atomic_facts.yaml,sha256=9icyigsMooyBR_nEwWgj9eBAnuc3kMZMNnEy6AxFSKU,2430
+sdg_hub/configs/knowledge/auxilary_instructions.yaml,sha256=aCgIjvNacdC2ZHThEvhZKvwORK6KqErVvVYQYQrIDLE,2034
+sdg_hub/configs/knowledge/detailed_summary.yaml,sha256=PBymlZljkzN8kbo5DgmNsSM_Xb76SZifuS5Yl-x4Uy4,365
+sdg_hub/configs/knowledge/evaluate_faithfulness.yaml,sha256=iuvx5vNNm_jzHlmcKF83StaDYezRz2vQn3JUHM-TMdQ,3054
+sdg_hub/configs/knowledge/evaluate_question.yaml,sha256=02mikEAJCUEkREBo7KxPY9H6iTUHQN-4cRkn2XMlVQ8,1915
+sdg_hub/configs/knowledge/evaluate_relevancy.yaml,sha256=ASh8A1HAYO1h1tQRrwGnkUmK1n-WDKLdfW_LbSW1ipQ,3690
+sdg_hub/configs/knowledge/extractive_summary.yaml,sha256=06Z9lDiZUsQEURhpwWUVXA3wYO3bRaC0aNoGCpo3-44,376
+sdg_hub/configs/knowledge/generate_code_questions_responses.yaml,sha256=cIus2JYMYDvxHFVSU9QVa-1IK5KoChb3rCU2b4b9UmI,908
+sdg_hub/configs/knowledge/generate_questions_responses.yaml,sha256=H9nb_5xGP7k6HtC3VboXqpiI5kQ9Xp3vjhXH3YIFesk,2525
+sdg_hub/configs/knowledge/mcq_generation.yaml,sha256=d4VKegnVIexwCn0e2AJs-0DC6XdLyUBGaCsQVwzICUE,3152
+sdg_hub/configs/knowledge/router.yaml,sha256=9m_cX3xl808Vwrcq2PACyX45QFPkrV2nVYIY8x10JBU,119
+sdg_hub/configs/knowledge/simple_generate_qa.yaml,sha256=OsuZP9SxQeUhTsHdhUO10mnjJ1u_6xekW5IQucFpRco,1565
+sdg_hub/configs/reasoning/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sdg_hub/configs/reasoning/dynamic_cot.yaml,sha256=6XY_mFpB_oKFQ7U2CmHTqkJRGVHgOvpNmIDfhksYW6o,2641
+sdg_hub/configs/skills/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sdg_hub/configs/skills/analyzer.yaml,sha256=QBtyjaU6HBZqzNOmev_W4_scn_hH7Rfxd2xL_LcPLho,2261
+sdg_hub/configs/skills/annotation.yaml,sha256=k5nJ357kUr0Uvq7Hkt3Ey22UbgSjgSjIomjHFfjaQnY,916
+sdg_hub/configs/skills/contexts.yaml,sha256=MZ2QpuGhTce6kuEsMleaGblljhGG-yhXBuH42htA2P4,1161
+sdg_hub/configs/skills/critic.yaml,sha256=Dr7anOKa7Xx1oDonXzsCfXwKIl4hUTArx2Sb_rgpLQI,1808
+sdg_hub/configs/skills/evaluate_freeform_pair.yaml,sha256=MOI0-GyKrJ_O4v1mm8A1lIKxXfwcS3dA7GjlpDEuXRU,4055
+sdg_hub/configs/skills/evaluate_freeform_questions.yaml,sha256=yDmLd-3A9pN5VLaT4lAcJ_ZvCY43LYlcS1KEdxpBRjU,2559
+sdg_hub/configs/skills/evaluate_grounded_pair.yaml,sha256=vMQtsHpNxPOOHnkzqWPp-N1gSfwPqTbfcKmNfhb9WS8,4648
+sdg_hub/configs/skills/evaluate_grounded_questions.yaml,sha256=9yr97azFhMdOfYp11BFtDSIhhP4wjQMOxYZnKWKlCPU,3115
+sdg_hub/configs/skills/freeform_questions.yaml,sha256=N6R3c1jNiSSw6T-OUJULpLnPHuaSXjvoNjSqTKL6EOY,1500
+sdg_hub/configs/skills/freeform_responses.yaml,sha256=4URTMsPpgSDOVj71Gw3lL82QWnUFR37iE72BIMwwv7c,1544
+sdg_hub/configs/skills/grounded_questions.yaml,sha256=t6pKjt5Fp_ThZueB7JBrUKuQLQY_At-Y9O67OtrIXMo,1898
+sdg_hub/configs/skills/grounded_responses.yaml,sha256=kVOeBp3BjKCFKG2qConXIQVVPI1EgcKJgKn6DFAkl1s,1860
+sdg_hub/configs/skills/judge.yaml,sha256=FxnJA_wdmyMyMqGEZDAT8hc2itO845mGDNXgpmV2EUU,3203
+sdg_hub/configs/skills/planner.yaml,sha256=yNF6t0EnmwYt1EV9Y3-vkmPcbOQRtvoLr8MITuiUw_A,2086
+sdg_hub/configs/skills/respond.yaml,sha256=K1Q5X5_Q1k60hNDbHDjMYBzxbyOIEEHTQcXW6qQ4Ve0,108
+sdg_hub/configs/skills/revised_responder.yaml,sha256=rjypOJbhZV9PuOD9YhlYgymxOJV8Zdzzz54x6Fxn2bY,2875
+sdg_hub/configs/skills/router.yaml,sha256=7YnFp6H5wYD8W5Qn1Ac4r9dGBSFUDhZSNwmglQ99PgQ,3545
+sdg_hub/configs/skills/simple_generate_qa_freeform.yaml,sha256=j8cJtEKSvtA__rE08iU6oz2XnfIgj0HiLVL8-6RhK3c,1431
+sdg_hub/configs/skills/simple_generate_qa_grounded.yaml,sha256=tvX9EN5TArFesOOqpdN3hb-IHe7O82a2twQd-gzyCgw,1500
+sdg_hub/configs/skills/icl_examples/STEM.yaml,sha256=5dcLC5jXOEeDasBkTunnHYrlddI3HcHYnEAXZcrd0ds,8412
+sdg_hub/configs/skills/icl_examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sdg_hub/configs/skills/icl_examples/coding.yaml,sha256=a5m-pUcV9xUb54gQ5U3vsU1RBXzOmsfX0CjTW7U62zo,5240
+sdg_hub/configs/skills/icl_examples/extraction.yaml,sha256=P751l6NvFRkINWz-bX5jgnd_if2bl3d_NlhGI7g81xw,4654
+sdg_hub/configs/skills/icl_examples/humanities.yaml,sha256=tZyiJ4Q3gG4uuoDXw6g__lX3ySEUaRZW2GhW1ustwaM,11370
+sdg_hub/configs/skills/icl_examples/math.yaml,sha256=hNq-QudlXrg9CWLpJdrZ4v3vifGTWhyp2gcfwPdR3_o,6776
+sdg_hub/configs/skills/icl_examples/reasoning.yaml,sha256=eesIlH9SO07TVF20gy18MZrcDzLhSmynd_F_lvg0oQg,4335
+sdg_hub/configs/skills/icl_examples/roleplay.yaml,sha256=LYEyA7wv7QWQscUNQr0K_lotNoWSfuoAEncx3PCRYIs,6997
+sdg_hub/configs/skills/icl_examples/writing.yaml,sha256=El-57IjZ5IvdcmCHyHvX_M2RFFkEos572220be8ecrQ,11335
+sdg_hub/flows/generation/knowledge/mmlu_bench.yaml,sha256=Rueuxr_n1zabE_nGqOgUfh5hqVmEONRka9NLiZANSew,346
+sdg_hub/flows/generation/knowledge/simple_knowledge.yaml,sha256=o4uyfs1nDiECcNROdsvHKiM46NYvQufo9dF4XSGpY54,298
+sdg_hub/flows/generation/knowledge/synth_knowledge.yaml,sha256=ZTZvevfwDQSKUwPcv1i5IzIchsRHSEN03eTefedQmU8,2172
+sdg_hub/flows/generation/knowledge/synth_knowledge1.5.yaml,sha256=aVnHkp0DkeuVgWdZ2eUQf5-uzI8tPYOkrs27yoF8m5g,3393
+sdg_hub/flows/generation/skills/improve_responses.yaml,sha256=wUV0awTmKHNZ62pHiw_yz-IdG0OYgT_dCwlMUlZS3TA,2683
+sdg_hub/flows/generation/skills/simple_freeform_skill.yaml,sha256=iVEomFH1E52JA7KLmTIwkS1PnzxUJVPMgbK2O-m80As,309
+sdg_hub/flows/generation/skills/simple_grounded_skill.yaml,sha256=LTLxqdgbLIKSJonuIRHhcRSpit1EawwNvytWzXWXe2E,309
+sdg_hub/flows/generation/skills/synth_grounded_skills.yaml,sha256=91Dm--agpmbm02hIVnFhEndjppKsQEWXDbckR9GAzKM,2045
+sdg_hub/flows/generation/skills/synth_skills.yaml,sha256=9lhQcxXXbN4V9ztPph4fyjUtctll2FYtKY-V4grQdy4,1492
+sdg_hub/utils/__init__.py,sha256=UEo-9qPt5iVKBIRvgZhOI0SoIBO6zeBxOuLvUQXaM3g,185
+sdg_hub/utils/datautils.py,sha256=0t_SZ_UXBKl8uL6rVp3SUh8YKRbzKlh2oO5gr2cKyEw,389
+sdg_hub-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sdg_hub-0.1.0.dist-info/METADATA,sha256=y2r66Mmm4OCTiouJZcLVyTFHR1o3eqD5pAlS-8ow8uE,7247
+sdg_hub-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sdg_hub-0.1.0.dist-info/top_level.txt,sha256=TqI7d-HE1n6zkXFkU0nF3A1Ct0P0pBaqI675uFokhx4,8
+sdg_hub-0.1.0.dist-info/RECORD,,

sdg_hub-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+