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

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,6 @@ class ModelProviderName(str, Enum):
     huggingface = "huggingface"
     vertex = "vertex"
     together_ai = "together_ai"
+    siliconflow_cn = "siliconflow_cn"
+    cerebras = "cerebras"
+    docker_model_runner = "docker_model_runner"

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. ",
     )
@@ -252,12 +252,12 @@ class EvalConfig(KilnParentedModel, KilnParentModel, parent_of={"runs": EvalRun}
             # This will raise a TypeError if the dict contains non-JSON-serializable objects
             json.dumps(self.properties)
         except TypeError as e:
-            raise ValueError(f"Properties must be JSON serializable: {str(e)}")
+            raise ValueError(f"Properties must be JSON serializable: {e!s}")
         return self
 
 
 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/external_tool_server.py

@@ -0,0 +1,298 @@
+from enum import Enum
+from typing import Any, Dict
+
+from pydantic import Field, PrivateAttr, model_validator
+
+from kiln_ai.datamodel.basemodel import (
+    FilenameString,
+    KilnParentedModel,
+)
+from kiln_ai.utils.config import MCP_SECRETS_KEY, Config
+from kiln_ai.utils.exhaustive_error import raise_exhaustive_enum_error
+
+
+class ToolServerType(str, Enum):
+    """
+    Enumeration of supported external tool server types.
+    """
+
+    remote_mcp = "remote_mcp"
+    local_mcp = "local_mcp"
+
+
+class ExternalToolServer(KilnParentedModel):
+    """
+    Configuration for communicating with a external MCP (Model Context Protocol) Server for LLM tool calls. External tool servers can be remote or local.
+
+    This model stores the necessary configuration to connect to and authenticate with
+    external MCP servers that provide tools for LLM interactions.
+    """
+
+    name: FilenameString = Field(description="The name of the external tool.")
+    type: ToolServerType = Field(
+        description="The type of external tool server. Remote tools are hosted on a remote server",
+    )
+    description: str | None = Field(
+        default=None,
+        description="A description of the external tool for you and your team. Will not be used in prompts/training/validation.",
+    )
+    properties: Dict[str, Any] = Field(
+        default={},
+        description="Configuration properties specific to the tool type.",
+    )
+
+    # Private variable to store unsaved secrets
+    _unsaved_secrets: dict[str, str] = PrivateAttr(default_factory=dict)
+
+    def model_post_init(self, __context: Any) -> None:
+        # Process secrets after initialization (pydantic v2 hook)
+        self._process_secrets_from_properties()
+
+    def _process_secrets_from_properties(self) -> None:
+        """
+        Extract secrets from properties and move them to _unsaved_secrets.
+        This removes secrets from the properties dict so they aren't saved to file.
+        Clears existing _unsaved_secrets first to handle property updates correctly.
+        """
+        # Clear existing unsaved secrets since we're reprocessing
+        self._unsaved_secrets.clear()
+
+        secret_keys = self.get_secret_keys()
+
+        if not secret_keys:
+            return
+
+        # Extract secret values from properties based on server type
+        match self.type:
+            case ToolServerType.remote_mcp:
+                headers = self.properties.get("headers", {})
+                for key_name in secret_keys:
+                    if key_name in headers:
+                        self._unsaved_secrets[key_name] = headers[key_name]
+                        # Remove from headers immediately so they are not saved to file
+                        del headers[key_name]
+
+            case ToolServerType.local_mcp:
+                env_vars = self.properties.get("env_vars", {})
+                for key_name in secret_keys:
+                    if key_name in env_vars:
+                        self._unsaved_secrets[key_name] = env_vars[key_name]
+                        # Remove from env_vars immediately so they are not saved to file
+                        del env_vars[key_name]
+
+            case _:
+                raise_exhaustive_enum_error(self.type)
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        """
+        Override __setattr__ to process secrets whenever properties are updated.
+        """
+        super().__setattr__(name, value)
+
+        # Process secrets whenever properties are updated
+        if name == "properties":
+            self._process_secrets_from_properties()
+
+    @model_validator(mode="after")
+    def validate_required_fields(self) -> "ExternalToolServer":
+        """Validate that each tool type has the required configuration."""
+        match self.type:
+            case ToolServerType.remote_mcp:
+                server_url = self.properties.get("server_url", None)
+                if not isinstance(server_url, str):
+                    raise ValueError(
+                        "server_url must be a string for external tools of type 'remote_mcp'"
+                    )
+                if not server_url:
+                    raise ValueError(
+                        "server_url is required to connect to a remote MCP server"
+                    )
+
+                headers = self.properties.get("headers", None)
+                if headers is None:
+                    raise ValueError("headers must be set when type is 'remote_mcp'")
+                if not isinstance(headers, dict):
+                    raise ValueError(
+                        "headers must be a dictionary for external tools of type 'remote_mcp'"
+                    )
+
+                secret_header_keys = self.properties.get("secret_header_keys", None)
+                # Secret header keys are optional, but if they are set, they must be a list of strings
+                if secret_header_keys is not None:
+                    if not isinstance(secret_header_keys, list):
+                        raise ValueError(
+                            "secret_header_keys must be a list for external tools of type 'remote_mcp'"
+                        )
+                    if not all(isinstance(k, str) for k in secret_header_keys):
+                        raise ValueError("secret_header_keys must contain only strings")
+
+            case ToolServerType.local_mcp:
+                command = self.properties.get("command", None)
+                if not isinstance(command, str):
+                    raise ValueError(
+                        "command must be a string to start a local MCP server"
+                    )
+                if not command.strip():
+                    raise ValueError("command is required to start a local MCP server")
+
+                args = self.properties.get("args", None)
+                if not isinstance(args, list):
+                    raise ValueError(
+                        "arguments must be a list to start a local MCP server"
+                    )
+
+                env_vars = self.properties.get("env_vars", {})
+                if not isinstance(env_vars, dict):
+                    raise ValueError(
+                        "environment variables must be a dictionary for external tools of type 'local_mcp'"
+                    )
+
+                secret_env_var_keys = self.properties.get("secret_env_var_keys", None)
+                # Secret env var keys are optional, but if they are set, they must be a list of strings
+                if secret_env_var_keys is not None:
+                    if not isinstance(secret_env_var_keys, list):
+                        raise ValueError(
+                            "secret_env_var_keys must be a list for external tools of type 'local_mcp'"
+                        )
+                    if not all(isinstance(k, str) for k in secret_env_var_keys):
+                        raise ValueError(
+                            "secret_env_var_keys must contain only strings"
+                        )
+
+            case _:
+                # Type checking will catch missing cases
+                raise_exhaustive_enum_error(self.type)
+        return self
+
+    def get_secret_keys(self) -> list[str]:
+        """
+        Get the list of secret key names based on server type.
+
+        Returns:
+            List of secret key names (header names for remote, env var names for local)
+        """
+        match self.type:
+            case ToolServerType.remote_mcp:
+                return self.properties.get("secret_header_keys", [])
+            case ToolServerType.local_mcp:
+                return self.properties.get("secret_env_var_keys", [])
+            case _:
+                raise_exhaustive_enum_error(self.type)
+
+    def retrieve_secrets(self) -> tuple[dict[str, str], list[str]]:
+        """
+        Retrieve secrets from configuration system or in-memory storage.
+        Automatically determines which secret keys to retrieve based on the server type.
+        Config secrets take precedence over unsaved secrets.
+
+        Returns:
+            Tuple of (secrets_dict, missing_secrets_list) where:
+            - secrets_dict: Dictionary mapping key names to their secret values
+            - missing_secrets_list: List of secret key names that are missing values
+        """
+        secrets = {}
+        missing_secrets = []
+        secret_keys = self.get_secret_keys()
+
+        if secret_keys and len(secret_keys) > 0:
+            config = Config.shared()
+            mcp_secrets = config.get_value(MCP_SECRETS_KEY)
+
+            for key_name in secret_keys:
+                secret_value = None
+
+                # First check config secrets (persistent storage), key is mcp_server_id::key_name
+                secret_key = self._config_secret_key(key_name)
+                secret_value = mcp_secrets.get(secret_key) if mcp_secrets else None
+
+                # Fall back to unsaved secrets (in-memory storage)
+                if (
+                    not secret_value
+                    and hasattr(self, "_unsaved_secrets")
+                    and key_name in self._unsaved_secrets
+                ):
+                    secret_value = self._unsaved_secrets[key_name]
+
+                if secret_value:
+                    secrets[key_name] = secret_value
+                else:
+                    missing_secrets.append(key_name)
+
+        return secrets, missing_secrets
+
+    def _save_secrets(self) -> None:
+        """
+        Save unsaved secrets to the configuration system.
+        """
+        secret_keys = self.get_secret_keys()
+
+        # No secrets to save
+        if not secret_keys:
+            return
+
+        if self.id is None:
+            raise ValueError("Server ID cannot be None when saving secrets")
+
+        # Check if secrets are already saved
+        if not hasattr(self, "_unsaved_secrets") or not self._unsaved_secrets:
+            return
+
+        config = Config.shared()
+        mcp_secrets: dict[str, str] = config.get_value(MCP_SECRETS_KEY) or {}
+
+        # Store secrets with the pattern: mcp_server_id::key_name
+        for key_name, secret_value in self._unsaved_secrets.items():
+            secret_key = self._config_secret_key(key_name)
+            mcp_secrets[secret_key] = secret_value
+
+        config.update_settings({MCP_SECRETS_KEY: mcp_secrets})
+
+        # Clear unsaved secrets after saving
+        self._unsaved_secrets.clear()
+
+    def delete_secrets(self) -> None:
+        """
+        Delete all secrets for this tool server from the configuration system.
+        """
+        secret_keys = self.get_secret_keys()
+
+        config = Config.shared()
+        mcp_secrets = config.get_value(MCP_SECRETS_KEY) or dict[str, str]()
+
+        # Remove secrets with the pattern: mcp_server_id::key_name
+        for key_name in secret_keys:
+            secret_key = self._config_secret_key(key_name)
+            if secret_key in mcp_secrets:
+                del mcp_secrets[secret_key]
+
+        # Always call update_settings to maintain consistency with the old behavior
+        config.update_settings({MCP_SECRETS_KEY: mcp_secrets})
+
+    def save_to_file(self) -> None:
+        """
+        Override save_to_file to automatically save any unsaved secrets before saving to file.
+
+        This ensures that secrets are always saved when the object is saved,
+        preventing the issue where secrets could be lost if save_to_file is called
+        without explicitly saving secrets first.
+        """
+        # Save any unsaved secrets first
+        if hasattr(self, "_unsaved_secrets") and self._unsaved_secrets:
+            self._save_secrets()
+
+        # Call the parent save_to_file method
+        super().save_to_file()
+
+    #  Internal helpers
+
+    def _config_secret_key(self, key_name: str) -> str:
+        """
+        Generate the secret key pattern for storing/retrieving secrets.
+
+        Args:
+            key_name: The name of the secret key
+
+        Returns:
+            The formatted secret key: "{server_id}::{key_name}"
+        """
+        return f"{self.id}::{key_name}"

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/json_schema.py

@@ -84,25 +84,40 @@ def schema_from_json_str(v: str) -> Dict:
     """
     try:
         parsed = json.loads(v)
-        jsonschema.Draft202012Validator.check_schema(parsed)
         if not isinstance(parsed, dict):
             raise ValueError(f"JSON schema must be a dict, not {type(parsed)}")
-        # Top level arrays are valid JSON schemas, but we don't want to allow them here as they often cause issues
-        if (
-            "type" not in parsed
-            or parsed["type"] != "object"
-            or "properties" not in parsed
-        ):
-            raise ValueError(f"JSON schema must be an object with properties: {v}")
+
+        validate_schema_dict(parsed)
         return parsed
-    except jsonschema.exceptions.SchemaError as e:
-        raise ValueError(f"Invalid JSON schema: {v} \n{e}")
     except json.JSONDecodeError as e:
         raise ValueError(f"Invalid JSON: {v}\n {e}")
     except Exception as e:
         raise ValueError(f"Unexpected error parsing JSON schema: {v}\n {e}")
 
 
+def validate_schema_dict(v: Dict):
+    """Parse and validate a JSON schema dictionary.
+
+    Args:
+        v: Dictionary containing a JSON schema definition
+
+    Returns:
+        Dict containing the parsed JSON schema
+
+    Raises:
+        ValueError: If the input is not a valid JSON schema object with required properties
+    """
+    try:
+        jsonschema.Draft202012Validator.check_schema(v)
+        # Top level arrays are valid JSON schemas, but we don't want to allow them here as they often cause issues
+        if "type" not in v or v["type"] != "object" or "properties" not in v:
+            raise ValueError(f"JSON schema must be an object with properties: {v}")
+    except jsonschema.exceptions.SchemaError as e:
+        raise ValueError(f"Invalid JSON schema: {v} \n{e}")
+    except Exception as e:
+        raise ValueError(f"Unexpected error validating dict JSON schema: {v}\n {e}")
+
+
 def string_to_json_key(s: str) -> str:
     """Convert a string to a valid JSON key."""
     return re.sub(r"[^a-z0-9_]", "", s.strip().lower().replace(" ", "_"))

kiln_ai/datamodel/project.py

@@ -1,10 +1,14 @@
 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.external_tool_server import ExternalToolServer
 from kiln_ai.datamodel.task import Task
 
 
-class Project(KilnParentModel, parent_of={"tasks": Task}):
+class Project(
+    KilnParentModel,
+    parent_of={"tasks": Task, "external_tool_servers": ExternalToolServer},
+):
     """
     A collection of related tasks.
 
@@ -12,12 +16,15 @@ 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
+
+    def external_tool_servers(self, readonly: bool = False) -> list[ExternalToolServer]:
+        return super().external_tool_servers(readonly=readonly)  # type: ignore

kiln_ai/datamodel/prompt.py

@@ -1,6 +1,6 @@
 from pydantic import BaseModel, Field
 
-from kiln_ai.datamodel.basemodel import NAME_FIELD, KilnParentedModel
+from kiln_ai.datamodel.basemodel import FilenameString, KilnParentedModel
 
 
 class BasePrompt(BaseModel):
@@ -10,7 +10,7 @@ class BasePrompt(BaseModel):
     The "Prompt" model name is reserved for the custom prompts parented by a task.
     """
 
-    name: str = NAME_FIELD
+    name: FilenameString = Field(description="The name of the prompt.")
     description: str | None = Field(
         default=None,
         description="A more detailed description of the prompt.",

kiln_ai/datamodel/prompt_id.py

@@ -60,11 +60,11 @@ def _check_prompt_id(id: str) -> str:
         return id
 
     if id.startswith("fine_tune_prompt::"):
-        # check it had a fine_tune_id after the :: -- 'fine_tune_prompt::fine_tune_id'
-        fine_tune_id = id[18:]
-        if len(fine_tune_id) == 0:
+        # check it had a fine_tune_id after the :: -- 'fine_tune_prompt::[project_id]::[task_id]::fine_tune_id'
+        parts = id.split("::")
+        if len(parts) != 4 or len(parts[3]) == 0:
             raise ValueError(
-                f"Invalid fine-tune prompt ID: {id}. Expected format: 'fine_tune_prompt::[fine_tune_id]'."
+                f"Invalid fine-tune prompt ID: {id}. Expected format: 'fine_tune_prompt::[project_id]::[task_id]::[fine_tune_id]'."
             )
         return id
 

kiln_ai/datamodel/registry.py

@@ -14,18 +14,3 @@ def all_projects() -> list[Project]:
             # deleted files are possible continue with the rest
             continue
     return projects
-
-
-def project_from_id(project_id: str) -> Project | None:
-    project_paths = Config.shared().projects
-    if project_paths is not None:
-        for project_path in project_paths:
-            try:
-                project = Project.load_from_file(project_path)
-                if project.id == project_id:
-                    return project
-            except Exception:
-                # deleted files are possible continue with the rest
-                continue
-
-    return None