adaptive-harmony 0.1.23__py3-none-any.whl

adaptive_harmony/metric_logger.py

@@ -0,0 +1,452 @@
+import html
+import json
+import os
+import tempfile
+from abc import ABC, abstractmethod
+from collections import defaultdict
+from json.decoder import JSONDecodeError
+from pathlib import Path
+from typing import Any, Mapping
+
+from loguru import logger as loguru
+from rich.pretty import pprint
+
+from adaptive_harmony.logging_table import Table
+
+
+class Logger(ABC):
+    @abstractmethod
+    def __call__(self, metrics: Mapping[str, str | int | float | Table]): ...
+
+    @abstractmethod
+    def log_config(self, config: dict[str, Any]): ...
+
+    @staticmethod
+    @abstractmethod
+    def is_available() -> bool: ...
+
+    @property
+    def training_monitoring_link(self) -> str | None:
+        return None
+
+    def close(self):
+        pass
+
+
+class MLFlowLogger(Logger):
+    def __init__(
+        self,
+        project_name: str,
+        run_name: str,
+        tracking_uri: str,
+        monitoring_link: str | None = None,
+        experiment_tags: dict[str, str] | None = None,
+        run_tags: dict[str, str] | None = None,
+        min_table_logging_step_interval: int = 5,
+    ):
+        try:
+            import mlflow
+        except ImportError:
+            raise ImportError(
+                "MLFlow is not available."
+                "To install adaptive-harmony with MLFlow support, install `adaptive-harmony[mlflow]`"
+            )
+
+        self._mlflow = mlflow
+        mlflow.set_tracking_uri(tracking_uri)
+        _ = mlflow.set_experiment(project_name)
+        if experiment_tags:
+            _ = mlflow.set_experiment_tags(experiment_tags)
+        self.run = mlflow.start_run(run_name=run_name, log_system_metrics=None, tags=run_tags)
+        self.monitoring_link = monitoring_link
+        self.step = 0
+        self.last_logged_tables_step = 0
+        self.min_table_logging_step_interval = min_table_logging_step_interval
+        self._log_tables_as_artifacts: bool = False
+
+    @staticmethod
+    def is_available() -> bool:
+        try:
+            import mlflow  # noqa: F401
+
+            return True
+        except ImportError:
+            return False
+
+    def __call__(self, metrics: Mapping[str, str | int | float | Table]):
+        metric_logs: dict[str, float] = {}
+        str_logs: dict[str, str] = {}
+        tables: dict[str, Table] = {}
+        for entry, data in metrics.items():
+            if isinstance(data, int) or isinstance(data, float):
+                metric_logs.update({entry: float(data)})
+            elif isinstance(data, Table):
+                tables.update({entry: data})
+            elif isinstance(data, str):
+                str_logs.update({entry: data})
+            else:
+                print(f"MLFlow logger does not support type: {type(data)}")
+        self._mlflow.log_metrics(metric_logs, step=self.step, synchronous=True)
+        self._mlflow.log_params(str_logs)
+
+        if self.step == 0 or (self.step - self.last_logged_tables_step > self.min_table_logging_step_interval):
+            for table_entry, table in tables.items():
+                headers, rows = table.export()
+                # Transpose rows to columns for MLflow
+                if rows:
+                    columns = list(zip(*rows))
+                    table_dict = {header: list(column) for header, column in zip(headers, columns)}
+                    table_file_name = f"{table_entry}/step_{self.step}.json"
+                    if not self._log_tables_as_artifacts:
+                        try:
+                            self._mlflow.log_table(data=table_dict, artifact_file=table_file_name)
+                        except JSONDecodeError:
+                            loguru.warning(
+                                f"Reached limit of # tables that can be logged to a single run at step {self.step}"
+                                "logging tables as artifacts from now on"
+                            )
+                            self._log_tables_as_artifacts = True
+                    else:
+                        with tempfile.TemporaryDirectory() as tmp_dir:
+                            path = Path(tmp_dir, table_file_name.replace("/", "_"))
+                            path.parent.mkdir(parents=True, exist_ok=True)
+                            path.write_text(json.dumps(table_dict))
+                            self._mlflow.log_artifact(local_path=str(path))
+            self.last_logged_tables_step = self.step
+
+        self.step += 1
+
+    def log_config(self, config: dict[str, Any]):
+        for key, value in config.items():
+            try:
+                # MLflow handles params differently - convert to string for complex types
+                if isinstance(value, (dict, list)):
+                    self._mlflow.log_param(key, json.dumps(value))
+                else:
+                    self._mlflow.log_param(key, value)
+            except Exception as e:
+                print(
+                    f"Warning: Argument '{key}' with value '{str(value)[:100]}...' "
+                    f"(type: {type(value).__name__}) could not be logged to mlflow. Error: {e}"
+                )
+
+    @property
+    def training_monitoring_link(self) -> str:
+        return self.monitoring_link or self._mlflow.get_tracking_uri()
+
+    def close(self):
+        self._mlflow.end_run()
+
+
+class WandbLogger(Logger):
+    def __init__(
+        self,
+        project_name: str,
+        run_name: str,
+        entity: str | None = None,
+    ):
+        try:
+            import wandb
+        except ImportError:
+            raise ImportError(
+                "WandB is not available."
+                "To install adaptive-harmony with WandB support, install `adaptive-harmony[wandb]`"
+            )
+
+        self._wandb = wandb
+        self.run = wandb.init(project=project_name, name=run_name, entity=entity)
+        self.step = 0
+
+    @staticmethod
+    def is_available() -> bool:
+        try:
+            import wandb  # noqa: F401
+
+            return True
+        except ImportError:
+            return False
+
+    def __call__(self, metrics: Mapping[str, str | int | float | Table]):
+        logs = {k: self._process_metric(v) for k, v in metrics.items()}
+        str_logs = {k: str(v) for k, v in logs.items() if isinstance(v, str)}
+        metric_logs = {k: v for k, v in logs.items() if not isinstance(v, str)}
+        self._wandb.log(metric_logs, step=self.step, commit=True)
+        self.run.config.update(str_logs)
+        self.step += 1
+
+    def log_config(self, config: dict[str, Any]):
+        for key, value in config.items():
+            try:
+                self.run.config[key] = value
+            except Exception as e:
+                print(
+                    f"Warning: Argument '{key}' with value '{str(value)[:100]}...' "
+                    f"(type: {type(value).__name__}) could not be logged to wandb. Error: {e}"
+                )
+
+    def _process_metric(self, metric: str | int | float | Table):
+        if isinstance(metric, Table):
+            headers, rows = metric.export()
+            return self._wandb.Table(columns=headers, data=rows)
+        else:
+            return metric
+
+    @property
+    def training_monitoring_link(self) -> str:
+        return self.run.get_url()  # type: ignore
+
+    def close(self):
+        self._wandb.finish()
+
+
+class TBMetricsLogger(Logger):
+    def __init__(self, run_name: str, logging_dir: str, monitoring_link: str | None = None):
+        try:
+            from tensorboardX import SummaryWriter
+        except ImportError:
+            loguru.error(
+                "Tensorboard is not available."
+                "To install adaptive-harmony with TB support, install `adaptive-harmony[tensorboard]"
+            )
+            raise
+
+        self.monitoring_link = monitoring_link
+        self.logging_dir = os.path.join(logging_dir, run_name)
+        self.writer = SummaryWriter(str(self.logging_dir), flush_secs=15)
+        self.step = 0
+
+    @staticmethod
+    def is_available() -> bool:
+        try:
+            from tensorboardX import SummaryWriter  # noqa: F401
+
+            return True
+        except ImportError:
+            return False
+
+    def __call__(self, logs: Mapping[str, str | int | float | Table]):
+        modified_tables = False
+        for entry, data in logs.items():
+            if isinstance(data, int) or isinstance(data, float):
+                self.writer.add_scalar(entry, float(data), self.step)
+            elif isinstance(data, Table):
+                modified_tables = True
+                table_path = os.path.join(self.logging_dir, "html_tables", f"{entry}_{self.step}.html")
+                os.makedirs(os.path.dirname(table_path), exist_ok=True)
+                with open(table_path, "w") as f:
+                    f.write(data.to_html_table())
+            elif isinstance(data, str):
+                self.writer.add_text(entry, data)
+            else:
+                print(f"TensorBoard logger does not support type: {type(data)}")
+
+        if modified_tables:
+            self.create_index_page(os.path.join(self.logging_dir, "html_tables"), sample_files=None)
+
+        self.step += 1
+        self.writer.flush()
+
+    def log_config(self, config: dict[str, Any]):
+        print("Warming: TensorBoard logger does not support logging config parameters.")
+
+    def close(self):
+        self.writer.close()
+
+    @property
+    def training_monitoring_link(self) -> str:
+        return self.monitoring_link or self.logging_dir
+
+    def create_index_page(self, root_dir: str, sample_files: list[str] | None = None):
+        """
+        Traverses subdirectories to find all .html files OR uses a sample list
+        to create a grouped index.html file with relative links to them.
+
+        Args:
+            root_dir (str): The starting directory to search from.
+                            Defaults to the current directory.
+            sample_files (list, optional): A list of dummy file paths to use
+                                        for a layout preview. If None, the
+                                        script will search the file system.
+        """
+        if sample_files:
+            print("Using sample data to generate layout preview.")
+            html_files = sample_files
+        else:
+            print("Searching for HTML files...")
+            html_files = []
+            # os.walk is perfect for recursively exploring a directory tree
+            for dirpath, _, filenames in os.walk(root_dir):
+                for filename in filenames:
+                    # We are looking for HTML files, but we want to ignore any
+                    # index files we might have created previously.
+                    if filename.endswith(".html") and filename != "index.html":
+                        # Get the full path to the file
+                        full_path = os.path.join(dirpath, filename)
+                        # Get the path relative to the root_dir, which is what
+                        # we need for the hyperlink.
+                        relative_path = os.path.relpath(full_path, root_dir)
+                        # On Windows, paths use backslashes. For HTML links, we need
+                        # forward slashes.
+                        html_files.append(relative_path.replace("\\", "/"))
+
+        # Sort the list alphabetically for a clean, predictable order
+        html_files.sort()
+
+        # --- Group files by their parent directory ---
+        grouped_files = defaultdict(list)
+        for file_path in html_files:
+            parent_dir = os.path.dirname(file_path)
+            if not parent_dir:
+                parent_dir = "Top-Level Reports"  # Group for files in root
+            grouped_files[parent_dir].append(file_path)
+
+        # --- Start Generating the HTML for the index page ---
+
+        # A simple, clean stylesheet for the index page
+        css_style = """
+<style>
+    body {
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+        line-height: 1.6;
+        color: #333;
+        max-width: 800px;
+        margin: 40px auto;
+        padding: 0 20px;
+    }
+    h1 {
+        color: #111;
+        border-bottom: 2px solid #f0f0f0;
+        padding-bottom: 10px;
+    }
+    .group-container {
+        margin-bottom: 30px;
+    }
+    h2 {
+        font-size: 1.2rem;
+        color: #444;
+        margin-bottom: 10px;
+        padding-bottom: 5px;
+        border-bottom: 1px solid #e0e0e0;
+    }
+    ul {
+        list-style-type: none;
+        padding: 0;
+    }
+    li {
+        margin-bottom: 10px;
+        background-color: #f9f9f9;
+        border-radius: 5px;
+        box-shadow: 0 1px 3px rgba(0,0,0,0.05);
+        transition: box-shadow 0.2s ease-in-out;
+    }
+    li:hover {
+        box-shadow: 0 3px 8px rgba(0,0,0,0.1);
+    }
+    a {
+        text-decoration: none;
+        color: #0056b3;
+        display: block;
+        padding: 12px 15px;
+        font-weight: 500;
+    }
+    a:hover {
+        background-color: #f0f5fa;
+        border-radius: 5px;
+    }
+    .file-count {
+        font-size: 1rem;
+        color: #666;
+        margin-top: -10px;
+    }
+</style>
+    """
+
+        html_content = f"""
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Index of Reports</title>
+    {css_style}
+</head>
+<body>
+    <h1>Index of Generated Reports</h1>
+    <p class="file-count">Found {len(html_files)} report(s).</p>
+"""
+
+        if not html_files:
+            html_content += "<p>No HTML reports were found in the subdirectories.</p>"
+        else:
+            # Iterate over the grouped dictionary
+            for parent_dir, files in grouped_files.items():
+                html_content += "    <div class='group-container'>\n"
+                html_content += f"      <h2>{html.escape(parent_dir)}</h2>\n"
+                html_content += "      <ul>\n"
+                for file_path in files:
+                    # We use html.escape to ensure that any special characters in the
+                    # filename don't break the HTML.
+                    safe_path = html.escape(file_path)
+                    # Display the filename only, not the full path, as the group provides context
+                    display_name = html.escape(os.path.basename(file_path))
+                    html_content += f"        <li><a href='{safe_path}'>{display_name}</a></li>\n"
+                html_content += "      </ul>\n"
+                html_content += "    </div>\n"
+
+        html_content += """
+</body>
+</html>
+"""
+
+        # Write the generated HTML to the index.html file
+        index_file_path = os.path.join(root_dir, "index.html")
+        try:
+            with open(index_file_path, "w", encoding="utf-8") as f:
+                f.write(html_content)
+            print(f"Successfully created index.html with {len(html_files)} links.")
+        except OSError as e:
+            print(f"Error writing to file {index_file_path}: {e}")
+
+
+class StdoutLogger(Logger):
+    def __init__(self): ...
+
+    @staticmethod
+    def is_available() -> bool:
+        return True
+
+    def __call__(self, logs: Mapping[str, str | int | float | Table]):
+        pprint(logs)
+
+    def log_config(self, config: dict[str, Any]):
+        print("\n" + "=" * 50)
+        pprint(config)
+        print("=" * 50 + "\n")
+
+    def close(self):
+        pass
+
+
+def get_prod_logger() -> Logger:
+    job_id = os.environ.get("HARMONY_JOB_ID") or "unknown-job"
+    use_case_id = os.environ.get("HARMONY_USE_CASE_ID") or "unknown-use-case"
+    use_case_name = os.environ.get("HARMONY_USE_CASE") or "unknown-use-case"
+    recipe_name = os.environ.get("HARMONY_RECIPE_NAME") or "unknown-recipe"
+    run_name = os.environ.get("HARMONY_JOB_NAME") or "unknown-run"
+    if os.environ.get("WANDB_API_KEY") and WandbLogger.is_available():
+        return WandbLogger(project_name=use_case_name, run_name=f"{recipe_name}/{run_name}")
+    elif (uri := os.environ.get("MLFLOW_TRACKING_URI")) and MLFlowLogger.is_available():
+        monitoring_link = os.environ["MLFLOW_MONITORING_LINK"]
+        return MLFlowLogger(
+            project_name=use_case_name,
+            run_name=f"{recipe_name}/{run_name}",
+            tracking_uri=uri,
+            monitoring_link=monitoring_link,
+            experiment_tags={"adaptive.use_case_id": use_case_id},
+            run_tags={"adaptive.job_id": job_id},
+        )
+    elif (log_dir := os.environ.get("TENSORBOARD_LOGGING_DIR")) and TBMetricsLogger.is_available():
+        monitoring_link = os.path.join(os.environ["TENSORBOARD_MONITORING_LINK"], job_id)
+        return TBMetricsLogger(run_name=job_id, logging_dir=log_dir, monitoring_link=monitoring_link)
+    else:
+        return StdoutLogger()

adaptive_harmony/parameters/__init__.py

@@ -0,0 +1,2 @@
+# Re-export everything from harmony_client.parameters
+from harmony_client.parameters import *  # noqa: F403, F401

adaptive_harmony/runtime/__init__.py

@@ -0,0 +1,2 @@
+# Re-export everything from harmony_client.runtime
+from harmony_client.runtime import *  # noqa: F403, F401

adaptive_harmony/runtime/context.py

@@ -0,0 +1,2 @@
+# Re-export from harmony_client.runtime.context
+from harmony_client.runtime.context import *  # noqa: F403, F401

adaptive_harmony/runtime/data.py

@@ -0,0 +1,2 @@
+# Re-export from harmony_client.runtime.data
+from harmony_client.runtime.data import *  # noqa: F403, F401

adaptive_harmony/runtime/decorators.py

@@ -0,0 +1,2 @@
+# Re-export from harmony_client.runtime.decorators
+from harmony_client.runtime.decorators import *  # noqa: F403, F401

adaptive_harmony/runtime/model_artifact_save.py

@@ -0,0 +1,2 @@
+# Re-export from harmony_client.runtime.model_artifact_save
+from harmony_client.runtime.model_artifact_save import *  # noqa: F403, F401

adaptive_harmony/runtime/runner.py

@@ -0,0 +1,27 @@
+# Re-export from harmony_client.runtime.runner
+from harmony_client.runtime.context import RecipeConfig as RecipeConfig  # noqa: F401
+from harmony_client.runtime.context import RecipeContext as RecipeContext
+from harmony_client.runtime.runner import (  # noqa: F401
+    RunnerArgs as RunnerArgs,
+)
+from harmony_client.runtime.runner import (
+    _download_and_extract_recipe as _download_and_extract_recipe,
+)
+from harmony_client.runtime.runner import (
+    _get_params as _get_params,
+)
+from harmony_client.runtime.runner import (
+    _install_recipe_dependencies as _install_recipe_dependencies,
+)
+from harmony_client.runtime.runner import (
+    _load_and_run_recipe as _load_and_run_recipe,
+)
+from harmony_client.runtime.runner import (
+    _parse_script_metadata as _parse_script_metadata,
+)
+from harmony_client.runtime.runner import (
+    main as main,
+)
+
+if __name__ == "__main__":
+    main()

adaptive_harmony/runtime/simple_notifier.py

@@ -0,0 +1,2 @@
+# Re-export from harmony_client.runtime.simple_notifier
+from harmony_client.runtime.simple_notifier import *  # noqa: F403, F401

adaptive_harmony-0.1.23.dist-info/METADATA

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: adaptive-harmony
+Version: 0.1.23
+Summary: Adaptive Harmony training recipes and utilities for LLM fine-tuning
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.12
+Requires-Dist: harmony-client
+Requires-Dist: rich>=13.7.0
+Requires-Dist: datasets>=2.14.0
+Requires-Dist: hf-xet>=1.1.2
+Requires-Dist: loguru>=0.7.2
+Requires-Dist: pydantic-settings>=2.9.1
+Requires-Dist: pydantic>=2.10.5
+Requires-Dist: pybars3>=0.9.7
+Requires-Dist: pysbd>=0.3.4
+Requires-Dist: websockets>=15.0.1
+Requires-Dist: setproctitle>=1.3.3
+Requires-Dist: pydantic-xml>=2.16.0
+Requires-Dist: openai>=1.42.0
+Requires-Dist: pillow>=11.3.0
+Requires-Dist: boto3>=1.40
+Requires-Dist: tomli>=2
+Provides-Extra: tensorboard
+Requires-Dist: tensorboardX>=2.6.2.2; extra == "tensorboard"
+Provides-Extra: mlflow
+Requires-Dist: mlflow>=3.4.0; extra == "mlflow"
+Provides-Extra: wandb
+Requires-Dist: wandb>=0.19.11; extra == "wandb"
+Provides-Extra: all-monitoring
+Requires-Dist: tensorboardX>=2.6.2.2; extra == "all-monitoring"
+Requires-Dist: mlflow>=3.4.0; extra == "all-monitoring"
+Requires-Dist: wandb>=0.19.11; extra == "all-monitoring"
+Provides-Extra: mlflow-skinny
+Requires-Dist: mlflow-skinny>=3.4.0; extra == "mlflow-skinny"

adaptive_harmony-0.1.23.dist-info/RECORD

@@ -0,0 +1,67 @@
+adaptive_harmony/__init__.py,sha256=_KoDEWVU-mCtXWp7ZXXlWcTWSVVkE6_r8xlJDXyOxRw,4849
+adaptive_harmony/logging_table.py,sha256=kN5jS-PO0Y1B6KFicv3BnSyXz5OfThV4L1pCY3_kUmk,56
+adaptive_harmony/metric_logger.py,sha256=6KAp7UhhygiHgWj5l9Bhwc7Sg9cIhxSzAilpxp_7iZM,16619
+adaptive_harmony/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adaptive_harmony/common/__init__.py,sha256=qebnYmwNBurtouGDbK27mtwt9zLm3P0tHR_M9LnFZT4,967
+adaptive_harmony/common/callbacks.py,sha256=Q5qxVOAdnQRUZxy_ZcBAVxXTmSNA3o7L-cfEZ3JPnWs,8636
+adaptive_harmony/common/checkpointing.py,sha256=rNfzwTEvWzNbUMjkl4CUD3zfsYdsWU_ksR3Lqn-Ghck,6569
+adaptive_harmony/common/dpo.py,sha256=ioionFEnxzagfBVnIvLBh6rb6-d8WeWtVHgp-VDBKf8,3463
+adaptive_harmony/common/env_grpo.py,sha256=bQEBJ7TojBxnCIRopu_pkjzfTl1zAXRcW8olRDMDtIE,15149
+adaptive_harmony/common/grpo.py,sha256=LlG0NxpTtFga06YguTNDnEOVfBjRYHJoRyz4fbAFCRc,10384
+adaptive_harmony/common/gspo.py,sha256=O4z-BrKLusGeM8P6LWz77h8i0HrUhLR7_wxrAluxdxQ,2407
+adaptive_harmony/common/ppo.py,sha256=owJlajLDnOxq4LpjjIn-dLXJVmKlsQh3wMG0zfnbUxU,12393
+adaptive_harmony/common/rm.py,sha256=0HgJXUL722DWhqBOFk_do3k9NUk6g09bEW0qDZxGYfQ,3504
+adaptive_harmony/common/sft.py,sha256=A_g72b6Et7wCSApdc8TFcCn5JoRWQgYwG1WsKm-aiaY,4883
+adaptive_harmony/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adaptive_harmony/core/dataset.py,sha256=MnECz5f0ff3D8MYOvG4Q9RXAJmuoCSk5vi7ysgo4TBM,2474
+adaptive_harmony/core/display.py,sha256=Wid2sRv4MPUqDlpEcAhncBmkixT32JhkLCN9oAxw658,3073
+adaptive_harmony/core/image_utils.py,sha256=NJeK3IOB-hbTuc5XR5-eSqAzomwmDOwoZChsdcjyUV0,3775
+adaptive_harmony/core/reasoning.py,sha256=36HW5jBkAtWibx90CAVes_E8MlbzSAI0v0K4ITSzk-Q,445
+adaptive_harmony/core/rich_counter.py,sha256=z0uIq1pLES8F7wcdyQALxD3NU-vTOmlLPyeeyVotZRg,12334
+adaptive_harmony/core/rl_utils.py,sha256=gEY37o-h3jIF7lW9E9SGnFoIcBasBn3byO6-0SUK4PI,1023
+adaptive_harmony/core/schedulers.py,sha256=tqjxaIsjlXAkGWfTCnvnKhTCblrIJStHaUxfAGK3qwU,1361
+adaptive_harmony/core/structured_output.py,sha256=xvtQEor9Cjce5T4lYFLsN1NkZPqbomw15Jq7Cl3-MFM,14940
+adaptive_harmony/core/utils.py,sha256=1q2ouNOti5IH43vGIYrx5Jm7qPokQIOVbUKJw9aV5ss,13412
+adaptive_harmony/core/reward_client/__init__.py,sha256=q513qDHyTPmZZCYpedXbevHnykimn1hDqo6zzyTc65c,459
+adaptive_harmony/core/reward_client/client.py,sha256=4UcgWPuaptGNJz2isp895u1szA1chwLKn6WlpefnPn8,5946
+adaptive_harmony/core/reward_client/reward_types.py,sha256=1K0yfOzNAHT1GQfa8vpuWkt5o0Afe7iZ4lkzvdxWelY,817
+adaptive_harmony/core/reward_client/websocket_utils.py,sha256=3oedoZDhKLnwp98g1QanepWHCXv92G3k_IJC3_MPH0E,499
+adaptive_harmony/environment/__init__.py,sha256=6WpEGBGfQ4Cnr2rRncZ-S6nKDBllWimhwnN7DEqgDHQ,185
+adaptive_harmony/environment/environment.py,sha256=yDAcR2VzlU-2-OdWbqVi1IPtMCqNDwiDFjKstK1axpo,3907
+adaptive_harmony/evaluation/__init__.py,sha256=wsMYryTeiITYV0PHW86Alkz2z6WDdrKM6EkYON4VdLw,74
+adaptive_harmony/evaluation/evaluation_artifact.py,sha256=9rx0mDg5BENIWH6Zzq9br8CsKyJrkc_Ls8jXz0bPY0w,1958
+adaptive_harmony/graders/__init__.py,sha256=id10TznTfd5G0xmVNkjCbe-bWKuykHxOFCCqWrcVbXQ,580
+adaptive_harmony/graders/base_grader.py,sha256=TYOeFxXgoUoOK1HaiKgjnRAucyjdlX42e2kDs0jNi2Q,9988
+adaptive_harmony/graders/combined_grader.py,sha256=wmJDxBVS3U3kNPBC1nROlthfm3ZhfzWVAESzizGo9Bs,4597
+adaptive_harmony/graders/exceptions.py,sha256=YBUQpx1_3RkN_GcxvKLCtODhqPUqCdOiwmdxJ01vG9s,330
+adaptive_harmony/graders/reward_server_grader.py,sha256=93qkUIDdCvyvoe6OniJS500UuFtI74i1_e9fqCm_zWc,1360
+adaptive_harmony/graders/templated_prompt_judge.py,sha256=0TNg9agPABXn0aIrnpMyjQFW2Dr5303L53xirIfaatk,10076
+adaptive_harmony/graders/utils.py,sha256=iZHILLwQn72DXyyuFlb-6XUUEzG0t78VbaDs0yXfsWI,2533
+adaptive_harmony/graders/answer_relevancy_judge/__init__.py,sha256=942BWEsIpWdkNfjzp-Ma1ZXtpmop1MF0E7b1u0CcJKY,95
+adaptive_harmony/graders/answer_relevancy_judge/answer_relevancy_judge.py,sha256=KdYi6urGrVxgYBUExMGt5wit6Pf5f-K5Vfys5QgfM6w,4495
+adaptive_harmony/graders/answer_relevancy_judge/prompts.py,sha256=ncIbN2UVpc9lnVimkiL3w7QrjseXoeBRk6mJvEAbL0k,1894
+adaptive_harmony/graders/binary_judge/__init__.py,sha256=HmdU6eJyv4-EQPXqEtXG1kQ8Sco6X4D2iUzoOFZwRDY,188
+adaptive_harmony/graders/binary_judge/binary_judge.py,sha256=Y5DiqiGSo4A68rBYrjqY70Wxyny5v5HwWHjfzPWnyVw,8307
+adaptive_harmony/graders/binary_judge/prompts.py,sha256=3VQ5DebmMUBxqO9hAvLAsqfaTQw5aYqvExZozlGszZs,6415
+adaptive_harmony/graders/context_relevancy_judge/__init__.py,sha256=wrxO_2-cVZvFXOtMm2O1_1hdv__eqNrJ0bvxRrE9Pvc,98
+adaptive_harmony/graders/context_relevancy_judge/context_relevancy_judge.py,sha256=IATqNn_Uw6cp5jxdBl-fXMemg5webQcC-893e4wvggw,5294
+adaptive_harmony/graders/context_relevancy_judge/prompts.py,sha256=eb8tmrNuHT4I7qunf5pCfr3BVis2pWfgS-BBKo3XJQs,3647
+adaptive_harmony/graders/faithfulness_judge/__init__.py,sha256=8Dx5_aujk3TPR9p3iBIS8Xj1S9G2wxiQ8x44WIACUYc,85
+adaptive_harmony/graders/faithfulness_judge/faithfulness_judge.py,sha256=5qOcjfPeT_7-dUGZ4MO5GeYuy32U90Yg2GXVs-YZ7BE,6044
+adaptive_harmony/graders/faithfulness_judge/prompts.py,sha256=_3otDjyjUaKfebeE0yYZXU99zImi-uJ_E7D1sHEhZmg,984
+adaptive_harmony/graders/range_judge/__init__.py,sha256=h2LObCYzY0h8QumTBcfjNuBW31WfZ7rkojmrL0m4rbU,200
+adaptive_harmony/graders/range_judge/prompts.py,sha256=V2iVWUDGP54-I_pHR2yPyR9SuVYMa-yaOtCRag5Dq9s,9331
+adaptive_harmony/graders/range_judge/range_judge.py,sha256=Av8qMqcWm8J3c8Tli_yPqMJGTlQos9dlwAbi32HcBOo,8199
+adaptive_harmony/graders/range_judge/types.py,sha256=UlS_HhYiD5mNXEGK7M8jugFlk-WtvVNqMQh3IYqBUno,398
+adaptive_harmony/parameters/__init__.py,sha256=MBCDZ2YzqM8J2oU3BIH2t1mnr85xHrvlLQyU-lcEHdg,114
+adaptive_harmony/runtime/__init__.py,sha256=AQ9pixPP4KrHaElpDTtghaDN4VVrfh5meQJithPtnWo,108
+adaptive_harmony/runtime/context.py,sha256=G-aijdP0WLHfNU8zfPFm9czGiowU79yHRjvdqAC4mlc,113
+adaptive_harmony/runtime/data.py,sha256=oP1WKOLueVHuLodnz_ZHge8JCWR_YInZI7ug2LXKvQk,107
+adaptive_harmony/runtime/decorators.py,sha256=zDNnG_fNz-zgHnb-d5WCPNLMMKFRtL_ncz4wEGVSp-o,119
+adaptive_harmony/runtime/model_artifact_save.py,sha256=1Ui-Q1hP_eDAhKBFOXpEVix5Q3TY9_d11viXs0xsk3o,137
+adaptive_harmony/runtime/runner.py,sha256=70lNz2pe2dGEgqH8Igwp8ppGLDLxHVwNmxcyV4Y6HMM,898
+adaptive_harmony/runtime/simple_notifier.py,sha256=iVXtZwfcOvkZlWQgFC0qjE1P-yA6Y7Wx0SxQ9FoJ-0s,129
+adaptive_harmony-0.1.23.dist-info/METADATA,sha256=vSt6Q78VZyskfevyOZyIACXAKoSSfFEIm1FeTwgeipE,1429
+adaptive_harmony-0.1.23.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+adaptive_harmony-0.1.23.dist-info/top_level.txt,sha256=ZEmoKxkFM4M7H2mgH15wQ4Tf0Eb13FBmghRvC2seacU,17
+adaptive_harmony-0.1.23.dist-info/RECORD,,

adaptive_harmony-0.1.23.dist-info/WHEEL

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

adaptive_harmony-0.1.23.dist-info/top_level.txt

@@ -0,0 +1 @@
+adaptive_harmony