chatterer 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

chatterer/__init__.py

@@ -1,13 +1,24 @@
-from .llms import (
-    LLM,
-    InstructorLLM,
-    LangchainLLM,
-    OllamaLLM,
-)
-
-__all__ = [
-    "InstructorLLM",
-    "LangchainLLM",
-    "LLM",
-    "OllamaLLM",
-]
+from .llms import LLM
+
+__all__ = ["LLM"]
+
+try:
+    from .llms import LangchainLLM
+
+    __all__ += ["LangchainLLM"]
+except ImportError:
+    pass
+
+try:
+    from .llms import OllamaLLM
+
+    __all__ += ["OllamaLLM"]
+except ImportError:
+    pass
+
+try:
+    from .llms import InstructorLLM
+
+    __all__ += ["InstructorLLM"]
+except ImportError:
+    pass

chatterer/llms/__init__.py

@@ -0,0 +1,20 @@
+from importlib.util import find_spec
+
+from .base import LLM
+
+__all__ = ["LLM"]
+
+if find_spec("langchain_core") is not None:
+    from .langchain import LangchainLLM
+
+    __all__ += ["LangchainLLM"]
+
+if find_spec("ollama") is not None:
+    from .ollama import OllamaLLM
+
+    __all__ += ["OllamaLLM"]
+
+if find_spec("instructor") is not None:
+    from .instructor import InstructorLLM
+
+    __all__ += ["InstructorLLM"]

chatterer/llms/base.py

@@ -0,0 +1,42 @@
+from abc import ABC, abstractmethod
+from typing import (
+    Any,
+    ClassVar,
+    Iterator,
+    Sequence,
+    Type,
+    TypeVar,
+)
+
+from openai.types.chat import ChatCompletionMessageParam
+from pydantic import BaseModel, ConfigDict, Field
+
+P = TypeVar("P", bound=BaseModel)
+
+
+class LLM(BaseModel, ABC):
+    call_kwargs: dict[str, Any] = Field(default_factory=dict)
+    model_config: ClassVar[ConfigDict] = ConfigDict(arbitrary_types_allowed=True)
+
+    def __call__(self, messages: Sequence[ChatCompletionMessageParam]) -> str:
+        return self.generate(messages)
+
+    @abstractmethod
+    def generate(self, messages: Sequence[ChatCompletionMessageParam]) -> str: ...
+
+    @abstractmethod
+    def generate_stream(self, messages: Sequence[ChatCompletionMessageParam]) -> Iterator[str]: ...
+
+    @abstractmethod
+    def generate_pydantic(
+        self,
+        response_model: Type[P],
+        messages: Sequence[ChatCompletionMessageParam],
+    ) -> P: ...
+
+    def generate_pydantic_stream(
+        self,
+        response_model: Type[P],
+        messages: Sequence[ChatCompletionMessageParam],
+    ) -> Iterator[P]:
+        raise NotImplementedError

chatterer/llms/instructor.py

@@ -0,0 +1,127 @@
+from os import environ
+from typing import (
+    Any,
+    Iterator,
+    Self,
+    Sequence,
+    Type,
+)
+
+from instructor import Instructor, Mode, from_openai
+from openai import OpenAI
+from openai.types.chat import ChatCompletionMessageParam
+from pydantic import BaseModel
+
+from .base import LLM, P
+
+
+class Response(BaseModel):
+    response: str
+
+
+class InstructorLLM(LLM):
+    inst: Instructor
+
+    @classmethod
+    def openai(cls, call_kwargs: dict[str, Any] = {"model": "o3-mini"}) -> Self:
+        return cls(
+            inst=from_openai(OpenAI(), Mode.TOOLS_STRICT),
+            call_kwargs=call_kwargs,
+        )
+
+    @classmethod
+    def anthropic(
+        cls,
+        call_kwargs: dict[str, Any] = {
+            "model": "claude-3-7-sonnet-20250219",
+            "temperature": 0.7,
+            "max_tokens": 8192,
+        },
+    ) -> Self:
+        from anthropic import Anthropic
+        from instructor import from_anthropic
+
+        return cls(
+            inst=from_anthropic(client=Anthropic(), mode=Mode.ANTHROPIC_TOOLS),
+            call_kwargs=call_kwargs,
+        )
+
+    @classmethod
+    def gemini(
+        cls,
+        model_name: str = "gemini-2.0-flash",
+        call_kwargs: dict[str, Any] = {},
+    ) -> Self:
+        from google.generativeai.generative_models import GenerativeModel
+        from instructor import from_gemini
+
+        return cls(
+            inst=from_gemini(client=GenerativeModel(model_name=model_name), mode=Mode.GEMINI_TOOLS),
+            call_kwargs=call_kwargs,
+        )
+
+    @classmethod
+    def deepseek(cls, call_kwargs: dict[str, Any] = {"model": "deepseek-chat"}) -> Self:
+        return cls(
+            inst=from_openai(
+                OpenAI(
+                    base_url="https://api.deepseek.com/v1",
+                    api_key=environ["DEEPSEEK_API_KEY"],
+                ),
+                Mode.TOOLS_STRICT,
+            ),
+            call_kwargs=call_kwargs,
+        )
+
+    def generate(self, messages: Sequence[ChatCompletionMessageParam]) -> str:
+        if self.inst is None:
+            raise ValueError("Instructor instance is not initialized")
+        res = self.inst.chat.completions.create(
+            response_model=Response,
+            messages=list(messages),
+            **self.call_kwargs,
+        )
+        return res.response
+
+    def generate_stream(self, messages: Sequence[ChatCompletionMessageParam]) -> Iterator[str]:
+        if self.inst is None:
+            raise ValueError("Instructor instance is not initialized")
+        last_content: str = ""
+        for res in self.inst.chat.completions.create_partial(
+            response_model=Response,
+            messages=list(messages),
+            **self.call_kwargs,
+        ):
+            content: str = res.response
+            delta: str = content.removeprefix(last_content)
+            if not delta:
+                continue
+            last_content = content
+            yield delta
+
+    def generate_pydantic(
+        self,
+        response_model: Type[P],
+        messages: Sequence[ChatCompletionMessageParam],
+    ) -> P:
+        if self.inst is None:
+            raise ValueError("Instructor instance is not initialized")
+        return self.inst.chat.completions.create(
+            response_model=response_model,
+            messages=list(messages),
+            **self.call_kwargs,
+        )
+
+    def generate_pydantic_stream(
+        self,
+        response_model: Type[P],
+        messages: Sequence[ChatCompletionMessageParam],
+    ) -> Iterator[P]:
+        if self.inst is None:
+            raise ValueError("Instructor instance is not initialized")
+        for res in self.inst.chat.completions.create_partial(
+            response_model=response_model,
+            messages=list(messages),
+            **self.call_kwargs,
+        ):
+            yield res

chatterer/llms/langchain.py

@@ -0,0 +1,49 @@
+from typing import (
+    Iterator,
+    Sequence,
+    Type,
+)
+
+from langchain_community.adapters.openai import (
+    convert_openai_messages,
+)
+from langchain_core.language_models.chat_models import BaseChatModel
+from openai.types.chat import ChatCompletionMessageParam
+
+from .base import LLM, P
+
+
+class LangchainLLM(LLM):
+    client: BaseChatModel
+
+    def generate(self, messages: Sequence[ChatCompletionMessageParam]) -> str:
+        content = self.client.invoke(convert_openai_messages([dict(msg) for msg in messages])).content
+        if isinstance(content, str):
+            return content
+        else:
+            return "".join(part for part in content if isinstance(part, str))
+
+    def generate_stream(self, messages: Sequence[ChatCompletionMessageParam]) -> Iterator[str]:
+        for chunk in self.client.stream(convert_openai_messages([dict(msg) for msg in messages])):
+            content = chunk.content
+            if isinstance(content, str):
+                yield content
+            elif isinstance(content, list):
+                for part in content:
+                    if isinstance(part, str):
+                        yield part
+                    else:
+                        continue
+            else:
+                continue
+
+    def generate_pydantic(
+        self,
+        response_model: Type[P],
+        messages: Sequence[ChatCompletionMessageParam],
+    ) -> P:
+        result = self.client.with_structured_output(response_model).invoke(convert_openai_messages([dict(msg) for msg in messages]))
+        if isinstance(result, response_model):
+            return result
+        else:
+            return response_model.model_validate(result)

chatterer/llms/ollama.py

@@ -0,0 +1,69 @@
+from typing import (
+    Any,
+    Callable,
+    Iterator,
+    Literal,
+    Mapping,
+    Optional,
+    Sequence,
+    Type,
+)
+
+from ollama import Options, Tool, chat
+from openai.types.chat import ChatCompletionMessageParam
+from pydantic.json_schema import JsonSchemaValue
+
+from .base import LLM, P
+
+
+class OllamaLLM(LLM):
+    model: str
+    tools: Optional[Sequence[Mapping[str, Any] | Tool | Callable]] = None
+    stream: bool = False
+    format: Optional[Literal["", "json"] | JsonSchemaValue] = None
+    options: Optional[Mapping[str, Any] | Options] = None
+    keep_alive: Optional[float | str] = None
+
+    def generate(self, messages: Sequence[ChatCompletionMessageParam]) -> str:
+        return "".join(self.generate_stream(messages))
+
+    def generate_stream(self, messages: Sequence[ChatCompletionMessageParam]) -> Iterator[str]:
+        model = str(self.call_kwargs.get("model", self.model))
+        format = self.call_kwargs.get("format", self.format)
+        options = self.call_kwargs.get("options", self.options)
+        keep_alive = self.call_kwargs.get("keep_alive", self.keep_alive)
+        tools = self.call_kwargs.get("tools", self.tools)
+        return (
+            res.message.content or ""
+            for res in chat(
+                model=model,
+                messages=messages,
+                tools=tools,
+                stream=True,
+                format=format,
+                options=options,
+                keep_alive=keep_alive,
+            )
+        )
+
+    def generate_pydantic(
+        self,
+        response_model: Type[P],
+        messages: Sequence[ChatCompletionMessageParam],
+    ) -> P:
+        model = str(self.call_kwargs.get("model", self.model))
+        format = response_model.model_json_schema()
+        options = self.call_kwargs.get("options", self.options)
+        keep_alive = self.call_kwargs.get("keep_alive", self.keep_alive)
+        return response_model.model_validate_json(
+            chat(
+                model=model,
+                messages=messages,
+                tools=None,
+                stream=False,
+                format=format,
+                options=options,
+                keep_alive=keep_alive,
+            ).message.content
+            or ""
+        )

{chatterer-0.1.0.dist-info → chatterer-0.1.2.dist-info}/METADATA

@@ -1,13 +1,15 @@
 Metadata-Version: 2.2
 Name: chatterer
-Version: 0.1.0
+Version: 0.1.2
 Summary: The highest-level interface for various LLM APIs.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Requires-Dist: openai>=1.63.2
 Provides-Extra: all
-Requires-Dist: anthropic>=0.46.0; extra == "all"
+Requires-Dist: anthropic>=0.49.0; extra == "all"
+Requires-Dist: google-generativeai>=0.8.4; extra == "all"
 Requires-Dist: instructor>=1.7.2; extra == "all"
+Requires-Dist: jsonref>=1.1.0; extra == "all"
 Requires-Dist: langchain-community>=0.3.18; extra == "all"
 Requires-Dist: ollama>=0.4.7; extra == "all"
 

chatterer-0.1.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+chatterer/__init__.py,sha256=zi6zoXdpdWL35p-BYAKrsNWcqi_T3RqpflugLy_93mg,370
+chatterer/llms/__init__.py,sha256=3vUVxkeyBz9xi6nAYg2D7ZtSeuZumTMS5pdJHj3JDpI,435
+chatterer/llms/base.py,sha256=rdYJgpNeDoR-1Cmuea5rBYTJ8Jmtof3U6rFzcUcnG_Y,1196
+chatterer/llms/instructor.py,sha256=QP7rbyENN-4m7kNXGnP1r0kb6ioF0ozkEG0qe5BjQnc,3936
+chatterer/llms/langchain.py,sha256=cuKYWtunCNLNs15P_mlOIbxjvmClrYphSKqAqg3b05k,1723
+chatterer/llms/ollama.py,sha256=amhcGB-xK5ooDAlFzl0aln76x5e13NRKaUkzZ7rcEm0,2304
+chatterer-0.1.2.dist-info/METADATA,sha256=FRpuLBBieJbmIHcSM17V4DU3lw92JonmLCYU8gPYxFk,6192
+chatterer-0.1.2.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+chatterer-0.1.2.dist-info/top_level.txt,sha256=7nSQKP0bHxPRc7HyzdbKsJdkvPgYD0214o6slRizv9s,10
+chatterer-0.1.2.dist-info/RECORD,,

{chatterer-0.1.0.dist-info → chatterer-0.1.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (75.8.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

chatterer/llms.py

@@ -1,291 +0,0 @@
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from os import environ
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Iterator,
-    Literal,
-    Mapping,
-    Optional,
-    Self,
-    Sequence,
-    Type,
-    TypeVar,
-)
-
-from openai import OpenAI
-from openai.types.chat import ChatCompletionMessageParam
-from pydantic import BaseModel, create_model
-from pydantic.json_schema import JsonSchemaValue
-
-if TYPE_CHECKING:
-    from instructor import Instructor
-    from langchain_core.language_models.chat_models import BaseChatModel
-    from ollama import Options, Tool
-
-P = TypeVar("P", bound=BaseModel)
-
-
-@dataclass
-class LLM(ABC):
-    call_kwargs: dict[str, Any]
-
-    @abstractmethod
-    def generate(
-        self, messages: Sequence[ChatCompletionMessageParam]
-    ) -> str: ...
-
-    @abstractmethod
-    def generate_stream(
-        self, messages: Sequence[ChatCompletionMessageParam]
-    ) -> Iterator[str]: ...
-
-    @abstractmethod
-    def generate_pydantic(
-        self,
-        response_model: Type[P],
-        messages: Sequence[ChatCompletionMessageParam],
-    ) -> P: ...
-
-    def generate_pydantic_stream(
-        self,
-        response_model: Type[P],
-        messages: Sequence[ChatCompletionMessageParam],
-    ) -> Iterator[P]:
-        raise NotImplementedError
-
-
-@dataclass
-class InstructorLLM(LLM):
-    inst: "Instructor"
-
-    @property
-    def dependency(self) -> list[str]:
-        return ["instructor"]
-
-    @classmethod
-    def openai(
-        cls, call_kwargs: dict[str, Any] = {"model": "o3-mini"}
-    ) -> Self:
-        from instructor import Mode, from_openai
-
-        return cls(
-            inst=from_openai(OpenAI(), Mode.TOOLS_STRICT),
-            call_kwargs=call_kwargs,
-        )
-
-    @classmethod
-    def anthropic(
-        cls,
-        call_kwargs: dict[str, Any] = {
-            "temperature": 0.7,
-            "max_tokens": 8192,
-            "model": "claude-3-5-sonnet-20241022",
-        },
-    ) -> Self:
-
-        from anthropic import Anthropic
-        from instructor import Mode, from_anthropic
-
-        return cls(
-            inst=from_anthropic(
-                client=Anthropic(), mode=Mode.ANTHROPIC_TOOLS
-            ),
-            call_kwargs=call_kwargs,
-        )
-
-    @classmethod
-    def deepseek(
-        cls, call_kwargs: dict[str, Any] = {"model": "deepseek-chat"}
-    ) -> Self:
-
-        from instructor import Mode, from_openai
-
-        return cls(
-            inst=from_openai(
-                OpenAI(
-                    base_url="https://api.deepseek.com/v1",
-                    api_key=environ["DEEPSEEK_API_KEY"],
-                ),
-                Mode.TOOLS_STRICT,
-            ),
-            call_kwargs=call_kwargs,
-        )
-
-    def generate(
-        self, messages: Sequence[ChatCompletionMessageParam]
-    ) -> str:
-        res = self.inst.chat.completions.create(
-            response_model=create_model(
-                "Response",
-                response=(str, ...),
-            ),
-            messages=list(messages),
-            **self.call_kwargs,
-        )
-        return str(getattr(res, "response", "") or "")
-
-    def generate_stream(
-        self, messages: Sequence[ChatCompletionMessageParam]
-    ) -> Iterator[str]:
-        last_content: str = ""
-        for res in self.inst.chat.completions.create_partial(
-            response_model=create_model(
-                "Response",
-                response=(str, ...),
-            ),
-            messages=list(messages),
-            **self.call_kwargs,
-        ):
-            content = str(getattr(res, "response", "") or "")
-            delta: str = content.removeprefix(last_content)
-            if not delta:
-                continue
-            last_content = content
-            yield delta
-
-    def generate_pydantic(
-        self,
-        response_model: Type[P],
-        messages: Sequence[ChatCompletionMessageParam],
-    ) -> P:
-        return self.inst.chat.completions.create(
-            response_model=response_model,
-            messages=list(messages),
-            **self.call_kwargs,
-        )
-
-    def generate_pydantic_stream(
-        self,
-        response_model: Type[P],
-        messages: Sequence[ChatCompletionMessageParam],
-    ) -> Iterator[P]:
-        for res in self.inst.chat.completions.create_partial(
-            response_model=response_model,
-            messages=list(messages),
-            **self.call_kwargs,
-        ):
-            yield res
-
-
-@dataclass
-class OllamaLLM(LLM):
-    model: str
-    tools: Optional[Sequence[Mapping[str, Any] | "Tool" | Callable]] = None
-    stream: bool = False
-    format: Optional[Literal["", "json"] | JsonSchemaValue] = None
-    options: Optional[Mapping[str, Any] | "Options"] = None
-    keep_alive: Optional[float | str] = None
-
-    def generate(
-        self, messages: Sequence[ChatCompletionMessageParam]
-    ) -> str:
-        return "".join(self.generate_stream(messages))
-
-    def generate_stream(
-        self, messages: Sequence[ChatCompletionMessageParam]
-    ) -> Iterator[str]:
-        from ollama import chat
-
-        model = str(self.call_kwargs.get("model", self.model))
-        format = self.call_kwargs.get("format", self.format)
-        options = self.call_kwargs.get("options", self.options)
-        keep_alive = self.call_kwargs.get("keep_alive", self.keep_alive)
-        tools = self.call_kwargs.get("tools", self.tools)
-        return (
-            res.message.content or ""
-            for res in chat(
-                model=model,
-                messages=messages,
-                tools=tools,
-                stream=True,
-                format=format,
-                options=options,
-                keep_alive=keep_alive,
-            )
-        )
-
-    def generate_pydantic(
-        self,
-        response_model: Type[P],
-        messages: Sequence[ChatCompletionMessageParam],
-    ) -> P:
-        from ollama import chat
-
-        model = str(self.call_kwargs.get("model", self.model))
-        format = response_model.model_json_schema()
-        options = self.call_kwargs.get("options", self.options)
-        keep_alive = self.call_kwargs.get("keep_alive", self.keep_alive)
-        return response_model.model_validate_json(
-            chat(
-                model=model,
-                messages=messages,
-                tools=None,
-                stream=False,
-                format=format,
-                options=options,
-                keep_alive=keep_alive,
-            ).message.content
-            or ""
-        )
-
-
-@dataclass
-class LangchainLLM(LLM):
-    client: "BaseChatModel"
-
-    def generate(
-        self, messages: Sequence[ChatCompletionMessageParam]
-    ) -> str:
-        from langchain_community.adapters.openai import (
-            convert_openai_messages,
-        )
-
-        content = self.client.invoke(
-            convert_openai_messages([dict(msg) for msg in messages])
-        ).content
-        if isinstance(content, str):
-            return content
-        else:
-            return "".join(part for part in content if isinstance(part, str))
-
-    def generate_stream(
-        self, messages: Sequence[ChatCompletionMessageParam]
-    ) -> Iterator[str]:
-        from langchain_community.adapters.openai import (
-            convert_openai_messages,
-        )
-
-        for chunk in self.client.stream(
-            convert_openai_messages([dict(msg) for msg in messages])
-        ):
-            content = chunk.content
-            if isinstance(content, str):
-                yield content
-            elif isinstance(content, list):
-                for part in content:
-                    if isinstance(part, str):
-                        yield part
-                    else:
-                        continue
-            else:
-                continue
-
-    def generate_pydantic(
-        self,
-        response_model: Type[P],
-        messages: Sequence[ChatCompletionMessageParam],
-    ) -> P:
-        from langchain_community.adapters.openai import (
-            convert_openai_messages,
-        )
-
-        result = self.client.with_structured_output(response_model).invoke(
-            convert_openai_messages([dict(msg) for msg in messages])
-        )
-        if isinstance(result, response_model):
-            return result
-        else:
-            return response_model.model_validate(result)

chatterer-0.1.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-chatterer/__init__.py,sha256=uxj5SEbjxpGGt1ukNLgkafrE90DGdpIc6NcxumBrcDI,180
-chatterer/llms.py,sha256=wDi4EX1Ebe7vKI8Cd2qTEo2BzzY0UyERryrd7eQafyg,8299
-chatterer-0.1.0.dist-info/METADATA,sha256=bsXI0wNj3WueyfOXicNgUG6Ru7KqFgFi61fs9mLZpj8,6086
-chatterer-0.1.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-chatterer-0.1.0.dist-info/top_level.txt,sha256=7nSQKP0bHxPRc7HyzdbKsJdkvPgYD0214o6slRizv9s,10
-chatterer-0.1.0.dist-info/RECORD,,