kiln-ai 0.11.1__py3-none-any.whl → 0.12.0__py3-none-any.whl

kiln_ai/datamodel/test_example_models.py

@@ -11,7 +11,6 @@ from kiln_ai.datamodel import (
     Finetune,
     Project,
     Task,
-    TaskDeterminism,
     TaskOutput,
     TaskOutputRating,
     TaskOutputRatingType,
@@ -125,7 +124,6 @@ def test_structured_output_workflow(tmp_path):
         name="Structured Output Task",
         parent=project,
         instruction="Generate a JSON object with name and age",
-        determinism=TaskDeterminism.semantic_match,
         output_json_schema=json.dumps(
             {
                 "type": "object",
@@ -142,7 +140,7 @@ def test_structured_output_workflow(tmp_path):
 
     # Create runs
     runs = []
-    for source in DataSourceType:
+    for source in [DataSourceType.human, DataSourceType.synthetic]:
         for _ in range(2):
             task_run = TaskRun(
                 input="Generate info for John Doe",
@@ -157,7 +155,7 @@ def test_structured_output_workflow(tmp_path):
                         "adapter_name": "TestAdapter",
                         "model_name": "GPT-4",
                         "model_provider": "OpenAI",
-                        "prompt_builder_name": "TestPromptBuilder",
+                        "prompt_id": "simple_prompt_builder",
                     },
                 ),
                 parent=task,
@@ -216,9 +214,9 @@ def test_structured_output_workflow(tmp_path):
 
     assert loaded_task.name == "Structured Output Task"
     assert len(loaded_task.requirements) == 2
-    assert len(loaded_task.runs()) == 5
-
     loaded_runs = loaded_task.runs()
+    assert len(loaded_runs) == 5
+
     for task_run in loaded_runs:
         output = task_run.output
         assert output.rating is not None
@@ -472,7 +470,7 @@ def test_valid_synthetic_task_output():
                 "adapter_name": "TestAdapter",
                 "model_name": "GPT-4",
                 "model_provider": "OpenAI",
-                "prompt_builder_name": "TestPromptBuilder",
+                "prompt_id": "simple_prompt_builder",
             },
         ),
     )
@@ -480,7 +478,7 @@ def test_valid_synthetic_task_output():
     assert output.source.properties["adapter_name"] == "TestAdapter"
     assert output.source.properties["model_name"] == "GPT-4"
     assert output.source.properties["model_provider"] == "OpenAI"
-    assert output.source.properties["prompt_builder_name"] == "TestPromptBuilder"
+    assert output.source.properties["prompt_id"] == "simple_prompt_builder"
 
 
 def test_invalid_synthetic_task_output_missing_keys():
@@ -509,23 +507,21 @@ def test_invalid_synthetic_task_output_empty_values():
                     "adapter_name": "TestAdapter",
                     "model_name": "",
                     "model_provider": "OpenAI",
-                    "prompt_builder_name": "TestPromptBuilder",
+                    "prompt_id": "simple_prompt_builder",
                 },
             ),
         )
 
 
 def test_invalid_synthetic_task_output_non_string_values():
-    with pytest.raises(
-        ValidationError, match="'prompt_builder_name' must be of type str"
-    ):
+    with pytest.raises(ValidationError, match="'prompt_id' must be of type str"):
         DataSource(
             type=DataSourceType.synthetic,
             properties={
                 "adapter_name": "TestAdapter",
                 "model_name": "GPT-4",
                 "model_provider": "OpenAI",
-                "prompt_builder_name": 123,
+                "prompt_id": 123,
             },
         )
 

kiln_ai/datamodel/test_json_schema.py

@@ -4,6 +4,7 @@ from pydantic import BaseModel
 from kiln_ai.datamodel.json_schema import (
     JsonObjectSchema,
     schema_from_json_str,
+    string_to_json_key,
     validate_schema,
 )
 
@@ -123,3 +124,25 @@ def test_triangle_schema():
     validate_schema({"a": 1, "b": 2, "c": 3}, json_triangle_schema)
     with pytest.raises(Exception):
         validate_schema({"a": 1, "b": 2, "c": "3"}, json_triangle_schema)
+
+
+@pytest.mark.parametrize(
+    "input_str,expected",
+    [
+        ("hello world", "hello_world"),
+        ("Hello World", "hello_world"),
+        ("hello_world", "hello_world"),
+        ("HELLO WORLD", "hello_world"),
+        ("hello123", "hello123"),
+        ("hello-world", "helloworld"),
+        ("hello!@#$%^&*()world", "helloworld"),
+        ("  hello  world  ", "hello__world"),
+        ("hello__world", "hello__world"),
+        ("", ""),
+        ("!@#$%", ""),
+        ("snake_case_string", "snake_case_string"),
+        ("camelCaseString", "camelcasestring"),
+    ],
+)
+def test_string_to_json_key(input_str: str, expected: str):
+    assert string_to_json_key(input_str) == expected

kiln_ai/datamodel/test_models.py

@@ -385,7 +385,7 @@ def test_task_run_input_source_validation(tmp_path):
     assert task_run.input_source is not None
 
     # Test 3: Creating without input_source should fail when strict mode is on
-    with patch("kiln_ai.datamodel.strict_mode", return_value=True):
+    with patch("kiln_ai.datamodel.task_run.strict_mode", return_value=True):
         with pytest.raises(ValueError) as exc_info:
             task_run = TaskRun(
                 input="test input 3",
@@ -442,7 +442,7 @@ def test_task_output_source_validation(tmp_path):
     assert task_output.source is not None
 
     # Test 3: Creating without source should fail when strict mode is on
-    with patch("kiln_ai.datamodel.strict_mode", return_value=True):
+    with patch("kiln_ai.datamodel.task_output.strict_mode", return_value=True):
         with pytest.raises(ValueError) as exc_info:
             task_output = TaskOutput(
                 output="test output 3",

kiln_ai/datamodel/test_prompt_id.py

@@ -0,0 +1,129 @@
+import pytest
+from pydantic import BaseModel, ValidationError
+
+from kiln_ai.datamodel import (
+    PromptGenerators,
+    PromptId,
+)
+from kiln_ai.datamodel.prompt_id import is_frozen_prompt
+
+
+# Test model to validate the PromptId type
+class ModelTester(BaseModel):
+    prompt_id: PromptId
+
+
+def test_valid_prompt_generator_names():
+    """Test that valid prompt generator names are accepted"""
+    for generator in PromptGenerators:
+        model = ModelTester(prompt_id=generator.value)
+        assert model.prompt_id == generator.value
+
+
+def test_valid_saved_prompt_id():
+    """Test that valid saved prompt IDs are accepted"""
+    valid_id = "id::prompt_789"
+    model = ModelTester(prompt_id=valid_id)
+    assert model.prompt_id == valid_id
+
+
+def test_valid_fine_tune_prompt_id():
+    """Test that valid fine-tune prompt IDs are accepted"""
+    valid_id = "fine_tune_prompt::ft_123456"
+    model = ModelTester(prompt_id=valid_id)
+    assert model.prompt_id == valid_id
+
+
+@pytest.mark.parametrize(
+    "invalid_id",
+    [
+        pytest.param("id::project_123::task_456", id="missing_prompt_id"),
+        pytest.param("id::task_456::prompt_789", id="too_many_parts"),
+        pytest.param("id::", id="empty_parts"),
+    ],
+)
+def test_invalid_saved_prompt_id_format(invalid_id):
+    """Test that invalid saved prompt ID formats are rejected"""
+    with pytest.raises(ValidationError, match="Invalid saved prompt ID"):
+        ModelTester(prompt_id=invalid_id)
+
+
+@pytest.mark.parametrize(
+    "invalid_id,expected_error",
+    [
+        ("fine_tune_prompt::", "Invalid fine-tune prompt ID: fine_tune_prompt::"),
+        ("fine_tune_prompt", "Invalid prompt ID: fine_tune_prompt"),
+    ],
+)
+def test_invalid_fine_tune_prompt_id_format(invalid_id, expected_error):
+    """Test that invalid fine-tune prompt ID formats are rejected"""
+    with pytest.raises(ValidationError, match=expected_error):
+        ModelTester(prompt_id=invalid_id)
+
+
+def test_completely_invalid_formats():
+    """Test that completely invalid formats are rejected"""
+    invalid_ids = [
+        "",  # Empty string
+        "invalid_format",  # Random string
+        "id:wrong_format",  # Almost correct but wrong separator
+        "fine_tune:wrong_format",  # Almost correct but wrong prefix
+        ":::",  # Just separators
+    ]
+
+    for invalid_id in invalid_ids:
+        with pytest.raises(ValidationError, match="Invalid prompt ID"):
+            ModelTester(prompt_id=invalid_id)
+
+
+def test_prompt_generator_case_sensitivity():
+    """Test that prompt generator names are case sensitive"""
+    # Take first generator and modify its case
+    first_generator = next(iter(PromptGenerators)).value
+    wrong_case = first_generator.upper()
+    if wrong_case == first_generator:
+        wrong_case = first_generator.lower()
+
+    with pytest.raises(ValidationError):
+        ModelTester(prompt_id=wrong_case)
+
+
+@pytest.mark.parametrize(
+    "valid_id",
+    [
+        "task_run_config::project_123::task_456::config_123",  # Valid task run config prompt ID
+    ],
+)
+def test_valid_task_run_config_prompt_id(valid_id):
+    """Test that valid eval prompt IDs are accepted"""
+    model = ModelTester(prompt_id=valid_id)
+    assert model.prompt_id == valid_id
+
+
+@pytest.mark.parametrize(
+    "invalid_id,expected_error",
+    [
+        ("task_run_config::", "Invalid task run config prompt ID"),
+        ("task_run_config::p1", "Invalid task run config prompt ID"),
+        ("task_run_config::p1::t1", "Invalid task run config prompt ID"),
+        ("task_run_config::p1::t1::c1::extra", "Invalid task run config prompt ID"),
+    ],
+)
+def test_invalid_eval_prompt_id_format(invalid_id, expected_error):
+    """Test that invalid eval prompt ID formats are rejected"""
+    with pytest.raises(ValidationError, match=expected_error):
+        ModelTester(prompt_id=invalid_id)
+
+
+@pytest.mark.parametrize(
+    "id,should_be_frozen",
+    [
+        ("simple_prompt_builder", False),
+        ("id::prompt_123", True),
+        ("task_run_config::p1::t1", True),
+        ("fine_tune_prompt::ft_123", True),
+    ],
+)
+def test_is_frozen_prompt(id, should_be_frozen):
+    """Test that the is_frozen_prompt function works"""
+    assert is_frozen_prompt(id) == should_be_frozen

kiln_ai/datamodel/test_task.py

@@ -0,0 +1,159 @@
+import pytest
+from pydantic import ValidationError
+
+from kiln_ai.datamodel.datamodel_enums import TaskOutputRatingType
+from kiln_ai.datamodel.prompt_id import PromptGenerators
+from kiln_ai.datamodel.task import RunConfig, RunConfigProperties, Task, TaskRunConfig
+from kiln_ai.datamodel.task_output import normalize_rating
+
+
+def test_runconfig_valid_creation():
+    task = Task(id="task1", name="Test Task", instruction="Do something")
+
+    config = RunConfig(
+        task=task,
+        model_name="gpt-4",
+        model_provider_name="openai",
+        prompt_id=PromptGenerators.SIMPLE,
+    )
+
+    assert config.task == task
+    assert config.model_name == "gpt-4"
+    assert config.model_provider_name == "openai"
+    assert config.prompt_id == PromptGenerators.SIMPLE  # Check default value
+
+
+def test_runconfig_missing_required_fields():
+    with pytest.raises(ValidationError) as exc_info:
+        RunConfig()
+
+    errors = exc_info.value.errors()
+    assert (
+        len(errors) == 4
+    )  # task, model_name, model_provider_name, and prompt_id are required
+    assert any(error["loc"][0] == "task" for error in errors)
+    assert any(error["loc"][0] == "model_name" for error in errors)
+    assert any(error["loc"][0] == "model_provider_name" for error in errors)
+    assert any(error["loc"][0] == "prompt_id" for error in errors)
+
+
+def test_runconfig_custom_prompt_id():
+    task = Task(id="task1", name="Test Task", instruction="Do something")
+
+    config = RunConfig(
+        task=task,
+        model_name="gpt-4",
+        model_provider_name="openai",
+        prompt_id=PromptGenerators.SIMPLE_CHAIN_OF_THOUGHT,
+    )
+
+    assert config.prompt_id == PromptGenerators.SIMPLE_CHAIN_OF_THOUGHT
+
+
+@pytest.fixture
+def sample_task():
+    return Task(name="Test Task", instruction="Test instruction")
+
+
+@pytest.fixture
+def sample_run_config_props(sample_task):
+    return RunConfigProperties(
+        model_name="gpt-4",
+        model_provider_name="openai",
+        prompt_id=PromptGenerators.SIMPLE,
+    )
+
+
+def test_task_run_config_valid_creation(sample_task, sample_run_config_props):
+    config = TaskRunConfig(
+        name="Test Config",
+        description="Test description",
+        run_config_properties=sample_run_config_props,
+        parent=sample_task,
+    )
+
+    assert config.name == "Test Config"
+    assert config.description == "Test description"
+    assert config.run_config_properties == sample_run_config_props
+    assert config.parent_task() == sample_task
+
+
+def test_task_run_config_minimal_creation(sample_task, sample_run_config_props):
+    # Test creation with only required fields
+    config = TaskRunConfig(
+        name="Test Config",
+        run_config_properties=sample_run_config_props,
+        parent=sample_task,
+    )
+
+    assert config.name == "Test Config"
+    assert config.description is None
+    assert config.run_config_properties == sample_run_config_props
+
+
+def test_task_run_config_missing_required_fields(sample_task):
+    # Test missing name
+    with pytest.raises(ValidationError) as exc_info:
+        TaskRunConfig(
+            run_config_properties=RunConfigProperties(
+                task=sample_task, model_name="gpt-4", model_provider_name="openai"
+            ),
+            parent=sample_task,
+        )
+    assert "Field required" in str(exc_info.value)
+
+    # Test missing run_config
+    with pytest.raises(ValidationError) as exc_info:
+        TaskRunConfig(name="Test Config", parent=sample_task)
+    assert "Field required" in str(exc_info.value)
+
+
+def test_task_run_config_missing_task_in_run_config(sample_task):
+    with pytest.raises(
+        ValidationError, match="Input should be a valid dictionary or instance of Task"
+    ):
+        # Create a run config without a task
+        RunConfig(
+            model_name="gpt-4",
+            model_provider_name="openai",
+            task=None,  # type: ignore
+        )
+
+
+@pytest.mark.parametrize(
+    "rating_type,rating,expected",
+    [
+        (TaskOutputRatingType.five_star, 1, 0),
+        (TaskOutputRatingType.five_star, 2, 0.25),
+        (TaskOutputRatingType.five_star, 3, 0.5),
+        (TaskOutputRatingType.five_star, 4, 0.75),
+        (TaskOutputRatingType.five_star, 5, 1),
+        (TaskOutputRatingType.pass_fail, 0, 0),
+        (TaskOutputRatingType.pass_fail, 1, 1),
+        (TaskOutputRatingType.pass_fail, 0.5, 0.5),
+        (TaskOutputRatingType.pass_fail_critical, -1, 0),
+        (TaskOutputRatingType.pass_fail_critical, 0, 0.5),
+        (TaskOutputRatingType.pass_fail_critical, 1, 1),
+        (TaskOutputRatingType.pass_fail_critical, 0.5, 0.75),
+    ],
+)
+def test_normalize_rating(rating_type, rating, expected):
+    assert normalize_rating(rating, rating_type) == expected
+
+
+@pytest.mark.parametrize(
+    "rating_type,rating",
+    [
+        (TaskOutputRatingType.five_star, 0),
+        (TaskOutputRatingType.five_star, 6),
+        (TaskOutputRatingType.pass_fail, -0.5),
+        (TaskOutputRatingType.pass_fail, 1.5),
+        (TaskOutputRatingType.pass_fail_critical, -1.5),
+        (TaskOutputRatingType.pass_fail_critical, 1.5),
+        (TaskOutputRatingType.custom, 0),
+        (TaskOutputRatingType.custom, 99),
+    ],
+)
+def test_normalize_rating_errors(rating_type, rating):
+    with pytest.raises(ValueError):
+        normalize_rating(rating, rating_type)

kiln_ai/utils/config.py

@@ -142,10 +142,15 @@ class Config:
             raise AttributeError(f"Config has no attribute '{name}'")
 
     @classmethod
-    def settings_path(cls, create=True):
+    def settings_dir(cls, create=True):
         settings_dir = os.path.join(Path.home(), ".kiln_ai")
         if create and not os.path.exists(settings_dir):
             os.makedirs(settings_dir)
+        return settings_dir
+
+    @classmethod
+    def settings_path(cls, create=True):
+        settings_dir = cls.settings_dir(create)
         return os.path.join(settings_dir, "settings.yaml")
 
     @classmethod

{kiln_ai-0.11.1.dist-info → kiln_ai-0.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiln-ai
-Version: 0.11.1
+Version: 0.12.0
 Summary: Kiln AI
 Project-URL: Homepage, https://getkiln.ai
 Project-URL: Repository, https://github.com/Kiln-AI/kiln
@@ -71,6 +71,7 @@ The library has a [comprehensive set of docs](https://kiln-ai.github.io/Kiln/kil
   - [Load an Existing Dataset into a Kiln Task Dataset](#load-an-existing-dataset-into-a-kiln-task-dataset)
   - [Using your Kiln Dataset in a Notebook or Project](#using-your-kiln-dataset-in-a-notebook-or-project)
   - [Using Kiln Dataset in Pandas](#using-kiln-dataset-in-pandas)
+  - [Building and Running a Kiln Task from Code](#building-and-running-a-kiln-task-from-code)
 - [Full API Reference](#full-api-reference)
 
 ## Installation
@@ -232,6 +233,41 @@ final_df = pd.concat(dfs, ignore_index=True)
 print(final_df)
 ```
 
+### Building and Running a Kiln Task from Code
+
+```python
+# Step 1: Create or Load a Task -- choose one of the following 1.A or 1.B
+
+# Step 1.A: Optionally load an existing task from disk
+# task = datamodel.Task.load_from_file("path/to/task.kiln")
+
+# Step 1.B: Create a new task in code, without saving to disk.
+task = datamodel.Task(
+    name="test task",
+    instruction="Tell a joke, given a subject.",
+)
+# replace with a valid JSON schema https://json-schema.org for your task (json string, not a python dict).
+# Or delete this line to use plaintext output
+task.output_json_schema = json_joke_schema
+
+# Step 2: Create an Adapter to run the task, with a specific model and provider
+adapter = adapter_for_task(task, model_name="llama_3_1_8b", provider="groq")
+
+# Step 3: Invoke the Adapter to run the task
+task_input = "cows"
+response = await adapter.invoke(task_input)
+print(f"Output: {response.output.output}")
+
+# Step 4 (optional): Load the task from disk and print the results.
+#  This will only work if the task was loaded from disk, or you called task.save_to_file() before invoking the adapter (epemerial tasks don't save their result to disk)
+task = datamodel.Task.load_from_file(tmp_path / "test_task.kiln")
+for run in task.runs():
+    print(f"Run: {run.id}")
+    print(f"Input: {run.input}")
+    print(f"Output: {run.output}")
+
+```
+
 ## Full API Reference
 
 The library can do a lot more than the examples we've shown here.

kiln_ai-0.12.0.dist-info/RECORD

@@ -0,0 +1,100 @@
+kiln_ai/__init__.py,sha256=Sc4z8LRVFMwJUoc_DPVUriSXTZ6PO9MaJ80PhRbKyB8,34
+kiln_ai/adapters/__init__.py,sha256=4qEnFkkRSHPKDU7AvYNkqXECjZO_K7PzDCK3HbsY7o4,902
+kiln_ai/adapters/adapter_registry.py,sha256=o7JhzL627W3WMvpztsI_D0pqLPXP-IgIf3e-o7DAVxE,3720
+kiln_ai/adapters/ml_model_list.py,sha256=IzxswO2zORd7bsovswvRpZMwIs1BZcMtPcnhLZ7xzkk,40969
+kiln_ai/adapters/ollama_tools.py,sha256=ZkiGCaocKTMsb1JoySupv9a1OQuE72CCuKsNpyp6jNU,3551
+kiln_ai/adapters/prompt_builders.py,sha256=LYHTIaisQMBFtWDRIGo1QJgOsmQ-NBpQ8fI4eImHxaQ,15269
+kiln_ai/adapters/provider_tools.py,sha256=CGNLW0xhFyj93HFwznCoDrrbyQbQAaS2mJuOKaMB6gU,14435
+kiln_ai/adapters/run_output.py,sha256=_WVNqJ9cQehgEJR3Jy5_Pp29QnurpmEf-S6UU6WAegE,271
+kiln_ai/adapters/test_adapter_registry.py,sha256=opowxLBWm0lZTPL9S4qEaOS8HB82dTpZeNuhpE_cNHU,6379
+kiln_ai/adapters/test_generate_docs.py,sha256=RQ5flkg4fbosj_fB3RiRZyXSqD_UtOHNBYJsne6UkzU,2782
+kiln_ai/adapters/test_ollama_tools.py,sha256=xAUzL0IVmmXadVehJu1WjqbhpKEYGAgGt3pWx7hrubc,2514
+kiln_ai/adapters/test_prompt_adaptors.py,sha256=CKyToDKS4v-tQO9pq4tiq_ypnY4ePhY9yrRAtG-58p0,7516
+kiln_ai/adapters/test_prompt_builders.py,sha256=5Xvfr-oQg_LLrle6UqfpRHWcPUYa8ywG3aL1rM7q1Jw,22054
+kiln_ai/adapters/test_provider_tools.py,sha256=DtnC6oFuiBvvbhD-kdCcWzEYqXZfMBM_DexuQdyAVR8,28664
+kiln_ai/adapters/data_gen/__init__.py,sha256=QTZWaf7kq5BorhPvexJfwDEKmjRmIbhwW9ei8LW2SIs,276
+kiln_ai/adapters/data_gen/data_gen_prompts.py,sha256=kudjHnAz7L3q0k_NLyTlaIV7M0uRFrxXNcfcnjOE2uc,5810
+kiln_ai/adapters/data_gen/data_gen_task.py,sha256=0PuYCcj09BtpgNj23mKj_L45mKZBdV5VreUeZ-Tj_xM,6642
+kiln_ai/adapters/data_gen/test_data_gen_task.py,sha256=cRKUKMvC0uVompbmPTKwbnQ_N3c0cQDm4J_9H4Y5U18,10129
+kiln_ai/adapters/eval/base_eval.py,sha256=jVXMiVBC07ZnLEuZVAjUAYewsnuV99put39n_GZcG1M,7261
+kiln_ai/adapters/eval/eval_runner.py,sha256=A8GhVEt4J_p2-EZlN592blVxY0anKiMiLgac155pcfQ,10688
+kiln_ai/adapters/eval/g_eval.py,sha256=VXYZi-5WG8Go4E2shaOL4D3V2cL_c2zmEno2N1b2WPM,14295
+kiln_ai/adapters/eval/registry.py,sha256=gZ_s0VgEx79Fswkgi1tS4yOl7lzpkvUBJZ62RldhM_w,626
+kiln_ai/adapters/eval/test_base_eval.py,sha256=AGq09bziZm9zh_37PP59AzpkWW7hQU1o7vHSiDsObhY,10723
+kiln_ai/adapters/eval/test_eval_runner.py,sha256=58jRE_2qHZmsDlMj41DrbgE8w9PKC9wwAT-vbi_R4Ec,18567
+kiln_ai/adapters/eval/test_g_eval.py,sha256=wcR56b3vSKn88JeCCQz92p8TMgZlgSP1ged_XlFrYlg,16162
+kiln_ai/adapters/eval/test_g_eval_data.py,sha256=8caiZfLWnXVX8alrBPrH7L7gqqSS9vO7u6PzcHurQcA,27769
+kiln_ai/adapters/fine_tune/__init__.py,sha256=DxdTR60chwgck1aEoVYWyfWi6Ed2ZkdJj0lar-SEAj4,257
+kiln_ai/adapters/fine_tune/base_finetune.py,sha256=n3mfE_3bhhzmN_MQxO5qNezN-qpl4WFamZ3ih41dx4o,6069
+kiln_ai/adapters/fine_tune/dataset_formatter.py,sha256=qRhSSkMhTWn13OMb6LKPVwAU7uY4bB49GDiVSuhDkNg,14449
+kiln_ai/adapters/fine_tune/finetune_registry.py,sha256=H1B-opCTlIyd9JlIFTKsY_ctxUX9ziEc49_gnmg1SZg,483
+kiln_ai/adapters/fine_tune/fireworks_finetune.py,sha256=6IfTDn_8tg6PR0OFudRx6V7Wjvf4P7t0fm_xyRwII68,13978
+kiln_ai/adapters/fine_tune/openai_finetune.py,sha256=Dz9E_0BWfrIkvv8ArZe-RKPwbIKPZ3v8rfbc3JELyTY,8571
+kiln_ai/adapters/fine_tune/test_base_finetune.py,sha256=0zWxFYrDGVuoQNQmi9vVUEkBc4mstfHnsUjQmiJA-sE,10864
+kiln_ai/adapters/fine_tune/test_dataset_formatter.py,sha256=T3jbFZooLVBaGCE0LUVxwPxzM3l8IY41zUj3jPk-Zi8,24027
+kiln_ai/adapters/fine_tune/test_fireworks_tinetune.py,sha256=e88z5-KtU9Y7frXqCVy6r6iE6S-tInn5oMOqmSnbR2I,18144
+kiln_ai/adapters/fine_tune/test_openai_finetune.py,sha256=H63Xk2PNHbt5Ev5IQpdR9JZ4uz-Huo2gfuC4mHHqe0w,20011
+kiln_ai/adapters/model_adapters/__init__.py,sha256=FyNq-twr1zQR55Hd_sDlTcVZ8JsZ9jrIBBURtZNjlss,272
+kiln_ai/adapters/model_adapters/base_adapter.py,sha256=tY67FJlWzYY-Ha1FyBMes3KacklFfTSqvU6-crILQsc,9597
+kiln_ai/adapters/model_adapters/langchain_adapters.py,sha256=LVggQGeg_fIol1uYo375JHmjh7pwDhCACVe1K7lh28Y,12996
+kiln_ai/adapters/model_adapters/openai_compatible_config.py,sha256=oxiUUESM9f5EVMePDSJI7s6YaMmmBkFMCEdxA50mwgw,241
+kiln_ai/adapters/model_adapters/openai_model_adapter.py,sha256=KuCPFuNZ5aZwymLL8k87PNjUVOs9JyR91W7VKtw9yN8,11438
+kiln_ai/adapters/model_adapters/test_base_adapter.py,sha256=uQyKrHLN3Jha6R-6SWkEME6brQecVFdPTSXogo-xpt0,6556
+kiln_ai/adapters/model_adapters/test_langchain_adapter.py,sha256=PArWTKytzUoM9Lc9Q0bEOcvZDNTF2SzfR9ln8sf0Hzg,11884
+kiln_ai/adapters/model_adapters/test_openai_model_adapter.py,sha256=CV6a3Sf3f3szpk1MLBoAjcuL5B5-4n86j8tMlEA-Bhg,6844
+kiln_ai/adapters/model_adapters/test_saving_adapter_results.py,sha256=1XFQQxdSIbqSoQEdxHOYJcY0cMb59qpTDPOmL9bW4B8,7870
+kiln_ai/adapters/model_adapters/test_structured_output.py,sha256=7N5xniBWXDxwb4gvV8k0bbrlTir2kWBE6Q_z2azBJvs,11865
+kiln_ai/adapters/parsers/__init__.py,sha256=TGJS_8JhjUwg5Bnq4cDmwt5eIRo4vowmcL2A72L1Hzk,202
+kiln_ai/adapters/parsers/base_parser.py,sha256=DaoZVEOOuFTMZd5ZTpl_as6-xc9NPWGP2fAmP12J58M,389
+kiln_ai/adapters/parsers/json_parser.py,sha256=IszrBrhIFrrVr76UZsuejkBdqpZG27mU72264HVgVzE,1274
+kiln_ai/adapters/parsers/parser_registry.py,sha256=G9bAZrnWrR0a82JAQHsSqA2o7-CjrZUBANZljY_6ZxE,623
+kiln_ai/adapters/parsers/r1_parser.py,sha256=9nMEWDAbRSTFuu_--0HMVfVg9IYSoUNQHHw9OxETlRw,2558
+kiln_ai/adapters/parsers/test_json_parser.py,sha256=9kdWe_vRC5wjP8A1Ym6Zu6enDIz4ARCNiRpcZr7_3ak,1971
+kiln_ai/adapters/parsers/test_parser_registry.py,sha256=S4MdX7cnhCbmeKq8tZwMwRdGWr-019Z-fw5zey9Wm08,1043
+kiln_ai/adapters/parsers/test_r1_parser.py,sha256=Ys1ICRNVgt54rf8IEKNav5sz9zHYvvcVAUuoSwwftg8,4517
+kiln_ai/adapters/repair/__init__.py,sha256=dOO9MEpEhjiwzDVFg3MNfA2bKMPlax9iekDatpTkX8E,217
+kiln_ai/adapters/repair/repair_task.py,sha256=iW0bHWQq6Tir6ULTATWFS0zpwNji8Tbwhm2lZu52RsM,3342
+kiln_ai/adapters/repair/test_repair_task.py,sha256=iY7h-o-hnB0zwlkX--WuQlCsd5sKbhksS0hIIPCxt7E,7944
+kiln_ai/datamodel/__init__.py,sha256=GbRfDrdSq9d_-HxzmFIicTmLO3qz-O3XGvSwDPh3XCk,1957
+kiln_ai/datamodel/basemodel.py,sha256=TwMBfNFJ7-5bp2QOoTQUl_YVrF0pkDAk5Rdk6EWEXxI,22143
+kiln_ai/datamodel/datamodel_enums.py,sha256=w8aJeuLWdrH6ZCZ0y2-o0IOmXcl7qXpOMHyrHHoJmkA,2040
+kiln_ai/datamodel/dataset_filters.py,sha256=hWKxGJ-mSl4y0igyNcpmRoRYCiGrf0_uN4MMU9Fe_ng,3180
+kiln_ai/datamodel/dataset_split.py,sha256=q4l4SlUvjLV547bzk7Z-fbmj_o26GDcYOZ2rA5RPh3c,5612
+kiln_ai/datamodel/eval.py,sha256=kio2LqQ87MsP75DJTiIVdVfopTZXH4xjGN9g11V1mUU,13826
+kiln_ai/datamodel/finetune.py,sha256=TYoNVRAfbjqvrY-1YmHwG6xSoDljiJWuuVcTbvQAJL4,4569
+kiln_ai/datamodel/json_schema.py,sha256=sjc2LkbWWFhlqX5QOvLeWrovkmoX_tn3iQquxKDA8Pk,2990
+kiln_ai/datamodel/model_cache.py,sha256=9X4aAigbkFdytckgw8InCMh86uBna0ME_1HJSeMPEn0,4495
+kiln_ai/datamodel/project.py,sha256=uVH2_3TDFtsG_tpts81A-zbd9uPDFxAwMCKZt_km3IE,727
+kiln_ai/datamodel/prompt.py,sha256=70JPYHfgyX18cHW_DXoMzIOA28Jbaz6gyabElmpycyc,1161
+kiln_ai/datamodel/prompt_id.py,sha256=eU2TV0RZapn-BgnZ4sOSNOOVEQ3aPaLzW4YSYCd3OBo,2531
+kiln_ai/datamodel/registry.py,sha256=XwGFXJFKZtOpR1Z9ven6SftggfADdZRm8TFxCEVtfUQ,957
+kiln_ai/datamodel/strict_mode.py,sha256=sm4Xka8mnJHCShtbh6MMU5dDQv-cLj8lHgHkmFKpsl0,849
+kiln_ai/datamodel/task.py,sha256=r-_zgrQCIiIkN8gvBISdU449Z9oKp7E1XL0lkik_rVI,7036
+kiln_ai/datamodel/task_output.py,sha256=0h4QvzV-hksE_AGHWsUHbYf5F95Zn7uU7WFbeIbAEck,12507
+kiln_ai/datamodel/task_run.py,sha256=yquE0jyr_9WzcvrMsEmZfXUnn8zZDEZIXZhVcVBMrT8,7038
+kiln_ai/datamodel/test_basemodel.py,sha256=KJLJf0stuQq4ksOtoPM_w1VQrGz2FGdOT6cdrMkib9s,17750
+kiln_ai/datamodel/test_dataset_filters.py,sha256=v88QPkIsq4diUmoUF3-qj5KAW2rLRp0KDAm_pexbFy4,1894
+kiln_ai/datamodel/test_dataset_split.py,sha256=5CHO1Lq4xQBB72tV2SPER7OZODJNvj15qxi_cYBV2Rs,11157
+kiln_ai/datamodel/test_datasource.py,sha256=Pzh1l20__xObgdBaIMNJarG-jwmEsujRFkRmUBLuK0g,3220
+kiln_ai/datamodel/test_eval_model.py,sha256=J7MqwWBgPpeXGqh3IacVUUHdZFJSZ2MgTsUNu-hNOJw,19528
+kiln_ai/datamodel/test_example_models.py,sha256=fpqh0u7zFhWHcRHgtxCjX8RD2oKHYOP_mJJymaUhEZU,20944
+kiln_ai/datamodel/test_json_schema.py,sha256=UgKwAFcdrJTq2byh7Yf-HoSAtiHiGAsNZxfkIvoMxIg,3915
+kiln_ai/datamodel/test_model_cache.py,sha256=Fy-ucYNzS5JEG-8SFY4nVHA8iRbXXxai20f8_oGl97o,8184
+kiln_ai/datamodel/test_model_perf.py,sha256=NdD7L8XraGkunaEKGPsfYwdcbIgdjhFanOO3G6hU158,3235
+kiln_ai/datamodel/test_models.py,sha256=hmV7sTbOamWJCwOY96w-g4PQRv4Uai-XaHtg0QKH-ak,19295
+kiln_ai/datamodel/test_nested_save.py,sha256=xciCddqvPyKyoyjC5Lx_3Kh1t4LJv1xYRAPazR3SRcs,5588
+kiln_ai/datamodel/test_output_rating.py,sha256=zvPIp2shAgCs2RQBgwYoL09fRA3krHvgAqUa91RlWR0,15125
+kiln_ai/datamodel/test_prompt_id.py,sha256=ihyXVPQi0dSLGnBM7rTXRnVaiWXhh7HJmSy4nZZKmso,4225
+kiln_ai/datamodel/test_registry.py,sha256=PhS4anLi5Bf_023obuTlO5DALhtPB8WIc_bX12Yg6Po,2705
+kiln_ai/datamodel/test_task.py,sha256=FYyoEqJXQIy8rcBsLTdki4-1z9COnZQk1-aoS3ZoNuU,5307
+kiln_ai/utils/__init__.py,sha256=PTD0MwBCKAMIOGsTAwsFaJOusTJJoRFTfOGqRvCaU-E,142
+kiln_ai/utils/config.py,sha256=9navMS2ooSviz74Bq8raf5-01DFfDf9SSVfpasIIPlo,6993
+kiln_ai/utils/exhaustive_error.py,sha256=TkkRixIAR3CPEKHeAJzyv0mtxp6BxUBKMvobA3vzQug,262
+kiln_ai/utils/formatting.py,sha256=VtB9oag0lOGv17dwT7OPX_3HzBfaU9GsLH-iLete0yM,97
+kiln_ai/utils/name_generator.py,sha256=v26TgpCwQbhQFcZvzgjZvURinjrOyyFhxpsI6NQrHKc,1914
+kiln_ai/utils/test_config.py,sha256=Jw3nMFeIgZUsZDRJJY2HpB-2EkR2NoZ-rDe_o9oA7ws,9174
+kiln_ai/utils/test_name_geneator.py,sha256=9-hSTBshyakqlPbFnNcggwLrL7lcPTitauBYHg9jFWI,1513
+kiln_ai-0.12.0.dist-info/METADATA,sha256=CnOHwkyknO0XqFIRL65XVEQl_375cHnvMneIy8J3PWE,10656
+kiln_ai-0.12.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kiln_ai-0.12.0.dist-info/licenses/LICENSE.txt,sha256=_NA5pnTYgRRr4qH6lE3X-TuZJ8iRcMUi5ASoGr-lEx8,1209
+kiln_ai-0.12.0.dist-info/RECORD,,