measyai 2.0.0__tar.gz

measyai-2.0.0/.gitignore

@@ -0,0 +1,13 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.venv/
+venv/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/

measyai-2.0.0/LICENSE

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

measyai-2.0.0/PKG-INFO

@@ -0,0 +1,251 @@
+Metadata-Version: 2.4
+Name: measyai
+Version: 2.0.0
+Summary: Typed Python client for the MeasyAI API — OpenAI-compatible chat completions, streaming, batches and webhook verification.
+Project-URL: Homepage, https://measyai.com
+Project-URL: Documentation, https://docs.measyai.com
+Project-URL: Source, https://github.com/measyai/Python-SDK
+Project-URL: Issues, https://github.com/measyai/Python-SDK/issues
+Project-URL: Changelog, https://github.com/measyai/Python-SDK/releases
+Author-email: MeasyAI <support@measyai.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,api-client,chat,llm,measyai,openai,streaming
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+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: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: httpx<1,>=0.27
+Provides-Extra: dev
+Requires-Dist: mypy>=1.11; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# MeasyAI Python SDK
+
+Python client for the [MeasyAI API](https://docs.measyai.com).
+
+```bash
+pip install measyai
+```
+
+Requires Python 3.9+. One dependency: [httpx](https://www.python-httpx.org/).
+
+## Chat
+
+```python
+from measyai import MeasyAI
+
+client = MeasyAI()  # reads MEASYAI_API_KEY
+
+completion = client.chat.create(
+    model="measyai/meridian",
+    messages=[{"role": "user", "content": "Explain HTTP/3 briefly."}],
+)
+print(completion.text)
+```
+
+`completion.text` is the first choice's content. The full shape is there
+when you need it — `completion.choices[0].finish_reason`,
+`completion.usage.total_tokens`.
+
+## Streaming
+
+`stream()` opens the connection before it returns, so a rejected request
+raises there rather than on the first frame. Iterating yields chunks;
+`text()` yields just the deltas.
+
+```python
+with client.chat.stream(
+    messages=[{"role": "user", "content": "Why is Postgres MVCC useful?"}],
+) as stream:
+    for delta in stream.text():
+        print(delta, end="", flush=True)
+```
+
+Use it as a context manager. Iterating to the end releases the connection
+on its own, but breaking out early only does so once the iterator is
+collected — `with` makes that immediate.
+
+For finish reasons or the closing usage block, iterate the chunks:
+
+```python
+with client.chat.stream(messages=messages) as stream:
+    for chunk in stream:
+        if chunk.usage:
+            print(f"\n{chunk.usage.total_tokens} tokens")
+```
+
+## Async
+
+`AsyncMeasyAI` has the same surface with `await` on the calls and
+`async for` on the streams.
+
+```python
+import asyncio
+from measyai import AsyncMeasyAI
+
+async def main() -> None:
+    async with AsyncMeasyAI() as client:
+        stream = await client.chat.stream(
+            messages=[{"role": "user", "content": "Explain QUIC."}],
+        )
+        async with stream:
+            async for delta in stream.text():
+                print(delta, end="", flush=True)
+
+asyncio.run(main())
+```
+
+## Unmodelled parameters
+
+Anything this package does not model is passed as a keyword argument and
+forwarded to the provider unchanged:
+
+```python
+client.chat.create(
+    messages=messages,
+    temperature=0.2,
+    tools=my_tools,
+    response_format={"type": "json_object"},
+)
+```
+
+`model`, `messages` and `stream` are owned by the method signature and are
+refused rather than silently dropped — otherwise `stream=True` would hand
+`create()` an SSE body it then tries to decode as JSON.
+
+Response fields this package does not model are kept too: every object
+carries the payload it was built from in `.raw`.
+
+## Batches
+
+```python
+from measyai import BatchRequest
+
+batch = client.batches.create([
+    BatchRequest(custom_id="row-1", body={"messages": messages}),
+])
+
+done = client.batches.wait(batch.id, interval=5)
+print(f"{done.completed} completed, {done.failed} failed")
+
+for item in done.items:
+    if item.response:
+        print(item.custom_id, item.response.text)
+```
+
+`wait()` polls until the batch is terminal. It waits indefinitely by
+default — a large batch legitimately runs for hours — so pass `timeout=`
+if you want it to give up.
+
+## Webhooks
+
+Verify against the **raw** body. Re-encoding a payload you already decoded
+will not reproduce the same bytes, and the check will fail on a delivery
+that was perfectly valid.
+
+```python
+import measyai
+
+@app.post("/webhooks/measyai")
+async def receive(request: Request):
+    raw = await request.body()
+
+    if not measyai.verify_webhook(
+        secret,
+        request.headers[measyai.HEADER_SIGNATURE],
+        request.headers[measyai.HEADER_TIMESTAMP],
+        raw,
+    ):
+        raise HTTPException(400)
+    ...
+```
+
+The timestamp is signed inside the message and checked against a
+tolerance, so a captured delivery cannot be replayed. The comparison is
+constant-time.
+
+## Errors
+
+Everything raised inherits from `MeasyAIError`. Below it the tree forks on
+why the call failed: `APIError` when the API rejected the request,
+`APIConnectionError` when there was never a response.
+
+```python
+from measyai import APIError, MeasyAIError
+
+try:
+    completion = client.chat.create(messages=messages)
+except APIError as err:
+    if err.retryable:  # 429 or 5xx — worth backing off
+        ...
+    print(err.code, err.request_id)
+except MeasyAIError:
+    ...  # connection, timeout, malformed body
+```
+
+`APIError` also subclasses by status — `AuthenticationError`,
+`RateLimitError`, `NotFoundError` and the rest — so you can catch just the
+case you handle. Branch on `err.code`, which is stable; `err.message` is
+written for humans and may be reworded.
+
+Nothing is retried for you. `retryable` tells you when a retry could
+succeed; the backoff policy is yours.
+
+## Configuration
+
+```python
+client = MeasyAI(
+    api_key="msy_...",              # or MEASYAI_API_KEY
+    base_url="http://localhost:8080",  # or MEASYAI_BASE_URL
+    user_agent="acme-crm/3.1",      # appended, for server logs
+    timeout=httpx.Timeout(connect=10.0, read=60.0),
+)
+```
+
+The default timeouts bound *stalls*, not total duration — a streamed
+generation legitimately runs for minutes, and an overall deadline would
+cut it off mid-answer.
+
+Pass `http_client=` to supply your own `httpx.Client` for a proxy, a
+custom transport or a test double. You keep ownership of it: closing the
+MeasyAI client leaves yours open.
+
+Reuse one client for the life of the process. It is safe to share between
+threads, and a client per call throws away the connection pool.
+
+## Using an OpenAI client instead
+
+The `/v1` surface is OpenAI-compatible, so the official OpenAI SDK works
+by changing its base URL:
+
+```python
+from openai import OpenAI
+
+client = OpenAI(api_key="msy_...", base_url="https://api.measyai.com/v1")
+```
+
+Use this package when you also want batches and webhook verification
+typed.
+
+## Links
+
+- [Documentation](https://docs.measyai.com)
+- [Status](https://status.measyai.com)
+- [Go SDK](https://github.com/measyai/Go-SDK)
+- [TypeScript SDK](https://github.com/measyai/NPM-SDK)
+
+MIT licensed.

measyai-2.0.0/README.md

@@ -0,0 +1,216 @@
+# MeasyAI Python SDK
+
+Python client for the [MeasyAI API](https://docs.measyai.com).
+
+```bash
+pip install measyai
+```
+
+Requires Python 3.9+. One dependency: [httpx](https://www.python-httpx.org/).
+
+## Chat
+
+```python
+from measyai import MeasyAI
+
+client = MeasyAI()  # reads MEASYAI_API_KEY
+
+completion = client.chat.create(
+    model="measyai/meridian",
+    messages=[{"role": "user", "content": "Explain HTTP/3 briefly."}],
+)
+print(completion.text)
+```
+
+`completion.text` is the first choice's content. The full shape is there
+when you need it — `completion.choices[0].finish_reason`,
+`completion.usage.total_tokens`.
+
+## Streaming
+
+`stream()` opens the connection before it returns, so a rejected request
+raises there rather than on the first frame. Iterating yields chunks;
+`text()` yields just the deltas.
+
+```python
+with client.chat.stream(
+    messages=[{"role": "user", "content": "Why is Postgres MVCC useful?"}],
+) as stream:
+    for delta in stream.text():
+        print(delta, end="", flush=True)
+```
+
+Use it as a context manager. Iterating to the end releases the connection
+on its own, but breaking out early only does so once the iterator is
+collected — `with` makes that immediate.
+
+For finish reasons or the closing usage block, iterate the chunks:
+
+```python
+with client.chat.stream(messages=messages) as stream:
+    for chunk in stream:
+        if chunk.usage:
+            print(f"\n{chunk.usage.total_tokens} tokens")
+```
+
+## Async
+
+`AsyncMeasyAI` has the same surface with `await` on the calls and
+`async for` on the streams.
+
+```python
+import asyncio
+from measyai import AsyncMeasyAI
+
+async def main() -> None:
+    async with AsyncMeasyAI() as client:
+        stream = await client.chat.stream(
+            messages=[{"role": "user", "content": "Explain QUIC."}],
+        )
+        async with stream:
+            async for delta in stream.text():
+                print(delta, end="", flush=True)
+
+asyncio.run(main())
+```
+
+## Unmodelled parameters
+
+Anything this package does not model is passed as a keyword argument and
+forwarded to the provider unchanged:
+
+```python
+client.chat.create(
+    messages=messages,
+    temperature=0.2,
+    tools=my_tools,
+    response_format={"type": "json_object"},
+)
+```
+
+`model`, `messages` and `stream` are owned by the method signature and are
+refused rather than silently dropped — otherwise `stream=True` would hand
+`create()` an SSE body it then tries to decode as JSON.
+
+Response fields this package does not model are kept too: every object
+carries the payload it was built from in `.raw`.
+
+## Batches
+
+```python
+from measyai import BatchRequest
+
+batch = client.batches.create([
+    BatchRequest(custom_id="row-1", body={"messages": messages}),
+])
+
+done = client.batches.wait(batch.id, interval=5)
+print(f"{done.completed} completed, {done.failed} failed")
+
+for item in done.items:
+    if item.response:
+        print(item.custom_id, item.response.text)
+```
+
+`wait()` polls until the batch is terminal. It waits indefinitely by
+default — a large batch legitimately runs for hours — so pass `timeout=`
+if you want it to give up.
+
+## Webhooks
+
+Verify against the **raw** body. Re-encoding a payload you already decoded
+will not reproduce the same bytes, and the check will fail on a delivery
+that was perfectly valid.
+
+```python
+import measyai
+
+@app.post("/webhooks/measyai")
+async def receive(request: Request):
+    raw = await request.body()
+
+    if not measyai.verify_webhook(
+        secret,
+        request.headers[measyai.HEADER_SIGNATURE],
+        request.headers[measyai.HEADER_TIMESTAMP],
+        raw,
+    ):
+        raise HTTPException(400)
+    ...
+```
+
+The timestamp is signed inside the message and checked against a
+tolerance, so a captured delivery cannot be replayed. The comparison is
+constant-time.
+
+## Errors
+
+Everything raised inherits from `MeasyAIError`. Below it the tree forks on
+why the call failed: `APIError` when the API rejected the request,
+`APIConnectionError` when there was never a response.
+
+```python
+from measyai import APIError, MeasyAIError
+
+try:
+    completion = client.chat.create(messages=messages)
+except APIError as err:
+    if err.retryable:  # 429 or 5xx — worth backing off
+        ...
+    print(err.code, err.request_id)
+except MeasyAIError:
+    ...  # connection, timeout, malformed body
+```
+
+`APIError` also subclasses by status — `AuthenticationError`,
+`RateLimitError`, `NotFoundError` and the rest — so you can catch just the
+case you handle. Branch on `err.code`, which is stable; `err.message` is
+written for humans and may be reworded.
+
+Nothing is retried for you. `retryable` tells you when a retry could
+succeed; the backoff policy is yours.
+
+## Configuration
+
+```python
+client = MeasyAI(
+    api_key="msy_...",              # or MEASYAI_API_KEY
+    base_url="http://localhost:8080",  # or MEASYAI_BASE_URL
+    user_agent="acme-crm/3.1",      # appended, for server logs
+    timeout=httpx.Timeout(connect=10.0, read=60.0),
+)
+```
+
+The default timeouts bound *stalls*, not total duration — a streamed
+generation legitimately runs for minutes, and an overall deadline would
+cut it off mid-answer.
+
+Pass `http_client=` to supply your own `httpx.Client` for a proxy, a
+custom transport or a test double. You keep ownership of it: closing the
+MeasyAI client leaves yours open.
+
+Reuse one client for the life of the process. It is safe to share between
+threads, and a client per call throws away the connection pool.
+
+## Using an OpenAI client instead
+
+The `/v1` surface is OpenAI-compatible, so the official OpenAI SDK works
+by changing its base URL:
+
+```python
+from openai import OpenAI
+
+client = OpenAI(api_key="msy_...", base_url="https://api.measyai.com/v1")
+```
+
+Use this package when you also want batches and webhook verification
+typed.
+
+## Links
+
+- [Documentation](https://docs.measyai.com)
+- [Status](https://status.measyai.com)
+- [Go SDK](https://github.com/measyai/Go-SDK)
+- [TypeScript SDK](https://github.com/measyai/NPM-SDK)
+
+MIT licensed.

measyai-2.0.0/pyproject.toml

@@ -0,0 +1,104 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "measyai"
+description = "Typed Python client for the MeasyAI API — OpenAI-compatible chat completions, streaming, batches and webhook verification."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.9"
+dynamic = ["version"]
+authors = [{ name = "MeasyAI", email = "support@measyai.com" }]
+keywords = ["measyai", "ai", "llm", "chat", "streaming", "openai", "api-client"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "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",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Programming Language :: Python :: Implementation :: PyPy",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+]
+dependencies = ["httpx>=0.27,<1"]
+
+[project.urls]
+Homepage = "https://measyai.com"
+Documentation = "https://docs.measyai.com"
+Source = "https://github.com/measyai/Python-SDK"
+Issues = "https://github.com/measyai/Python-SDK/issues"
+Changelog = "https://github.com/measyai/Python-SDK/releases"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.24",
+    "mypy>=1.11",
+    "ruff>=0.6",
+]
+
+[tool.hatch.version]
+path = "src/measyai/_version.py"
+
+[tool.hatch.build.targets.sdist]
+# The wheel is the package; the sdist adds what you need to rebuild and
+# verify it, and nothing else.
+include = ["src/measyai", "tests", "README.md", "LICENSE", "pyproject.toml"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/measyai"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+filterwarnings = ["error"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py39"
+src = ["src", "tests"]
+
+[tool.ruff.format]
+# Ruff would reformat the Python inside the README's fences, which is
+# written for reading rather than for a formatter.
+exclude = ["*.md"]
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP", "B", "C4", "SIM", "RUF"]
+ignore = [
+    # The package supports 3.9, so `typing.Optional`/`Dict`/`Type` and
+    # `typing.Union` stay. PEP 604 and PEP 585 spellings are only safe in
+    # annotation positions here (`from __future__ import annotations`),
+    # and using one spelling in annotations and another in the runtime
+    # positions next to them reads as an inconsistency rather than as the
+    # version boundary it actually is.
+    "UP006",
+    "UP007",
+    "UP035",
+    "UP045",
+    # `datetime.timezone.utc` over `datetime.UTC`: the latter is 3.11+.
+    "UP017",
+]
+
+[tool.ruff.lint.isort]
+# `tests` is a package here so `tests.conftest` imports the same way
+# under pytest as it does under the linter.
+known-first-party = ["measyai", "tests"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["B011"]
+
+[tool.mypy]
+# No `python_version` pin: current mypy refuses 3.9, and the pytest matrix
+# is what actually proves the package still runs there.
+strict = true
+warn_unreachable = true
+files = ["src/measyai"]

measyai-2.0.0/src/measyai/__init__.py

@@ -0,0 +1,102 @@
+"""Python client for the MeasyAI API.
+
+The `/v1` surface is OpenAI-compatible, so the official OpenAI SDK works
+by pointing its `base_url` at `https://api.measyai.com/v1`. Use this
+package when you also want the endpoints OpenAI has no equivalent for —
+batches and webhook verification — typed.
+
+```python
+from measyai import MeasyAI
+
+client = MeasyAI()  # reads MEASYAI_API_KEY
+
+with client.chat.stream(
+    model="measyai/meridian",
+    messages=[{"role": "user", "content": "Explain HTTP/3 briefly."}],
+) as stream:
+    for delta in stream.text():
+        print(delta, end="", flush=True)
+```
+"""
+
+from __future__ import annotations
+
+from ._client import DEFAULT_BASE_URL, DEFAULT_TIMEOUT, AsyncMeasyAI, MeasyAI
+from ._version import __version__
+from .errors import (
+    APIConnectionError,
+    APIError,
+    APITimeoutError,
+    AuthenticationError,
+    BadRequestError,
+    ConflictError,
+    InternalServerError,
+    MeasyAIError,
+    NotFoundError,
+    PermissionDeniedError,
+    RateLimitError,
+)
+from .resources import AsyncChatStream, ChatStream
+from .types import (
+    Batch,
+    BatchItem,
+    BatchRequest,
+    BatchWithItems,
+    ChatCompletion,
+    ChatCompletionChunk,
+    Choice,
+    ChunkChoice,
+    ChunkDelta,
+    Message,
+    Model,
+    Usage,
+)
+from .webhooks import (
+    DEFAULT_TOLERANCE,
+    HEADER_DELIVERY,
+    HEADER_EVENT,
+    HEADER_SIGNATURE,
+    HEADER_TIMESTAMP,
+    sign_webhook,
+    verify_webhook,
+)
+
+__all__ = [
+    "DEFAULT_BASE_URL",
+    "DEFAULT_TIMEOUT",
+    "DEFAULT_TOLERANCE",
+    "HEADER_DELIVERY",
+    "HEADER_EVENT",
+    "HEADER_SIGNATURE",
+    "HEADER_TIMESTAMP",
+    "APIConnectionError",
+    "APIError",
+    "APITimeoutError",
+    "AsyncChatStream",
+    "AsyncMeasyAI",
+    "AuthenticationError",
+    "BadRequestError",
+    "Batch",
+    "BatchItem",
+    "BatchRequest",
+    "BatchWithItems",
+    "ChatCompletion",
+    "ChatCompletionChunk",
+    "ChatStream",
+    "Choice",
+    "ChunkChoice",
+    "ChunkDelta",
+    "ConflictError",
+    "InternalServerError",
+    "MeasyAI",
+    "MeasyAIError",
+    "Message",
+    "Model",
+    "NotFoundError",
+    "PermissionDeniedError",
+    "RateLimitError",
+    "Usage",
+    "__version__",
+    "sign_webhook",
+    "verify_webhook",
+]