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

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/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.1.dist-info → kiln_ai-0.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiln-ai
-Version: 0.8.1
+Version: 0.12.0
 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,8 @@ 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)
+  - [Building and Running a Kiln Task from Code](#building-and-running-a-kiln-task-from-code)
+- [Full API Reference](#full-api-reference)
 
 ## Installation
 
@@ -95,11 +95,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 +233,43 @@ final_df = pd.concat(dfs, ignore_index=True)
 print(final_df)
 ```
 
-### Advanced Usage
+### 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.
 
-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.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,,

kiln_ai/adapters/base_adapter.py

@@ -1,191 +0,0 @@
-import json
-from abc import ABCMeta, abstractmethod
-from dataclasses import dataclass
-from typing import Dict
-
-from kiln_ai.datamodel import (
-    DataSource,
-    DataSourceType,
-    Task,
-    TaskOutput,
-    TaskRun,
-)
-from kiln_ai.datamodel.json_schema import validate_schema
-from kiln_ai.utils.config import Config
-
-from .prompt_builders import BasePromptBuilder, SimplePromptBuilder
-
-
-@dataclass
-class AdapterInfo:
-    adapter_name: str
-    model_name: str
-    model_provider: str
-    prompt_builder_name: str
-
-
-@dataclass
-class RunOutput:
-    output: Dict | str
-    intermediate_outputs: Dict[str, str] | None
-
-
-class BaseAdapter(metaclass=ABCMeta):
-    """Base class for AI model adapters that handle task execution.
-
-    This abstract class provides the foundation for implementing model-specific adapters
-    that can process tasks with structured or unstructured inputs/outputs. It handles
-    input/output validation, prompt building, and run tracking.
-
-    Attributes:
-        prompt_builder (BasePromptBuilder): Builder for constructing prompts for the model
-        kiln_task (Task): The task configuration and metadata
-        output_schema (dict | None): JSON schema for validating structured outputs
-        input_schema (dict | None): JSON schema for validating structured inputs
-    """
-
-    def __init__(
-        self,
-        kiln_task: Task,
-        prompt_builder: BasePromptBuilder | None = None,
-        tags: list[str] | None = None,
-    ):
-        self.prompt_builder = prompt_builder or SimplePromptBuilder(kiln_task)
-        self.kiln_task = kiln_task
-        self.output_schema = self.kiln_task.output_json_schema
-        self.input_schema = self.kiln_task.input_json_schema
-        self.default_tags = tags
-
-    async def invoke_returning_raw(
-        self,
-        input: Dict | str,
-        input_source: DataSource | None = None,
-    ) -> Dict | str:
-        result = await self.invoke(input, input_source)
-        if self.kiln_task.output_json_schema is None:
-            return result.output.output
-        else:
-            return json.loads(result.output.output)
-
-    async def invoke(
-        self,
-        input: Dict | str,
-        input_source: DataSource | None = None,
-    ) -> TaskRun:
-        # validate input
-        if self.input_schema is not None:
-            if not isinstance(input, dict):
-                raise ValueError(f"structured input is not a dict: {input}")
-            validate_schema(input, self.input_schema)
-
-        # Run
-        run_output = await self._run(input)
-
-        # validate output
-        if self.output_schema is not None:
-            if not isinstance(run_output.output, dict):
-                raise RuntimeError(
-                    f"structured response is not a dict: {run_output.output}"
-                )
-            validate_schema(run_output.output, self.output_schema)
-        else:
-            if not isinstance(run_output.output, str):
-                raise RuntimeError(
-                    f"response is not a string for non-structured task: {run_output.output}"
-                )
-
-        # Generate the run and output
-        run = self.generate_run(input, input_source, run_output)
-
-        # Save the run if configured to do so, and we have a path to save to
-        if Config.shared().autosave_runs and self.kiln_task.path is not None:
-            run.save_to_file()
-        else:
-            # Clear the ID to indicate it's not persisted
-            run.id = None
-
-        return run
-
-    def has_structured_output(self) -> bool:
-        return self.output_schema is not None
-
-    @abstractmethod
-    def adapter_info(self) -> AdapterInfo:
-        pass
-
-    @abstractmethod
-    async def _run(self, input: Dict | str) -> RunOutput:
-        pass
-
-    def build_prompt(self) -> str:
-        return self.prompt_builder.build_prompt()
-
-    # create a run and task output
-    def generate_run(
-        self, input: Dict | str, input_source: DataSource | None, run_output: RunOutput
-    ) -> TaskRun:
-        # Convert input and output to JSON strings if they are dictionaries
-        input_str = json.dumps(input) if isinstance(input, dict) else input
-        output_str = (
-            json.dumps(run_output.output)
-            if isinstance(run_output.output, dict)
-            else run_output.output
-        )
-
-        # If no input source is provided, use the human data source
-        if input_source is None:
-            input_source = DataSource(
-                type=DataSourceType.human,
-                properties={"created_by": Config.shared().user_id},
-            )
-
-        new_task_run = TaskRun(
-            parent=self.kiln_task,
-            input=input_str,
-            input_source=input_source,
-            output=TaskOutput(
-                output=output_str,
-                # Synthetic since an adapter, not a human, is creating this
-                source=DataSource(
-                    type=DataSourceType.synthetic,
-                    properties=self._properties_for_task_output(),
-                ),
-            ),
-            intermediate_outputs=run_output.intermediate_outputs,
-            tags=self.default_tags or [],
-        )
-
-        exclude_fields = {
-            "id": True,
-            "created_at": True,
-            "updated_at": True,
-            "path": True,
-            "output": {"id": True, "created_at": True, "updated_at": True},
-        }
-        new_run_dump = new_task_run.model_dump(exclude=exclude_fields)
-
-        # Check if the same run already exists
-        existing_task_run = next(
-            (
-                task_run
-                for task_run in self.kiln_task.runs()
-                if task_run.model_dump(exclude=exclude_fields) == new_run_dump
-            ),
-            None,
-        )
-        if existing_task_run:
-            return existing_task_run
-
-        return new_task_run
-
-    def _properties_for_task_output(self) -> Dict[str, str | int | float]:
-        props = {}
-
-        # adapter info
-        adapter_info = self.adapter_info()
-        props["adapter_name"] = adapter_info.adapter_name
-        props["model_name"] = adapter_info.model_name
-        props["model_provider"] = adapter_info.model_provider
-        props["prompt_builder_name"] = adapter_info.prompt_builder_name
-
-        return props