wirelog 0.1.0__tar.gz

wirelog-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,24 @@
+name: CI
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install package
+        run: pip install -e .
+      - name: Run tests
+        run: python -m unittest discover tests -v
+      - name: Verify zero dependencies
+        run: |
+          pip show wirelog | grep -E "^Requires:" | grep -qE "^Requires:\s*$" || \
+          (echo "ERROR: wirelog has dependencies!" && exit 1)
+      - name: Compile check
+        run: python -m py_compile src/wirelog/client.py

wirelog-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,21 @@
+name: Publish to PyPI
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Install build tools
+        run: pip install build
+      - name: Build package
+        run: python -m build
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

wirelog-0.1.0/.gitignore

@@ -0,0 +1,36 @@
+# Build/dist
+dist/
+build/
+*.egg-info/
+__pycache__/
+*.pyc
+*.pyo
+
+# Virtual env
+.venv/
+venv/
+env/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Env
+.env
+.env.local
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Misc
+*.bak
+*.tmp

wirelog-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 WireLog
+
+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.

wirelog-0.1.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: wirelog
+Version: 0.1.0
+Summary: WireLog analytics client — zero dependencies
+Project-URL: Homepage, https://wirelog.ai
+Project-URL: Repository, https://github.com/wirelogai/wirelog-python
+Project-URL: Documentation, https://docs.wirelog.ai
+Author-email: WireLog <hello@wirelog.ai>
+License: MIT
+License-File: LICENSE
+Keywords: ai-agents,analytics,events,tracking,wirelog
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# wirelog
+
+[WireLog](https://wirelog.ai) analytics client for Python. **Zero dependencies** — stdlib only.
+
+## Install
+
+```bash
+pip install wirelog
+```
+
+## Quick Start
+
+```python
+from wirelog import WireLog
+
+wl = WireLog(api_key="sk_your_secret_key")
+
+# Track an event
+wl.track("signup", user_id="u_123", event_properties={"plan": "free"})
+
+# Query analytics (returns Markdown by default)
+result = wl.query("signup | last 7d | count by day")
+print(result)
+
+# Identify a user (bind device → user, set profile)
+wl.identify("alice@acme.org", device_id="dev_abc", user_properties={"plan": "pro"})
+```
+
+## Configuration
+
+```python
+wl = WireLog(
+    api_key="sk_...",         # or set WIRELOG_API_KEY env var
+    host="https://api.wirelog.ai", # or set WIRELOG_HOST env var
+    timeout=30,                # HTTP timeout in seconds
+)
+```
+
+## API
+
+### `wl.track(event_type, *, user_id, device_id, session_id, event_properties, user_properties, insert_id)`
+
+Track a single event. Auto-generates `insert_id` and `time` if not provided.
+
+### `wl.track_batch(events)`
+
+Track multiple events in one request (up to 2000).
+
+### `wl.query(q, *, format="llm", limit=100, offset=0)`
+
+Run a pipe DSL query. Format: `"llm"` (Markdown), `"json"`, or `"csv"`.
+
+### `wl.identify(user_id, *, device_id, user_properties, user_property_ops)`
+
+Bind a device to a user and/or update profile properties.
+
+## Zero Dependencies
+
+This library uses only the Python standard library (`urllib.request`, `json`, `time`, `uuid`, `os`). No `requests`, no `httpx`, no `urllib3`. It works out of the box on any Python 3.9+ installation.
+
+## Learn More
+
+- [WireLog](https://wirelog.ai) — headless analytics for agents and LLMs
+- [Query language docs](https://docs.wirelog.ai/query-language)
+- [API reference](https://docs.wirelog.ai/reference/api)

wirelog-0.1.0/README.md

@@ -0,0 +1,65 @@
+# wirelog
+
+[WireLog](https://wirelog.ai) analytics client for Python. **Zero dependencies** — stdlib only.
+
+## Install
+
+```bash
+pip install wirelog
+```
+
+## Quick Start
+
+```python
+from wirelog import WireLog
+
+wl = WireLog(api_key="sk_your_secret_key")
+
+# Track an event
+wl.track("signup", user_id="u_123", event_properties={"plan": "free"})
+
+# Query analytics (returns Markdown by default)
+result = wl.query("signup | last 7d | count by day")
+print(result)
+
+# Identify a user (bind device → user, set profile)
+wl.identify("alice@acme.org", device_id="dev_abc", user_properties={"plan": "pro"})
+```
+
+## Configuration
+
+```python
+wl = WireLog(
+    api_key="sk_...",         # or set WIRELOG_API_KEY env var
+    host="https://api.wirelog.ai", # or set WIRELOG_HOST env var
+    timeout=30,                # HTTP timeout in seconds
+)
+```
+
+## API
+
+### `wl.track(event_type, *, user_id, device_id, session_id, event_properties, user_properties, insert_id)`
+
+Track a single event. Auto-generates `insert_id` and `time` if not provided.
+
+### `wl.track_batch(events)`
+
+Track multiple events in one request (up to 2000).
+
+### `wl.query(q, *, format="llm", limit=100, offset=0)`
+
+Run a pipe DSL query. Format: `"llm"` (Markdown), `"json"`, or `"csv"`.
+
+### `wl.identify(user_id, *, device_id, user_properties, user_property_ops)`
+
+Bind a device to a user and/or update profile properties.
+
+## Zero Dependencies
+
+This library uses only the Python standard library (`urllib.request`, `json`, `time`, `uuid`, `os`). No `requests`, no `httpx`, no `urllib3`. It works out of the box on any Python 3.9+ installation.
+
+## Learn More
+
+- [WireLog](https://wirelog.ai) — headless analytics for agents and LLMs
+- [Query language docs](https://docs.wirelog.ai/query-language)
+- [API reference](https://docs.wirelog.ai/reference/api)

wirelog-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "wirelog"
+version = "0.1.0"
+description = "WireLog analytics client — zero dependencies"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+authors = [{name = "WireLog", email = "hello@wirelog.ai"}]
+keywords = ["analytics", "wirelog", "events", "tracking", "ai-agents"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://wirelog.ai"
+Repository = "https://github.com/wirelogai/wirelog-python"
+Documentation = "https://docs.wirelog.ai"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/wirelog"]

wirelog-0.1.0/src/wirelog/__init__.py

@@ -0,0 +1,6 @@
+"""WireLog analytics client — zero dependencies."""
+
+from wirelog.client import WireLog
+
+__all__ = ["WireLog"]
+__version__ = "0.1.0"

wirelog-0.1.0/src/wirelog/client.py

@@ -0,0 +1,138 @@
+"""WireLog analytics client. Zero external dependencies — stdlib only."""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+import uuid
+from typing import Any
+from urllib.error import HTTPError
+from urllib.request import Request, urlopen
+
+
+class WireLogError(Exception):
+    """Raised when the WireLog API returns an error."""
+
+    def __init__(self, status: int, message: str) -> None:
+        super().__init__(f"WireLog API {status}: {message}")
+        self.status = status
+
+
+class WireLog:
+    """WireLog analytics client.
+
+    Zero external dependencies. Uses only the Python standard library.
+
+    Args:
+        api_key: API key (pk_, sk_, or aat_). Falls back to WIRELOG_API_KEY env var.
+        host: API base URL. Falls back to WIRELOG_HOST env var or https://api.wirelog.ai.
+        timeout: HTTP timeout in seconds. Default 30.
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        host: str | None = None,
+        timeout: int = 30,
+    ) -> None:
+        self.api_key = api_key or os.environ.get("WIRELOG_API_KEY", "")
+        self.host = (
+            host or os.environ.get("WIRELOG_HOST", "https://api.wirelog.ai")
+        ).rstrip("/")
+        self.timeout = timeout
+
+    def track(
+        self,
+        event_type: str,
+        *,
+        user_id: str | None = None,
+        device_id: str | None = None,
+        session_id: str | None = None,
+        event_properties: dict[str, Any] | None = None,
+        user_properties: dict[str, Any] | None = None,
+        insert_id: str | None = None,
+    ) -> dict[str, Any]:
+        """Track a single event. Returns {"accepted": N}."""
+        body: dict[str, Any] = {"event_type": event_type}
+        if user_id is not None:
+            body["user_id"] = user_id
+        if device_id is not None:
+            body["device_id"] = device_id
+        if session_id is not None:
+            body["session_id"] = session_id
+        if event_properties is not None:
+            body["event_properties"] = event_properties
+        if user_properties is not None:
+            body["user_properties"] = user_properties
+        if insert_id is not None:
+            body["insert_id"] = insert_id
+        else:
+            body["insert_id"] = uuid.uuid4().hex
+        body["time"] = _iso_now()
+        return self._post("/track", body)
+
+    def track_batch(self, events: list[dict[str, Any]]) -> dict[str, Any]:
+        """Track multiple events. Returns {"accepted": N}."""
+        return self._post("/track", {"events": events})
+
+    def query(
+        self,
+        q: str,
+        *,
+        format: str = "llm",
+        limit: int = 100,
+        offset: int = 0,
+    ) -> Any:
+        """Run a pipe DSL query. Returns Markdown (default), JSON, or CSV."""
+        return self._post(
+            "/query",
+            {"q": q, "format": format, "limit": limit, "offset": offset},
+        )
+
+    def identify(
+        self,
+        user_id: str,
+        *,
+        device_id: str | None = None,
+        user_properties: dict[str, Any] | None = None,
+        user_property_ops: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Bind device to user and/or set profile properties."""
+        body: dict[str, Any] = {"user_id": user_id}
+        if device_id is not None:
+            body["device_id"] = device_id
+        if user_properties is not None:
+            body["user_properties"] = user_properties
+        if user_property_ops is not None:
+            body["user_property_ops"] = user_property_ops
+        return self._post("/identify", body)
+
+    def _post(self, path: str, body: dict[str, Any]) -> Any:
+        """Send a POST request to the WireLog API."""
+        url = f"{self.host}{path}"
+        data = json.dumps(body).encode("utf-8")
+        req = Request(
+            url,
+            data=data,
+            headers={
+                "Content-Type": "application/json",
+                "X-API-Key": self.api_key,
+            },
+            method="POST",
+        )
+        try:
+            with urlopen(req, timeout=self.timeout) as resp:
+                raw = resp.read()
+                content_type = resp.headers.get("Content-Type", "")
+                if "application/json" in content_type:
+                    return json.loads(raw)
+                return raw.decode("utf-8")
+        except HTTPError as e:
+            msg = e.read().decode("utf-8", errors="replace")
+            raise WireLogError(e.code, msg) from e
+
+
+def _iso_now() -> str:
+    """Current UTC time in ISO 8601 format."""
+    return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())

wirelog-0.1.0/tests/test_client.py

@@ -0,0 +1,143 @@
+"""Unit tests for the WireLog client. Uses only stdlib (no pytest)."""
+
+from __future__ import annotations
+
+import json
+import unittest
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from threading import Thread
+from typing import Any
+
+from wirelog import WireLog
+
+
+class MockHandler(BaseHTTPRequestHandler):
+    """Simple mock WireLog API server."""
+
+    last_request: dict[str, Any] = {}
+    response_body: dict[str, Any] = {"accepted": 1}
+    response_status: int = 200
+
+    def do_POST(self) -> None:
+        length = int(self.headers.get("Content-Length", 0))
+        body = self.rfile.read(length)
+        MockHandler.last_request = {
+            "path": self.path,
+            "headers": dict(self.headers),
+            "body": json.loads(body) if body else {},
+        }
+        self.send_response(MockHandler.response_status)
+        self.send_header("Content-Type", "application/json")
+        self.end_headers()
+        self.wfile.write(json.dumps(MockHandler.response_body).encode())
+
+    def log_message(self, format: str, *args: Any) -> None:
+        pass  # Suppress request logging
+
+
+class TestWireLogClient(unittest.TestCase):
+    server: HTTPServer
+    thread: Thread
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.server = HTTPServer(("127.0.0.1", 0), MockHandler)
+        cls.thread = Thread(target=cls.server.serve_forever, daemon=True)
+        cls.thread.start()
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        cls.server.shutdown()
+
+    def _client(self) -> WireLog:
+        port = self.server.server_address[1]
+        return WireLog(api_key="sk_test_key", host=f"http://127.0.0.1:{port}")
+
+    def test_track_sends_event(self) -> None:
+        MockHandler.response_body = {"accepted": 1}
+        MockHandler.response_status = 200
+        client = self._client()
+
+        result = client.track("signup", user_id="u_123", event_properties={"plan": "free"})
+
+        self.assertEqual(result, {"accepted": 1})
+        self.assertEqual(MockHandler.last_request["path"], "/track")
+        self.assertEqual(MockHandler.last_request["body"]["event_type"], "signup")
+        self.assertEqual(MockHandler.last_request["body"]["user_id"], "u_123")
+        self.assertEqual(
+            MockHandler.last_request["body"]["event_properties"], {"plan": "free"}
+        )
+        self.assertIn("insert_id", MockHandler.last_request["body"])
+        self.assertIn("time", MockHandler.last_request["body"])
+
+    def test_track_batch(self) -> None:
+        MockHandler.response_body = {"accepted": 2}
+        MockHandler.response_status = 200
+        client = self._client()
+
+        events = [
+            {"event_type": "page_view", "user_id": "u_1"},
+            {"event_type": "click", "user_id": "u_2"},
+        ]
+        result = client.track_batch(events)
+
+        self.assertEqual(result, {"accepted": 2})
+        self.assertEqual(MockHandler.last_request["body"]["events"], events)
+
+    def test_query(self) -> None:
+        MockHandler.response_body = {"rows": [{"count": 42}]}
+        MockHandler.response_status = 200
+        client = self._client()
+
+        result = client.query("* | last 7d | count")
+
+        self.assertEqual(result, {"rows": [{"count": 42}]})
+        self.assertEqual(MockHandler.last_request["path"], "/query")
+        self.assertEqual(
+            MockHandler.last_request["body"]["q"], "* | last 7d | count"
+        )
+        self.assertEqual(MockHandler.last_request["body"]["format"], "llm")
+
+    def test_identify(self) -> None:
+        MockHandler.response_body = {"ok": True}
+        MockHandler.response_status = 200
+        client = self._client()
+
+        result = client.identify(
+            "alice@acme.org",
+            device_id="dev_123",
+            user_properties={"email": "alice@acme.org", "plan": "pro"},
+        )
+
+        self.assertEqual(result, {"ok": True})
+        self.assertEqual(MockHandler.last_request["path"], "/identify")
+        self.assertEqual(
+            MockHandler.last_request["body"]["user_id"], "alice@acme.org"
+        )
+        self.assertEqual(
+            MockHandler.last_request["body"]["device_id"], "dev_123"
+        )
+
+    def test_api_key_header(self) -> None:
+        MockHandler.response_body = {"accepted": 1}
+        MockHandler.response_status = 200
+        client = self._client()
+
+        client.track("test")
+
+        self.assertEqual(
+            MockHandler.last_request["headers"]["X-Api-Key"], "sk_test_key"
+        )
+
+    def test_constructor_defaults(self) -> None:
+        client = WireLog()
+        self.assertEqual(client.host, "https://api.wirelog.ai")
+        self.assertEqual(client.api_key, "")
+
+    def test_host_trailing_slash_stripped(self) -> None:
+        client = WireLog(api_key="sk_test", host="https://api.wirelog.ai/")
+        self.assertEqual(client.host, "https://api.wirelog.ai")
+
+
+if __name__ == "__main__":
+    unittest.main()