kiln-ai 0.18.0__py3-none-any.whl → 0.19.0__py3-none-any.whl

kiln_ai/adapters/test_remote_config.py

@@ -1,12 +1,22 @@
 import asyncio
+import json
+import logging
 import os
 from unittest.mock import patch
 
 import pytest
 
-from kiln_ai.adapters.ml_model_list import built_in_models
+from kiln_ai.adapters.ml_model_list import (
+    KilnModel,
+    KilnModelProvider,
+    ModelFamily,
+    ModelName,
+    ModelProviderName,
+    StructuredOutputMode,
+    built_in_models,
+)
 from kiln_ai.adapters.remote_config import (
-    deserialize_config,
+    deserialize_config_at_path,
     dump_builtin_config,
     load_from_url,
     load_remote_models,
@@ -14,17 +24,49 @@ from kiln_ai.adapters.remote_config import (
 )
 
 
+@pytest.fixture
+def mock_model() -> KilnModel:
+    return KilnModel(
+        family=ModelFamily.gpt,
+        name=ModelName.gpt_4_1,
+        friendly_name="GPT 4.1",
+        providers=[
+            KilnModelProvider(
+                name=ModelProviderName.openai,
+                model_id="gpt-4.1",
+                provider_finetune_id="gpt-4.1-2025-04-14",
+                structured_output_mode=StructuredOutputMode.json_schema,
+                supports_logprobs=True,
+                suggested_for_evals=True,
+            ),
+            KilnModelProvider(
+                name=ModelProviderName.openrouter,
+                model_id="openai/gpt-4.1",
+                structured_output_mode=StructuredOutputMode.json_schema,
+                supports_logprobs=True,
+                suggested_for_evals=True,
+            ),
+            KilnModelProvider(
+                name=ModelProviderName.azure_openai,
+                model_id="gpt-4.1",
+                suggested_for_evals=True,
+            ),
+        ],
+    )
+
+
 def test_round_trip(tmp_path):
     path = tmp_path / "models.json"
     serialize_config(built_in_models, path)
-    loaded = deserialize_config(path)
+    loaded = deserialize_config_at_path(path)
     assert [m.model_dump(mode="json") for m in loaded] == [
         m.model_dump(mode="json") for m in built_in_models
     ]
 
 
-def test_load_from_url():
-    sample = [built_in_models[0].model_dump(mode="json")]
+def test_load_from_url(mock_model):
+    sample_model = mock_model
+    sample = [sample_model.model_dump(mode="json")]
 
     class FakeResponse:
         def raise_for_status(self):
@@ -37,23 +79,59 @@ def test_load_from_url():
         "kiln_ai.adapters.remote_config.requests.get", return_value=FakeResponse()
     ):
         models = load_from_url("http://example.com/models.json")
-    assert [m.model_dump(mode="json") for m in models] == sample
+
+    assert len(models) == 1
+    assert sample_model == models[0]
+
+
+def test_load_from_url_calls_deserialize_config_data(mock_model):
+    """Test that load_from_url calls deserialize_config_data with the model_list from the response."""
+    sample_model_data = [mock_model.model_dump(mode="json")]
+    response_data = {"model_list": sample_model_data}
+
+    class FakeResponse:
+        def raise_for_status(self):
+            pass
+
+        def json(self):
+            return response_data
+
+    with (
+        patch(
+            "kiln_ai.adapters.remote_config.requests.get", return_value=FakeResponse()
+        ) as mock_get,
+        patch(
+            "kiln_ai.adapters.remote_config.deserialize_config_data"
+        ) as mock_deserialize,
+    ):
+        mock_deserialize.return_value = [mock_model]
+
+        result = load_from_url("http://example.com/models.json")
+
+        # Verify requests.get was called with correct URL
+        mock_get.assert_called_once_with("http://example.com/models.json", timeout=10)
+
+        # Verify deserialize_config_data was called with the model_list data
+        mock_deserialize.assert_called_once_with(response_data)
+
+        # Verify the result is what deserialize_config_data returned
+        assert result == [mock_model]
 
 
 def test_dump_builtin_config(tmp_path):
     path = tmp_path / "out.json"
     dump_builtin_config(path)
-    loaded = deserialize_config(path)
+    loaded = deserialize_config_at_path(path)
     assert [m.model_dump(mode="json") for m in loaded] == [
         m.model_dump(mode="json") for m in built_in_models
     ]
 
 
 @pytest.mark.asyncio
-async def test_load_remote_models_success(monkeypatch):
+async def test_load_remote_models_success(monkeypatch, mock_model):
     del os.environ["KILN_SKIP_REMOTE_MODEL_LIST"]
     original = built_in_models.copy()
-    sample_models = [built_in_models[0]]
+    sample_models = [mock_model]
 
     def fake_fetch(url):
         return sample_models
@@ -80,21 +158,299 @@ async def test_load_remote_models_failure(monkeypatch):
     assert built_in_models == original
 
 
-def test_deserialize_config_with_extra_keys(tmp_path):
+def test_deserialize_config_with_extra_keys(tmp_path, mock_model):
     # Take a valid model and add an extra key, ensure it is ignored and still loads
-    import json
-
-    from kiln_ai.adapters.ml_model_list import built_in_models
-
-    model_dict = built_in_models[0].model_dump(mode="json")
+    model_dict = mock_model.model_dump(mode="json")
     model_dict["extra_key"] = "should be ignored or error"
     model_dict["providers"][0]["extra_key"] = "should be ignored or error"
     data = {"model_list": [model_dict]}
     path = tmp_path / "extra.json"
     path.write_text(json.dumps(data))
     # Should NOT raise, and extra key should be ignored
-    models = deserialize_config(path)
+    models = deserialize_config_at_path(path)
     assert hasattr(models[0], "family")
     assert not hasattr(models[0], "extra_key")
     assert hasattr(models[0], "providers")
     assert not hasattr(models[0].providers[0], "extra_key")
+
+
+def test_deserialize_config_with_invalid_models(tmp_path, caplog, mock_model):
+    """Test comprehensive handling of invalid models and providers during deserialization."""
+
+    # Create a fully valid model as baseline
+    valid_model = mock_model.model_dump(mode="json")
+
+    # Case 1: Invalid model - missing required field 'family'
+    invalid_model_missing_family = mock_model.model_dump(mode="json")
+    del invalid_model_missing_family["family"]
+
+    # Case 2: Invalid model - invalid data type for required field
+    invalid_model_wrong_type = mock_model.model_dump(mode="json")
+    invalid_model_wrong_type["name"] = None  # name should be a string, not None
+
+    # Case 3: Invalid model - completely malformed
+    invalid_model_malformed = {"not_a_valid_model": "at_all"}
+
+    # Case 4: Valid model with one invalid provider (should keep model, skip invalid provider)
+    valid_model_invalid_provider = mock_model.model_dump(mode="json")
+    valid_model_invalid_provider["name"] = "test_model_invalid_provider"  # Unique name
+    valid_model_invalid_provider["providers"][0]["name"] = "unknown-provider-123"
+
+    # Case 5: Valid model with mixed valid/invalid providers (should keep model and valid providers)
+    valid_model_mixed_providers = mock_model.model_dump(mode="json")
+    valid_model_mixed_providers["name"] = "test_model_mixed_providers"  # Unique name
+    # Add a second provider that's valid
+    valid_provider = valid_model_mixed_providers["providers"][0].copy()
+    valid_provider["name"] = "azure_openai"
+    # Make first provider invalid
+    valid_model_mixed_providers["providers"][0]["name"] = "invalid-provider-1"
+    # Add invalid provider with missing required field
+    invalid_provider = valid_model_mixed_providers["providers"][0].copy()
+    del invalid_provider["name"]
+    # Add another invalid provider with wrong type
+    invalid_provider_2 = valid_model_mixed_providers["providers"][0].copy()
+    invalid_provider_2["supports_structured_output"] = "not_a_boolean"
+
+    valid_model_mixed_providers["providers"] = [
+        valid_model_mixed_providers["providers"][0],  # invalid name
+        valid_provider,  # valid
+        invalid_provider,  # missing name
+        invalid_provider_2,  # wrong type
+    ]
+
+    # Case 6: Valid model with all invalid providers (should keep model with empty providers)
+    valid_model_all_invalid_providers = mock_model.model_dump(mode="json")
+    valid_model_all_invalid_providers["name"] = (
+        "test_model_all_invalid_providers"  # Unique name
+    )
+    valid_model_all_invalid_providers["providers"][0]["name"] = "unknown-provider-456"
+    if len(valid_model_all_invalid_providers["providers"]) > 1:
+        valid_model_all_invalid_providers["providers"][1]["name"] = (
+            "another-unknown-provider"
+        )
+    if len(valid_model_all_invalid_providers["providers"]) > 2:
+        valid_model_all_invalid_providers["providers"][2]["name"] = (
+            "yet-another-unknown-provider"
+        )
+
+    data = {
+        "model_list": [
+            valid_model,  # Should be kept
+            invalid_model_missing_family,  # Should be skipped
+            invalid_model_wrong_type,  # Should be skipped
+            invalid_model_malformed,  # Should be skipped
+            valid_model_invalid_provider,  # Should be kept with empty providers
+            valid_model_mixed_providers,  # Should be kept with 1 valid provider
+            valid_model_all_invalid_providers,  # Should be kept with empty providers
+        ]
+    }
+    path = tmp_path / "mixed_models.json"
+    path.write_text(json.dumps(data))
+
+    # Enable logging to capture warnings
+    with caplog.at_level(logging.WARNING):
+        models = deserialize_config_at_path(path)
+
+    # Should have 4 valid models (original + 3 with provider issues but valid model structure)
+    assert len(models) == 4
+
+    # Check the first model is fully intact
+    assert models[0].name == mock_model.name
+    assert models[0].family == mock_model.family
+    assert len(models[0].providers) == 3  # mock_model has 3 providers
+
+    # Check model with invalid provider has remaining valid providers
+    model_with_invalid_provider = next(
+        m for m in models if m.name == valid_model_invalid_provider["name"]
+    )
+    # Should keep the valid providers from the original model (openrouter, azure_openai)
+    assert len(model_with_invalid_provider.providers) == 2
+    provider_names = {p.name.value for p in model_with_invalid_provider.providers}
+    assert provider_names == {"openrouter", "azure_openai"}
+
+    # Check model with mixed providers has only the valid one
+    model_with_mixed_providers = next(
+        m for m in models if m.name == valid_model_mixed_providers["name"]
+    )
+    assert len(model_with_mixed_providers.providers) == 1
+    assert model_with_mixed_providers.providers[0].name.value == "azure_openai"
+
+    # Check model with all invalid providers has empty providers
+    model_with_all_invalid_providers = next(
+        m for m in models if m.name == valid_model_all_invalid_providers["name"]
+    )
+    assert len(model_with_all_invalid_providers.providers) == 0
+
+    # Check warning logs
+    warning_logs = [
+        record for record in caplog.records if record.levelno == logging.WARNING
+    ]
+
+    # Should have warnings for:
+    # - 3 invalid models (missing family, wrong type, malformed)
+    # - 1 invalid provider in case 4 (unknown-provider-123)
+    # - 3 invalid providers in case 5 (invalid-provider-1, missing name, wrong type boolean)
+    # - 3 invalid providers in case 6 (unknown-provider-456, another-unknown-provider, yet-another-unknown-provider)
+    assert len(warning_logs) >= 10
+
+    # Check that warning messages contain expected content
+    model_warnings = [
+        log for log in warning_logs if "Failed to validate a model from" in log.message
+    ]
+    provider_warnings = [
+        log
+        for log in warning_logs
+        if "Failed to validate a model provider" in log.message
+    ]
+
+    assert len(model_warnings) == 3  # 3 completely invalid models
+    assert (
+        len(provider_warnings) == 7
+    )  # Exactly 7 invalid providers across different models
+
+
+def test_deserialize_config_empty_provider_list(tmp_path, mock_model):
+    """Test that models with empty provider lists are handled correctly."""
+    model_with_empty_providers = mock_model.model_dump(mode="json")
+    model_with_empty_providers["providers"] = []
+
+    data = {"model_list": [model_with_empty_providers]}
+    path = tmp_path / "empty_providers.json"
+    path.write_text(json.dumps(data))
+
+    models = deserialize_config_at_path(path)
+    assert len(models) == 1
+    assert len(models[0].providers) == 0
+
+
+def test_deserialize_config_missing_provider_field(tmp_path, caplog, mock_model):
+    """Test that models missing the providers field are handled correctly."""
+    model_without_providers = mock_model.model_dump(mode="json")
+    del model_without_providers["providers"]
+
+    data = {"model_list": [model_without_providers]}
+    path = tmp_path / "no_providers.json"
+    path.write_text(json.dumps(data))
+
+    with caplog.at_level(logging.WARNING):
+        models = deserialize_config_at_path(path)
+
+    # Model should be kept with empty providers (deserialize_config handles missing providers gracefully)
+    assert len(models) == 1
+    assert len(models[0].providers) == 0
+    assert models[0].name == mock_model.name
+
+    # Should not have any warnings since the function handles missing providers gracefully
+    warning_logs = [
+        record for record in caplog.records if record.levelno == logging.WARNING
+    ]
+    assert len(warning_logs) == 0
+
+
+def test_deserialize_config_provider_with_extra_fields(tmp_path, mock_model):
+    """Test that providers with extra unknown fields are handled gracefully."""
+    model_with_extra_provider_fields = mock_model.model_dump(mode="json")
+    model_with_extra_provider_fields["providers"][0]["unknown_field"] = (
+        "should_be_ignored"
+    )
+    model_with_extra_provider_fields["providers"][0]["another_extra"] = {
+        "nested": "data"
+    }
+
+    data = {"model_list": [model_with_extra_provider_fields]}
+    path = tmp_path / "extra_provider_fields.json"
+    path.write_text(json.dumps(data))
+
+    models = deserialize_config_at_path(path)
+    assert len(models) == 1
+    assert len(models[0].providers) == 3  # mock_model has 3 providers
+    # Extra fields should be ignored, not present in the final object
+    assert not hasattr(models[0].providers[0], "unknown_field")
+    assert not hasattr(models[0].providers[0], "another_extra")
+
+
+def test_deserialize_config_model_with_extra_fields(tmp_path, mock_model):
+    """Test that models with extra unknown fields are handled gracefully."""
+    model_with_extra_fields = mock_model.model_dump(mode="json")
+    model_with_extra_fields["future_field"] = "should_be_ignored"
+    model_with_extra_fields["complex_extra"] = {"nested": {"data": [1, 2, 3]}}
+
+    data = {"model_list": [model_with_extra_fields]}
+    path = tmp_path / "extra_model_fields.json"
+    path.write_text(json.dumps(data))
+
+    models = deserialize_config_at_path(path)
+    assert len(models) == 1
+    assert models[0].name == mock_model.name
+    # Extra fields should be ignored, not present in the final object
+    assert not hasattr(models[0], "future_field")
+    assert not hasattr(models[0], "complex_extra")
+
+
+def test_deserialize_config_mixed_valid_invalid_providers_single_model(
+    tmp_path, caplog, mock_model
+):
+    """Test a single model with a mix of valid and invalid providers in detail."""
+    model = mock_model.model_dump(mode="json")
+
+    # Create a mix of provider scenarios
+    valid_provider_1 = model["providers"][0].copy()
+    valid_provider_1["name"] = "openai"
+
+    valid_provider_2 = model["providers"][0].copy()
+    valid_provider_2["name"] = "azure_openai"
+
+    invalid_provider_unknown_name = model["providers"][0].copy()
+    invalid_provider_unknown_name["name"] = "nonexistent_provider"
+
+    invalid_provider_missing_name = model["providers"][0].copy()
+    del invalid_provider_missing_name["name"]
+
+    invalid_provider_wrong_type = model["providers"][0].copy()
+    invalid_provider_wrong_type["supports_structured_output"] = "not_a_boolean"
+
+    model["providers"] = [
+        valid_provider_1,
+        invalid_provider_unknown_name,
+        valid_provider_2,
+        invalid_provider_missing_name,
+        invalid_provider_wrong_type,
+    ]
+
+    data = {"model_list": [model]}
+    path = tmp_path / "mixed_providers_single.json"
+    path.write_text(json.dumps(data))
+
+    with caplog.at_level(logging.WARNING):
+        models = deserialize_config_at_path(path)
+
+    # Should have 1 model with 2 valid providers
+    assert len(models) == 1
+    assert len(models[0].providers) == 2
+    assert models[0].providers[0].name.value == "openai"
+    assert models[0].providers[1].name.value == "azure_openai"
+
+    # Should have logged 3 provider validation warnings
+    provider_warnings = [
+        log
+        for log in caplog.records
+        if log.levelno == logging.WARNING
+        and "Failed to validate a model provider" in log.message
+    ]
+    assert len(provider_warnings) == 3
+
+
+def test_deserialize_config_empty_json_structures(tmp_path):
+    """Test various empty JSON structures."""
+    # Test empty model_list
+    data = {"model_list": []}
+    path = tmp_path / "empty_model_list.json"
+    path.write_text(json.dumps(data))
+    models = deserialize_config_at_path(path)
+    assert len(models) == 0
+
+    # Test empty object with no model_list key
+    path = tmp_path / "empty_object.json"
+    path.write_text(json.dumps({}))
+    with pytest.raises(ValueError):
+        deserialize_config_at_path(path)

kiln_ai/datamodel/basemodel.py

@@ -2,22 +2,17 @@ import json
 import os
 import re
 import shutil
+import unicodedata
 import uuid
 from abc import ABCMeta
 from builtins import classmethod
 from datetime import datetime
 from pathlib import Path
-from typing import (
-    Any,
-    Dict,
-    List,
-    Optional,
-    Type,
-    TypeVar,
-)
+from typing import Any, Callable, Dict, List, Optional, Type, TypeVar
 
 from pydantic import (
     BaseModel,
+    BeforeValidator,
     ConfigDict,
     Field,
     ValidationError,
@@ -26,7 +21,7 @@ from pydantic import (
     model_validator,
 )
 from pydantic_core import ErrorDetails
-from typing_extensions import Self
+from typing_extensions import Annotated, Self
 
 from kiln_ai.datamodel.model_cache import ModelCache
 from kiln_ai.utils.config import Config
@@ -44,33 +39,64 @@ PT = TypeVar("PT", bound="KilnParentedModel")
 
 # Naming conventions:
 # 1) Names are filename safe as they may be used as file names. They are informational and not to be used in prompts/training/validation.
-# 2) Descrptions are for Kiln users to describe/understanding the purpose of this object. They must never be used in prompts/training/validation. Use "instruction/requirements" instead.
-
-# Filename compatible names
-NAME_REGEX = r"^[A-Za-z0-9 _-]+$"
-NAME_FIELD = Field(
-    min_length=1,
-    max_length=120,
-    pattern=NAME_REGEX,
-    description="A name for this entity.",
-)
-SHORT_NAME_FIELD = Field(
-    min_length=1,
-    max_length=32,
-    pattern=NAME_REGEX,
-    description="A name for this entity",
-)
+# 2) Descriptions are for Kiln users to describe/understanding the purpose of this object. They must never be used in prompts/training/validation. Use "instruction/requirements" instead.
+
+# Forbidden chars are not allowed in filenames on one or more platforms.
+# ref: https://en.wikipedia.org/wiki/Filename#Problematic_characters
+FORBIDDEN_CHARS_REGEX = r"[/\\?%*:|\"<>.,;=\n]"
+FORBIDDEN_CHARS = "/ \\ ? % * : | < > . , ; = \\n"
+
+
+def name_validator(*, min_length: int, max_length: int) -> Callable[[Any], str]:
+    def fn(name: Any) -> str:
+        if name is None:
+            raise ValueError("Name is required")
+        if not isinstance(name, str):
+            raise ValueError(f"Input should be a valid string, got {type(name)}")
+        if len(name) < min_length:
+            raise ValueError(
+                f"Name is too short. Min length is {min_length} characters, got {len(name)}"
+            )
+        if len(name) > max_length:
+            raise ValueError(
+                f"Name is too long. Max length is {max_length} characters, got {len(name)}"
+            )
+        if string_to_valid_name(name) != name:
+            raise ValueError(
+                f"Name is invalid. The name cannot contain any of the following characters: {FORBIDDEN_CHARS}, consecutive whitespace/underscores, or leading/trailing whitespace/underscores"
+            )
+        return name
+
+    return fn
 
 
 def string_to_valid_name(name: str) -> str:
-    # Replace any character not allowed by NAME_REGEX with an underscore
-    valid_name = re.sub(r"[^A-Za-z0-9 _-]", "_", name)
+    # https://docs.python.org/3/library/unicodedata.html#unicodedata.normalize
+    valid_name = unicodedata.normalize("NFKD", name)
+    # Replace any forbidden chars with an underscore
+    valid_name = re.sub(FORBIDDEN_CHARS_REGEX, "_", valid_name)
+    # Replace control characters with an underscore
+    valid_name = re.sub(r"[\x00-\x1F]", "_", valid_name)
+    # Replace consecutive whitespace with a single space
+    valid_name = re.sub(r"\s+", " ", valid_name)
     # Replace consecutive underscores with a single underscore
     valid_name = re.sub(r"_+", "_", valid_name)
     # Remove leading and trailing underscores or whitespace
     return valid_name.strip("_").strip()
 
 
+# Usage:
+# class MyModel(KilnBaseModel):
+#     name: FilenameString = Field(description="The name of the model.")
+#     name_short: FilenameStringShort = Field(description="The short name of the model.")
+FilenameString = Annotated[
+    str, BeforeValidator(name_validator(min_length=1, max_length=120))
+]
+FilenameStringShort = Annotated[
+    str, BeforeValidator(name_validator(min_length=1, max_length=32))
+]
+
+
 class KilnBaseModel(BaseModel):
     """Base model for all Kiln data models with common functionality for persistence and versioning.
 
@@ -470,7 +496,7 @@ class KilnParentModel(KilnBaseModel, metaclass=ABCMeta):
             ValidationError: If validation fails for the model or any of its children
         """
         # Validate first, then save. Don't want error half way through, and partly persisted
-        # TODO P2: save to tmp dir, then move atomically. But need to merge directories so later.
+        # We should save to a tmp dir and move atomically, but need to merge directories later.
         cls._validate_nested(data, save=False, path=path, parent=parent)
         instance = cls._validate_nested(data, save=True, path=path, parent=parent)
         return instance

kiln_ai/datamodel/datamodel_enums.py

@@ -97,3 +97,5 @@ class ModelProviderName(str, Enum):
     huggingface = "huggingface"
     vertex = "vertex"
     together_ai = "together_ai"
+    siliconflow_cn = "siliconflow_cn"
+    cerebras = "cerebras"

kiln_ai/datamodel/dataset_split.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING
 
 from pydantic import BaseModel, Field, model_validator
 
-from kiln_ai.datamodel.basemodel import NAME_FIELD, KilnParentedModel
+from kiln_ai.datamodel.basemodel import FilenameString, KilnParentedModel
 from kiln_ai.datamodel.dataset_filters import (
     DatasetFilter,
     DatasetFilterId,
@@ -26,7 +26,9 @@ class DatasetSplitDefinition(BaseModel):
     Example: name="train", description="The training set", percentage=0.8 (80% of the dataset)
     """
 
-    name: str = NAME_FIELD
+    name: FilenameString = Field(
+        description="The name of the dataset split definition."
+    )
     description: str | None = Field(
         default=None,
         description="A description of the dataset for you and your team. Not used in training.",
@@ -70,7 +72,7 @@ class DatasetSplit(KilnParentedModel):
     Maintains a list of IDs for each split, to avoid data duplication.
     """
 
-    name: str = NAME_FIELD
+    name: FilenameString = Field(description="The name of the dataset split.")
     description: str | None = Field(
         default=None,
         description="A description of the dataset for you and your team. Not used in training.",

kiln_ai/datamodel/eval.py

@@ -7,7 +7,7 @@ from typing_extensions import Self
 
 from kiln_ai.datamodel.basemodel import (
     ID_TYPE,
-    NAME_FIELD,
+    FilenameString,
     KilnParentedModel,
     KilnParentModel,
 )
@@ -202,7 +202,7 @@ class EvalConfig(KilnParentedModel, KilnParentModel, parent_of={"runs": EvalRun}
     A eval might have many configs, example running the same eval with 2 different models. Comparing eval results is only valid within the scope of the same config.
     """
 
-    name: str = NAME_FIELD
+    name: FilenameString = Field(description="The name of the eval config.")
     model_name: str = Field(
         description="The name of the model to use for this eval config. ",
     )
@@ -257,7 +257,7 @@ class EvalConfig(KilnParentedModel, KilnParentModel, parent_of={"runs": EvalRun}
 
 
 class Eval(KilnParentedModel, KilnParentModel, parent_of={"configs": EvalConfig}):
-    name: str = NAME_FIELD
+    name: FilenameString = Field(description="The name of the eval.")
     description: str | None = Field(
         default=None, description="The description of the eval"
     )

kiln_ai/datamodel/finetune.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING, Dict, Union
 from pydantic import Field, model_validator
 from typing_extensions import Self
 
-from kiln_ai.datamodel.basemodel import NAME_FIELD, KilnParentedModel
+from kiln_ai.datamodel.basemodel import FilenameString, KilnParentedModel
 from kiln_ai.datamodel.datamodel_enums import (
     ChatStrategy,
     FineTuneStatusType,
@@ -26,7 +26,7 @@ class Finetune(KilnParentedModel):
     Initially holds a reference to a training job, with needed identifiers to update the status. When complete, contains the new model ID.
     """
 
-    name: str = NAME_FIELD
+    name: FilenameString = Field(description="The name of the fine-tune.")
     description: str | None = Field(
         default=None,
         description="A description of the fine-tune for you and your team. Not used in training.",

kiln_ai/datamodel/project.py

@@ -1,6 +1,6 @@
 from pydantic import Field
 
-from kiln_ai.datamodel.basemodel import NAME_FIELD, KilnParentModel
+from kiln_ai.datamodel.basemodel import FilenameString, KilnParentModel
 from kiln_ai.datamodel.task import Task
 
 
@@ -12,12 +12,12 @@ class Project(KilnParentModel, parent_of={"tasks": Task}):
     of the overall goals.
     """
 
-    name: str = NAME_FIELD
+    name: FilenameString = Field(description="The name of the project.")
     description: str | None = Field(
         default=None,
         description="A description of the project for you and your team. Will not be used in prompts/training/validation.",
     )
 
-    # Needed for typechecking. TODO P2: fix this in KilnParentModel
+    # Needed for typechecking. We should fix this in KilnParentModel
     def tasks(self) -> list[Task]:
         return super().tasks()  # type: ignore