kiln-ai 0.0.4__py3-none-any.whl → 0.5.1__py3-none-any.whl

kiln_ai/utils/config.py

@@ -0,0 +1,170 @@
+import getpass
+import os
+import threading
+from pathlib import Path
+from typing import Any, Callable, Dict, Optional
+
+import yaml
+
+
+class ConfigProperty:
+    def __init__(
+        self,
+        type_: type,
+        default: Any = None,
+        env_var: Optional[str] = None,
+        default_lambda: Optional[Callable[[], Any]] = None,
+        sensitive: bool = False,
+    ):
+        self.type = type_
+        self.default = default
+        self.env_var = env_var
+        self.default_lambda = default_lambda
+        self.sensitive = sensitive
+
+
+class Config:
+    _shared_instance = None
+
+    def __init__(self, properties: Dict[str, ConfigProperty] | None = None):
+        self._properties: Dict[str, ConfigProperty] = properties or {
+            "user_id": ConfigProperty(
+                str,
+                env_var="KILN_USER_ID",
+                default_lambda=_get_user_id,
+            ),
+            "autosave_runs": ConfigProperty(
+                bool,
+                env_var="KILN_AUTOSAVE_RUNS",
+                default=True,
+            ),
+            "open_ai_api_key": ConfigProperty(
+                str,
+                env_var="OPENAI_API_KEY",
+                sensitive=True,
+            ),
+            "groq_api_key": ConfigProperty(
+                str,
+                env_var="GROQ_API_KEY",
+                sensitive=True,
+            ),
+            "ollama_base_url": ConfigProperty(
+                str,
+                env_var="OLLAMA_BASE_URL",
+            ),
+            "bedrock_access_key": ConfigProperty(
+                str,
+                env_var="AWS_ACCESS_KEY_ID",
+                sensitive=True,
+            ),
+            "bedrock_secret_key": ConfigProperty(
+                str,
+                env_var="AWS_SECRET_ACCESS_KEY",
+                sensitive=True,
+            ),
+            "open_router_api_key": ConfigProperty(
+                str,
+                env_var="OPENROUTER_API_KEY",
+                sensitive=True,
+            ),
+            "projects": ConfigProperty(
+                list,
+                default_lambda=lambda: [],
+            ),
+        }
+        self._settings = self.load_settings()
+
+    @classmethod
+    def shared(cls):
+        if cls._shared_instance is None:
+            cls._shared_instance = cls()
+        return cls._shared_instance
+
+    # Get a value, mockable for testing
+    def get_value(self, name: str) -> Any:
+        try:
+            return self.__getattr__(name)
+        except AttributeError:
+            return None
+
+    def __getattr__(self, name: str) -> Any:
+        if name == "_properties":
+            return super().__getattribute__("_properties")
+        if name not in self._properties:
+            return super().__getattribute__(name)
+
+        property_config = self._properties[name]
+
+        # Check if the value is in settings
+        if name in self._settings:
+            return property_config.type(self._settings[name])
+
+        # Check environment variable
+        if property_config.env_var and property_config.env_var in os.environ:
+            value = os.environ[property_config.env_var]
+            return property_config.type(value)
+
+        # Use default value or default_lambda
+        if property_config.default_lambda:
+            value = property_config.default_lambda()
+        else:
+            value = property_config.default
+
+        return property_config.type(value)
+
+    def __setattr__(self, name, value):
+        if name in ("_properties", "_settings"):
+            super().__setattr__(name, value)
+        elif name in self._properties:
+            self.update_settings({name: value})
+        else:
+            raise AttributeError(f"Config has no attribute '{name}'")
+
+    @classmethod
+    def settings_path(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 os.path.join(settings_dir, "settings.yaml")
+
+    @classmethod
+    def load_settings(cls):
+        if not os.path.isfile(cls.settings_path(create=False)):
+            return {}
+        with open(cls.settings_path(), "r") as f:
+            settings = yaml.safe_load(f.read()) or {}
+        return settings
+
+    def settings(self, hide_sensitive=False):
+        if hide_sensitive:
+            return {
+                k: "[hidden]"
+                if k in self._properties and self._properties[k].sensitive
+                else v
+                for k, v in self._settings.items()
+            }
+        return self._settings
+
+    def save_setting(self, name: str, value: Any):
+        self.update_settings({name: value})
+
+    def update_settings(self, new_settings: Dict[str, Any]):
+        # Lock to prevent race conditions in multi-threaded scenarios
+        with threading.Lock():
+            # Fresh load to avoid clobbering changes from other instances
+            current_settings = self.load_settings()
+            current_settings.update(new_settings)
+            # remove None values
+            current_settings = {
+                k: v for k, v in current_settings.items() if v is not None
+            }
+            with open(self.settings_path(), "w") as f:
+                yaml.dump(current_settings, f)
+            self._settings = current_settings
+
+
+def _get_user_id():
+    try:
+        return getpass.getuser() or "unknown_user"
+    except Exception:
+        return "unknown_user"

kiln_ai/utils/formatting.py

@@ -0,0 +1,5 @@
+import re
+
+
+def snake_case(s: str) -> str:
+    return re.sub(r"(?<!^)(?=[A-Z])", "_", s).lower()

kiln_ai/utils/test_config.py

@@ -0,0 +1,245 @@
+import getpass
+import os
+from unittest.mock import patch
+
+import pytest
+import yaml
+from kiln_ai.utils.config import Config, ConfigProperty, _get_user_id
+
+
+@pytest.fixture
+def mock_yaml_file(tmp_path):
+    yaml_file = tmp_path / "test_settings.yaml"
+    return str(yaml_file)
+
+
+@pytest.fixture
+def config_with_yaml(mock_yaml_file):
+    with patch(
+        "kiln_ai.utils.config.Config.settings_path",
+        return_value=mock_yaml_file,
+    ):
+        yield Config(
+            properties={
+                "example_property": ConfigProperty(
+                    str, default="default_value", env_var="EXAMPLE_PROPERTY"
+                ),
+                "int_property": ConfigProperty(int, default=0),
+            }
+        )
+
+
+@pytest.fixture(autouse=True)
+def reset_config():
+    Config._shared_instance = None
+    yield
+    Config._shared_instance = None
+
+
+def test_shared_instance():
+    config1 = Config.shared()
+    config2 = Config.shared()
+    assert config1 is config2
+
+
+def test_property_default_value(config_with_yaml):
+    config = config_with_yaml
+    assert config.example_property == "default_value"
+
+
+def test_property_env_var(reset_config, config_with_yaml):
+    os.environ["EXAMPLE_PROPERTY"] = "env_value"
+    config = config_with_yaml
+    assert config.example_property == "env_value"
+    del os.environ["EXAMPLE_PROPERTY"]
+
+
+def test_property_setter(config_with_yaml):
+    config = config_with_yaml
+    config.example_property = "new_value"
+    assert config.example_property == "new_value"
+
+
+def test_nonexistent_property(config_with_yaml):
+    config = config_with_yaml
+    with pytest.raises(AttributeError):
+        config.nonexistent_property
+
+
+def test_property_type_conversion(config_with_yaml):
+    config = config_with_yaml
+    config = Config(properties={"int_property": ConfigProperty(int, default="42")})
+    assert isinstance(config.int_property, int)
+    assert config.int_property == 42
+
+
+def test_property_priority(config_with_yaml):
+    os.environ["EXAMPLE_PROPERTY"] = "env_value"
+    config = config_with_yaml
+
+    # Environment variable takes precedence over default
+    assert config.example_property == "env_value"
+
+    # Setter takes precedence over environment variable
+    config.example_property = "new_value"
+    assert config.example_property == "new_value"
+
+    del os.environ["EXAMPLE_PROPERTY"]
+
+
+def test_default_lambda(config_with_yaml):
+    config = config_with_yaml
+
+    def default_lambda():
+        return "lambda_value"
+
+    config = Config(
+        properties={
+            "lambda_property": ConfigProperty(str, default_lambda=default_lambda)
+        }
+    )
+
+    assert config.lambda_property == "lambda_value"
+
+
+def test_get_user_id_none(monkeypatch):
+    monkeypatch.setattr(getpass, "getuser", lambda: None)
+    assert _get_user_id() == "unknown_user"
+
+
+def test_get_user_id_exception(monkeypatch):
+    def mock_getuser():
+        raise Exception("Test exception")
+
+    monkeypatch.setattr(getpass, "getuser", mock_getuser)
+    assert _get_user_id() == "unknown_user"
+
+
+def test_get_user_id_valid(monkeypatch):
+    monkeypatch.setattr(getpass, "getuser", lambda: "test_user")
+    assert _get_user_id() == "test_user"
+
+
+def test_user_id_default(config_with_yaml):
+    # assert Config.shared().user_id == "scosman"
+    assert len(Config.shared().user_id) > 0
+
+
+def test_yaml_persistence(config_with_yaml, mock_yaml_file):
+    # Set a value
+    config_with_yaml.example_property = "yaml_value"
+
+    # Check that the value was saved to the YAML file
+    with open(mock_yaml_file, "r") as f:
+        saved_settings = yaml.safe_load(f)
+    assert saved_settings["example_property"] == "yaml_value"
+
+    # Create a new config instance to test loading from YAML
+    new_config = Config(
+        properties={
+            "example_property": ConfigProperty(
+                str, default="default_value", env_var="EXAMPLE_PROPERTY"
+            ),
+        }
+    )
+
+    # Check that the value is loaded from YAML
+    assert new_config.example_property == "yaml_value"
+
+    # Set an environment variable to check that yaml takes priority
+    os.environ["EXAMPLE_PROPERTY"] = "env_value"
+
+    # Check that the YAML value takes priority
+    assert new_config.example_property == "yaml_value"
+
+    # Clean up the environment variable
+    del os.environ["EXAMPLE_PROPERTY"]
+
+
+def test_yaml_type_conversion(config_with_yaml, mock_yaml_file):
+    # Set an integer value
+    config_with_yaml.int_property = 42
+
+    # Check that the value was saved to the YAML file
+    with open(mock_yaml_file, "r") as f:
+        saved_settings = yaml.safe_load(f)
+    assert saved_settings["int_property"] == 42
+
+    # Create a new config instance to test loading and type conversion from YAML
+    new_config = Config(
+        properties={
+            "int_property": ConfigProperty(int, default=0),
+        }
+    )
+
+    # Check that the value is loaded from YAML and converted to int
+    assert new_config.int_property == 42
+    assert isinstance(new_config.int_property, int)
+
+
+def test_settings_hide_sensitive():
+    config = Config(
+        {
+            "public_key": ConfigProperty(str, default="public_value"),
+            "secret_key": ConfigProperty(str, default="secret_value", sensitive=True),
+        }
+    )
+
+    # Set values
+    config.public_key = "public_test"
+    config.secret_key = "secret_test"
+
+    # Test without hiding sensitive data
+    visible_settings = config.settings(hide_sensitive=False)
+    assert visible_settings == {
+        "public_key": "public_test",
+        "secret_key": "secret_test",
+    }
+
+    # Test with hiding sensitive data
+    hidden_settings = config.settings(hide_sensitive=True)
+    assert hidden_settings == {"public_key": "public_test", "secret_key": "[hidden]"}
+
+
+def test_list_property(config_with_yaml, mock_yaml_file):
+    # Add a list property to the config
+    config_with_yaml._properties["list_property"] = ConfigProperty(list, default=[])
+
+    # Set initial values
+    config_with_yaml.list_property = ["item1", "item2"]
+
+    # Check that the property returns a list
+    assert isinstance(config_with_yaml.list_property, list)
+    assert config_with_yaml.list_property == ["item1", "item2"]
+
+    # Update the list
+    config_with_yaml.list_property = ["item1", "item2", "item3"]
+    assert config_with_yaml.list_property == ["item1", "item2", "item3"]
+
+    # Check that the value was saved to the YAML file
+    with open(mock_yaml_file, "r") as f:
+        saved_settings = yaml.safe_load(f)
+    assert saved_settings["list_property"] == ["item1", "item2", "item3"]
+
+    # Create a new config instance to test loading from YAML
+    new_config = Config(
+        properties={
+            "list_property": ConfigProperty(list, default=[]),
+        }
+    )
+
+    # Check that the value is loaded from YAML and is a list
+    assert isinstance(new_config.list_property, list)
+    assert new_config.list_property == ["item1", "item2", "item3"]
+
+
+def test_stale_values_bug(config_with_yaml):
+    assert config_with_yaml.example_property == "default_value"
+
+    # Simulate updating the settings file with set_attr
+    config_with_yaml.example_property = "second_value"
+    assert config_with_yaml.example_property == "second_value"
+
+    # Simulate updating the settings file with set_settings
+    config_with_yaml.update_settings({"example_property": "third_value"})
+    assert config_with_yaml.example_property == "third_value"

{kiln_ai-0.0.4.dist-info → kiln_ai-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kiln-ai
-Version: 0.0.4
+Version: 0.5.1
 Summary: Kiln AI
 Home-page: https://kiln-ai.com
 License: Proprietary
@@ -16,3 +16,24 @@ Classifier: Programming Language :: Python :: 3.12
 Project-URL: Bug Tracker, https://github.com/Kiln-AI/kiln/issues
 Project-URL: Documentation, https://github.com/Kiln-AI/kiln#readme
 Project-URL: Repository, https://github.com/Kiln-AI/kiln
+Description-Content-Type: text/markdown
+
+# kiln_ai
+
+[![PyPI - Version](https://img.shields.io/pypi/v/kiln-ai.svg?logo=pypi&label=PyPI&logoColor=gold)](https://pypi.org/project/kiln-ai)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/kiln-ai.svg)](https://pypi.org/project/kiln-ai)
+
+---
+
+## Installation
+
+```console
+pip install kiln_ai
+```
+
+## About Kiln AI
+
+Learn more about Kiln AI at [kiln-ai.com](https://kiln-ai.com)
+
+Github: [github.com/Kiln-AI/kiln](https://github.com/Kiln-AI/kiln)
+

kiln_ai-0.5.1.dist-info/RECORD

@@ -0,0 +1,29 @@
+kiln_ai/adapters/base_adapter.py,sha256=kNQgi_wK3qEwHciN0puiupUoBLq9uxhj-o5chikoLbU,5524
+kiln_ai/adapters/langchain_adapters.py,sha256=AER7ltCyHJQf-SH3pXAWbtKgUrw2bKZAcqU15ZO_x2U,4992
+kiln_ai/adapters/ml_model_list.py,sha256=Lv5T7xlPGnOlxA6DJEPHds9f2FIQ8dq-kqgOgv6G-T8,15036
+kiln_ai/adapters/prompt_builders.py,sha256=O0Z5v3hm0C2Cmx-9ugR-L4ISijakGB4t5nem3N7J65w,4308
+kiln_ai/adapters/repair/repair_task.py,sha256=PXcGyTo-_ChzdutwnUoMNs0QAUHlqqjGGiq03z38jag,3296
+kiln_ai/adapters/repair/test_repair_task.py,sha256=T-1L-YvaWx-ZMOv-brtdSsUgGeNR1fkgb6x8c0lMr4w,7818
+kiln_ai/adapters/test_langchain_adapter.py,sha256=rKC7_SxV_pQmImCLo-4tBEiOJ4k6uf5uRzOgxChp-8w,1875
+kiln_ai/adapters/test_ml_model_list.py,sha256=I6aY_MLkyAGRz6VE7Gd_pJAgKD3CUrc5NrG7VS8BUQc,2806
+kiln_ai/adapters/test_prompt_adaptors.py,sha256=OkQVbODIiZUUxbb-WqLQad3rWYctQzbOFOe6b8p4JCo,6032
+kiln_ai/adapters/test_prompt_builders.py,sha256=R2TLRZOrHRUShLMANZ4AJB5ZGdDSegD-J3geVM_dy90,10639
+kiln_ai/adapters/test_saving_adapter_results.py,sha256=Y1NV4EGnt3KO6B6Gmzo4SIS8fjUZAB1jm64bFU5fS_s,6040
+kiln_ai/adapters/test_structured_output.py,sha256=OQ7yfjAmZd53CEylckhiPzJehZ9NF5Vbko6GCdwQGAg,8754
+kiln_ai/datamodel/__init__.py,sha256=1iUYcXtgnEPonQfYgDtiDaixs_h5MXl03l4nNHZzBjo,13574
+kiln_ai/datamodel/basemodel.py,sha256=-aE5UVwQu1JUJEwjSKV-7u6faxpYZruL_ucRrhA5Y4Q,14559
+kiln_ai/datamodel/json_schema.py,sha256=v-sbC7SuBpzoMKUKNvrBHhVjGxfVzcICcxDJZvkYHc4,1382
+kiln_ai/datamodel/test_basemodel.py,sha256=GRnMWd16Tt-9GGZZ6UIDKiaGt5nLQxcIVkEQxuXGfS4,8633
+kiln_ai/datamodel/test_datasource.py,sha256=vS-DFCKAdLJ8ltTH79ws8tjw8WTKhCQ8amMvKGyEsFY,3264
+kiln_ai/datamodel/test_example_models.py,sha256=9uNi-ZCNMWrhqS0pTDb3jUHlHRTKQJZx5Hsylxb6ljE,20934
+kiln_ai/datamodel/test_json_schema.py,sha256=lYTSx2NiywjxRIRT6k6AcM_nmeAymkUvzhsfFbFml04,3198
+kiln_ai/datamodel/test_models.py,sha256=SZlItqmxjbh8H-0ANoxbayfSppLuBGpRHeQp6mpUcjo,5929
+kiln_ai/datamodel/test_nested_save.py,sha256=9BHh0iVqKY_Ug87uGhTyiRJ9frwy1mUhaqnyMD2oX5Y,5587
+kiln_ai/datamodel/test_output_rating.py,sha256=8PHvxh6jGRXNedl8oSTtr8Ur1lwnJ28xl47preX7X9c,2646
+kiln_ai/utils/config.py,sha256=jXUB8lwFkxLNEaizwIsoeFLg1BwjWr39-5KdEGF37Bg,5424
+kiln_ai/utils/formatting.py,sha256=VtB9oag0lOGv17dwT7OPX_3HzBfaU9GsLH-iLete0yM,97
+kiln_ai/utils/test_config.py,sha256=22i5t7tElOoVYfgR_Nmif3QriPt9yAqlK8e5CgiCCUM,7410
+kiln_ai-0.5.1.dist-info/LICENSE.txt,sha256=-AhuIX-CMdNGJNj74C29e9cKKmsh-1PBPINCsNvwAeg,82
+kiln_ai-0.5.1.dist-info/METADATA,sha256=kiprIC5n7bnGF0irnxvcQNZGHE1GLD8E8e7HRQRfNAo,1238
+kiln_ai-0.5.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+kiln_ai-0.5.1.dist-info/RECORD,,

kiln_ai/__init.__.py

@@ -1,3 +0,0 @@
-import coreadd
-
-__all__ = ["coreadd"]

kiln_ai/coreadd.py

@@ -1,3 +0,0 @@
-# TODO_P0: remove example function
-def add(a, b) -> int:
-    return a + b + 1

kiln_ai/datamodel/project.py

@@ -1,15 +0,0 @@
-from pydantic import BaseModel
-from typing import Optional
-
-
-class KilnProject(BaseModel):
-    version: int = 1
-    name: str
-    path: Optional[str] = None
-
-    def __init__(self, name: str, path: Optional[str] = None):
-        # TODO: learn about pydantic init
-        super().__init__(name=name, path=path)
-        if path is not None and name is not None:
-            # path and name are mutually exclusive for constructor, name comes from path if passed
-            raise ValueError("path and name are mutually exclusive")

kiln_ai-0.0.4.dist-info/RECORD

@@ -1,8 +0,0 @@
-kiln_ai/__init.__.py,sha256=4OOrqjKxMymEivpmr_q0UPol0N_zJhgurRwxxShFTfQ,38
-kiln_ai/coreadd.py,sha256=2VSwMUN89ewbmsn-uUUzRUNq1otD5DTjmM_Z_XG4Mc8,78
-kiln_ai/datamodel/__init__.py,sha256=EHMToTvBMGWp6vEbBpKICmDex77su8mLgbFBVqNJVGA,60
-kiln_ai/datamodel/project.py,sha256=IH_skMyfZ-ieeYTzdMc0IrA8MSKvfEQij9HLkYXuwsM,528
-kiln_ai-0.0.4.dist-info/LICENSE.txt,sha256=-AhuIX-CMdNGJNj74C29e9cKKmsh-1PBPINCsNvwAeg,82
-kiln_ai-0.0.4.dist-info/METADATA,sha256=IldGPZe9E1yAZB56xg12815PA1ebEPaLUdWvIi6HrjM,731
-kiln_ai-0.0.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-kiln_ai-0.0.4.dist-info/RECORD,,