langchain-ollama 0.3.4__tar.gz → 0.3.6__tar.gz

{langchain_ollama-0.3.4 → langchain_ollama-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-ollama
-Version: 0.3.4
+Version: 0.3.6
 Summary: An integration package connecting Ollama and LangChain
 License: MIT
 Project-URL: Source Code, https://github.com/langchain-ai/langchain/tree/master/libs/partners/ollama
@@ -8,7 +8,7 @@ Project-URL: Release Notes, https://github.com/langchain-ai/langchain/releases?q
 Project-URL: repository, https://github.com/langchain-ai/langchain
 Requires-Python: >=3.9
 Requires-Dist: ollama<1.0.0,>=0.5.1
-Requires-Dist: langchain-core<1.0.0,>=0.3.68
+Requires-Dist: langchain-core<1.0.0,>=0.3.70
 Description-Content-Type: text/markdown
 
 # langchain-ollama

{langchain_ollama-0.3.4 → langchain_ollama-0.3.6}/langchain_ollama/__init__.py

@@ -1,6 +1,15 @@
 """This is the langchain_ollama package.
 
-It provides infrastructure for interacting with the Ollama service.
+Provides infrastructure for interacting with the `Ollama <https://ollama.com/>`__
+service.
+
+.. note::
+    **Newly added in 0.3.4:** ``validate_model_on_init`` param on all models.
+    This parameter allows you to validate the model exists in Ollama locally on
+    initialization. If set to ``True``, it will raise an error if the model does not
+    exist locally. This is useful for ensuring that the model is available before
+    attempting to use it, especially in environments where models may not be
+    pre-downloaded.
 """
 
 from importlib import metadata

{langchain_ollama-0.3.4 → langchain_ollama-0.3.6}/langchain_ollama/chat_models.py

@@ -2,7 +2,9 @@
 
 from __future__ import annotations
 
+import ast
 import json
+import logging
 from collections.abc import AsyncIterator, Iterator, Mapping, Sequence
 from operator import itemgetter
 from typing import (
@@ -57,6 +59,8 @@ from typing_extensions import Self, is_typeddict
 
 from ._utils import validate_model
 
+log = logging.getLogger(__name__)
+
 
 def _get_usage_metadata_from_generation_info(
     generation_info: Optional[Mapping[str, Any]],
@@ -77,33 +81,45 @@ def _get_usage_metadata_from_generation_info(
 
 def _parse_json_string(
     json_string: str,
+    *,
     raw_tool_call: dict[str, Any],
-    skip: bool,  # noqa: FBT001
+    skip: bool,
 ) -> Any:
     """Attempt to parse a JSON string for tool calling.
 
+    It first tries to use the standard json.loads. If that fails, it falls
+    back to ast.literal_eval to safely parse Python literals, which is more
+    robust against models using single quotes or containing apostrophes.
+
     Args:
         json_string: JSON string to parse.
-        skip: Whether to ignore parsing errors and return the value anyways.
         raw_tool_call: Raw tool call to include in error message.
+        skip: Whether to ignore parsing errors and return the value anyways.
 
     Returns:
-        The parsed JSON string.
+        The parsed JSON string or Python literal.
 
     Raises:
-        OutputParserException: If the JSON string wrong invalid and skip=False.
+        OutputParserException: If the string is invalid and skip=False.
     """
     try:
         return json.loads(json_string)
-    except json.JSONDecodeError as e:
-        if skip:
-            return json_string
-        msg = (
-            f"Function {raw_tool_call['function']['name']} arguments:\n\n"
-            f"{raw_tool_call['function']['arguments']}\n\nare not valid JSON. "
-            f"Received JSONDecodeError {e}"
-        )
-        raise OutputParserException(msg) from e
+    except json.JSONDecodeError:
+        try:
+            # Use ast.literal_eval to safely parse Python-style dicts
+            # (e.g. with single quotes)
+            return ast.literal_eval(json_string)
+        except (SyntaxError, ValueError) as e:
+            # If both fail, and we're not skipping, raise an informative error.
+            if skip:
+                return json_string
+            msg = (
+                f"Function {raw_tool_call['function']['name']} arguments:\n\n"
+                f"{raw_tool_call['function']['arguments']}"
+                "\n\nare not valid JSON or a Python literal. "
+                f"Received error: {e}"
+            )
+            raise OutputParserException(msg) from e
     except TypeError as e:
         if skip:
             return json_string
@@ -424,7 +440,10 @@ class ChatOllama(BaseChatModel):
       unless you set ``reasoning`` to ``True``."""
 
     validate_model_on_init: bool = False
-    """Whether to validate the model exists in Ollama locally on initialization."""
+    """Whether to validate the model exists in Ollama locally on initialization.
+
+    .. versionadded:: 0.3.4
+    """
 
     mirostat: Optional[int] = None
     """Enable Mirostat sampling for controlling perplexity.
@@ -821,6 +840,28 @@ class ChatOllama(BaseChatModel):
         reasoning = kwargs.get("reasoning", self.reasoning)
         for stream_resp in self._create_chat_stream(messages, stop, **kwargs):
             if not isinstance(stream_resp, str):
+                content = (
+                    stream_resp["message"]["content"]
+                    if "message" in stream_resp and "content" in stream_resp["message"]
+                    else ""
+                )
+
+                # Warn and skip responses with done_reason: 'load' and empty content
+                # These indicate the model was loaded but no actual generation occurred
+                is_load_response_with_empty_content = (
+                    stream_resp.get("done") is True
+                    and stream_resp.get("done_reason") == "load"
+                    and not content.strip()
+                )
+
+                if is_load_response_with_empty_content:
+                    log.warning(
+                        "Ollama returned empty response with done_reason='load'."
+                        "This typically indicates the model was loaded but no content "
+                        "was generated. Skipping this response."
+                    )
+                    continue
+
                 if stream_resp.get("done") is True:
                     generation_info = dict(stream_resp)
                     if "model" in generation_info:
@@ -829,12 +870,6 @@ class ChatOllama(BaseChatModel):
                 else:
                     generation_info = None
 
-                content = (
-                    stream_resp["message"]["content"]
-                    if "message" in stream_resp and "content" in stream_resp["message"]
-                    else ""
-                )
-
                 additional_kwargs = {}
                 if (
                     reasoning
@@ -881,6 +916,28 @@ class ChatOllama(BaseChatModel):
         reasoning = kwargs.get("reasoning", self.reasoning)
         async for stream_resp in self._acreate_chat_stream(messages, stop, **kwargs):
             if not isinstance(stream_resp, str):
+                content = (
+                    stream_resp["message"]["content"]
+                    if "message" in stream_resp and "content" in stream_resp["message"]
+                    else ""
+                )
+
+                # Warn and skip responses with done_reason: 'load' and empty content
+                # These indicate the model was loaded but no actual generation occurred
+                is_load_response_with_empty_content = (
+                    stream_resp.get("done") is True
+                    and stream_resp.get("done_reason") == "load"
+                    and not content.strip()
+                )
+
+                if is_load_response_with_empty_content:
+                    log.warning(
+                        "Ollama returned empty response with done_reason='load'. "
+                        "This typically indicates the model was loaded but no content "
+                        "was generated. Skipping this response."
+                    )
+                    continue
+
                 if stream_resp.get("done") is True:
                     generation_info = dict(stream_resp)
                     if "model" in generation_info:
@@ -889,12 +946,6 @@ class ChatOllama(BaseChatModel):
                 else:
                     generation_info = None
 
-                content = (
-                    stream_resp["message"]["content"]
-                    if "message" in stream_resp and "content" in stream_resp["message"]
-                    else ""
-                )
-
                 additional_kwargs = {}
                 if (
                     reasoning

{langchain_ollama-0.3.4 → langchain_ollama-0.3.6}/langchain_ollama/embeddings.py

@@ -128,7 +128,10 @@ class OllamaEmbeddings(BaseModel, Embeddings):
     """Model name to use."""
 
     validate_model_on_init: bool = False
-    """Whether to validate the model exists in ollama locally on initialization."""
+    """Whether to validate the model exists in ollama locally on initialization.
+
+    .. versionadded:: 0.3.4
+    """
 
     base_url: Optional[str] = None
     """Base url the model is hosted under."""
@@ -296,7 +299,10 @@ class OllamaEmbeddings(BaseModel, Embeddings):
             raise ValueError(msg)
         return (
             await self._async_client.embed(
-                self.model, texts, keep_alive=self.keep_alive
+                self.model,
+                texts,
+                options=self._default_params,
+                keep_alive=self.keep_alive,
             )
         )["embeddings"]
 

{langchain_ollama-0.3.4 → langchain_ollama-0.3.6}/langchain_ollama/llms.py

@@ -53,7 +53,10 @@ class OllamaLLM(BaseLLM):
       be present directly within the main response content."""
 
     validate_model_on_init: bool = False
-    """Whether to validate the model exists in ollama locally on initialization."""
+    """Whether to validate the model exists in ollama locally on initialization.
+
+    .. versionadded:: 0.3.4
+    """
 
     mirostat: Optional[int] = None
     """Enable Mirostat sampling for controlling perplexity.

{langchain_ollama-0.3.4 → langchain_ollama-0.3.6}/pyproject.toml

@@ -9,10 +9,10 @@ authors = []
 requires-python = ">=3.9"
 dependencies = [
     "ollama>=0.5.1,<1.0.0",
-    "langchain-core<1.0.0,>=0.3.68",
+    "langchain-core<1.0.0,>=0.3.70",
 ]
 name = "langchain-ollama"
-version = "0.3.4"
+version = "0.3.6"
 description = "An integration package connecting Ollama and LangChain"
 readme = "README.md"
 

langchain_ollama-0.3.6/tests/unit_tests/test_chat_models.py

@@ -0,0 +1,270 @@
+"""Test chat model integration."""
+
+import json
+import logging
+from collections.abc import Generator
+from contextlib import contextmanager
+from typing import Any
+from unittest.mock import MagicMock, patch
+
+import pytest
+from httpx import Client, Request, Response
+from langchain_core.exceptions import OutputParserException
+from langchain_core.messages import ChatMessage, HumanMessage
+from langchain_tests.unit_tests import ChatModelUnitTests
+
+from langchain_ollama.chat_models import (
+    ChatOllama,
+    _parse_arguments_from_tool_call,
+    _parse_json_string,
+)
+
+MODEL_NAME = "llama3.1"
+
+
+class TestChatOllama(ChatModelUnitTests):
+    @property
+    def chat_model_class(self) -> type[ChatOllama]:
+        return ChatOllama
+
+    @property
+    def chat_model_params(self) -> dict:
+        return {"model": MODEL_NAME}
+
+
+def test__parse_arguments_from_tool_call() -> None:
+    raw_response = '{"model":"sample-model","message":{"role":"assistant","content":"","tool_calls":[{"function":{"name":"get_profile_details","arguments":{"arg_1":"12345678901234567890123456"}}}]},"done":false}'  # noqa: E501
+    raw_tool_calls = json.loads(raw_response)["message"]["tool_calls"]
+    response = _parse_arguments_from_tool_call(raw_tool_calls[0])
+    assert response is not None
+    assert isinstance(response["arg_1"], str)
+
+
+@contextmanager
+def _mock_httpx_client_stream(
+    *args: Any, **kwargs: Any
+) -> Generator[Response, Any, Any]:
+    yield Response(
+        status_code=200,
+        content='{"message": {"role": "assistant", "content": "The meaning ..."}}',
+        request=Request(method="POST", url="http://whocares:11434"),
+    )
+
+
+def test_arbitrary_roles_accepted_in_chatmessages(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(Client, "stream", _mock_httpx_client_stream)
+    llm = ChatOllama(
+        model=MODEL_NAME,
+        verbose=True,
+        format=None,
+    )
+    messages = [
+        ChatMessage(
+            role="somerandomrole",
+            content="I'm ok with you adding any role message now!",
+        ),
+        ChatMessage(role="control", content="thinking"),
+        ChatMessage(role="user", content="What is the meaning of life?"),
+    ]
+    llm.invoke(messages)
+
+
+@patch("langchain_ollama.chat_models.validate_model")
+def test_validate_model_on_init(mock_validate_model: Any) -> None:
+    """Test that the model is validated on initialization when requested."""
+    # Test that validate_model is called when validate_model_on_init=True
+    ChatOllama(model=MODEL_NAME, validate_model_on_init=True)
+    mock_validate_model.assert_called_once()
+    mock_validate_model.reset_mock()
+
+    # Test that validate_model is NOT called when validate_model_on_init=False
+    ChatOllama(model=MODEL_NAME, validate_model_on_init=False)
+    mock_validate_model.assert_not_called()
+
+    # Test that validate_model is NOT called by default
+    ChatOllama(model=MODEL_NAME)
+    mock_validate_model.assert_not_called()
+
+
+# Define a dummy raw_tool_call for the function signature
+dummy_raw_tool_call = {
+    "function": {"name": "test_func", "arguments": ""},
+}
+
+
+# --- Regression tests for tool-call argument parsing (see #30910) ---
+
+
+@pytest.mark.parametrize(
+    "input_string, expected_output",
+    [
+        # Case 1: Standard double-quoted JSON
+        ('{"key": "value", "number": 123}', {"key": "value", "number": 123}),
+        # Case 2: Single-quoted string (the original bug)
+        ("{'key': 'value', 'number': 123}", {"key": "value", "number": 123}),
+        # Case 3: String with an internal apostrophe
+        ('{"text": "It\'s a great test!"}', {"text": "It's a great test!"}),
+        # Case 4: Mixed quotes that ast can handle
+        ("{'text': \"It's a great test!\"}", {"text": "It's a great test!"}),
+    ],
+)
+def test_parse_json_string_success_cases(
+    input_string: str, expected_output: Any
+) -> None:
+    """Tests that _parse_json_string correctly parses valid and fixable strings."""
+    raw_tool_call = {"function": {"name": "test_func", "arguments": input_string}}
+    result = _parse_json_string(input_string, raw_tool_call=raw_tool_call, skip=False)
+    assert result == expected_output
+
+
+def test_parse_json_string_failure_case_raises_exception() -> None:
+    """Tests that _parse_json_string raises an exception for truly malformed strings."""
+    malformed_string = "{'key': 'value',,}"
+    raw_tool_call = {"function": {"name": "test_func", "arguments": malformed_string}}
+    with pytest.raises(OutputParserException):
+        _parse_json_string(
+            malformed_string,
+            raw_tool_call=raw_tool_call,
+            skip=False,
+        )
+
+
+def test_parse_json_string_skip_returns_input_on_failure() -> None:
+    """Tests that skip=True returns the original string on parse failure."""
+    malformed_string = "{'not': valid,,,}"
+    raw_tool_call = {"function": {"name": "test_func", "arguments": malformed_string}}
+    result = _parse_json_string(
+        malformed_string,
+        raw_tool_call=raw_tool_call,
+        skip=True,
+    )
+    assert result == malformed_string
+
+
+def test_load_response_with_empty_content_is_skipped(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test that load responses with empty content log a warning and are skipped."""
+    load_only_response = [
+        {
+            "model": "test-model",
+            "created_at": "2025-01-01T00:00:00.000000000Z",
+            "done": True,
+            "done_reason": "load",
+            "message": {"role": "assistant", "content": ""},
+        }
+    ]
+
+    with patch("langchain_ollama.chat_models.Client") as mock_client_class:
+        mock_client = MagicMock()
+        mock_client_class.return_value = mock_client
+        mock_client.chat.return_value = load_only_response
+
+        llm = ChatOllama(model="test-model")
+
+        with (
+            caplog.at_level(logging.WARNING),
+            pytest.raises(ValueError, match="No data received from Ollama stream"),
+        ):
+            llm.invoke([HumanMessage("Hello")])
+
+        assert "Ollama returned empty response with done_reason='load'" in caplog.text
+
+
+def test_load_response_with_whitespace_content_is_skipped(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test load responses w/ only whitespace content log a warning and are skipped."""
+    load_whitespace_response = [
+        {
+            "model": "test-model",
+            "created_at": "2025-01-01T00:00:00.000000000Z",
+            "done": True,
+            "done_reason": "load",
+            "message": {"role": "assistant", "content": "   \n  \t  "},
+        }
+    ]
+
+    with patch("langchain_ollama.chat_models.Client") as mock_client_class:
+        mock_client = MagicMock()
+        mock_client_class.return_value = mock_client
+        mock_client.chat.return_value = load_whitespace_response
+
+        llm = ChatOllama(model="test-model")
+
+        with (
+            caplog.at_level(logging.WARNING),
+            pytest.raises(ValueError, match="No data received from Ollama stream"),
+        ):
+            llm.invoke([HumanMessage("Hello")])
+        assert "Ollama returned empty response with done_reason='load'" in caplog.text
+
+
+def test_load_followed_by_content_response(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test load responses log a warning and are skipped when followed by content."""
+    load_then_content_response = [
+        {
+            "model": "test-model",
+            "created_at": "2025-01-01T00:00:00.000000000Z",
+            "done": True,
+            "done_reason": "load",
+            "message": {"role": "assistant", "content": ""},
+        },
+        {
+            "model": "test-model",
+            "created_at": "2025-01-01T00:00:01.000000000Z",
+            "done": True,
+            "done_reason": "stop",
+            "message": {
+                "role": "assistant",
+                "content": "Hello! How can I help you today?",
+            },
+        },
+    ]
+
+    with patch("langchain_ollama.chat_models.Client") as mock_client_class:
+        mock_client = MagicMock()
+        mock_client_class.return_value = mock_client
+        mock_client.chat.return_value = load_then_content_response
+
+        llm = ChatOllama(model="test-model")
+
+        with caplog.at_level(logging.WARNING):
+            result = llm.invoke([HumanMessage("Hello")])
+
+        assert "Ollama returned empty response with done_reason='load'" in caplog.text
+        assert result.content == "Hello! How can I help you today?"
+        assert result.response_metadata.get("done_reason") == "stop"
+
+
+def test_load_response_with_actual_content_is_not_skipped(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test load responses with actual content are NOT skipped and log no warning."""
+    load_with_content_response = [
+        {
+            "model": "test-model",
+            "created_at": "2025-01-01T00:00:00.000000000Z",
+            "done": True,
+            "done_reason": "load",
+            "message": {"role": "assistant", "content": "This is actual content"},
+        }
+    ]
+
+    with patch("langchain_ollama.chat_models.Client") as mock_client_class:
+        mock_client = MagicMock()
+        mock_client_class.return_value = mock_client
+        mock_client.chat.return_value = load_with_content_response
+
+        llm = ChatOllama(model="test-model")
+
+        with caplog.at_level(logging.WARNING):
+            result = llm.invoke([HumanMessage("Hello")])
+
+        assert result.content == "This is actual content"
+        assert result.response_metadata.get("done_reason") == "load"
+        assert not caplog.text

langchain_ollama-0.3.6/tests/unit_tests/test_embeddings.py

@@ -0,0 +1,63 @@
+"""Test embedding model integration."""
+
+from typing import Any
+from unittest.mock import Mock, patch
+
+from langchain_ollama.embeddings import OllamaEmbeddings
+
+MODEL_NAME = "llama3.1"
+
+
+def test_initialization() -> None:
+    """Test embedding model initialization."""
+    OllamaEmbeddings(model=MODEL_NAME, keep_alive=1)
+
+
+@patch("langchain_ollama.embeddings.validate_model")
+def test_validate_model_on_init(mock_validate_model: Any) -> None:
+    """Test that the model is validated on initialization when requested."""
+    # Test that validate_model is called when validate_model_on_init=True
+    OllamaEmbeddings(model=MODEL_NAME, validate_model_on_init=True)
+    mock_validate_model.assert_called_once()
+    mock_validate_model.reset_mock()
+
+    # Test that validate_model is NOT called when validate_model_on_init=False
+    OllamaEmbeddings(model=MODEL_NAME, validate_model_on_init=False)
+    mock_validate_model.assert_not_called()
+
+    # Test that validate_model is NOT called by default
+    OllamaEmbeddings(model=MODEL_NAME)
+    mock_validate_model.assert_not_called()
+
+
+@patch("langchain_ollama.embeddings.Client")
+def test_embed_documents_passes_options(mock_client_class: Any) -> None:
+    """Test that embed_documents method passes options including num_gpu."""
+    # Create a mock client instance
+    mock_client = Mock()
+    mock_client_class.return_value = mock_client
+
+    # Mock the embed method response
+    mock_client.embed.return_value = {"embeddings": [[0.1, 0.2, 0.3]]}
+
+    # Create embeddings with num_gpu parameter
+    embeddings = OllamaEmbeddings(model=MODEL_NAME, num_gpu=4, temperature=0.5)
+
+    # Call embed_documents
+    result = embeddings.embed_documents(["test text"])
+
+    # Verify the result
+    assert result == [[0.1, 0.2, 0.3]]
+
+    # Check that embed was called with correct arguments
+    mock_client.embed.assert_called_once()
+    call_args = mock_client.embed.call_args
+
+    # Verify the keyword arguments
+    assert "options" in call_args.kwargs
+    assert "keep_alive" in call_args.kwargs
+
+    # Verify options contain num_gpu and temperature
+    options = call_args.kwargs["options"]
+    assert options["num_gpu"] == 4
+    assert options["temperature"] == 0.5

langchain_ollama-0.3.4/tests/unit_tests/test_chat_models.py

@@ -1,85 +0,0 @@
-"""Test chat model integration."""
-
-import json
-from collections.abc import Generator
-from contextlib import contextmanager
-from typing import Any
-from unittest.mock import patch
-
-import pytest
-from httpx import Client, Request, Response
-from langchain_core.messages import ChatMessage
-from langchain_tests.unit_tests import ChatModelUnitTests
-
-from langchain_ollama.chat_models import ChatOllama, _parse_arguments_from_tool_call
-
-MODEL_NAME = "llama3.1"
-
-
-class TestChatOllama(ChatModelUnitTests):
-    @property
-    def chat_model_class(self) -> type[ChatOllama]:
-        return ChatOllama
-
-    @property
-    def chat_model_params(self) -> dict:
-        return {"model": MODEL_NAME}
-
-
-def test__parse_arguments_from_tool_call() -> None:
-    raw_response = '{"model":"sample-model","message":{"role":"assistant","content":"","tool_calls":[{"function":{"name":"get_profile_details","arguments":{"arg_1":"12345678901234567890123456"}}}]},"done":false}'  # noqa: E501
-    raw_tool_calls = json.loads(raw_response)["message"]["tool_calls"]
-    response = _parse_arguments_from_tool_call(raw_tool_calls[0])
-    assert response is not None
-    assert isinstance(response["arg_1"], str)
-
-
-@contextmanager
-def _mock_httpx_client_stream(
-    *args: Any, **kwargs: Any
-) -> Generator[Response, Any, Any]:
-    yield Response(
-        status_code=200,
-        content='{"message": {"role": "assistant", "content": "The meaning ..."}}',
-        request=Request(method="POST", url="http://whocares:11434"),
-    )
-
-
-def test_arbitrary_roles_accepted_in_chatmessages(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(Client, "stream", _mock_httpx_client_stream)
-
-    llm = ChatOllama(
-        model=MODEL_NAME,
-        verbose=True,
-        format=None,
-    )
-
-    messages = [
-        ChatMessage(
-            role="somerandomrole",
-            content="I'm ok with you adding any role message now!",
-        ),
-        ChatMessage(role="control", content="thinking"),
-        ChatMessage(role="user", content="What is the meaning of life?"),
-    ]
-
-    llm.invoke(messages)
-
-
-@patch("langchain_ollama.chat_models.validate_model")
-def test_validate_model_on_init(mock_validate_model: Any) -> None:
-    """Test that the model is validated on initialization when requested."""
-    # Test that validate_model is called when validate_model_on_init=True
-    ChatOllama(model=MODEL_NAME, validate_model_on_init=True)
-    mock_validate_model.assert_called_once()
-    mock_validate_model.reset_mock()
-
-    # Test that validate_model is NOT called when validate_model_on_init=False
-    ChatOllama(model=MODEL_NAME, validate_model_on_init=False)
-    mock_validate_model.assert_not_called()
-
-    # Test that validate_model is NOT called by default
-    ChatOllama(model=MODEL_NAME)
-    mock_validate_model.assert_not_called()

langchain_ollama-0.3.4/tests/unit_tests/test_embeddings.py

@@ -1,30 +0,0 @@
-"""Test embedding model integration."""
-
-from typing import Any
-from unittest.mock import patch
-
-from langchain_ollama.embeddings import OllamaEmbeddings
-
-MODEL_NAME = "llama3.1"
-
-
-def test_initialization() -> None:
-    """Test embedding model initialization."""
-    OllamaEmbeddings(model=MODEL_NAME, keep_alive=1)
-
-
-@patch("langchain_ollama.embeddings.validate_model")
-def test_validate_model_on_init(mock_validate_model: Any) -> None:
-    """Test that the model is validated on initialization when requested."""
-    # Test that validate_model is called when validate_model_on_init=True
-    OllamaEmbeddings(model=MODEL_NAME, validate_model_on_init=True)
-    mock_validate_model.assert_called_once()
-    mock_validate_model.reset_mock()
-
-    # Test that validate_model is NOT called when validate_model_on_init=False
-    OllamaEmbeddings(model=MODEL_NAME, validate_model_on_init=False)
-    mock_validate_model.assert_not_called()
-
-    # Test that validate_model is NOT called by default
-    OllamaEmbeddings(model=MODEL_NAME)
-    mock_validate_model.assert_not_called()