py-llmify 0.1.0__tar.gz

py_llmify-0.1.0/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mathis Kristoffer Arends
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights  
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell  
+copies of the Software, and to permit persons to whom the Software is  
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in  
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE  
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN  
+THE SOFTWARE.

py_llmify-0.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: py-llmify
+Version: 0.1.0
+Summary: A minimal, fast, and type-safe Python library for LLM chat completions with OpenAI and Azure OpenAI support
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: openai>=2.14.0
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: python-dotenv>=1.2.1
+Dynamic: license-file

py_llmify-0.1.0/llmify/__init__.py

@@ -0,0 +1,12 @@
+from .messages import SystemMessage, UserMessage, AssistantMessage, ImageMessage
+from .providers import ChatOpenAI, ChatAzureOpenAI, BaseChatModel
+
+__all__ = [
+    "SystemMessage",
+    "UserMessage",
+    "AssistantMessage",
+    "ImageMessage",
+    "ChatOpenAI",
+    "ChatAzureOpenAI",
+    "BaseChatModel",
+]

py_llmify-0.1.0/llmify/messages.py

@@ -0,0 +1,65 @@
+import base64
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import Literal
+
+
+class _MessageRole(StrEnum):
+    SYSTEM = "system"
+    USER = "user"
+    ASSISTANT = "assistant"
+
+
+_MediaType = Literal["image/jpeg", "image/png"]
+
+
+@dataclass
+class Message:
+    role: _MessageRole
+    content: str
+
+
+class SystemMessage(Message):
+    def __init__(self, content: str):
+        super().__init__(role=_MessageRole.SYSTEM, content=content)
+
+
+class UserMessage(Message):
+    def __init__(self, content: str):
+        super().__init__(role=_MessageRole.USER, content=content)
+
+
+class AssistantMessage(Message):
+    def __init__(self, content: str):
+        super().__init__(role=_MessageRole.ASSISTANT, content=content)
+
+
+@dataclass
+class ImageMessage(Message):
+    base64_data: str
+    media_type: _MediaType
+
+    def __init__(
+        self,
+        base64_data: str,
+        media_type: _MediaType | None = None,
+        text: str | None = None,
+    ):
+        self.base64_data = base64_data
+
+        if media_type is None:
+            self.media_type = self._detect_media_type(base64_data)
+        else:
+            self.media_type = media_type
+
+        super().__init__(role=_MessageRole.USER, content=text or "")
+
+    @staticmethod
+    def _detect_media_type(base64_data: str) -> _MediaType:
+        try:
+            header = base64.b64decode(base64_data[:20])
+            if header.startswith(b"\x89PNG"):
+                return "image/png"
+        except Exception:
+            pass
+        return "image/jpeg"

py_llmify-0.1.0/llmify/providers/__init__.py

@@ -0,0 +1,11 @@
+from .openai import ChatOpenAI
+from .azure import ChatAzureOpenAI
+
+from .base import BaseChatModel, BaseOpenAICompatible
+
+__all__ = [
+    "ChatOpenAI",
+    "ChatAzureOpenAI",
+    "BaseChatModel",
+    "BaseOpenAICompatible",
+]

py_llmify-0.1.0/llmify/providers/azure.py

@@ -0,0 +1,55 @@
+import os
+import httpx
+from openai import AsyncAzureOpenAI
+from llmify.providers.base import BaseOpenAICompatible
+from typing import Any
+from dotenv import load_dotenv
+
+load_dotenv(override=True)
+
+
+class ChatAzureOpenAI(BaseOpenAICompatible):
+    def __init__(
+        self,
+        model: str = "gpt-4o",
+        api_key: str | None = None,
+        azure_endpoint: str | None = None,
+        api_version: str = "2024-02-15-preview",
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+        top_p: float | None = None,
+        frequency_penalty: float | None = None,
+        presence_penalty: float | None = None,
+        stop: str | list[str] | None = None,
+        seed: int | None = None,
+        response_format: dict | None = None,
+        timeout: float | httpx.Timeout | None = 60.0,
+        max_retries: int = 2,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            max_tokens=max_tokens,
+            temperature=temperature,
+            top_p=top_p,
+            frequency_penalty=frequency_penalty,
+            presence_penalty=presence_penalty,
+            stop=stop,
+            seed=seed,
+            response_format=response_format,
+            timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
+        )
+        if api_key is None:
+            api_key = os.getenv("AZURE_OPENAI_API_KEY")
+        if azure_endpoint is None:
+            azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
+
+        self._client = AsyncAzureOpenAI(
+            api_key=api_key,
+            azure_endpoint=azure_endpoint,
+            api_version=api_version,
+            timeout=timeout,
+            max_retries=max_retries,
+        )
+        self._model = model

py_llmify-0.1.0/llmify/providers/base.py

@@ -0,0 +1,175 @@
+from abc import ABC, abstractmethod
+from typing import TypeVar, Any
+
+from collections.abc import AsyncIterator
+from pydantic import BaseModel
+import httpx
+from openai import AsyncOpenAI, AsyncAzureOpenAI
+from openai.types.chat import ChatCompletion, ChatCompletionChunk
+
+from llmify.messages import Message, ImageMessage
+
+T = TypeVar("T", bound=BaseModel)
+
+
+class BaseChatModel(ABC):
+    def __init__(
+        self,
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+        top_p: float | None = None,
+        frequency_penalty: float | None = None,
+        presence_penalty: float | None = None,
+        stop: str | list[str] | None = None,
+        seed: int | None = None,
+        response_format: dict | None = None,
+        timeout: float | httpx.Timeout | None = 60.0,
+        max_retries: int = 2,
+        **kwargs: Any,
+    ):
+        self._default_max_tokens = max_tokens
+        self._default_temperature = temperature
+        self._default_top_p = top_p
+        self._default_frequency_penalty = frequency_penalty
+        self._default_presence_penalty = presence_penalty
+        self._default_stop = stop
+        self._default_seed = seed
+        self._default_response_format = response_format
+        self._default_timeout = timeout
+        self._default_max_retries = max_retries
+        self._default_kwargs = kwargs
+
+    def _merge_params(self, method_kwargs: dict[str, Any]) -> dict[str, Any]:
+        params = {**self._default_kwargs, **method_kwargs}
+
+        param_mapping = {
+            "max_tokens": self._default_max_tokens,
+            "temperature": self._default_temperature,
+            "top_p": self._default_top_p,
+            "frequency_penalty": self._default_frequency_penalty,
+            "presence_penalty": self._default_presence_penalty,
+            "stop": self._default_stop,
+            "seed": self._default_seed,
+            "response_format": self._default_response_format,
+        }
+
+        for key, default_value in param_mapping.items():
+            if key not in method_kwargs and default_value is not None:
+                params[key] = default_value
+
+        params = {k: v for k, v in params.items() if v is not None}
+        return params
+
+    @abstractmethod
+    async def invoke(
+        self,
+        messages: list[Message],
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+        **kwargs: Any,
+    ) -> str:
+        pass
+
+    @abstractmethod
+    async def invoke_structured(
+        self,
+        messages: list[Message],
+        response_model: type[T],
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+        **kwargs: Any,
+    ) -> T:
+        pass
+
+    @abstractmethod
+    async def stream(
+        self,
+        messages: list[Message],
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[str]:
+        pass
+
+
+class BaseOpenAICompatible(BaseChatModel):
+    _client: AsyncOpenAI | AsyncAzureOpenAI
+    _model: str
+
+    def _convert_messages(self, messages: list[Message]) -> list[dict]:
+        converted = []
+        for msg in messages:
+            if not isinstance(msg, ImageMessage):
+                converted.append({"role": msg.role, "content": msg.content})
+                continue
+
+            content = []
+            if msg.content:
+                content.append({"type": "text", "text": msg.content})
+            content.append(
+                {
+                    "type": "image_url",
+                    "image_url": {
+                        "url": f"data:{msg.media_type};base64,{msg.base64_data}"
+                    },
+                }
+            )
+            converted.append({"role": msg.role, "content": content})
+
+        return converted
+
+    async def invoke(
+        self,
+        messages: list[Message],
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+        **kwargs: Any,
+    ) -> str:
+        params = self._merge_params(
+            {"max_tokens": max_tokens, "temperature": temperature, **kwargs}
+        )
+        response: ChatCompletion = await self._client.chat.completions.create(
+            model=self._model, messages=self._convert_messages(messages), **params
+        )
+        return response.choices[0].message.content or ""
+
+    async def invoke_structured(
+        self,
+        messages: list[Message],
+        response_model: type[T],
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+        **kwargs: Any,
+    ) -> T:
+        params = self._merge_params(
+            {"max_tokens": max_tokens, "temperature": temperature, **kwargs}
+        )
+        response = await self._client.beta.chat.completions.parse(
+            model=self._model,
+            messages=self._convert_messages(messages),
+            response_format=response_model,
+            **params,
+        )
+        return response.choices[0].message.parsed
+
+    async def stream(
+        self,
+        messages: list[Message],
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[str]:
+        params = self._merge_params(
+            {"max_tokens": max_tokens, "temperature": temperature, **kwargs}
+        )
+        stream = await self._client.chat.completions.create(
+            model=self._model,
+            messages=self._convert_messages(messages),
+            stream=True,
+            **params,
+        )
+        chunk: ChatCompletionChunk
+        async for chunk in stream:
+            content = chunk.choices[0].delta.content
+            if content is not None:
+                yield content

py_llmify-0.1.0/llmify/providers/openai.py

@@ -0,0 +1,51 @@
+import os
+import httpx
+from openai import AsyncOpenAI
+from llmify.providers.base import BaseOpenAICompatible
+from typing import Any
+from dotenv import load_dotenv
+
+load_dotenv(override=True)
+
+
+class ChatOpenAI(BaseOpenAICompatible):
+    def __init__(
+        self,
+        model: str = "gpt-4o",
+        api_key: str | None = None,
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+        top_p: float | None = None,
+        frequency_penalty: float | None = None,
+        presence_penalty: float | None = None,
+        stop: str | list[str] | None = None,
+        seed: int | None = None,
+        response_format: dict | None = None,
+        timeout: float | httpx.Timeout | None = 60.0,
+        max_retries: int = 2,
+        default_headers: dict | None = None,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            max_tokens=max_tokens,
+            temperature=temperature,
+            top_p=top_p,
+            frequency_penalty=frequency_penalty,
+            presence_penalty=presence_penalty,
+            stop=stop,
+            seed=seed,
+            response_format=response_format,
+            timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
+        )
+        if api_key is None:
+            api_key = os.getenv("OPENAI_API_KEY")
+
+        self._client = AsyncOpenAI(
+            api_key=api_key,
+            timeout=timeout,
+            max_retries=max_retries,
+            default_headers=default_headers,
+        )
+        self._model = model

py_llmify-0.1.0/py_llmify.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: py-llmify
+Version: 0.1.0
+Summary: A minimal, fast, and type-safe Python library for LLM chat completions with OpenAI and Azure OpenAI support
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: openai>=2.14.0
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: python-dotenv>=1.2.1
+Dynamic: license-file

py_llmify-0.1.0/py_llmify.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENCE
+README.md
+pyproject.toml
+llmify/__init__.py
+llmify/messages.py
+llmify/providers/__init__.py
+llmify/providers/azure.py
+llmify/providers/base.py
+llmify/providers/openai.py
+py_llmify.egg-info/PKG-INFO
+py_llmify.egg-info/SOURCES.txt
+py_llmify.egg-info/dependency_links.txt
+py_llmify.egg-info/requires.txt
+py_llmify.egg-info/top_level.txt
+tests/test_messages.py
+tests/test_openai_integration.py
+tests/test_params.py
+tests/test_providers.py

py_llmify-0.1.0/py_llmify.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

py_llmify-0.1.0/py_llmify.egg-info/requires.txt

@@ -0,0 +1,3 @@
+openai>=2.14.0
+pydantic>=2.12.5
+python-dotenv>=1.2.1

py_llmify-0.1.0/py_llmify.egg-info/top_level.txt

@@ -0,0 +1 @@
+llmify

py_llmify-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "py-llmify"
+version = "0.1.0"
+description = "A minimal, fast, and type-safe Python library for LLM chat completions with OpenAI and Azure OpenAI support"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "openai>=2.14.0",
+    "pydantic>=2.12.5",
+    "python-dotenv>=1.2.1",
+]
+
+[dependency-groups]
+dev = [
+    "pre-commit>=4.5.1",
+    "pytest>=9.0.2",
+    "pytest-asyncio>=1.3.0",
+]

py_llmify-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

py_llmify-0.1.0/tests/test_messages.py

@@ -0,0 +1,26 @@
+from llmify import UserMessage, SystemMessage, ImageMessage
+
+
+def test_user_message():
+    msg = UserMessage("Hello")
+    assert msg.role == "user"
+    assert msg.content == "Hello"
+
+
+def test_system_message():
+    msg = SystemMessage("You are helpful")
+    assert msg.role == "system"
+    assert msg.content == "You are helpful"
+
+
+def test_image_message_with_text():
+    msg = ImageMessage(base64_data="abc123", text="What is this?")
+    assert msg.role == "user"
+    assert msg.content == "What is this?"
+    assert msg.base64_data == "abc123"
+
+
+def test_image_message_auto_detect_png():
+    png_base64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFBQIAX8jx0gAAAABJRU5ErkJggg=="
+    msg = ImageMessage(base64_data=png_base64)
+    assert msg.media_type == "image/png"

py_llmify-0.1.0/tests/test_openai_integration.py

@@ -0,0 +1,40 @@
+import pytest
+from unittest.mock import AsyncMock, patch
+from llmify import ChatOpenAI, UserMessage
+
+
+@pytest.mark.asyncio
+@patch("llmify.providers.openai.AsyncOpenAI")
+async def test_invoke_with_mock(mock_client):
+    mock_response = AsyncMock()
+    mock_response.choices = [AsyncMock(message=AsyncMock(content="Hello!"))]
+    mock_client.return_value.chat.completions.create = AsyncMock(
+        return_value=mock_response
+    )
+
+    llm = ChatOpenAI(api_key="fake-key")
+    response = await llm.invoke([UserMessage("Hi")])
+
+    assert response == "Hello!"
+
+
+@pytest.mark.asyncio
+@patch("llmify.providers.openai.AsyncOpenAI")
+async def test_streaming_with_mock(mock_client):
+    chunk1 = AsyncMock(choices=[AsyncMock(delta=AsyncMock(content="Hel"))])
+    chunk2 = AsyncMock(choices=[AsyncMock(delta=AsyncMock(content="lo!"))])
+
+    async def mock_stream(*args, **kwargs):
+        yield chunk1
+        yield chunk2
+
+    mock_client.return_value.chat.completions.create = AsyncMock(
+        return_value=mock_stream()
+    )
+
+    llm = ChatOpenAI(api_key="fake-key")
+    chunks = []
+    async for chunk in llm.stream([UserMessage("Hi")]):
+        chunks.append(chunk)
+
+    assert chunks == ["Hel", "lo!"]

py_llmify-0.1.0/tests/test_params.py

@@ -0,0 +1,35 @@
+from llmify import BaseChatModel
+
+
+class DummyModel(BaseChatModel):
+    async def invoke(self, messages, **kwargs):
+        return self._merge_params(kwargs)
+
+    async def invoke_structured(self, messages, response_model, **kwargs):
+        pass
+
+    async def stream(self, messages, **kwargs):
+        pass
+
+
+def test_default_params():
+    model = DummyModel(max_tokens=100, temperature=0.7)
+    params = model._merge_params({})
+
+    assert params["max_tokens"] == 100
+    assert params["temperature"] == 0.7
+
+
+def test_override_params():
+    model = DummyModel(max_tokens=100, temperature=0.7)
+    params = model._merge_params({"max_tokens": 200})
+
+    assert params["max_tokens"] == 200
+    assert params["temperature"] == 0.7
+
+
+def test_none_params_filtered():
+    model = DummyModel(max_tokens=None)
+    params = model._merge_params({})
+
+    assert "max_tokens" not in params

py_llmify-0.1.0/tests/test_providers.py

@@ -0,0 +1,32 @@
+from llmify.providers import BaseOpenAICompatible
+from llmify import UserMessage, ImageMessage
+
+
+class DummyOpenAI(BaseOpenAICompatible):
+    pass
+
+
+def test_convert_simple_messages():
+    provider = DummyOpenAI()
+    messages = [UserMessage("Hello")]
+
+    converted = provider._convert_messages(messages)
+
+    assert converted == [{"role": "user", "content": "Hello"}]
+
+
+def test_convert_image_message():
+    provider = DummyOpenAI()
+    messages = [
+        ImageMessage(base64_data="abc123", media_type="image/png", text="What is this?")
+    ]
+
+    converted = provider._convert_messages(messages)
+
+    assert converted[0]["role"] == "user"
+    assert len(converted[0]["content"]) == 2
+    assert converted[0]["content"][0] == {"type": "text", "text": "What is this?"}
+    assert converted[0]["content"][1]["type"] == "image_url"
+    assert (
+        "data:image/png;base64,abc123" in converted[0]["content"][1]["image_url"]["url"]
+    )