sunholo 0.61.0__tar.gz → 0.61.4__tar.gz

{sunholo-0.61.0 → sunholo-0.61.4}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: sunholo
-Version: 0.61.0
+Version: 0.61.4
 Summary: Large Language Model DevOps - a package to help deploy LLMs to the Cloud.
 Home-page: https://github.com/sunholo-data/sunholo-py
-Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.61.0.tar.gz
+Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.61.4.tar.gz
 Author: Holosun ApS
 Author-email: multivac@sunholo.com
 License: Apache License, Version 2.0

{sunholo-0.61.0 → sunholo-0.61.4}/setup.py

@@ -1,7 +1,7 @@
 from setuptools import setup, find_packages
 
 # Define your base version
-version = '0.61.0'
+version = '0.61.4'
 
 setup(
     name='sunholo',

{sunholo-0.61.0 → sunholo-0.61.4}/sunholo/agents/chat_history.py

@@ -74,7 +74,7 @@ def embeds_to_json(message: dict):
     # Output: '[{"type": "image", "url": "https://example.com/image.png"}]'
     ```
     """
-    if len(message['embeds'] > 0):
+    if 'embeds' in message and len(message['embeds']) > 0:
         return json.dumps(message.get("embeds"))
     else:
         return ""

{sunholo-0.61.0 → sunholo-0.61.4}/sunholo/components/vectorstore.py

@@ -45,7 +45,7 @@ def pick_vectorstore(vs_str, vector_name, embeddings, read_only=None):
         return vectorstore
     
     elif vs_str == 'cloudsql' or vs_str == 'postgres':
-        from langchain.vectorstores.pgvector import PGVector
+        from langchain_community.vectorstores import PGVector
 
         log.debug("Inititaing CloudSQL/Postgres pgvector")
         #setup_cloudsql(vector_name) 

{sunholo-0.61.0 → sunholo-0.61.4}/sunholo/utils/config.py

@@ -75,7 +75,7 @@ def load_all_configs():
             if filename in config_cache:
                 cached_config, cache_time = config_cache[filename]
                 if (current_time - cache_time) < timedelta(minutes=5):
-                    log.info(f"Returning cached config for {filename}")
+                    log.debug(f"Returning cached config for {filename}")
                     config = cached_config
                 else:
                     config = reload_config_file(config_file, filename)
@@ -167,7 +167,7 @@ def load_config(filename: str=None) -> tuple[dict, str]:
     
     return config, filename
 
-def load_config_key(key: str, vector_name: str, kind: str=None):
+def load_config_key(key: str, vector_name: str, kind: str):
     """
     Load a specific key from a configuration file.
 
@@ -192,27 +192,16 @@ def load_config_key(key: str, vector_name: str, kind: str=None):
     
     configs_by_kind = load_all_configs()
 
-    if kind:
-        log.debug(f"Got kind: {kind} - applying to configs")
+    log.debug(f"Got kind: {kind} - applying to configs")
     
     if not configs_by_kind:
         log.warning("Did not load configs via folder")
              
-    if kind and configs_by_kind.get(kind):
-        config = configs_by_kind[kind]
-        filename = kind
-    else:
-        config, filename = load_config(filename)
+    config = configs_by_kind[kind]
 
-    log.debug(f"Fetching '{key}' for '{vector_name}'")
     apiVersion = config.get('apiVersion')
-    kind = config.get('kind')
-    vac = config.get('vac')
 
-    if not apiVersion or not kind:
-        raise ValueError("Deprecated config file, move to config with `apiVersion` and `kind` set")
-
-    log.debug(f"Loaded config file {kind}/{apiVersion}")
+    log.debug(f"Fetching '{key}' for '{vector_name}' from '{kind}/{apiVersion}'")
     
     if kind == 'vacConfig':
         if vector_name == 'global':
@@ -226,7 +215,7 @@ def load_config_key(key: str, vector_name: str, kind: str=None):
             raise ValueError("Deprecated config file, move to config with `vac:` at top level for `vector_name`")
         vac_config = vac.get(vector_name)
         if not vac_config:
-            raise ValueError(f"No config array was found for {vector_name} in {filename}")
+            raise ValueError(f"No config array was found for {vector_name} in {kind}")
         
         log.debug(f'vac_config: {vac_config} for {vector_name} - fetching "{key}"')
         key_value = vac_config.get(key)

{sunholo-0.61.0 → sunholo-0.61.4}/sunholo.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: sunholo
-Version: 0.61.0
+Version: 0.61.4
 Summary: Large Language Model DevOps - a package to help deploy LLMs to the Cloud.
 Home-page: https://github.com/sunholo-data/sunholo-py
-Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.61.0.tar.gz
+Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.61.4.tar.gz
 Author: Holosun ApS
 Author-email: multivac@sunholo.com
 License: Apache License, Version 2.0

{sunholo-0.61.0 → sunholo-0.61.4}/sunholo.egg-info/SOURCES.txt

@@ -106,6 +106,5 @@ sunholo/utils/parsers.py
 sunholo/utils/user_ids.py
 sunholo/vertex/__init__.py
 sunholo/vertex/init_vertex.py
-test/test_dispatch_to_qa.py
 tests/test_chat_history.py
 tests/test_config.py

sunholo-0.61.4/tests/test_config.py

@@ -0,0 +1,15 @@
+import pytest
+from unittest.mock import patch, mock_open
+from sunholo.utils import config
+
+def test_load_config():
+    expected_config = {"key": "value"}
+    with pytest.raises(FileNotFoundError):
+        config.load_config("non_existent_file")
+    with patch("builtins.open", mock_open(read_data='{"key": "value"}'), create=True):
+        result, _ = config.load_config("mock_file.json")
+        assert result == expected_config
+
+def test_load_config_key():
+    with pytest.raises(KeyError):
+        config.load_config_key("non_existent_key", "mock_vector_name")

sunholo-0.61.0/test/test_dispatch_to_qa.py

@@ -1,73 +0,0 @@
-import pytest
-import requests_mock
-from sunholo.agents import dispatch_to_qa
-
-
-def setup():
-    user_input = 'mock_user_input'
-    chat_history = 'mock_chat_history'
-    vector_name = 'mock_vector_name'
-    stream = 'mock_stream'
-    return user_input, chat_history, vector_name, stream
-
-
-def test_prep_request_payload():
-    user_input, chat_history, vector_name, stream = setup()
-    # Call 'prep_request_payload' with the mock data
-    qna_endpoint, qna_data = dispatch_to_qa.prep_request_payload(user_input, chat_history, vector_name, stream)
-    # Check the returned 'qna_endpoint' and 'qna_data'
-    assert qna_endpoint == 'expected_qna_endpoint'
-    assert qna_data == 'expected_qna_data'
-
-
-def test_send_to_qa():
-    user_input, chat_history, vector_name, stream = setup()
-    mock_qna_endpoint = 'http://mock.qna.endpoint'
-    mock_response = {'status': 'success'}
-    with requests_mock.Mocker() as m:
-        m.post(mock_qna_endpoint, json=mock_response)
-        response = dispatch_to_qa.send_to_qa(user_input, chat_history, vector_name, stream)
-        assert response == mock_response
-
-    # Scenario where 'stream' is True and the response is a generator that yields response content chunks
-    mock_response_chunk = 'mock_response_chunk'
-    m.post(mock_qna_endpoint, text=mock_response_chunk)
-    response = dispatch_to_qa.send_to_qa(user_input, chat_history, vector_name, True)
-    assert next(response) == mock_response_chunk
-
-    # Scenario where an HTTP error occurs
-    m.post(mock_qna_endpoint, status_code=500)
-    response = dispatch_to_qa.send_to_qa(user_input, chat_history, vector_name, stream)
-    assert 'Error' in response
-
-    # Scenario where any other error occurs
-    m.post(mock_qna_endpoint, exc=requests_mock.exceptions.ReadTimeout)
-    response = dispatch_to_qa.send_to_qa(user_input, chat_history, vector_name, stream)
-    assert 'Error' in response
-
-
-def test_send_to_qa_async():
-    user_input, chat_history, vector_name, stream = setup()
-    mock_qna_endpoint = 'http://mock.qna.endpoint'
-    mock_response = {'status': 'success'}
-    import aiohttp
-
-    @pytest.mark.asyncio
-    async def test_send_to_qa_async():
-        user_input, chat_history, vector_name, stream = setup()
-        mock_qna_endpoint = 'http://mock.qna.endpoint'
-        mock_response = {'status': 'success'}
-        async with aiohttp.ClientSession() as session:
-            async with session.post(mock_qna_endpoint, json=mock_response) as resp:
-                response = await dispatch_to_qa.send_to_qa_async(user_input, chat_history, vector_name, stream)
-                assert response == mock_response
-
-        # Scenario where an HTTP error occurs
-        async with session.post(mock_qna_endpoint, status=500) as resp:
-            response = await dispatch_to_qa.send_to_qa_async(user_input, chat_history, vector_name, stream)
-            assert 'Error' in response
-
-        # Scenario where any other error occurs
-        async with session.post(mock_qna_endpoint, raise_for_status=False) as resp:
-            response = await dispatch_to_qa.send_to_qa_async(user_input, chat_history, vector_name, stream)
-            assert 'Error' in response

sunholo-0.61.0/tests/test_config.py

@@ -1,40 +0,0 @@
-import pytest
-from sunholo.utils import config
-
-# Test for the `load_config` function
-def test_load_config():
-    # Assuming the function is supposed to load a configuration from a file
-    # and return a dictionary with the configuration data
-    expected_config = {"key": "value"}
-    with pytest.raises(FileNotFoundError):
-        config.load_config("non_existent_file")
-    with pytest.mock.patch("builtins.open", pytest.mock.mock_open(read_data="key: value"), create=True):
-        assert config.load_config("mock_file.yaml") == expected_config
-
-# Test for the `load_config_key` function
-def test_load_config_key():
-    # Assuming the function is supposed to load a specific key from the configuration
-    expected_value = "value"
-    with pytest.raises(KeyError):
-        config.load_config_key("non_existent_key", "mock_vector_name")
-    with pytest.mock.patch("sunholo.utils.config.load_all_configs", return_value={"mock_vector_name": {"key": "value"}}):
-        assert config.load_config_key("key", "mock_vector_name") == expected_value
-
-# Test for the `get_module_filepath` function
-def test_get_module_filepath():
-    # Assuming the function is supposed to return the absolute path of a module file
-    expected_path = "/absolute/path/to/module/file"
-    with pytest.mock.patch("os.path.dirname", return_value="/absolute/path/to"):
-        assert config.get_module_filepath("module/file") == expected_path
-
-# Test for the `fetch_config` function
-def test_fetch_config():
-    # Assuming the function is supposed to fetch configuration from a cloud storage bucket
-    expected_update_time = "2022-01-01T00:00:00Z"
-    with pytest.mock.patch("google.cloud.storage.Client") as mock_client:
-        mock_bucket = mock_client.return_value.get_bucket.return_value
-        mock_blob = mock_bucket.get_blob.return_value
-        mock_blob.updated = expected_update_time
-        assert config.fetch_config("bucket_name", "blob_name") == expected_update_time
-        mock_bucket.get_blob.return_value = None
-        assert config.fetch_config("bucket_name", "blob_name") is None