guardloop 0.2.0__py3-none-any.whl

guardloop/telemetry/__init__.py

@@ -0,0 +1,5 @@
+"""Telemetry helpers for GuardLoop."""
+
+from guardloop.telemetry.tracer import Telemetry
+
+__all__ = ["Telemetry"]

guardloop/telemetry/conventions.py

@@ -0,0 +1,98 @@
+"""OpenTelemetry attribute names behind one compatibility layer.
+
+The GenAI semantic conventions are still evolving, so provider wrappers should
+use these constants instead of scattering raw strings through the codebase.
+"""
+
+from __future__ import annotations
+
+from decimal import Decimal
+
+AttributeValue = str | bool | int | float
+Attributes = dict[str, AttributeValue]
+
+GEN_AI_SYSTEM = "gen_ai.system"
+GEN_AI_OPERATION_NAME = "gen_ai.operation.name"
+GEN_AI_REQUEST_MODEL = "gen_ai.request.model"
+GEN_AI_RESPONSE_MODEL = "gen_ai.response.model"
+GEN_AI_USAGE_INPUT_TOKENS = "gen_ai.usage.input_tokens"
+GEN_AI_USAGE_OUTPUT_TOKENS = "gen_ai.usage.output_tokens"
+
+GUARDLOOP_COST_USD = "guardloop.budget.cost_usd"
+GUARDLOOP_ESTIMATED_COST_USD = "guardloop.budget.estimated_cost_usd"
+GUARDLOOP_TOOL_NAME = "guardloop.tool.name"
+GUARDLOOP_TOOL_CALLS_USED = "guardloop.tool.calls_used"
+GUARDLOOP_CIRCUIT_BREAKER_STATE = "guardloop.circuit_breaker.state"
+GUARDLOOP_CIRCUIT_BREAKER_FAILURE_COUNT = "guardloop.circuit_breaker.failure_count"
+GUARDLOOP_CIRCUIT_BREAKER_BLOCKED = "guardloop.circuit_breaker.blocked"
+GUARDLOOP_CIRCUIT_BREAKER_REMAINING_OPEN_SECONDS = (
+    "guardloop.circuit_breaker.remaining_open_seconds"
+)
+GUARDLOOP_TERMINATED_REASON = "guardloop.terminated_reason"
+
+
+def decimal_attr(value: Decimal) -> float:
+    return float(value)
+
+
+def run_attributes() -> Attributes:
+    return {"guardloop.operation": "agent.run"}
+
+
+def llm_request_attributes(
+    *,
+    provider: str,
+    model: str,
+    estimated_input_tokens: int,
+    reserved_output_tokens: int,
+    estimated_cost_usd: Decimal,
+) -> Attributes:
+    return {
+        GEN_AI_SYSTEM: provider,
+        GEN_AI_OPERATION_NAME: "chat",
+        GEN_AI_REQUEST_MODEL: model,
+        "guardloop.estimated_input_tokens": estimated_input_tokens,
+        "guardloop.reserved_output_tokens": reserved_output_tokens,
+        GUARDLOOP_ESTIMATED_COST_USD: decimal_attr(estimated_cost_usd),
+    }
+
+
+def llm_response_attributes(
+    *,
+    model: str,
+    input_tokens: int,
+    output_tokens: int,
+    cost_usd: Decimal,
+) -> Attributes:
+    return {
+        GEN_AI_RESPONSE_MODEL: model,
+        GEN_AI_USAGE_INPUT_TOKENS: input_tokens,
+        GEN_AI_USAGE_OUTPUT_TOKENS: output_tokens,
+        GUARDLOOP_COST_USD: decimal_attr(cost_usd),
+    }
+
+
+def tool_attributes(
+    *,
+    tool_name: str,
+    calls_used: int,
+    breaker_state: str | None = None,
+    breaker_failure_count: int | None = None,
+    breaker_blocked: bool | None = None,
+    breaker_remaining_open_seconds: float | None = None,
+) -> Attributes:
+    attributes: Attributes = {
+        GUARDLOOP_TOOL_NAME: tool_name,
+        GUARDLOOP_TOOL_CALLS_USED: calls_used,
+    }
+    if breaker_state is not None:
+        attributes[GUARDLOOP_CIRCUIT_BREAKER_STATE] = breaker_state
+    if breaker_failure_count is not None:
+        attributes[GUARDLOOP_CIRCUIT_BREAKER_FAILURE_COUNT] = breaker_failure_count
+    if breaker_blocked is not None:
+        attributes[GUARDLOOP_CIRCUIT_BREAKER_BLOCKED] = breaker_blocked
+    if breaker_remaining_open_seconds is not None:
+        attributes[GUARDLOOP_CIRCUIT_BREAKER_REMAINING_OPEN_SECONDS] = (
+            breaker_remaining_open_seconds
+        )
+    return attributes

guardloop/telemetry/tracer.py

@@ -0,0 +1,86 @@
+"""OpenTelemetry span creation and optional exporter setup."""
+
+from __future__ import annotations
+
+from collections.abc import Generator
+from contextlib import contextmanager
+
+from opentelemetry import trace
+from opentelemetry.trace import Span, Status, StatusCode, Tracer
+
+from guardloop.models import TelemetryConfig
+from guardloop.telemetry.conventions import Attributes
+
+_otel_configured = False
+
+
+def configure_otel_export(config: TelemetryConfig) -> None:
+    """Configure an SDK exporter only when the user asks for one."""
+
+    global _otel_configured
+    if _otel_configured or (not config.otlp_endpoint and not config.console_exporter):
+        return
+
+    try:
+        from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+        from opentelemetry.sdk.resources import Resource
+        from opentelemetry.sdk.trace import TracerProvider
+        from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
+    except ImportError as exc:
+        raise RuntimeError(
+            "OpenTelemetry export requires the 'otel' extra: pip install guardloop[otel]"
+        ) from exc
+
+    resource = Resource.create({"service.name": config.service_name})
+    provider = TracerProvider(resource=resource)
+
+    if config.otlp_endpoint:
+        provider.add_span_processor(
+            BatchSpanProcessor(OTLPSpanExporter(endpoint=config.otlp_endpoint))
+        )
+    if config.console_exporter:
+        provider.add_span_processor(BatchSpanProcessor(ConsoleSpanExporter()))
+
+    trace.set_tracer_provider(provider)
+    _otel_configured = True
+
+
+class Telemetry:
+    """Thin wrapper around OpenTelemetry spans."""
+
+    def __init__(self, config: TelemetryConfig, *, tracer: Tracer | None = None) -> None:
+        self.config = config
+        if config.enabled:
+            configure_otel_export(config)
+        self.tracer = tracer or trace.get_tracer("guardloop")
+
+    @contextmanager
+    def start_span(self, name: str, attributes: Attributes | None = None) -> Generator[Span]:
+        if not self.config.enabled:
+            yield trace.get_current_span()
+            return
+        with self.tracer.start_as_current_span(name, attributes=attributes) as span:
+            yield span
+
+    def set_attributes(self, span: Span, attributes: Attributes) -> None:
+        if not self.config.enabled:
+            return
+        for key, value in attributes.items():
+            span.set_attribute(key, value)
+
+    def record_exception(self, span: Span, exc: BaseException) -> None:
+        if not self.config.enabled:
+            return
+        span.record_exception(exc)
+        span.set_status(Status(StatusCode.ERROR, str(exc)))
+
+    def mark_ok(self, span: Span) -> None:
+        if self.config.enabled:
+            span.set_status(Status(StatusCode.OK))
+
+    @staticmethod
+    def trace_id(span: Span) -> str | None:
+        context = span.get_span_context()
+        if not context.is_valid:
+            return None
+        return f"{context.trace_id:032x}"

guardloop/tokenization.py

@@ -0,0 +1,49 @@
+"""Token estimation helpers used before provider calls."""
+
+from __future__ import annotations
+
+import json
+import math
+from collections.abc import Mapping, Sequence
+from typing import cast
+
+import tiktoken
+
+
+def payload_to_text(payload: object) -> str:
+    """Flatten common LLM input payloads into text for token estimation."""
+
+    if payload is None:
+        return ""
+    if isinstance(payload, str):
+        return payload
+    if isinstance(payload, Mapping):
+        values = cast(Mapping[object, object], payload).values()
+        return " ".join(payload_to_text(value) for value in values)
+    if isinstance(payload, Sequence) and not isinstance(payload, bytes | bytearray | str):
+        items = cast(Sequence[object], payload)
+        return " ".join(payload_to_text(item) for item in items)
+    try:
+        return json.dumps(payload, default=str, sort_keys=True)
+    except TypeError:
+        return str(payload)
+
+
+def estimate_openai_tokens(model: str, payload: object) -> int:
+    text = payload_to_text(payload)
+    if not text:
+        return 0
+    try:
+        encoding = tiktoken.encoding_for_model(model)
+    except KeyError:
+        encoding = tiktoken.get_encoding("o200k_base")
+    return len(encoding.encode(text))
+
+
+def estimate_anthropic_tokens(payload: object) -> int:
+    """Conservative local estimate when Anthropic token counting is not used."""
+
+    text = payload_to_text(payload)
+    if not text:
+        return 0
+    return max(1, math.ceil(len(text) / 4))

guardloop/tools.py

@@ -0,0 +1,171 @@
+"""Runtime-aware tool wrappers."""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+from collections.abc import Callable
+from typing import Any
+
+from opentelemetry.trace import Span
+
+from guardloop.budget import BudgetController
+from guardloop.circuit_breaker import CircuitBreakerDecision, CircuitBreakerRegistry
+from guardloop.exceptions import CircuitBreakerOpen, GuardLoopError
+from guardloop.telemetry.conventions import tool_attributes
+from guardloop.telemetry.tracer import Telemetry
+
+
+class ToolRunner:
+    """Wrap arbitrary sync or async Python callables with runtime checks."""
+
+    def __init__(
+        self,
+        budget: BudgetController,
+        telemetry: Telemetry,
+        circuit_breakers: CircuitBreakerRegistry,
+    ) -> None:
+        self._budget = budget
+        self._telemetry = telemetry
+        self._circuit_breakers = circuit_breakers
+
+    def wrap(self, name: str, func: Callable[..., Any]) -> Callable[..., Any]:
+        async def wrapped(*args: Any, **kwargs: Any) -> Any:
+            return await self.call(name, func, *args, **kwargs)
+
+        return wrapped
+
+    async def call(self, name: str, func: Callable[..., Any], *args: Any, **kwargs: Any) -> Any:
+        with self._telemetry.start_span(
+            f"tool_call {name}",
+            tool_attributes(tool_name=name, calls_used=self._budget.tool_calls),
+        ) as span:
+            try:
+                decision = self._circuit_breakers.before_call(name)
+                _apply_breaker_decision(
+                    span,
+                    self._telemetry,
+                    decision,
+                    calls_used=self._budget.tool_calls,
+                    blocked=False,
+                )
+            except CircuitBreakerOpen as exc:
+                _apply_breaker_open(
+                    span,
+                    self._telemetry,
+                    name,
+                    exc,
+                    calls_used=self._budget.tool_calls,
+                )
+                self._telemetry.record_exception(span, exc)
+                raise
+
+            self._budget.record_tool_call_started(name)
+            self._telemetry.set_attributes(
+                span,
+                tool_attributes(tool_name=name, calls_used=self._budget.tool_calls),
+            )
+
+            try:
+                result = func(*args, **kwargs)
+                if inspect.isawaitable(result):
+                    result = await result
+                decision = self._circuit_breakers.record_success(name)
+                _apply_breaker_decision(
+                    span,
+                    self._telemetry,
+                    decision,
+                    calls_used=self._budget.tool_calls,
+                    blocked=False,
+                )
+                self._telemetry.mark_ok(span)
+                return result
+            except GuardLoopError as exc:
+                self._telemetry.record_exception(span, exc)
+                raise
+            except (asyncio.CancelledError, TimeoutError) as exc:
+                self._telemetry.record_exception(span, exc)
+                raise
+            except Exception as exc:
+                decision = self._circuit_breakers.record_failure(name)
+                _apply_breaker_decision(
+                    span,
+                    self._telemetry,
+                    decision,
+                    calls_used=self._budget.tool_calls,
+                    blocked=False,
+                )
+                self._telemetry.record_exception(span, exc)
+                raise
+
+
+def _apply_breaker_decision(
+    span: Span,
+    telemetry: Telemetry,
+    decision: CircuitBreakerDecision | None,
+    *,
+    calls_used: int,
+    blocked: bool,
+) -> None:
+    if decision is None:
+        return
+
+    snapshot = decision.snapshot
+    telemetry.set_attributes(
+        span,
+        tool_attributes(
+            tool_name=snapshot.tool_name,
+            calls_used=calls_used,
+            breaker_state=snapshot.state.value,
+            breaker_failure_count=snapshot.failure_count,
+            breaker_blocked=blocked,
+            breaker_remaining_open_seconds=snapshot.remaining_open_seconds,
+        ),
+    )
+    if not telemetry.config.enabled:
+        return
+    for event_name in decision.events:
+        span.add_event(
+            event_name,
+            tool_attributes(
+                tool_name=snapshot.tool_name,
+                calls_used=calls_used,
+                breaker_state=snapshot.state.value,
+                breaker_failure_count=snapshot.failure_count,
+                breaker_blocked=blocked,
+                breaker_remaining_open_seconds=snapshot.remaining_open_seconds,
+            ),
+        )
+
+
+def _apply_breaker_open(
+    span: Span,
+    telemetry: Telemetry,
+    tool_name: str,
+    exc: CircuitBreakerOpen,
+    *,
+    calls_used: int,
+) -> None:
+    attributes = tool_attributes(
+        tool_name=tool_name,
+        calls_used=calls_used,
+        breaker_state=str(exc.details.get("state", "open")),
+        breaker_failure_count=_int_detail(exc.details.get("failure_count")),
+        breaker_blocked=True,
+        breaker_remaining_open_seconds=_float_detail(exc.details.get("remaining_open_seconds")),
+    )
+    telemetry.set_attributes(span, attributes)
+    if telemetry.config.enabled:
+        span.add_event("guardloop.circuit_breaker.blocked", attributes)
+
+
+def _int_detail(value: object) -> int | None:
+    if isinstance(value, int):
+        return value
+    return None
+
+
+def _float_detail(value: object) -> float | None:
+    if isinstance(value, int | float):
+        return float(value)
+    return None

guardloop-0.2.0.dist-info/METADATA

@@ -0,0 +1,188 @@
+Metadata-Version: 2.4
+Name: guardloop
+Version: 0.2.0
+Summary: A production runtime guardrail for AI agents: budget caps, timeouts, tool limits, and OpenTelemetry traces.
+Project-URL: Homepage, https://github.com/awesome-pro/guardloop
+Project-URL: Documentation, https://github.com/awesome-pro/guardloop#readme
+Project-URL: Repository, https://github.com/awesome-pro/guardloop
+Project-URL: Issues, https://github.com/awesome-pro/guardloop/issues
+Project-URL: Changelog, https://github.com/awesome-pro/guardloop/releases
+Author-email: awesome-pro <147910430+awesome-pro@users.noreply.github.com>
+Maintainer-email: awesome-pro <147910430+awesome-pro@users.noreply.github.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agentic-ai,ai-agents,ai-safety,anthropic,circuit-breaker,llm,mlops,openai,opentelemetry,runtime-guardrails
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: anthropic<1,>=0.97.0
+Requires-Dist: openai<3,>=2.33.0
+Requires-Dist: opentelemetry-api<2,>=1.41.1
+Requires-Dist: pydantic<3,>=2.13.3
+Requires-Dist: tiktoken<1,>=0.12.0
+Provides-Extra: otel
+Requires-Dist: opentelemetry-exporter-otlp<2,>=1.41.1; extra == 'otel'
+Requires-Dist: opentelemetry-sdk<2,>=1.41.1; extra == 'otel'
+Description-Content-Type: text/markdown
+
+# GuardLoop
+
+GuardLoop is a production runtime guardrail for AI agents. It wraps model
+clients and tools with hard budget caps, timeout control, tool-call limits, and
+per-tool circuit breakers, with OpenTelemetry traces for every protected call.
+Runaway agent loops can be stopped before they burn through money, and flaky
+tools can be cut off before an agent retries them into a bigger incident.
+
+The v0.2 focus is intentionally sharp: **runtime guardrails for async Python
+agents** using direct OpenAI and Anthropic wrappers plus protected tool calls.
+
+```python
+from guardloop import (
+    GuardLoop,
+    BudgetConfig,
+    CircuitBreakerConfig,
+    CircuitBreakerPolicy,
+    RunContext,
+)
+
+runtime = GuardLoop(
+    budget=BudgetConfig(
+        cost_limit_usd="0.10",
+        token_limit=10_000,
+        time_limit_seconds=60,
+        tool_call_limit=20,
+    ),
+    circuit_breakers=CircuitBreakerConfig(
+        default=CircuitBreakerPolicy(
+            failure_threshold=3,
+            recovery_timeout_seconds=30,
+        )
+    ),
+)
+
+
+async def agent(ctx: RunContext, prompt: str) -> str:
+    response = await ctx.openai.responses.create(
+        model="gpt-5.2",
+        input=prompt,
+        max_output_tokens=300,
+    )
+    return str(response.output_text)
+
+
+result = await runtime.run(agent, "research agent runtime safety")
+print(result.model_dump_json(indent=2))
+```
+
+## Why This Exists
+
+Agents are loops around probabilistic systems. When they go wrong, they can call
+the same model or tool repeatedly, spend unexpected money, and fail without a
+clear trace. GuardLoop puts an explicit execution layer around that loop:
+
+```mermaid
+flowchart LR
+    U["User code"] --> R["GuardLoop"]
+    R --> B["BudgetController"]
+    R --> CB["CircuitBreakerRegistry"]
+    R --> T["OpenTelemetry spans"]
+    R --> C["RunContext"]
+    C --> O["Wrapped OpenAI client"]
+    C --> A["Wrapped Anthropic client"]
+    C --> W["Wrapped tools"]
+```
+
+## Install
+
+After the first PyPI release is published:
+
+```bash
+pip install guardloop
+```
+
+For local development:
+
+```bash
+uv sync
+```
+
+Optional OpenTelemetry exporters are available through the `otel` extra:
+
+```bash
+pip install "guardloop[otel]"
+```
+
+For local development with the extra:
+
+```bash
+uv sync --extra otel
+```
+
+## Try the No-Key Demo
+
+```bash
+uv run python examples/runaway_cost_prevention.py
+```
+
+The demo uses a fake OpenAI-compatible client and intentionally loops forever.
+GuardLoop stops it when the next model request would exceed the cost cap.
+
+```bash
+uv run python examples/tool_circuit_breaker.py
+```
+
+This demo uses a failing fake tool. GuardLoop allows the first failures,
+opens the circuit breaker, then rejects the next call without invoking the tool.
+
+## Live Provider Smoke Tests
+
+```bash
+export OPENAI_API_KEY="..."
+export ANTHROPIC_API_KEY="..."
+
+uv run python examples/live_openai_basic.py
+uv run python examples/live_anthropic_basic.py
+```
+
+Both live examples can be customized with `OPENAI_MODEL` or `ANTHROPIC_MODEL`.
+
+## Quality Gates
+
+```bash
+uv run pytest
+uv run pytest --cov=guardloop
+uv run ruff check .
+uv run ruff format --check .
+uv run pyright
+```
+
+## v0.2 Scope
+
+- Async Python runtime with `src/` package layout.
+- Hard caps for cost, tokens, time, and tool calls.
+- Per-tool circuit breakers with closed, open, and half-open states.
+- Global default breaker policy plus per-tool overrides.
+- Direct wrappers for `AsyncOpenAI.responses.create`.
+- Direct wrappers for `AsyncAnthropic.messages.create`.
+- OpenTelemetry spans for agent runs, LLM calls, and tools.
+- Fake-client tests and demos that do not require API keys.
+
+## Roadmap
+
+- v0.2: per-tool circuit breakers.
+- v0.3: verifier/self-healing retry loop.
+- v0.4: LangGraph and OpenAI Agents SDK adapters.
+- v0.5: Jaeger/Phoenix trace screenshots, blog post, and GitHub release.

guardloop-0.2.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+guardloop/__init__.py,sha256=z_rm7p_BCSR-S7VUwydPKbsvKFO8UXy_Tfllyjn0LmA,1144
+guardloop/budget.py,sha256=FblwBnSc4chzEQLyVlO5Rwx1CEPS7eQDNuDvaPCvtDc,6313
+guardloop/circuit_breaker.py,sha256=JUPV-rAhl9R4VDuQm2DCGtPibeb1rmtM6RhGLV4ufwo,8511
+guardloop/context.py,sha256=oCFBbjoL04_Vb47tnZYdIks7r4reQpycL3HvxazBzNw,2274
+guardloop/exceptions.py,sha256=mzSUpfCsL-ZB8_jm8eq18E_mjnfEwpteBOog6_jl17k,2500
+guardloop/models.py,sha256=uOKSPRcvs5SqK09jqrbXQrBdQJWxgG12TOylYtz4xAg,3103
+guardloop/pricing.py,sha256=b6c-809SK1CZer-qfVXDKgsJTAQ09yBE2O_u0PlI7uQ,4452
+guardloop/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+guardloop/runtime.py,sha256=3VAfJ6Y6AxT_IswWkbavfujy1OXBpaaioA7L1Nw2ToA,6991
+guardloop/tokenization.py,sha256=XrZSPTctqLU_EzV2CrkhdufG-_Q_DHj-eYkDk494ZRQ,1492
+guardloop/tools.py,sha256=_V0utz3mRyaeFV8ebEy-Ml1iwvAugDd0LB02LsR-JCM,5608
+guardloop/providers/__init__.py,sha256=sVVUMpTgimGDYFse6z9p--DtuXSngWEyvp4v3KfCX9k,227
+guardloop/providers/anthropic.py,sha256=o2UxZ3QS48gkTj9x2YwxKWH73ie49WP20oUn5Z6ZilI,5142
+guardloop/providers/openai.py,sha256=5lucBznrljtENeRihbyi26CI3Yk-Uvn1fcWEq8dDkkU,4889
+guardloop/telemetry/__init__.py,sha256=toNqNsQqM5PDyBL6wRNEftpaR2erOax-PD9lXZnI6vU,114
+guardloop/telemetry/conventions.py,sha256=3RIQbgAMz-eefsgtzW9ad-7n4Q3jsGzz1t5NQOA6AqY,3232
+guardloop/telemetry/tracer.py,sha256=UHStG6IzlxxcFZuqG6oOaeGZRB0H3OhtJSXDENlVInI,3011
+guardloop-0.2.0.dist-info/METADATA,sha256=Z8zFkvXCkVO4RTgsY4-ITi1X3z0Nryb83shRmYi2zCA,5806
+guardloop-0.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+guardloop-0.2.0.dist-info/licenses/LICENSE,sha256=Ep4HSTCouInWuzqdZd-rio_XKIZSrtgGYw5mbgFCGsU,1068
+guardloop-0.2.0.dist-info/RECORD,,

guardloop-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

guardloop-0.2.0.dist-info/licenses/LICENSE

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