langchain-b12 0.1.9__tar.gz → 0.1.11__tar.gz

{langchain_b12-0.1.9 → langchain_b12-0.1.11}/PKG-INFO

@@ -1,11 +1,10 @@
 Metadata-Version: 2.4
 Name: langchain-b12
-Version: 0.1.9
+Version: 0.1.11
 Summary: A reusable collection of tools and implementations for Langchain
 Author-email: Vincent Min <vincent.min@b12-consulting.com>
 Requires-Python: >=3.11
 Requires-Dist: langchain-core>=0.3.60
-Requires-Dist: tenacity>=9.1.2
 Description-Content-Type: text/markdown
 
 # Langchain B12

{langchain_b12-0.1.9 → langchain_b12-0.1.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "langchain-b12"
-version = "0.1.9"
+version = "0.1.11"
 description = "A reusable collection of tools and implementations for Langchain"
 readme = "README.md"
 authors = [
@@ -9,7 +9,6 @@ authors = [
 requires-python = ">=3.11"
 dependencies = [
     "langchain-core>=0.3.60",
-    "tenacity>=9.1.2",
 ]
 
 [dependency-groups]

{langchain_b12-0.1.9 → langchain_b12-0.1.11}/src/langchain_b12/genai/genai.py

@@ -35,14 +35,7 @@ from langchain_core.tools import BaseTool
 from langchain_core.utils.function_calling import (
     convert_to_openai_tool,
 )
-from pydantic import BaseModel, ConfigDict, Field
-from tenacity import (
-    retry,
-    retry_if_exception_type,
-    stop_after_attempt,
-    stop_never,
-    wait_exponential_jitter,
-)
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 
 from langchain_b12.genai.genai_utils import (
     convert_messages_to_contents,
@@ -84,7 +77,9 @@ class ChatGenAI(BaseChatModel):
     seed: int | None = None
     """Random seed for the generation."""
     max_retries: int | None = Field(default=3)
-    """Maximum number of retries when generation fails. None disables retries."""
+    """Maximum number of retries. Prefer `http_retry_options`, but this is kept for compatibility."""
+    http_retry_options: types.HttpRetryOptions | None = Field(default=None)
+    """HTTP retry options for API requests. If not set, max_retries will be used to create default options."""
     safety_settings: list[types.SafetySetting] | None = None
     """The default safety settings to use for all generations.
 
@@ -107,6 +102,13 @@ class ChatGenAI(BaseChatModel):
         arbitrary_types_allowed=True,
     )
 
+    @model_validator(mode="after")
+    def _setup_retry_options(self) -> "ChatGenAI":
+        """Convert max_retries to http_retry_options if not explicitly set."""
+        if self.http_retry_options is None and self.max_retries is not None:
+            self.http_retry_options = types.HttpRetryOptions(attempts=self.max_retries)
+        return self
+
     @property
     def _llm_type(self) -> str:
         return "vertexai"
@@ -183,29 +185,10 @@ class ChatGenAI(BaseChatModel):
         run_manager: CallbackManagerForLLMRun | None = None,
         **kwargs: Any,
     ) -> ChatResult:
-        @retry(
-            reraise=True,
-            stop=stop_after_attempt(self.max_retries + 1)
-            if self.max_retries is not None
-            else stop_never,
-            wait=wait_exponential_jitter(initial=1, max=60),
-            retry=retry_if_exception_type(Exception),
-            before_sleep=lambda retry_state: logger.warning(
-                "ChatGenAI._generate failed (attempt %d/%s). "
-                "Retrying in %.2fs... Error: %s",
-                retry_state.attempt_number,
-                self.max_retries + 1 if self.max_retries is not None else "∞",
-                retry_state.next_action.sleep,
-                retry_state.outcome.exception(),
-            ),
+        stream_iter = self._stream(
+            messages, stop=stop, run_manager=run_manager, **kwargs
         )
-        def _generate_with_retry() -> ChatResult:
-            stream_iter = self._stream(
-                messages, stop=stop, run_manager=run_manager, **kwargs
-            )
-            return generate_from_stream(stream_iter)
-
-        return _generate_with_retry()
+        return generate_from_stream(stream_iter)
 
     async def _agenerate(
         self,
@@ -214,29 +197,10 @@ class ChatGenAI(BaseChatModel):
         run_manager: AsyncCallbackManagerForLLMRun | None = None,
         **kwargs: Any,
     ) -> ChatResult:
-        @retry(
-            reraise=True,
-            stop=stop_after_attempt(self.max_retries + 1)
-            if self.max_retries is not None
-            else stop_never,
-            wait=wait_exponential_jitter(initial=1, max=60),
-            retry=retry_if_exception_type(Exception),
-            before_sleep=lambda retry_state: logger.warning(
-                "ChatGenAI._agenerate failed (attempt %d/%s). "
-                "Retrying in %.2fs... Error: %s",
-                retry_state.attempt_number,
-                self.max_retries + 1 if self.max_retries is not None else "∞",
-                retry_state.next_action.sleep,
-                retry_state.outcome.exception(),
-            ),
+        stream_iter = self._astream(
+            messages, stop=stop, run_manager=run_manager, **kwargs
         )
-        async def _agenerate_with_retry() -> ChatResult:
-            stream_iter = self._astream(
-                messages, stop=stop, run_manager=run_manager, **kwargs
-            )
-            return await agenerate_from_stream(stream_iter)
-
-        return await _agenerate_with_retry()
+        return await agenerate_from_stream(stream_iter)
 
     def _stream(
         self,
@@ -246,10 +210,16 @@ class ChatGenAI(BaseChatModel):
         **kwargs: Any,
     ) -> Iterator[ChatGenerationChunk]:
         system_message, contents = self._prepare_request(messages=messages)
+        http_options = (
+            types.HttpOptions(retry_options=self.http_retry_options)
+            if self.http_retry_options
+            else None
+        )
         response_iter = self.client.models.generate_content_stream(
             model=self.model_name,
             contents=contents,
             config=types.GenerateContentConfig(
+                http_options=http_options,
                 system_instruction=system_message,
                 temperature=self.temperature,
                 top_k=self.top_k,
@@ -282,10 +252,16 @@ class ChatGenAI(BaseChatModel):
         **kwargs: Any,
     ) -> AsyncIterator[ChatGenerationChunk]:
         system_message, contents = self._prepare_request(messages=messages)
+        http_options = (
+            types.HttpOptions(retry_options=self.http_retry_options)
+            if self.http_retry_options
+            else None
+        )
         response_iter = self.client.aio.models.generate_content_stream(
             model=self.model_name,
             contents=contents,
             config=types.GenerateContentConfig(
+                http_options=http_options,
                 system_instruction=system_message,
                 temperature=self.temperature,
                 top_k=self.top_k,

langchain_b12-0.1.11/tests/test_genai.py

@@ -0,0 +1,210 @@
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from google.genai import Client, types
+from langchain_b12.genai.genai import ChatGenAI
+from langchain_core.messages import HumanMessage
+
+
+def _make_response_chunk(text: str) -> types.GenerateContentResponse:
+    """Helper to create a response chunk."""
+    return types.GenerateContentResponse(
+        candidates=[
+            types.Candidate(content=types.Content(parts=[types.Part(text=text)]))
+        ]
+    )
+
+
+def test_chatgenai():
+    client = MagicMock(spec=Client)
+    model = ChatGenAI(client=client, model="foo", temperature=1)
+    assert model.model_name == "foo"
+    assert model.temperature == 1
+    assert model.client == client
+
+
+def test_chatgenai_invocation():
+    client: Client = MagicMock(spec=Client)
+    client.models.generate_content_stream.return_value = iter(
+        (
+            _make_response_chunk("bar"),
+            _make_response_chunk("baz"),
+        )
+    )
+    model = ChatGenAI(client=client)
+    messages = [HumanMessage(content="foo")]
+    response = model.invoke(messages)
+    method: MagicMock = client.models.generate_content_stream
+    method.assert_called_once()
+    assert response.content == "barbaz"
+
+
+def test_max_retries_converts_to_http_retry_options():
+    """Test that max_retries is properly converted to HttpRetryOptions."""
+    client = MagicMock(spec=Client)
+    model = ChatGenAI(client=client, max_retries=5)
+
+    assert model.http_retry_options is not None
+    assert model.http_retry_options.attempts == 5
+
+
+def test_http_retry_options_passed_directly():
+    """Test that http_retry_options can be passed directly."""
+    client = MagicMock(spec=Client)
+    retry_options = types.HttpRetryOptions(
+        attempts=10,
+        initial_delay=2.0,
+        max_delay=30.0,
+    )
+    model = ChatGenAI(client=client, http_retry_options=retry_options)
+
+    assert model.http_retry_options == retry_options
+    assert model.http_retry_options.attempts == 10
+    assert model.http_retry_options.initial_delay == 2.0
+
+
+def test_http_retry_options_overrides_max_retries():
+    """Test that explicit http_retry_options overrides max_retries."""
+    client = MagicMock(spec=Client)
+    retry_options = types.HttpRetryOptions(attempts=7)
+    model = ChatGenAI(client=client, max_retries=3, http_retry_options=retry_options)
+
+    # http_retry_options should take precedence
+    assert model.http_retry_options == retry_options
+    assert model.http_retry_options.attempts == 7
+
+
+def test_retry_options_passed_in_stream_config():
+    """Test that retry options are passed to GenerateContentConfig."""
+    client: Client = MagicMock(spec=Client)
+    client.models.generate_content_stream.return_value = iter(
+        [_make_response_chunk("success")]
+    )
+
+    model = ChatGenAI(client=client, max_retries=5)
+    messages = [HumanMessage(content="foo")]
+    response = model.invoke(messages)
+
+    # Verify the config was called with http_options containing retry_options
+    call_args = client.models.generate_content_stream.call_args
+    config = call_args.kwargs["config"]
+    assert config.http_options is not None
+    assert config.http_options.retry_options is not None
+    assert config.http_options.retry_options.attempts == 5
+
+
+def test_no_retry_options_when_max_retries_none():
+    """Test that no http_retry_options are set when max_retries is None."""
+    client = MagicMock(spec=Client)
+    model = ChatGenAI(client=client, max_retries=None)
+
+    assert model.http_retry_options is None
+
+
+# --- Streaming behavior tests ---
+
+
+def test_stream_yields_chunks_immediately():
+    """Test that stream yields chunks as they arrive, not buffered."""
+    client: Client = MagicMock(spec=Client)
+    chunks_yielded: list[str] = []
+
+    def mock_stream():
+        for text in ["chunk1", "chunk2", "chunk3"]:
+            # Track when chunks are yielded from the source
+            chunks_yielded.append(f"source:{text}")
+            yield _make_response_chunk(text)
+
+    client.models.generate_content_stream.return_value = mock_stream()
+
+    model = ChatGenAI(client=client, max_retries=3)
+    messages = [HumanMessage(content="foo")]
+
+    received: list[str] = []
+    for chunk in model.stream(messages):
+        received.append(chunk.content)
+        # After receiving each chunk, check that source yielded it
+        assert len(received) == len([c for c in chunks_yielded if c.startswith("source:")])
+
+    assert received == ["chunk1", "chunk2", "chunk3"]
+
+
+def test_stream_error_propagates():
+    """Test that errors during streaming are propagated."""
+    client: Client = MagicMock(spec=Client)
+
+    def failing_stream():
+        yield _make_response_chunk("first")
+        raise Exception("Mid-stream error")
+
+    client.models.generate_content_stream.return_value = failing_stream()
+
+    model = ChatGenAI(client=client, max_retries=3)
+    messages = [HumanMessage(content="foo")]
+
+    chunks = []
+    with pytest.raises(Exception, match="Mid-stream error"):
+        for chunk in model.stream(messages):
+            chunks.append(chunk.content)
+
+    # First chunk was received before error
+    assert chunks == ["first"]
+
+
+# --- Async streaming tests ---
+
+
+async def _async_iter(items):
+    """Helper to create an async iterator from items."""
+    for item in items:
+        yield item
+
+
+@pytest.mark.asyncio
+async def test_astream_yields_chunks_immediately():
+    """Test that async stream yields chunks as they arrive."""
+    client: Client = MagicMock(spec=Client)
+
+    chunks = [
+        _make_response_chunk("async1"),
+        _make_response_chunk("async2"),
+        _make_response_chunk("async3"),
+    ]
+
+    # generate_content_stream returns a coroutine that resolves to async iterator
+    client.aio.models.generate_content_stream = AsyncMock(
+        return_value=_async_iter(chunks)
+    )
+
+    model = ChatGenAI(client=client, max_retries=3)
+    messages = [HumanMessage(content="foo")]
+
+    received: list[str] = []
+    async for chunk in model.astream(messages):
+        received.append(chunk.content)
+
+    assert received == ["async1", "async2", "async3"]
+
+
+@pytest.mark.asyncio
+async def test_astream_error_propagates():
+    """Test that errors during async streaming are propagated."""
+    client: Client = MagicMock(spec=Client)
+
+    async def failing_after_first():
+        yield _make_response_chunk("first")
+        raise Exception("Async mid-stream error")
+
+    client.aio.models.generate_content_stream = AsyncMock(
+        return_value=failing_after_first()
+    )
+
+    model = ChatGenAI(client=client, max_retries=3)
+    messages = [HumanMessage(content="foo")]
+
+    chunks = []
+    with pytest.raises(Exception, match="Async mid-stream error"):
+        async for chunk in model.astream(messages):
+            chunks.append(chunk.content)
+
+    assert chunks == ["first"]

{langchain_b12-0.1.9 → langchain_b12-0.1.11}/uv.lock

@@ -252,11 +252,10 @@ wheels = [
 
 [[package]]
 name = "langchain-b12"
-version = "0.1.8"
+version = "0.1.10"
 source = { editable = "." }
 dependencies = [
     { name = "langchain-core" },
-    { name = "tenacity" },
 ]
 
 [package.dev-dependencies]
@@ -273,10 +272,7 @@ google = [
 ]
 
 [package.metadata]
-requires-dist = [
-    { name = "langchain-core", specifier = ">=0.3.60" },
-    { name = "tenacity", specifier = ">=9.1.2" },
-]
+requires-dist = [{ name = "langchain-core", specifier = ">=0.3.60" }]
 
 [package.metadata.requires-dev]
 citations = [

langchain_b12-0.1.9/tests/test_genai.py

@@ -1,124 +0,0 @@
-from unittest.mock import MagicMock, patch
-
-import pytest
-from google.genai import Client, types
-from langchain_b12.genai.genai import ChatGenAI
-from langchain_core.messages import HumanMessage
-
-
-def test_chatgenai():
-    client = MagicMock(spec=Client)
-    model = ChatGenAI(client=client, model="foo", temperature=1)
-    assert model.model_name == "foo"
-    assert model.temperature == 1
-    assert model.client == client
-
-
-def test_chatgenai_invocation():
-    client: Client = MagicMock(spec=Client)
-    client.models.generate_content_stream.return_value = iter(
-        (
-            types.GenerateContentResponse(
-                candidates=[
-                    types.Candidate(
-                        content=types.Content(parts=[types.Part(text="bar")])
-                    ),
-                ]
-            ),
-            types.GenerateContentResponse(
-                candidates=[
-                    types.Candidate(
-                        content=types.Content(parts=[types.Part(text="baz")])
-                    ),
-                ]
-            ),
-        )
-    )
-    model = ChatGenAI(client=client)
-    messages = [HumanMessage(content="foo")]
-    response = model.invoke(messages)
-    method: MagicMock = client.models.generate_content_stream
-    method.assert_called_once()
-    assert response.content == "barbaz"
-
-
-def _make_success_response():
-    """Helper to create a successful streaming response."""
-    return iter(
-        [
-            types.GenerateContentResponse(
-                candidates=[
-                    types.Candidate(
-                        content=types.Content(parts=[types.Part(text="success")])
-                    ),
-                ]
-            ),
-        ]
-    )
-
-
-@patch("langchain_b12.genai.genai.wait_exponential_jitter", return_value=lambda _: 0)
-def test_chatgenai_retry_succeeds_after_failure(mock_wait):
-    """Test that retry logic succeeds after transient failures."""
-    client: Client = MagicMock(spec=Client)
-
-    # First two calls fail, third succeeds
-    client.models.generate_content_stream.side_effect = [
-        Exception("Transient error 1"),
-        Exception("Transient error 2"),
-        _make_success_response(),
-    ]
-
-    model = ChatGenAI(client=client, max_retries=3)
-    messages = [HumanMessage(content="foo")]
-    response = model.invoke(messages)
-
-    assert response.content == "success"
-    assert client.models.generate_content_stream.call_count == 3
-
-
-@patch("langchain_b12.genai.genai.wait_exponential_jitter", return_value=lambda _: 0)
-def test_chatgenai_retry_exhausted_raises(mock_wait):
-    """Test that exception is raised after all retries are exhausted."""
-    client: Client = MagicMock(spec=Client)
-
-    # All calls fail
-    client.models.generate_content_stream.side_effect = Exception("Persistent error")
-
-    model = ChatGenAI(client=client, max_retries=2)
-    messages = [HumanMessage(content="foo")]
-
-    with pytest.raises(Exception, match="Persistent error"):
-        model.invoke(messages)
-
-    # Initial attempt + 2 retries = 3 total calls
-    assert client.models.generate_content_stream.call_count == 3
-
-
-@patch("langchain_b12.genai.genai.wait_exponential_jitter", return_value=lambda _: 0)
-def test_chatgenai_no_retry_when_max_retries_zero(mock_wait):
-    """Test that no retries occur when max_retries=0."""
-    client: Client = MagicMock(spec=Client)
-    client.models.generate_content_stream.side_effect = Exception("Error")
-
-    model = ChatGenAI(client=client, max_retries=0)
-    messages = [HumanMessage(content="foo")]
-
-    with pytest.raises(Exception, match="Error"):
-        model.invoke(messages)
-
-    # Only 1 attempt, no retries
-    assert client.models.generate_content_stream.call_count == 1
-
-
-def test_chatgenai_no_retry_on_success():
-    """Test that no retries occur when first attempt succeeds."""
-    client: Client = MagicMock(spec=Client)
-    client.models.generate_content_stream.return_value = _make_success_response()
-
-    model = ChatGenAI(client=client, max_retries=3)
-    messages = [HumanMessage(content="foo")]
-    response = model.invoke(messages)
-
-    assert response.content == "success"
-    assert client.models.generate_content_stream.call_count == 1