pop-python 1.0.3__py3-none-any.whl → 1.1.0__py3-none-any.whl

{pop_python-1.0.3.dist-info → pop_python-1.1.0.dist-info}/WHEEL

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

pop_python-1.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+POP
+tests

tests/conftest.py

@@ -0,0 +1,47 @@
+import importlib.util
+import os
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from pop.env_api_keys import has_api_key
+
+
+def _build_fake_response(content: str | None = None, tool_arguments: str | None = None) -> SimpleNamespace:
+    tool_calls = None
+    if tool_arguments is not None:
+        function = SimpleNamespace(arguments=tool_arguments)
+        tool_calls = [SimpleNamespace(function=function)]
+    message = SimpleNamespace(content=content, tool_calls=tool_calls)
+    choice = SimpleNamespace(message=message)
+    return SimpleNamespace(choices=[choice])
+
+
+@pytest.fixture
+def fake_response():
+    return _build_fake_response
+
+
+@pytest.fixture(scope="session")
+def tools():
+    tools_path = Path(__file__).resolve().parents[1] / "other_doc" / "function_calls.py"
+    spec = importlib.util.spec_from_file_location("function_calls", tools_path)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"Failed to load tools module from {tools_path}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module.tools
+
+
+def _is_live_enabled(provider: str | None = None) -> bool:
+    if os.getenv("POP_LIVE_TESTS") != "1":
+        return False
+    if provider:
+        return has_api_key(provider)
+    return True
+
+
+@pytest.fixture(scope="session")
+def live_enabled():
+    return _is_live_enabled

tests/test_api_registry.py

@@ -0,0 +1,36 @@
+from pop.api_registry import (
+    list_providers,
+    list_default_model,
+    list_models,
+    get_client,
+    get_model,
+)
+from pop.providers.local_client import LocalPyTorchClient
+
+
+def test_list_providers_contains_defaults():
+    providers = list_providers()
+    assert "openai" in providers
+    assert "local" in providers
+
+
+def test_list_default_model_contains_mapping():
+    defaults = list_default_model()
+    assert defaults.get("openai") is not None
+    assert defaults.get("local") == "local-llm"
+
+
+def test_list_models_includes_known_openai_model():
+    models = list_models()
+    assert "openai" in models
+    assert "gpt-4o" in models["openai"]
+
+
+def test_get_client_local():
+    client = get_client("local")
+    assert isinstance(client, LocalPyTorchClient)
+
+
+def test_get_model_uses_default_mapping():
+    client = get_model("local-llm")
+    assert isinstance(client, LocalPyTorchClient)

tests/test_context_utils.py

@@ -0,0 +1,54 @@
+import pytest
+
+from pop.context import Context
+from pop.utils.event_stream import to_event_stream
+from pop.utils.json_parse import parse_json, get_value
+from pop.utils.validation import validate_not_empty, validate_json
+from pop.utils.sanitize_unicode import sanitize
+from pop.utils.overflow import truncate_messages
+from pop.utils.http_proxy import get_session_with_proxy
+
+
+def test_context_append_and_to_messages():
+    ctx = Context(system="System")
+    ctx.append("user", "Hi")
+    ctx.append("assistant", "Hello")
+    assert ctx.to_messages() == [
+        {"role": "system", "content": "System"},
+        {"role": "user", "content": "Hi"},
+        {"role": "assistant", "content": "Hello"},
+    ]
+
+
+def test_event_stream_iteration():
+    def gen():
+        yield {"event": "start"}
+        yield {"event": "done"}
+
+    stream = to_event_stream(gen())
+    assert list(stream) == [{"event": "start"}, {"event": "done"}]
+
+
+def test_json_parse_and_get_value():
+    data = parse_json('{"a": 1}')
+    assert data["a"] == 1
+    assert get_value(data, "missing", default="x") == "x"
+
+
+def test_validation_helpers():
+    with pytest.raises(ValueError):
+        validate_not_empty("")
+    assert validate_json('{"ok": true}') == {"ok": True}
+    with pytest.raises(ValueError):
+        validate_json("{bad json}")
+
+
+def test_sanitize_and_truncate():
+    assert sanitize("caf\u00e9") == "cafe"
+    msgs = ["a" * 3, "b" * 3, "c" * 3]
+    assert truncate_messages(msgs, max_length=6) == ["aaa", "bbb"]
+
+
+def test_get_session_with_proxy():
+    session = get_session_with_proxy()
+    assert session.trust_env is True

tests/test_embedder.py

@@ -0,0 +1,64 @@
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+
+import pop.embedder as emb_mod
+from pop.embedder import Embedder
+
+
+def test_invalid_use_api_raises():
+    with pytest.raises(ValueError):
+        Embedder(use_api="bad-api")
+
+
+def test_openai_embedding_stub(monkeypatch):
+    class DummyEmbeddings:
+        def create(self, input, model):
+            return SimpleNamespace(data=[SimpleNamespace(embedding=[0.1, 0.2]) for _ in input])
+
+    class DummyClient:
+        def __init__(self, api_key=None):
+            self.embeddings = DummyEmbeddings()
+
+    monkeypatch.setattr(emb_mod, "openai", SimpleNamespace(Client=DummyClient))
+    embedder = Embedder(use_api="openai", model_name="text-embedding-3-small")
+    vecs = embedder.get_embedding(["hello", "world"])
+    assert isinstance(vecs, np.ndarray)
+    assert vecs.shape == (2, 2)
+
+
+def test_jina_embedding_stub(monkeypatch):
+    class DummyResponse:
+        status_code = 200
+
+        def json(self):
+            return {
+                "data": [
+                    {"embedding": [0.1, 0.2, 0.3]},
+                    {"embedding": [0.4, 0.5, 0.6]},
+                ]
+            }
+
+    def dummy_post(url, headers=None, json=None):
+        return DummyResponse()
+
+    monkeypatch.setattr(emb_mod.HTTPRequests, "post", dummy_post)
+    embedder = Embedder(use_api="jina", model_name="jina-embeddings-v3")
+    vecs = embedder.get_embedding(["a", "b"])
+    assert vecs.shape == (2, 3)
+
+
+def test_get_embedding_requires_list(monkeypatch):
+    class DummyEmbeddings:
+        def create(self, input, model):
+            return SimpleNamespace(data=[SimpleNamespace(embedding=[0.1, 0.2]) for _ in input])
+
+    class DummyClient:
+        def __init__(self, api_key=None):
+            self.embeddings = DummyEmbeddings()
+
+    monkeypatch.setattr(emb_mod, "openai", SimpleNamespace(Client=DummyClient))
+    embedder = Embedder(use_api="openai", model_name="text-embedding-3-small")
+    with pytest.raises(ValueError):
+        embedder.get_embedding("not-a-list")

tests/test_env_api_keys.py

@@ -0,0 +1,15 @@
+from pop.env_api_keys import has_api_key
+
+
+def test_has_api_key_true_when_set(monkeypatch):
+    monkeypatch.setenv("OPENAI_API_KEY", "test-key")
+    assert has_api_key("openai") is True
+
+
+def test_has_api_key_false_when_unset(monkeypatch):
+    monkeypatch.delenv("OPENAI_API_KEY", raising=False)
+    assert has_api_key("openai") is False
+
+
+def test_has_api_key_for_keyless_provider():
+    assert has_api_key("local") is True

tests/test_prompt_function.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import json
+from types import SimpleNamespace
+
+from pop.prompt_function import PromptFunction
+from pop.providers.llm_client import LLMClient
+
+
+class DummyClient(LLMClient):
+    def __init__(self, response):
+        self.response = response
+        self.model_name = "dummy-model"
+        self.last_call = None
+
+    def chat_completion(self, messages, model, temperature=0.0, **kwargs):
+        self.last_call = {
+            "messages": messages,
+            "model": model,
+            "temperature": temperature,
+            **kwargs,
+        }
+        return self.response
+
+
+def test_prepare_prompt_replacements(fake_response):
+    client = DummyClient(fake_response("ok"))
+    pf = PromptFunction(prompt="Hello <<<name>>>", client=client)
+    result = pf._prepare_prompt("Extra", name="World", ADD_BEFORE="Before", ADD_AFTER="After")
+    assert result == "Before\nHello World\nExtra\nAfter"
+
+
+def test_prepare_prompt_sys_fallback(fake_response):
+    client = DummyClient(fake_response("ok"))
+    pf = PromptFunction(sys_prompt="System instructions", prompt="", client=client)
+    result = pf._prepare_prompt(foo="bar")
+    assert result == "User instruction:\nfoo: bar"
+
+
+def test_execute_passes_options_and_defaults(fake_response):
+    client = DummyClient(fake_response("ok"))
+    pf = PromptFunction(prompt="Hello <<<name>>>", client=client)
+    fmt = {"type": "json_schema", "json_schema": {"name": "x", "schema": {"type": "object"}}}
+    tools = [{"type": "function", "function": {"name": "ping", "parameters": {"type": "object"}}}]
+    images = ["http://example.com/img.png"]
+
+    pf.execute(name="World", tools=tools, fmt=fmt, images=images)
+
+    assert client.last_call is not None
+    assert client.last_call["tools"] == tools
+    assert client.last_call["tool_choice"] == "auto"
+    assert client.last_call["response_format"] == fmt
+    assert client.last_call["images"] == images
+
+
+def test_execute_returns_tool_call_arguments(fake_response):
+    tool_args = json.dumps({"description": "walk", "when": "9am"})
+    client = DummyClient(fake_response(None, tool_arguments=tool_args))
+    pf = PromptFunction(prompt="<<<input>>>", client=client)
+    result = pf.execute(input="Remind me to walk at 9am.", tools=[{"type": "function", "function": {"name": "x"}}])
+    assert result == tool_args
+
+
+def test_improve_prompt_replaces_and_strips_output(monkeypatch, fake_response):
+    client = DummyClient(fake_response("unused"))
+    pf = PromptFunction(sys_prompt="Base prompt", prompt="", client=client)
+    monkeypatch.setattr(pf, "execute", lambda *args, **kwargs: "# OUTPUT\nImproved prompt")
+    improved = pf.improve_prompt(replace=True)
+    assert improved == "Improved prompt"
+    assert pf.sys_prompt == "Improved prompt"
+
+
+def test_load_prompt_resolves_relative_path():
+    content = PromptFunction.load_prompt("prompts/json_formatter_prompt.md")
+    assert "Generate a JSON Schema" in content
+
+
+def test_generate_schema_default_prompt_saves(tmp_path, monkeypatch):
+    response = SimpleNamespace(
+        choices=[SimpleNamespace(message=SimpleNamespace(content=json.dumps({"name": "test", "schema": {"type": "object"}})))]
+    )
+    client = DummyClient(response)
+    pf = PromptFunction(prompt="Return the square of an integer.", client=client)
+    monkeypatch.chdir(tmp_path)
+
+    schema = pf.generate_schema(save=True)
+
+    assert schema["name"] == "test"
+    saved = tmp_path / "schemas" / "test.json"
+    assert saved.exists()
+
+
+def test_save_writes_prompt(tmp_path, fake_response):
+    client = DummyClient(fake_response("ok"))
+    pf = PromptFunction(prompt="Hello", client=client)
+    target = tmp_path / "prompt.txt"
+    pf.save(str(target))
+    assert target.read_text(encoding="utf-8") == "Hello"

tests/test_web_snapshot.py

@@ -0,0 +1,47 @@
+import pop.utils.web_snapshot as ws
+
+
+def test_web_snapshot_headers_and_url(monkeypatch):
+    captured = {}
+
+    class DummyResponse:
+        text = "ok"
+
+        def raise_for_status(self):
+            return None
+
+    def dummy_get(url, headers=None):
+        captured["url"] = url
+        captured["headers"] = headers or {}
+        return DummyResponse()
+
+    monkeypatch.setattr(ws.requests, "get", dummy_get)
+
+    ws.get_text_snapshot(
+        "https://example.com",
+        use_api_key=False,
+        target_selector=["main", ".content"],
+        wait_for_selector=["#ready"],
+        exclude_selector=[".ads"],
+        links_at_end=True,
+        images_at_end=True,
+        image_caption=True,
+    )
+
+    assert captured["url"] == "https://r.jina.ai/https://example.com"
+    headers = captured["headers"]
+    assert headers["X-Target-Selector"] == "main,.content"
+    assert headers["X-Wait-For-Selector"] == "#ready"
+    assert headers["X-Remove-Selector"] == ".ads"
+    assert headers["X-With-Links-Summary"] == "true"
+    assert headers["X-With-Images-Summary"] == "true"
+    assert headers["X-With-Generated-Alt"] == "true"
+
+
+def test_web_snapshot_request_exception(monkeypatch):
+    def dummy_get(url, headers=None):
+        raise ws.requests.exceptions.RequestException("boom")
+
+    monkeypatch.setattr(ws.requests, "get", dummy_get)
+    result = ws.get_text_snapshot("https://example.com", use_api_key=False)
+    assert "Error fetching text snapshot" in result