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

kiln_ai/datamodel/test_dataset_split.py

@@ -5,6 +5,7 @@ from pydantic import ValidationError
 from kiln_ai.datamodel import (
     AllDatasetFilter,
     AllSplitDefinition,
+    DatasetFilterType,
     DatasetSplit,
     DatasetSplitDefinition,
     DataSource,
@@ -15,6 +16,8 @@ from kiln_ai.datamodel import (
     TaskOutputRating,
     TaskOutputRatingType,
     TaskRun,
+    ThinkingModelDatasetFilter,
+    ThinkingModelHighRatedFilter,
     Train60Test20Val20SplitDefinition,
     Train80Test20SplitDefinition,
 )
@@ -131,10 +134,33 @@ def test_all_dataset_filter(task_run):
 
 
 def test_high_rating_dataset_filter(sample_task_runs):
+    num_high_quality = 0
+    num_low_quality = 0
     for task_run in sample_task_runs:
-        assert HighRatingDatasetFilter(task_run) is (
-            task_run.output.rating.is_high_quality()
+        if HighRatingDatasetFilter(task_run):
+            num_high_quality += 1
+            assert task_run.output.rating.is_high_quality() is True
+        else:
+            num_low_quality += 1
+            assert task_run.output.rating.is_high_quality() is False
+
+        # Test repaired output always considered high quality
+        task_run = task_run.model_copy(
+            update={
+                "repair_instructions": "repair instructions",
+                "repaired_output": TaskOutput(
+                    output="repaired output",
+                    source=DataSource(
+                        type=DataSourceType.human,
+                        properties={"created_by": "test-user"},
+                    ),
+                ),
+            }
         )
+        assert HighRatingDatasetFilter(task_run) is True
+
+    assert num_high_quality == 6
+    assert num_low_quality == 4
 
 
 @pytest.mark.parametrize(
@@ -173,9 +199,11 @@ def test_dataset_split_with_high_rating_filter(sample_task, sample_task_runs):
         "Split Name",
         sample_task,
         Train80Test20SplitDefinition,
-        filter=HighRatingDatasetFilter,
+        filter_type=DatasetFilterType.HIGH_RATING,
     )
 
+    assert dataset.filter == DatasetFilterType.HIGH_RATING
+
     # Check that only high-rated task runs are included
     all_ids = []
     for ids in dataset.split_contents.values():
@@ -232,3 +260,72 @@ def test_smaller_sample(sample_task, sample_task_runs):
 
     # Now we should have 0 missing runs. It's okay that dataset has newer data.
     assert dataset.missing_count() == 0
+
+
+@pytest.mark.parametrize(
+    "thinking_data,expected_result",
+    [
+        ({"reasoning": "Here's my answer"}, True),
+        ({"chain_of_thought": "Here's my answer"}, True),
+        ({"unknown": "Here's my answer"}, False),
+        ({}, False),
+        (None, False),
+    ],
+)
+def test_thinking_model_dataset_filter(
+    sample_task_runs, thinking_data, expected_result
+):
+    # Create a task run with thinking output
+    task_run = sample_task_runs[0].model_copy(
+        update={
+            "output": TaskOutput(
+                output="Let me think about this...\nHere's my answer",
+                source=DataSource(
+                    type=DataSourceType.human,
+                    properties={"created_by": "test-user"},
+                ),
+                rating=TaskOutputRating(value=5, type=TaskOutputRatingType.five_star),
+            ),
+            "intermediate_outputs": thinking_data,
+        }
+    )
+
+    assert ThinkingModelDatasetFilter(task_run) is expected_result
+
+
+@pytest.mark.parametrize(
+    "thinking_data,rating,expected_result",
+    [
+        ({"reasoning": "Here's my answer"}, 5, True),
+        ({"chain_of_thought": "Here's my answer"}, 5, True),
+        ({"unknown": "Here's my answer"}, 5, False),
+        ({}, 5, False),
+        (None, 5, False),
+        ({"reasoning": "Here's my answer"}, 1, False),
+        ({"chain_of_thought": "Here's my answer"}, 1, False),
+        ({"unknown": "Here's my answer"}, 1, False),
+        ({}, 1, False),
+        (None, 1, False),
+    ],
+)
+def test_thinking_model_dataset_filter_high_rated(
+    sample_task_runs, thinking_data, rating, expected_result
+):
+    # Create a task run with thinking output
+    task_run = sample_task_runs[0].model_copy(
+        update={
+            "output": TaskOutput(
+                output="Let me think about this...\nHere's my answer",
+                source=DataSource(
+                    type=DataSourceType.human,
+                    properties={"created_by": "test-user"},
+                ),
+                rating=TaskOutputRating(
+                    value=rating, type=TaskOutputRatingType.five_star
+                ),
+            ),
+            "intermediate_outputs": thinking_data,
+        }
+    )
+
+    assert ThinkingModelHighRatedFilter(task_run) is expected_result

kiln_ai/datamodel/test_example_models.py

@@ -284,6 +284,9 @@ def test_task_output_requirement_rating_keys(tmp_path):
     assert task_run.output.rating.requirement_ratings is not None
 
 
+_schema_match = "This task requires a specific output schema. While the model produced JSON, that JSON didn't meet the schema."
+
+
 def test_task_output_schema_validation(tmp_path):
     # Create a project, task, and example hierarchy
     project = Project(name="Test Project", path=(tmp_path / "test_project"))
@@ -321,12 +324,24 @@ def test_task_output_schema_validation(tmp_path):
     task_output.save_to_file()
 
     # changing to invalid output
-    with pytest.raises(ValueError, match="does not match task output schema"):
+    with pytest.raises(
+        ValueError,
+        match=_schema_match,
+    ):
         task_output.output.output = '{"name": "John Doe", "age": "thirty"}'
         task_output.save_to_file()
 
+    # changing to invalid output from loaded model
+    loaded_task_output = TaskRun.load_from_file(task_output.path)
+    with pytest.raises(
+        ValueError,
+        match=_schema_match,
+    ):
+        loaded_task_output.output.output = '{"name": "John Doe", "age": "forty"}'
+        loaded_task_output.save_to_file()
+
     # Invalid case: output does not match task output schema
-    with pytest.raises(ValueError, match="does not match task output schema"):
+    with pytest.raises(ValueError, match=_schema_match):
         task_output = TaskRun(
             input="Test input",
             input_source=DataSource(
@@ -382,12 +397,18 @@ def test_task_input_schema_validation(tmp_path):
     valid_task_output.save_to_file()
 
     # Changing to invalid input
-    with pytest.raises(ValueError, match="does not match task input schema"):
+    with pytest.raises(ValueError, match=_schema_match):
         valid_task_output.input = '{"name": "John Doe", "age": "thirty"}'
         valid_task_output.save_to_file()
 
+    # loading from file, then changing to invalid input
+    loaded_task_output = TaskRun.load_from_file(valid_task_output.path)
+    with pytest.raises(ValueError, match=_schema_match):
+        loaded_task_output.input = '{"name": "John Doe", "age": "thirty"}'
+        loaded_task_output.save_to_file()
+
     # Invalid case: input does not match task input schema
-    with pytest.raises(ValueError, match="does not match task input schema"):
+    with pytest.raises(ValueError, match=_schema_match):
         task_output = TaskRun(
             input='{"name": "John Doe", "age": "thirty"}',
             input_source=DataSource(

kiln_ai/datamodel/test_model_cache.py

@@ -242,3 +242,27 @@ def test_check_timestamp_granularity_linux_error():
         cache = ModelCache()
         assert cache._check_timestamp_granularity() is False
         assert cache._enabled is False
+
+
+def test_get_model_readonly(model_cache, test_path):
+    if not model_cache._enabled:
+        pytest.skip("Cache is disabled on this fs")
+
+    model = ModelTest(name="test", value=123)
+    mtime_ns = test_path.stat().st_mtime_ns
+
+    # Set the model in the cache
+    model_cache.set_model(test_path, model, mtime_ns)
+
+    # Get the model in readonly mode
+    readonly_model = model_cache.get_model(test_path, ModelTest, readonly=True)
+    # Get a regular (copied) model
+    copied_model = model_cache.get_model(test_path, ModelTest)
+
+    # The readonly model should be the exact same instance as the cached model
+    assert readonly_model is model_cache.model_cache[test_path][0]
+    # While the regular get should be a different instance
+    assert copied_model is not model_cache.model_cache[test_path][0]
+
+    # Both should have the same data
+    assert readonly_model == copied_model == model

kiln_ai/datamodel/test_model_perf.py

@@ -0,0 +1,125 @@
+import shutil
+import uuid
+
+import pytest
+
+from kiln_ai.datamodel import (
+    DataSource,
+    DataSourceType,
+    Project,
+    Task,
+    TaskOutput,
+    TaskRun,
+)
+
+test_json_schema = """{
+  "type": "object",
+  "properties": {
+    "setup": {
+      "description": "The setup of the joke",
+      "title": "Setup",
+      "type": "string"
+    },
+    "punchline": {
+      "description": "The punchline to the joke",
+      "title": "Punchline",
+      "type": "string"
+    },
+    "rating": {
+      "anyOf": [
+        {
+          "type": "integer"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null,
+      "description": "How funny the joke is, from 1 to 10",
+      "title": "Rating"
+    }
+  },
+  "required": [
+    "setup",
+    "punchline"
+  ]
+}
+"""
+
+
+@pytest.fixture
+def task_run(tmp_path):
+    # setup a valid project/task/task_run for testing
+    output_source = DataSource(
+        type=DataSourceType.synthetic,
+        properties={
+            "model_name": "test-model",
+            "model_provider": "test-provider",
+            "adapter_name": "test-adapter",
+        },
+    )
+
+    project_path = tmp_path / "project.kiln"
+    project = Project(name="Test Project", path=project_path)
+    project.save_to_file()
+    task = Task(
+        name="Test Task",
+        instruction="Test Instruction",
+        parent=project,
+        output_json_schema=test_json_schema,
+        input_json_schema=test_json_schema,
+    )
+
+    task.save_to_file()
+
+    task_output = TaskOutput(
+        output='{"setup": "Why did the chicken cross the road?", "punchline": "To get to the other side"}',
+        source=DataSource(
+            type=DataSourceType.synthetic,
+            properties={
+                "model_name": "test-model",
+                "model_provider": "test-provider",
+                "adapter_name": "test-adapter",
+            },
+        ),
+    )
+
+    # Save for later usage
+    task_run = TaskRun(
+        input='{"setup": "Why did the chicken cross the road?", "punchline": "To get to the other side"}',
+        input_source=output_source,
+        output=task_output,
+    )
+    task_run.parent = task
+    task_run.save_to_file()
+
+    return task_run
+
+
+@pytest.mark.benchmark
+def test_benchmark_load_from_file(benchmark, task_run):
+    task_run_path = task_run.path
+
+    iterations = 500
+    total_time = 0
+
+    for _ in range(iterations):
+        # Copy the task to a new temp path, so we don't get warm loads/cached loads
+        temp_path = task_run.path.parent / f"temp_task_run_{uuid.uuid4()}.json"
+        shutil.copy(str(task_run_path), str(temp_path))
+
+        # only time loading the model (and one accessor for delayed validation)
+        start_time = benchmark._timer()
+        loaded = TaskRun.load_from_file(temp_path)
+        assert loaded.id == task_run.id
+        end_time = benchmark._timer()
+
+        total_time += end_time - start_time
+
+    avg_time_per_iteration = total_time / iterations
+    ops_per_second = 1.0 / avg_time_per_iteration
+
+    # I get 8k ops per second on my MBP. Lower value here for CI.
+    # Prior to optimization was 290 ops per second.
+    if ops_per_second < 1000:
+        pytest.fail(f"Ops per second: {ops_per_second:.6f}, expected more than 1k ops")

kiln_ai/datamodel/test_models.py

@@ -9,7 +9,9 @@ from kiln_ai.datamodel import (
     DataSource,
     DataSourceType,
     Finetune,
+    FinetuneDataStrategy,
     Project,
+    Prompt,
     Task,
     TaskOutput,
     TaskRun,
@@ -70,6 +72,20 @@ def test_save_to_file(test_project_file):
     assert data["description"] == "Test Description"
 
 
+def test_save_to_file_non_ascii(test_project_file):
+    project = Project(
+        name="Test Project", description="Chúc mừng!", path=test_project_file
+    )
+    project.save_to_file()
+
+    with open(test_project_file, "r", encoding="utf-8") as file:
+        data = json.load(file)
+
+    assert data["v"] == 1
+    assert data["name"] == "Test Project"
+    assert data["description"] == "Chúc mừng!"
+
+
 def test_task_defaults():
     task = Task(name="Test Task", instruction="Test Instruction")
     assert task.description is None
@@ -488,3 +504,116 @@ def test_task_run_tags_validation():
             tags=["valid_tag", "invalid tag"],
         )
     assert "Tags cannot contain spaces. Try underscores." in str(exc_info.value)
+
+
+def test_prompt_validation():
+    prompt = Prompt(name="Test Prompt Name", prompt="Test Prompt")
+    assert prompt.name == "Test Prompt Name"
+    assert prompt.prompt == "Test Prompt"
+
+    with pytest.raises(ValidationError):
+        Prompt(name="Test Prompt")
+
+    with pytest.raises(ValidationError):
+        Prompt(name="Test Prompt", prompt=None)
+
+    with pytest.raises(ValidationError):
+        Prompt(name="Test Prompt", prompt="")
+
+    with pytest.raises(ValidationError):
+        Prompt(prompt="Test Prompt")
+
+
+def test_prompt_parent_task():
+    task = Task(name="Test Task", instruction="Test Instruction")
+    prompt = Prompt(name="Test Prompt", prompt="Test Prompt", parent=task)
+    assert prompt.parent == task
+
+
+@pytest.mark.parametrize(
+    "thinking_instructions,data_strategy,should_raise,expected_message",
+    [
+        # Test 1: Valid case - no thinking instructions with final_only
+        (
+            None,
+            FinetuneDataStrategy.final_only,
+            False,
+            None,
+        ),
+        # Test 2: Valid case - thinking instructions with final_and_intermediate
+        (
+            "Think step by step",
+            FinetuneDataStrategy.final_and_intermediate,
+            False,
+            None,
+        ),
+        # Test 3: Invalid case - thinking instructions with final_only
+        (
+            "Think step by step",
+            FinetuneDataStrategy.final_only,
+            True,
+            "Thinking instructions can only be used when data_strategy is final_and_intermediate",
+        ),
+        # Test 4: Invalid case - no thinking instructions with final_and_intermediate
+        (
+            None,
+            FinetuneDataStrategy.final_and_intermediate,
+            True,
+            "Thinking instructions are required when data_strategy is final_and_intermediate",
+        ),
+    ],
+)
+def test_finetune_thinking_instructions_validation(
+    thinking_instructions, data_strategy, should_raise, expected_message
+):
+    base_params = {
+        "name": "test-finetune",
+        "provider": "openai",
+        "base_model_id": "gpt-3.5-turbo",
+        "dataset_split_id": "split1",
+        "system_message": "test message",
+        "data_strategy": data_strategy,
+    }
+
+    if thinking_instructions is not None:
+        base_params["thinking_instructions"] = thinking_instructions
+
+    if should_raise:
+        with pytest.raises(ValueError) as exc_info:
+            Finetune(**base_params)
+        assert expected_message in str(exc_info.value)
+    else:
+        finetune = Finetune(**base_params)
+        assert finetune.thinking_instructions == thinking_instructions
+        assert finetune.data_strategy == data_strategy
+
+
+@pytest.mark.parametrize(
+    "intermediate_outputs,expected",
+    [
+        # No intermediate outputs
+        (None, False),
+        # Empty intermediate outputs
+        ({}, False),
+        # Only chain_of_thought
+        ({"chain_of_thought": "thinking process"}, True),
+        # Only reasoning
+        ({"reasoning": "reasoning process"}, True),
+        # Both chain_of_thought and reasoning
+        (
+            {"chain_of_thought": "thinking process", "reasoning": "reasoning process"},
+            True,
+        ),
+        # Other intermediate outputs but no thinking data
+        ({"other_output": "some data"}, False),
+        # Mixed other outputs with thinking data
+        ({"chain_of_thought": "thinking process", "other_output": "some data"}, True),
+    ],
+)
+def test_task_run_has_thinking_training_data(intermediate_outputs, expected):
+    task_run = TaskRun(
+        input="test input",
+        output=TaskOutput(output="test output"),
+        intermediate_outputs=intermediate_outputs,
+    )
+    assert task_run.has_thinking_training_data() == expected

kiln_ai/utils/exhaustive_error.py

@@ -0,0 +1,6 @@
+from typing import NoReturn
+
+
+# Weird trick, but passing a enum to NoReturn triggers the type checker to complain unless all values are handled.
+def raise_exhaustive_enum_error(value: NoReturn) -> NoReturn:
+    raise ValueError(f"Unhandled enum value: {value}")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiln-ai
-Version: 0.8.0
+Version: 0.11.1
 Summary: Kiln AI
 Project-URL: Homepage, https://getkiln.ai
 Project-URL: Repository, https://github.com/Kiln-AI/kiln
@@ -19,8 +19,7 @@ Requires-Dist: jsonschema>=4.23.0
 Requires-Dist: langchain-aws>=0.2.4
 Requires-Dist: langchain-fireworks>=0.2.5
 Requires-Dist: langchain-groq>=0.2.0
-Requires-Dist: langchain-ollama>=0.2.0
-Requires-Dist: langchain-openai>=0.2.4
+Requires-Dist: langchain-ollama>=0.2.2
 Requires-Dist: langchain>=0.3.5
 Requires-Dist: openai>=1.53.0
 Requires-Dist: pdoc>=15.0.0
@@ -72,7 +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)
-- [Advanced Usage](#advanced-usage)
+- [Full API Reference](#full-api-reference)
 
 ## Installation
 
@@ -95,11 +94,14 @@ The Kiln Python library provides a set of Python classes that which help you eas
 
 ### Datamodel Overview
 
+Here's a high level overview of the Kiln datamodel. A project folder will reflect this nested structure:
+
 - Project: a Kiln Project that organizes related tasks
   - Task: a specific task including prompt instructions, input/output schemas, and requirements
     - TaskRun: a sample (run) of a task including input, output and human rating information
-    - DatasetSplit: a frozen collection of task runs divided into train/test/validation splits
     - Finetune: configuration and status tracking for fine-tuning models on task data
+    - Prompt: a prompt for this task
+    - DatasetSplit: a frozen collection of task runs divided into train/test/validation splits
 
 ### Load a Project
 
@@ -230,8 +232,8 @@ final_df = pd.concat(dfs, ignore_index=True)
 print(final_df)
 ```
 
-### Advanced Usage
+## Full API Reference
 
 The library can do a lot more than the examples we've shown here.
 
-See the [docs](https://kiln-ai.github.io/Kiln/kiln_core_docs/index.html) for more information.
+See the full API reference in the [docs](https://kiln-ai.github.io/Kiln/kiln_core_docs/index.html) under the `Submodules` section of the sidebar.

kiln_ai-0.11.1.dist-info/RECORD

@@ -0,0 +1,76 @@
+kiln_ai/__init__.py,sha256=Sc4z8LRVFMwJUoc_DPVUriSXTZ6PO9MaJ80PhRbKyB8,34
+kiln_ai/adapters/__init__.py,sha256=4qEnFkkRSHPKDU7AvYNkqXECjZO_K7PzDCK3HbsY7o4,902
+kiln_ai/adapters/adapter_registry.py,sha256=C4ayYVXRClj5-EEEpJEuMEMesbrJgPxz5yRBv6cyLGQ,3697
+kiln_ai/adapters/ml_model_list.py,sha256=4V6IinAhgYcGba3Kw3Ps2pJcHv5v7NC6Ob-8JN7fh3Y,36240
+kiln_ai/adapters/ollama_tools.py,sha256=0Of6ySbJ2d4j--9laOL6QKgRUQSrqX8dJUIrz20n59s,3561
+kiln_ai/adapters/prompt_builders.py,sha256=gnBf4SI_uz6W9gpkRaKOK9oHQX6eTjdSbKX-Tpaj2gQ,13906
+kiln_ai/adapters/provider_tools.py,sha256=CGNLW0xhFyj93HFwznCoDrrbyQbQAaS2mJuOKaMB6gU,14435
+kiln_ai/adapters/run_output.py,sha256=jANUFb_O_P47aWyA_YjLSl2y0Z7QFWPEUsOGE54BGY4,159
+kiln_ai/adapters/test_adapter_registry.py,sha256=obzcaifFLbgcokJwOCrhBe3IU-U3v4rPVBZya7p_hUM,6209
+kiln_ai/adapters/test_generate_docs.py,sha256=a0eO4fJdHhmvhB7aM3FW4nPYw-fqy1s5B6ZVDPRZtpQ,2730
+kiln_ai/adapters/test_ollama_tools.py,sha256=2KwYVaj3ySV3ld-z51TCGbJEMdb3MZj2eoEicIWz3Q4,2552
+kiln_ai/adapters/test_prompt_adaptors.py,sha256=Z-eGy206sDDXhsfngUOuYEUnaerPDOrQb64hipRxfW4,7550
+kiln_ai/adapters/test_prompt_builders.py,sha256=I6d888fIFDYzIp8DbnDWCrbRj8nlieLVrgiZzgqMV0s,20200
+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=0v7ufvuSeY5j-HerfrqXuCo30SYlS6EFIiVyiJM9xj0,5986
+kiln_ai/adapters/data_gen/test_data_gen_task.py,sha256=cRKUKMvC0uVompbmPTKwbnQ_N3c0cQDm4J_9H4Y5U18,10129
+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=wknJZDgkoj61O1TO5_HLTSdKZjvb78pmTyBRUBfCtYw,23968
+kiln_ai/adapters/fine_tune/test_fireworks_tinetune.py,sha256=qQCBUa6kje0P83vH7MWioVQ7IVPti_TFdJG_QaBwqjY,18105
+kiln_ai/adapters/fine_tune/test_openai_finetune.py,sha256=-QHKNr5LICTOoCDavGxAUnWoAWvL3eMWHywpMf69n1U,19972
+kiln_ai/adapters/model_adapters/__init__.py,sha256=FyNq-twr1zQR55Hd_sDlTcVZ8JsZ9jrIBBURtZNjlss,272
+kiln_ai/adapters/model_adapters/base_adapter.py,sha256=f91QR2mmn3x6bTfRFbgWe6N47aIB8ABpQjgv8Scru5Y,9183
+kiln_ai/adapters/model_adapters/langchain_adapters.py,sha256=JCCaXSFgtiNkr67tv4DRZRdmxGvq2JOkrQdC7H__ybw,12606
+kiln_ai/adapters/model_adapters/openai_compatible_config.py,sha256=o7Ae2uWm1bdqOZaSBbsjH1CH9bnSa1woqTHvP8ds0mY,286
+kiln_ai/adapters/model_adapters/openai_model_adapter.py,sha256=nSr_IcubCB7Dk6zkXsjvLrTAvnTedvHpXPZekiYK_cg,9545
+kiln_ai/adapters/model_adapters/test_base_adapter.py,sha256=rRN76HPepuXKmAEzZCJjK_cHZ6rJBLQ2poYpWOpxOaE,6408
+kiln_ai/adapters/model_adapters/test_langchain_adapter.py,sha256=UyQ-jdTFUpXHTO40nxHELIsV_YRA_RgF1xkAJ5oO-dM,12156
+kiln_ai/adapters/model_adapters/test_openai_model_adapter.py,sha256=3pSLHug_GPRpv5C9zE_hivOsbWgs5nLohS6DxtPz1jo,6914
+kiln_ai/adapters/model_adapters/test_saving_adapter_results.py,sha256=iIjI4Ox3wUpv6g1dcQ3zDFpma0MUqljJ_Lqbo8MbQuw,7393
+kiln_ai/adapters/model_adapters/test_structured_output.py,sha256=BipXAzkoKZuixwG2tPyqle9INuYd3teHDP12arncaXA,11871
+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=xX7GI3QZ9OEWV1BGr6OAAAFvHu3h6dYqJgOpqwRADmI,3842
+kiln_ai/adapters/repair/test_repair_task.py,sha256=2pxEwnmJCN_z35_kTNiaFSvnTw_njRinmHV1P9Y7UQw,7974
+kiln_ai/datamodel/__init__.py,sha256=aWGqXz4H-NGDFGBHcnArUVj3o-WgJsRACJ3QHF--8-k,36079
+kiln_ai/datamodel/basemodel.py,sha256=TwMBfNFJ7-5bp2QOoTQUl_YVrF0pkDAk5Rdk6EWEXxI,22143
+kiln_ai/datamodel/json_schema.py,sha256=VjjYkzy8X-QZqOQNZH6x7KitrtdcmZNttVP49iqBJAk,2817
+kiln_ai/datamodel/model_cache.py,sha256=9X4aAigbkFdytckgw8InCMh86uBna0ME_1HJSeMPEn0,4495
+kiln_ai/datamodel/registry.py,sha256=XwGFXJFKZtOpR1Z9ven6SftggfADdZRm8TFxCEVtfUQ,957
+kiln_ai/datamodel/test_basemodel.py,sha256=PqBlx5gIN3DxYjDuLzmNYIp-VwMvOQ9P5hOjPfOs-9g,17813
+kiln_ai/datamodel/test_dataset_split.py,sha256=7DXu3WaIGZ4Tyj0ahgrK7jRChDwU1eolXEdz4urkWNc,10530
+kiln_ai/datamodel/test_datasource.py,sha256=GAiZz31qezVVPwFqnt8wHMu15WvtlV89jw8C1Ue6YNI,3165
+kiln_ai/datamodel/test_example_models.py,sha256=ekAxweFBtkryheBFJMQvy0TkWvjNtlqBsJv3Pcu5uNE,21048
+kiln_ai/datamodel/test_json_schema.py,sha256=vdLnTQxxrcmuSrf6iOmkrmpfh7JnxqIw4B4dbDAAcZ4,3199
+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=s3zjlnN3zbSjPyLfz3PDABO8msKeQXDRd4WrpkLWrOE,19274
+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_registry.py,sha256=PhS4anLi5Bf_023obuTlO5DALhtPB8WIc_bX12Yg6Po,2705
+kiln_ai/utils/__init__.py,sha256=PTD0MwBCKAMIOGsTAwsFaJOusTJJoRFTfOGqRvCaU-E,142
+kiln_ai/utils/config.py,sha256=u289b2AHuQoPup_vILTSpgsO29fxJyU8zy8BwADAtvs,6859
+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.11.1.dist-info/METADATA,sha256=Dvlb27BCuxsJOpZHogOzrnlCYiL6FBLFCtCxu3gmee8,9217
+kiln_ai-0.11.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kiln_ai-0.11.1.dist-info/licenses/LICENSE.txt,sha256=_NA5pnTYgRRr4qH6lE3X-TuZJ8iRcMUi5ASoGr-lEx8,1209
+kiln_ai-0.11.1.dist-info/RECORD,,