confamnode 0.1.3__tar.gz → 0.2.0__tar.gz

{confamnode-0.1.3 → confamnode-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: confamnode
-Version: 0.1.3
+Version: 0.2.0
 Summary: The Nigerian AI inference gateway
 Project-URL: Repository, https://github.com/confamnodeai/confamnode
 Project-URL: Bug Tracker, https://github.com/confamnodeai/confamnode/issues
@@ -18,7 +18,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.10
-Requires-Dist: litellm>=1.87.1
+Requires-Dist: httpx>=0.28.1
 Requires-Dist: python-dotenv>=1.2.2
 Description-Content-Type: text/markdown
 

{confamnode-0.1.3 → confamnode-0.2.0}/confamnode/__init__.py

@@ -8,7 +8,7 @@ from confamnode.exceptions import (
 from confamnode.ansa import Ansa, Usage, Cost
 from confamnode import models
 
-__version__ = "0.1.3"
+__version__ = "0.2.0"
 
 __all__ = [
     "ConfamNode",

{confamnode-0.1.3 → confamnode-0.2.0}/confamnode/ansa.py

@@ -30,4 +30,25 @@ class Ansa:
     citations: list = field(default_factory=list)
     id: str = field(default_factory=lambda: f"confam-{uuid.uuid4()}")
     is_local: bool = False
-    is_ngn_data_residency: bool = False
+    is_ngn_data_residency: bool = False
+
+
+@dataclass
+class StreamDelta:
+    role: str | None = None
+    content: str | None = None
+    reasoning: str | None = None
+
+
+@dataclass
+class StreamChoice:
+    index: int = 0
+    delta: StreamDelta = field(default_factory=StreamDelta)
+    finish_reason: str | None = None
+
+
+@dataclass
+class StreamChunk:
+    id: str = ""
+    model: str = ""
+    choices: list = field(default_factory=list)

confamnode-0.2.0/confamnode/builders.py

@@ -0,0 +1,21 @@
+from confamnode.ansa import StreamChunk, StreamChoice, StreamDelta
+
+
+def parse_chunk(raw: dict) -> StreamChunk:
+    choices = []
+    for c in raw.get("choices", []):
+        d = c.get("delta", {})
+        choices.append(StreamChoice(
+            index=c.get("index", 0),
+            finish_reason=c.get("finish_reason"),
+            delta=StreamDelta(
+                role=d.get("role"),
+                content=d.get("content"),
+                reasoning=d.get("reasoning")
+            )
+        ))
+    return StreamChunk(
+        id=raw.get("id", ""),
+        model=raw.get("model", ""),
+        choices=choices,
+    )

confamnode-0.2.0/confamnode/client.py

@@ -0,0 +1,210 @@
+import os
+import json
+import httpx
+
+from typing import Union, List, Dict
+
+from confamnode.builders import parse_chunk
+from confamnode.ansa import Ansa, Usage, Cost
+from confamnode.registry import VALID_MODELS
+from confamnode.exceptions import ConfamAuthError, ConfamModelError
+from confamnode.config import DEFAULT_BASE_URL, DEFAULT_TIMEOUT, DEFAULT_CONNECT_TIMEOUT
+
+
+class ConfamNode:
+    def __init__(
+        self,
+        api_key: str = None,
+        base_url: str = None
+    ):
+        # Pick up from environment if not provided
+        api_key = api_key or os.environ.get("CONFAMNODE_API_KEY")
+
+        if not api_key:
+            raise ValueError("api_key is required")
+        
+        if not api_key.startswith("confam-"):
+            raise ConfamAuthError()
+        
+        self.api_key = api_key
+        self.base_url = base_url or DEFAULT_BASE_URL
+
+    def gist(
+        self,
+        model: str,
+        messages: Union[str, List[Dict[str, str]]],
+        system: str | None = "default",
+        **kwargs
+    ) -> "Ansa | ConfamStream":
+        if model not in VALID_MODELS:
+            raise ConfamModelError(model)
+        
+        # Handle string messages
+        if isinstance(messages, str):
+            messages = [{"role": "user", "content": messages}]
+        elif not isinstance(messages, list):
+            raise ValueError("messages must be a string or list")
+        
+        body = {
+            "model": model,
+            "messages": messages,
+            **kwargs
+        }
+
+        # System message tri-state
+        has_system_in_messages = any(m.get("role") == "system" for m in messages)
+        if not has_system_in_messages:
+            if system == "default":
+                pass 
+            else:
+                body["system"] = system # None or custom string
+
+        if kwargs.get("stream", False):
+            http_client = httpx.Client(
+                timeout=httpx.Timeout(DEFAULT_TIMEOUT, connect=DEFAULT_CONNECT_TIMEOUT)
+            )
+            req = http_client.build_request(
+                "POST",
+                f"{self.base_url}/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {self.api_key}",
+                    "Content-Type": "application/json",
+                },
+                json=body,
+            )
+            stream_response = http_client.send(req, stream=True)
+
+            if stream_response.status_code >= 400:
+                stream_response.read()
+                stream_response.close()
+                http_client.close()
+                error = stream_response.json().get("detail", "Requeest failed")
+                raise Exception(f"ConfamNode error {stream_response.status_code}: {error}")
+            
+            return ConfamStream(stream_response, http_client, model)
+        
+        response = httpx.post(
+            f"{self.base_url}/chat/completions",
+            headers={
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json",
+            },
+            json=body,
+            timeout=httpx.Timeout(DEFAULT_TIMEOUT, connect=DEFAULT_CONNECT_TIMEOUT)
+        )
+
+        if response.status_code >= 400:
+            error = response.json().get("detail", "Request failed")
+            raise Exception(f"ConfamNode error {response.status_code}: {error}")
+
+        data = response.json()
+        msg = data["choices"][0]["message"]
+        usage_data = data.get("usage", {})
+        confam = data.get("confam", {})
+        cost_data = confam.get("cost", {})
+
+        return Ansa(
+            id=confam.get("request_id", data.get("id", "")),
+            text=msg.get("content") or "",
+            model=model,
+            reasoning=msg.get("reasoning"),
+            tools=msg.get("tool_calls") or [],
+            citations=msg.get("citations") or [],
+            usage=Usage(
+                prompt_tokens=usage_data.get("prompt_tokens", 0),
+                completion_tokens=usage_data.get("completion_tokens", 0),
+                total_tokens=usage_data.get("total_tokens", 0),
+            ),
+            cost=Cost(
+                naira=cost_data.get("naira", 0.0),
+                naira_input=cost_data.get("naira_input", 0.0),
+                naira_output=cost_data.get("naira_output", 0.0),
+            ),
+            finish_reason=data["choices"][0].get("finish_reason", "stop"),
+            raw={
+                "id": data.get("id"),
+                "usage": {
+                    "prompt_tokens": usage_data.get("prompt_tokens", 0),
+                    "completion_tokens": usage_data.get("completion_tokens", 0)
+                }
+            },
+            is_local=confam.get("is_local", False),
+            is_ngn_data_residency=confam.get("is_ngn_data_residency", False),
+        )
+    
+
+class ConfamStream:
+    def __init__(self, stream_response, http_client, model: str):
+        self._stream_response = stream_response
+        self._http_client = http_client
+        self._model = model
+        self._chunks = []
+        self._ansa = None
+        self._confam_meta = {}
+
+    def __iter__(self):
+        try:
+            for line in self._stream_response.iter_lines():
+                if not line or not line.startswith("data: "):
+                    continue
+                payload_str = line[len("data: "):]
+                if payload_str.strip() == "[DONE]":
+                    break
+                try:
+                    raw = json.loads(payload_str)
+                except json.JSONDecodeError:
+                    continue
+
+                if "confam" in raw:
+                    self._confam_meta = raw["confam"]
+                    continue
+
+                if not raw.get("choices"):
+                    continue
+
+                chunk = parse_chunk(raw)
+                self._chunks.append(chunk)
+                yield chunk
+        finally:
+            self._stream_response.close()
+            self._http_client.close()
+
+        self._ansa = self._build_ansa()
+
+    def get_ansa(self) -> Ansa:
+        if self._ansa is None:
+            raise RuntimeError("Stream not complete yet. Iterate through all chunks first.")
+        return self._ansa
+    
+    def _build_ansa(self) -> Ansa:
+        # Collect text from all chunks
+        text = "".join([
+            c.choices[0].delta.content or ""
+            for c in self._chunks
+            if c.choices and c.choices[0].delta.content
+        ])
+
+        # Get finish reason from last chunk
+        if self._chunks and self._chunks[-1].choices:
+            finish_reason = self._chunks[-1].choices[0].finish_reason or "stop"
+
+        cost_data = self._confam_meta.get("cost", {})
+
+        return Ansa(
+            id=self._confam_meta.get("request_id", ""),
+            text=text,
+            model=self._model,
+            usage=Usage(prompt_tokens=0, completion_tokens=0, total_tokens=0),
+            cost=Cost(
+                naira=cost_data.get("naira", 0.0),
+                naira_input=cost_data.get("naira_input", 0.0),
+                naira_output=cost_data.get("naira_output", 0.0),
+            ),
+            finish_reason=finish_reason,
+            raw={
+                "id": self._confam_meta.get("request_id", ""),
+                "usage": {"prompt_tokens": 0, "completion_tokens": 0}
+            },
+            is_local=self._confam_meta.get("is_local", False),
+            is_ngn_data_residency=self._confam_meta.get("is_ngn_data_residency", False),
+        )

confamnode-0.2.0/confamnode/config.py

@@ -0,0 +1,3 @@
+DEFAULT_BASE_URL = "https://api.confamnode.com/v1"
+DEFAULT_TIMEOUT = 300.0
+DEFAULT_CONNECT_TIMEOUT = 10.0

{confamnode-0.1.3 → confamnode-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "confamnode"
-version = "0.1.3"
+version = "0.2.0"
 description = "The Nigerian AI inference gateway"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -21,7 +21,7 @@ classifiers = [
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
 ]
 dependencies = [
-    "litellm>=1.87.1",
+    "httpx>=0.28.1",
     "python-dotenv>=1.2.2",
 ]
 
@@ -43,4 +43,4 @@ anyio_mode = "auto"
 
 [build-system]
 requires = ["hatchling"]
-build-backend = "hatchling.build"
+build-backend = "hatchling.build"

{confamnode-0.1.3 → confamnode-0.2.0}/tests/test_ansa.py

@@ -1,4 +1,3 @@
-import pytest
 from confamnode.ansa import Ansa, Usage, Cost
 
 

confamnode-0.2.0/tests/test_client.py

@@ -0,0 +1,80 @@
+import os
+import pytest
+from unittest.mock import patch, MagicMock
+
+from confamnode.client import ConfamNode
+from confamnode.exceptions import ConfamAuthError
+
+
+def test_client_accepts_api_key():
+    client = ConfamNode(api_key="confam-abc123")
+    assert client.api_key == "confam-abc123"
+
+
+def test_client_raises_error_without_api_key():
+    with pytest.raises(ValueError, match="api_key is required"):
+        ConfamNode()
+
+
+def test_client_raises_error_on_invalid_key_format():
+    with pytest.raises(ConfamAuthError, match="Invalid ConfamNode API key format"):
+        ConfamNode(api_key="sk-openai-abc123")
+
+
+def test_client_key_starts_with_confam():
+    client = ConfamNode(api_key="confam-abc123")
+    assert client.api_key.startswith("confam-")
+
+
+def test_client_does_not_have_litellm_key():
+    client = ConfamNode(api_key="confam-abc123")
+    assert not hasattr(client, "litellm_key")
+
+
+def test_client_has_default_base_url():
+    client = ConfamNode(api_key="confam-abc123")
+    assert client.base_url == "https://api.confamnode.com/v1"
+
+
+def test_client_accepts_custom_base_url():
+    client = ConfamNode(
+        api_key="confam-abc123",
+        base_url="http://192.168.1.100:8000/v1"
+    )
+    assert client.base_url == "http://192.168.1.100:8000/v1"
+
+
+def test_client_picks_up_api_key_from_environment():
+    with patch.dict(os.environ, {"CONFAMNODE_API_KEY": "confam-abc123"}):
+        client = ConfamNode()
+        assert client.api_key == "confam-abc123"
+
+
+def test_client_explicit_key_overrides_environment():
+    with patch.dict(os.environ, {"CONFAMNODE_API_KEY": "confam-env123"}):
+        client = ConfamNode(api_key="confam-explicit123")
+        assert client.api_key == "confam-explicit123"
+
+
+def test_client_sends_confam_key_in_authorization_header():
+    mock_response = MagicMock()
+    mock_response.status_code = 200
+    mock_response.json.return_value = {
+        "id": "confam-xxx",
+        "object": "chat.completion",
+        "created": 1,
+        "model": "confam-speed",
+        "choices": [{"index": 0, "finish_reason": "stop",
+                     "message": {"role": "assistant", "content": "hi",
+                                 "reasoning": None, "tool_calls": None, "citations": None}}],
+        "usage": {"prompt_tokens": 5, "completion_tokens": 5, "total_tokens": 10},
+        "confam": {"request_id": "confam-xxx",
+                   "cost": {"naira": 0.0, "naira_input": 0.0, "naira_output": 0.0},
+                   "is_local": False, "is_ngn_data_residency": False}
+    }
+
+    client = ConfamNode(api_key="confam-abc123")
+    with patch("confamnode.client.httpx.post", return_value=mock_response) as mock_post:
+        client.gist(model="confam-speed", messages="hi")
+        call_headers = mock_post.call_args.kwargs["headers"]
+        assert call_headers["Authorization"] == "Bearer confam-abc123"

confamnode-0.2.0/tests/test_gist.py

@@ -0,0 +1,250 @@
+import pytest
+from unittest.mock import patch, MagicMock
+
+from confamnode import models
+from confamnode.client import ConfamNode
+from confamnode.ansa import Ansa, Usage, Cost
+from confamnode.exceptions import ConfamModelError
+
+
+
+@pytest.fixture
+def client():
+    return ConfamNode(api_key="confam-sk-test-abc123")
+
+
+@pytest.fixture
+def mock_proxy_response():
+    mock = MagicMock()
+    mock.status_code = 200
+    mock.json.return_value = {
+        "id": "confam-test-id",
+        "object": "chat.completion",
+        "created": 1234567890,
+        "model": "confam-speed",
+        "choices": [{
+            "index": 0,
+            "finish_reason": "stop",
+            "message": {
+                "role": "assistant",
+                "content": "How far! I dey fine.",
+                "reasoning": None,
+                "tool_calls": None,
+                "citations": None
+            }
+        }],
+        "usage": {
+            "prompt_tokens": 10,
+            "completion_tokens": 20,
+            "total_tokens": 30
+        },
+        "confam": {
+            "request_id": "confam-test-id",
+            "cost": {"naira": 0.0, "naira_input": 0.0, "naira_output": 0.0},
+            "is_local": False,
+            "is_ngn_data_residency": False
+        }
+    }
+    return mock
+
+
+def test_gist_requires_model(client):
+    with pytest.raises(TypeError):
+        client.gist(messages=[{"role": "user", "content": "How far?"}])
+
+
+def test_gist_requires_messages(client):
+    with pytest.raises(TypeError):
+        client.gist(model=models.SPEED)
+
+
+def test_gist_rejects_invalid_model(client):
+    with pytest.raises(ConfamModelError, match="Invalid model name"):
+        client.gist(model="gpt-4o", messages="How far?")
+
+
+def test_gist_returns_ansa_object(client, mock_proxy_response):
+    with patch("confamnode.client.httpx.post", return_value=mock_proxy_response):
+        ansa = client.gist(model=models.SPEED, messages="How far?")
+        assert isinstance(ansa, Ansa)
+
+
+def test_gist_returns_content(client, mock_proxy_response):
+    with patch("confamnode.client.httpx.post", return_value=mock_proxy_response):
+        ansa = client.gist(model=models.SPEED, messages="How far?")
+        assert ansa.text == "How far! I dey fine."
+
+
+def test_gist_has_model(client, mock_proxy_response):
+    with patch("confamnode.client.httpx.post", return_value=mock_proxy_response):
+        ansa =client.gist(model="confam-speed", messages="How far?")
+        assert ansa.model == "confam-speed"
+
+
+def test_gist_has_usage(client, mock_proxy_response):
+    with patch("confamnode.client.httpx.post", return_value=mock_proxy_response):
+        ansa = client.gist(model=models.SPEED, messages="How far?")
+        assert isinstance(ansa.usage, Usage)
+        assert ansa.usage.prompt_tokens == 10
+        assert ansa.usage.completion_tokens == 20
+        assert ansa.usage.total_tokens == 30
+
+
+def test_gist_has_cost(client, mock_proxy_response):
+    with patch("confamnode.client.httpx.post", return_value=mock_proxy_response):
+        ansa = client.gist(model=models.SPEED, messages="How far?")
+        assert isinstance(ansa.cost, Cost)
+        assert isinstance(ansa.cost.naira, float)
+
+
+def test_gist_comes_from_confam_object(client, mock_proxy_response):
+    mock_proxy_response.json.return_value["confam"]["cost"] = {
+        "naira": 0.596,
+        "naira_input": 0.075,
+        "naira_output": 0.521
+    }
+    with patch("confamnode.client.httpx.post", return_value=mock_proxy_response):
+        ansa = client.gist(model="confam-intelligence", messages="How far?")
+        assert ansa.cost.naira == 0.596
+        assert ansa.cost.naira_input == 0.075
+        assert ansa.cost.naira_output == 0.521
+
+
+def test_gist_has_finish_reason(client, mock_proxy_response):
+    with patch("confamnode.client.httpx.post", return_value=mock_proxy_response):
+        ansa = client.gist(model=models.SPEED, messages="How far?")
+        assert ansa.finish_reason == "stop"
+
+
+def test_gist_has_id(client, mock_proxy_response):
+    with patch("confamnode.client.httpx.post", return_value=mock_proxy_response):
+        ansa = client.gist(model=models.SPEED, messages="How far?")
+        assert ansa.id.startswith("confam-")
+
+
+def test_gist_has_raw(client, mock_proxy_response):
+    with patch("confamnode.client.httpx.post", return_value=mock_proxy_response):
+        ansa = client.gist(model=models.SPEED, messages="How far?")
+        assert isinstance(ansa.raw, dict)
+        assert "_hidden_params" not in ansa.raw
+
+
+def test_gist_accepts_string_messages(client, mock_proxy_response):
+    with patch("confamnode.client.httpx.post", return_value=mock_proxy_response):
+        ansa = client.gist(model=models.SPEED, messages="How far?")
+        assert ansa is not None
+
+
+def test_gist_converts_string_to_user_message_in_request(client, mock_proxy_response):
+    with patch("confamnode.client.httpx.post", return_value=mock_proxy_response) as mock_post:
+        client.gist(model=models.SPEED, messages="How far?")
+        body = mock_post.call_args.kwargs["json"]
+        user_msgs = [m for m in body["messages"] if m["role"] == "user"]
+        assert user_msgs[0]["content"] == "How far?"
+
+
+def test_gist_accepts_list_messages(client, mock_proxy_response):
+    with patch("confamnode.client.httpx.post", return_value=mock_proxy_response):
+        ansa = client.gist(
+            model=models.SPEED,
+            messages=[{"role": "user", "content": "How far?"}]
+        )
+        assert ansa is not None
+
+
+def test_gist_rejects_invalid_messages_type(client):
+    with pytest.raises(ValueError, match="messages must be a string or list"):
+        client.gist(model=models.SPEED, messages=123)
+
+
+def test_gist_passes_kwargs_to_proxy(client, mock_proxy_response):
+    with patch("confamnode.client.httpx.post", return_value=mock_proxy_response) as mock_post:
+        client.gist(model=models.SPEED, messages="How far?", temperature=0.7, max_tokens=500)
+        body = mock_post.call_args.kwargs["json"]
+        assert body["temperature"] == 0.7
+        assert body["max_tokens"] == 500
+
+
+def test_gist_does_not_prepend_openai_prefix(client, mock_proxy_response):
+    with patch("confamnode.client.httpx.post", return_value=mock_proxy_response) as mock_post:
+        client.gist(model="confam-speed", messages="How far?", temperature=0.7, max_tokens=500)
+        body = mock_post.call_args.kwargs["json"]
+        assert body["model"] == "confam-speed"
+        assert "openai/" not in body["model"]
+
+
+def test_gist_default_system_omits_system_field(client, mock_proxy_response):
+    with patch("confamnode.client.httpx.post", return_value=mock_proxy_response) as mock_post:
+        client.gist(model="confam-speed", messages="How far?")
+        body = mock_post.call_args.kwargs["json"]
+        assert "system" not in body
+
+
+def test_gist_custom_system_passes_as_field(client, mock_proxy_response):
+    with patch("confamnode.client.httpx.post", return_value=mock_proxy_response) as mock_post:
+        client.gist(model=models.SPEED, messages="Who you be?", system="You are a Konga assistant")
+        body = mock_post.call_args.kwargs["json"]
+        assert body["system"] == "You are a Konga assistant"
+
+
+def test_gist_system_none_passes_null(client, mock_proxy_response):
+    with patch("confamnode.client.httpx.post", return_value=mock_proxy_response) as mock_post:
+        client.gist(model=models.SPEED, messages="Who you be?", system=None)
+        body = mock_post.call_args.kwargs["json"]
+        assert "system" in body
+        assert body["system"] is None
+
+
+def test_gist_system_in_messages_list_is_respected(client, mock_proxy_response):
+    with patch("confamnode.client.httpx.post", return_value=mock_proxy_response) as mock_post:
+        client.gist(
+            model=models.SPEED,
+            messages=[
+                {"role": "system", "content": "You are a Konga assistant"},
+                {"role": "user", "content": "Who you be?"}
+            ]
+        )
+        body = mock_post.call_args.kwargs["json"]
+        assert body["messages"][0]["role"] == "system"
+        assert body["messages"][0]["content"] == "You are a Konga assistant"
+
+
+def test_gist_sets_local_from_confam_object(client, mock_proxy_response):
+    mock_proxy_response.json.return_value["confam"]["is_local"] = True
+    mock_proxy_response.json.return_value["confam"]["is_ngn_data_residency"] = True
+    with patch("confamnode.client.httpx.post", return_value=mock_proxy_response):
+        ansa = client.gist(model=models.NANO, messages="How you dey?")
+        assert ansa.is_local is True
+        assert ansa.is_ngn_data_residency is True
+
+
+def test_sets_is_local_false_for_cloud_model(client, mock_proxy_response):
+    with patch("confamnode.client.httpx.post", return_value=mock_proxy_response):
+        ansa = client.gist(model=models.SPEED, messages="How you dey?")
+        assert ansa.is_local is False
+        assert ansa.is_ngn_data_residency is False
+
+
+def test_gist_accepts_all_valid_models(client, mock_proxy_response):
+    valid_models = [models.LITE, models.SPEED, models.REASONING, models.NANO]
+    with patch("confamnode.client.httpx.post", return_value=mock_proxy_response):
+        for model in valid_models:
+            ansa = client.gist(model=model, messages="How far?")
+            assert ansa is not None
+
+
+def test_gist_raises_on_proxy_error(client):
+    mock_error_response = MagicMock()
+    mock_error_response.status_code = 402
+    mock_error_response.json.return_value = {"detail": "Insufficient wallet balance."}
+    with patch("confamnode.client.httpx.post", return_value=mock_error_response):
+        with pytest.raises(Exception):
+            client.gist(model="confam-intelligence", messages="How far?")
+
+
+def test_gist_reasoning_content_returned(client, mock_proxy_response):
+    mock_proxy_response.json.return_value["choices"][0]["message"]["reasoning"] = "step by step..."
+    with patch("confamnode.client.httpx.post", return_value=mock_proxy_response):
+        ansa = client.gist(model=models.REASONING, messages="Think carefully")
+        assert ansa.reasoning == "step by step..."
+