context-overlay 0.0.1__py3-none-any.whl

context_overlay/__init__.py

@@ -0,0 +1,13 @@
+"""OpenAI-compatible context overlay proxy."""
+
+from .config import ContextOverlayConfig, load_config
+from .skills import Skill, SkillStore
+from .transforms import apply_rules
+
+__all__ = [
+    "ContextOverlayConfig",
+    "Skill",
+    "SkillStore",
+    "apply_rules",
+    "load_config",
+]

context_overlay/cli.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import argparse
+
+import uvicorn
+
+from .config import load_config
+from .server import create_app
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="context-overlay")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    serve_parser = subparsers.add_parser("serve", help="Run the OpenAI-compatible context overlay proxy")
+    serve_parser.add_argument("--config", required=True, help="Path to YAML config")
+    serve_parser.add_argument("--host", default="127.0.0.1")
+    serve_parser.add_argument("--port", type=int, default=8011)
+    serve_parser.add_argument("--reload", action="store_true")
+
+    args = parser.parse_args()
+    if args.command == "serve":
+        config = load_config(args.config)
+        app = create_app(config)
+        uvicorn.run(app, host=args.host, port=args.port, reload=args.reload)

context_overlay/config.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any, Literal
+
+import yaml
+from pydantic import BaseModel, Field
+
+
+class UpstreamConfig(BaseModel):
+    base_url: str
+    api_key: str | None = None
+    timeout_seconds: float = 600.0
+
+
+class AuthConfig(BaseModel):
+    api_key: str | None = None
+
+
+class MatchConfig(BaseModel):
+    path: str | None = None
+    model_regex: str | None = None
+    messages_regex: list[str] = Field(default_factory=list)
+    extra_body: dict[str, Any] = Field(default_factory=dict)
+
+
+class ContentSourceConfig(BaseModel):
+    type: Literal["text", "file", "skill_dir"]
+    text: str | None = None
+    path: str | None = None
+    top_k: int = 3
+    max_chars: int = 24000
+    title: str = "Context Overlay"
+
+
+class TransformConfig(BaseModel):
+    type: Literal[
+        "prepend_system",
+        "append_system",
+        "insert_before",
+        "insert_after",
+        "regex_replace",
+        "prepend_user",
+        "append_user",
+        "route",
+        "reject",
+    ]
+    target: Literal["system", "user"] = "system"
+    pattern: str | None = None
+    replacement: str | None = None
+    content: str | ContentSourceConfig | None = None
+    upstream_base_url: str | None = None
+    model: str | None = None
+    reason: str | None = None
+
+
+class RuleConfig(BaseModel):
+    name: str
+    match: MatchConfig = Field(default_factory=MatchConfig)
+    transforms: list[TransformConfig] = Field(default_factory=list)
+
+
+class ContextOverlayConfig(BaseModel):
+    upstream: UpstreamConfig
+    auth: AuthConfig = Field(default_factory=AuthConfig)
+    rules: list[RuleConfig] = Field(default_factory=list)
+
+
+def _expand_env(value: Any) -> Any:
+    if isinstance(value, str):
+        return os.path.expandvars(value)
+    if isinstance(value, list):
+        return [_expand_env(item) for item in value]
+    if isinstance(value, dict):
+        return {key: _expand_env(item) for key, item in value.items()}
+    return value
+
+
+def load_config(path: str | Path) -> ContextOverlayConfig:
+    config_path = Path(path)
+    raw = yaml.safe_load(config_path.read_text(encoding="utf-8")) or {}
+    expanded = _expand_env(raw)
+    return ContextOverlayConfig.model_validate(expanded)

context_overlay/matching.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from .config import MatchConfig
+
+
+def message_text(messages: list[dict[str, Any]]) -> str:
+    parts: list[str] = []
+    for message in messages:
+        content = message.get("content")
+        if isinstance(content, str):
+            parts.append(content)
+        elif isinstance(content, list):
+            for item in content:
+                if isinstance(item, dict) and item.get("type") == "text":
+                    parts.append(str(item.get("text", "")))
+    return "\n".join(parts)
+
+
+def _contains_extra_body(body: dict[str, Any], expected: dict[str, Any]) -> bool:
+    for key, value in expected.items():
+        if body.get(key) != value:
+            return False
+    return True
+
+
+def request_matches(path: str, body: dict[str, Any], match: MatchConfig) -> bool:
+    if match.path and match.path != path:
+        return False
+    if match.model_regex:
+        model = str(body.get("model", ""))
+        if not re.search(match.model_regex, model):
+            return False
+    if match.extra_body and not _contains_extra_body(body, match.extra_body):
+        return False
+    if match.messages_regex:
+        text = message_text(body.get("messages") or [])
+        if not all(re.search(pattern, text, flags=re.IGNORECASE) for pattern in match.messages_regex):
+            return False
+    return True

context_overlay/server.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+from fastapi import FastAPI, Header, HTTPException, Request
+from fastapi.responses import JSONResponse, Response, StreamingResponse
+
+from .config import ContextOverlayConfig
+from .transforms import apply_rules
+
+
+def _check_auth(config: ContextOverlayConfig, authorization: str | None) -> None:
+    expected = config.auth.api_key
+    if not expected:
+        return
+    if authorization == f"Bearer {expected}":
+        return
+    raise HTTPException(status_code=401, detail="Invalid context-overlay API key")
+
+
+def _upstream_url(config: ContextOverlayConfig, path: str, body: dict[str, Any] | None = None) -> str:
+    base_url = config.upstream.base_url.rstrip("/")
+    if body and body.get("_context_overlay_upstream_base_url"):
+        base_url = str(body["_context_overlay_upstream_base_url"]).rstrip("/")
+    suffix = path.removeprefix("/v1")
+    return base_url + suffix
+
+
+def _forward_headers(config: ContextOverlayConfig, request: Request) -> dict[str, str]:
+    headers = {
+        key: value
+        for key, value in request.headers.items()
+        if key.lower() not in {"host", "content-length", "authorization"}
+    }
+    api_key = config.upstream.api_key
+    if api_key:
+        headers["authorization"] = f"Bearer {api_key}"
+    return headers
+
+
+def create_app(config: ContextOverlayConfig) -> FastAPI:
+    app = FastAPI(title="context-overlay")
+
+    @app.get("/health")
+    async def health() -> dict[str, str]:
+        return {"status": "ok"}
+
+    @app.api_route("/v1/{path:path}", methods=["GET", "POST", "PUT", "PATCH", "DELETE"])
+    async def proxy(path: str, request: Request, authorization: str | None = Header(default=None)) -> Response:
+        _check_auth(config, authorization)
+        full_path = f"/v1/{path}"
+        method = request.method
+        headers = _forward_headers(config, request)
+        timeout = httpx.Timeout(config.upstream.timeout_seconds)
+
+        if method == "POST" and full_path == "/v1/chat/completions":
+            body = await request.json()
+            try:
+                body = apply_rules(body, config, path=full_path)
+            except PermissionError as exc:
+                raise HTTPException(status_code=403, detail=str(exc)) from exc
+            except Exception as exc:  # noqa: BLE001 - return explicit transform errors.
+                raise HTTPException(status_code=400, detail=f"context-overlay transform error: {exc}") from exc
+            stream = bool(body.get("stream"))
+            upstream_url = _upstream_url(config, full_path, body)
+            body.pop("_context_overlay_upstream_base_url", None)
+            if stream:
+                return await _stream_request(method, upstream_url, headers, json_body=body, timeout=timeout)
+            async with httpx.AsyncClient(timeout=timeout) as client:
+                response = await client.request(method, upstream_url, headers=headers, json=body)
+            return Response(
+                content=response.content,
+                status_code=response.status_code,
+                media_type=response.headers.get("content-type"),
+            )
+
+        upstream_url = _upstream_url(config, full_path)
+        content = await request.body()
+        async with httpx.AsyncClient(timeout=timeout) as client:
+            response = await client.request(method, upstream_url, headers=headers, content=content, params=request.query_params)
+        return Response(
+            content=response.content,
+            status_code=response.status_code,
+            media_type=response.headers.get("content-type"),
+        )
+
+    return app
+
+
+async def _stream_request(
+    method: str,
+    url: str,
+    headers: dict[str, str],
+    json_body: dict[str, Any],
+    timeout: httpx.Timeout,
+) -> StreamingResponse:
+    client = httpx.AsyncClient(timeout=timeout)
+    request = client.build_request(method, url, headers=headers, json=json_body)
+    response = await client.send(request, stream=True)
+
+    async def iterator():
+        try:
+            async for chunk in response.aiter_bytes():
+                yield chunk
+        finally:
+            await response.aclose()
+            await client.aclose()
+
+    return StreamingResponse(
+        iterator(),
+        status_code=response.status_code,
+        media_type=response.headers.get("content-type", "text/event-stream"),
+    )

context_overlay/skills.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+TOKEN_RE = re.compile(r"[A-Za-z0-9_+\-.]+")
+
+
+def tokenize(text: str) -> set[str]:
+    return {token.lower() for token in TOKEN_RE.findall(text) if len(token) > 2}
+
+
+@dataclass(frozen=True)
+class Skill:
+    path: Path
+    name: str
+    description: str
+    content: str
+    category: str | None = None
+    score: int | None = None
+
+    @classmethod
+    def from_json_file(cls, path: Path) -> "Skill":
+        data = json.loads(path.read_text(encoding="utf-8"))
+        return cls(
+            path=path,
+            name=str(data.get("name") or path.stem),
+            description=str(data.get("description") or ""),
+            content=str(data.get("content") or ""),
+            category=data.get("category"),
+            score=data.get("score"),
+        )
+
+    def searchable_text(self) -> str:
+        return "\n".join(part for part in [self.name, self.description, self.category or "", self.content] if part)
+
+
+class SkillStore:
+    def __init__(self, skills: list[Skill]) -> None:
+        self.skills = skills
+        self._tokens = [tokenize(skill.searchable_text()) for skill in skills]
+
+    @classmethod
+    def from_dir(cls, path: str | Path) -> "SkillStore":
+        root = Path(path)
+        skills = [Skill.from_json_file(item) for item in sorted(root.glob("*.json"))]
+        return cls(skills)
+
+    def retrieve(self, query: str, top_k: int = 3) -> list[Skill]:
+        query_tokens = tokenize(query)
+        if not query_tokens:
+            return self.skills[:top_k]
+        scored: list[tuple[float, int, Skill]] = []
+        for idx, (skill, skill_tokens) in enumerate(zip(self.skills, self._tokens)):
+            if not skill_tokens:
+                continue
+            overlap = len(query_tokens & skill_tokens)
+            if overlap == 0:
+                continue
+            score = overlap / (len(query_tokens) ** 0.5 * len(skill_tokens) ** 0.5)
+            scored.append((score, -idx, skill))
+        scored.sort(reverse=True)
+        return [skill for _, _, skill in scored[:top_k]]
+
+
+def render_skills(skills: list[Skill], title: str = "Context Overlay", max_chars: int = 24000) -> str:
+    if not skills:
+        return ""
+    blocks = [f"# {title}", "Use the following planning context when relevant. Do not mention that it was injected."]
+    for idx, skill in enumerate(skills, 1):
+        blocks.append(f"\n## Skill {idx}: {skill.name}")
+        if skill.description:
+            blocks.append(f"Description: {skill.description}")
+        if skill.category:
+            blocks.append(f"Category: {skill.category}")
+        blocks.append(skill.content)
+    text = "\n".join(blocks).strip()
+    if len(text) <= max_chars:
+        return text
+    return text[: max_chars - 80].rstrip() + "\n\n[Context overlay truncated to fit the configured budget.]"

context_overlay/transforms.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import copy
+import re
+from pathlib import Path
+from typing import Any
+
+from .config import ContentSourceConfig, ContextOverlayConfig, TransformConfig
+from .matching import message_text, request_matches
+from .skills import SkillStore, render_skills
+
+
+def ensure_messages(body: dict[str, Any]) -> list[dict[str, Any]]:
+    messages = body.setdefault("messages", [])
+    if not isinstance(messages, list):
+        raise ValueError("Request body field 'messages' must be a list")
+    return messages
+
+
+def ensure_system_message(messages: list[dict[str, Any]]) -> dict[str, Any]:
+    for message in messages:
+        if message.get("role") == "system":
+            if not isinstance(message.get("content"), str):
+                message["content"] = str(message.get("content", ""))
+            return message
+    system = {"role": "system", "content": ""}
+    messages.insert(0, system)
+    return system
+
+
+def ensure_last_user_message(messages: list[dict[str, Any]]) -> dict[str, Any]:
+    for message in reversed(messages):
+        if message.get("role") == "user":
+            if not isinstance(message.get("content"), str):
+                message["content"] = _content_to_text(message.get("content"))
+            return message
+    user = {"role": "user", "content": ""}
+    messages.append(user)
+    return user
+
+
+def _content_to_text(content: Any) -> str:
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts = []
+        for item in content:
+            if isinstance(item, dict) and item.get("type") == "text":
+                parts.append(str(item.get("text", "")))
+        return "\n".join(parts)
+    return str(content or "")
+
+
+def resolve_content(content: str | ContentSourceConfig | None, body: dict[str, Any]) -> str:
+    if content is None:
+        return ""
+    if isinstance(content, str):
+        return content
+    if content.type == "text":
+        return content.text or ""
+    if content.type == "file":
+        if not content.path:
+            raise ValueError("file content source requires path")
+        return Path(content.path).read_text(encoding="utf-8")
+    if content.type == "skill_dir":
+        if not content.path:
+            raise ValueError("skill_dir content source requires path")
+        store = SkillStore.from_dir(content.path)
+        skills = store.retrieve(message_text(body.get("messages") or []), top_k=content.top_k)
+        return render_skills(skills, title=content.title, max_chars=content.max_chars)
+    raise ValueError(f"Unsupported content source: {content.type}")
+
+
+def _join(prefix: str, suffix: str) -> str:
+    if not prefix:
+        return suffix
+    if not suffix:
+        return prefix
+    return prefix.rstrip() + "\n\n" + suffix.lstrip()
+
+
+def apply_transform(body: dict[str, Any], transform: TransformConfig) -> dict[str, Any]:
+    messages = ensure_messages(body)
+    overlay = resolve_content(transform.content, body)
+    if transform.type == "reject":
+        raise PermissionError(transform.reason or "Request rejected by context-overlay rule")
+    if transform.type == "route":
+        if transform.model:
+            body["model"] = transform.model
+        if transform.upstream_base_url:
+            body["_context_overlay_upstream_base_url"] = transform.upstream_base_url
+        return body
+    if transform.type in {"prepend_system", "append_system", "insert_before", "insert_after", "regex_replace"}:
+        target = ensure_system_message(messages)
+    elif transform.type in {"prepend_user", "append_user"}:
+        target = ensure_last_user_message(messages)
+    else:
+        raise ValueError(f"Unsupported transform type: {transform.type}")
+
+    content = str(target.get("content") or "")
+    if transform.type in {"prepend_system", "prepend_user"}:
+        target["content"] = _join(overlay, content)
+    elif transform.type in {"append_system", "append_user"}:
+        target["content"] = _join(content, overlay)
+    elif transform.type == "insert_before":
+        if not transform.pattern:
+            target["content"] = _join(overlay, content)
+        else:
+            target["content"] = re.sub(transform.pattern, overlay + "\n\n" + r"\g<0>", content, count=1)
+    elif transform.type == "insert_after":
+        if not transform.pattern:
+            target["content"] = _join(content, overlay)
+        else:
+            target["content"] = re.sub(transform.pattern, r"\g<0>" + "\n\n" + overlay, content, count=1)
+    elif transform.type == "regex_replace":
+        if not transform.pattern:
+            raise ValueError("regex_replace requires pattern")
+        replacement = transform.replacement if transform.replacement is not None else overlay
+        target["content"] = re.sub(transform.pattern, replacement, content)
+    return body
+
+
+def apply_rules(body: dict[str, Any], config: ContextOverlayConfig, path: str = "/v1/chat/completions") -> dict[str, Any]:
+    transformed = copy.deepcopy(body)
+    for rule in config.rules:
+        if not request_matches(path, transformed, rule.match):
+            continue
+        for transform in rule.transforms:
+            transformed = apply_transform(transformed, transform)
+    return transformed

context_overlay-0.0.1.dist-info/METADATA

@@ -0,0 +1,160 @@
+Metadata-Version: 2.4
+Name: context-overlay
+Version: 0.0.1
+Summary: OpenAI-compatible context overlay proxy for injecting skills, memory, policies, and prompt patches.
+Author: InternScience
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/black-yt/context-overlay
+Project-URL: Repository, https://github.com/black-yt/context-overlay
+Project-URL: Issues, https://github.com/black-yt/context-overlay/issues
+Keywords: llm,openai,proxy,prompt,context,middleware
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.110
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2
+Requires-Dist: PyYAML>=6
+Requires-Dist: uvicorn[standard]>=0.27
+Provides-Extra: dev
+Requires-Dist: build>=1; extra == "dev"
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: respx>=0.21; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Dynamic: license-file
+
+# context-overlay
+
+`context-overlay` is an OpenAI-compatible request proxy that injects additional context into chat-completion requests without changing the upstream model server.
+
+It can be used for:
+
+- skill injection from local JSON skills
+- prompt overlays and prompt patches
+- policy or profile insertion
+- lightweight request routing
+- public demos through tools such as `ngrok` or `cloudflared`
+
+The package does not run an agent loop and does not execute tools. It only transforms OpenAI-compatible HTTP requests and forwards them to an upstream OpenAI-compatible endpoint.
+
+## Install
+
+```bash
+pip install context-overlay
+```
+
+For local development:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Quick Start
+
+Create `config.yaml`:
+
+```yaml
+upstream:
+  base_url: "http://127.0.0.1:8010/v1"
+  api_key: "unused"
+
+auth:
+  api_key: "proxy-key"
+
+rules:
+  - name: inject_science_skills
+    match:
+      path: "/v1/chat/completions"
+      messages_regex:
+        - "scientific"
+    transforms:
+      - type: append_system
+        content:
+          type: skill_dir
+          path: "./skills/generated_skills"
+          top_k: 3
+          max_chars: 24000
+```
+
+Run:
+
+```bash
+context-overlay serve --config config.yaml --host 127.0.0.1 --port 8011
+```
+
+Use it with the OpenAI SDK:
+
+```python
+from openai import OpenAI
+
+client = OpenAI(api_key="proxy-key", base_url="http://127.0.0.1:8011/v1")
+
+response = client.chat.completions.create(
+    model="Qwen3.5-9B",
+    messages=[{"role": "user", "content": "Analyze this scientific task."}],
+)
+
+print(response.choices[0].message.content)
+```
+
+## Public URL With ngrok
+
+```bash
+context-overlay serve --config config.yaml --host 127.0.0.1 --port 8011
+ngrok http 8011
+```
+
+Then set the SDK base URL to the public ngrok URL plus `/v1`.
+
+## Public URL With cloudflared
+
+Temporary URL:
+
+```bash
+context-overlay serve --config config.yaml --host 127.0.0.1 --port 8011
+cloudflared tunnel --url http://127.0.0.1:8011
+```
+
+Long-running production use should use a named Cloudflare Tunnel and your own access policy.
+
+## Rule Model
+
+Each rule has:
+
+- `match`: decides whether a request should be transformed.
+- `transforms`: one or more operations applied to the request body before forwarding.
+
+Supported match fields:
+
+- `path`
+- `model_regex`
+- `messages_regex`
+- `extra_body`
+
+Supported transform types:
+
+- `prepend_system`
+- `append_system`
+- `insert_before`
+- `insert_after`
+- `regex_replace`
+- `prepend_user`
+- `append_user`
+- `route`
+- `reject`
+
+Skill injection is implemented as a content source, not a special runtime mode.
+
+## Security Notes
+
+- Use `auth.api_key` before exposing the proxy publicly.
+- Keep upstream API keys on the server side.
+- Do not put secrets in skill files or prompt overlays.
+- Set upstream and client-side timeouts appropriate for your deployment.

context_overlay-0.0.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+context_overlay/__init__.py,sha256=_Cr5Y-Ruiv1dOJHuZC8y50IJiATRG2_rnDciGzHVGfU,288
+context_overlay/cli.py,sha256=SCKtVgRlMtz5GDnyx0cJVdo7RoseivaEX2KXnLuUSF0,881
+context_overlay/config.py,sha256=sTeKsI8sCBWBLGpt-wPxZYJsuVv0NiksTikbZ62-yGo,2235
+context_overlay/matching.py,sha256=tI8ZVzz-pBO_u9tUkjyvbp6eQ7DWzLwHQmaSrKma20Y,1384
+context_overlay/server.py,sha256=SJ9auIVd1Tf5ZLsWd6VDVv-qvFc-NPfo1TF2YL3tIek,4381
+context_overlay/skills.py,sha256=3im0p793_vV2bhbU-P1wDD8hNHtV4v5c6pph3_-lI88,2925
+context_overlay/transforms.py,sha256=I2FjNtqfTKZ-_OZ7yd-dCFmUmE7Ri_lMtP1Er3SimmM,5218
+context_overlay-0.0.1.dist-info/licenses/LICENSE,sha256=K1d9tbfSQ3rDkd7ALFcKEwhY38vrGhFXBaVCkR6AQd0,1070
+context_overlay-0.0.1.dist-info/METADATA,sha256=8c20Wt4PrNUqcEfR0sx54Fe0LZm4EQ58qN2WTyB7Hzo,4091
+context_overlay-0.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+context_overlay-0.0.1.dist-info/entry_points.txt,sha256=xRXzBHMeHRdgnk8nHqNrkyoa5an__7mdjlLh8KwFftk,61
+context_overlay-0.0.1.dist-info/top_level.txt,sha256=RGebGsK7jYk8TyqUJby0YFSb6OGslb-xhexx03ppnQI,16
+context_overlay-0.0.1.dist-info/RECORD,,

context_overlay-0.0.1.dist-info/WHEEL

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

context_overlay-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+context-overlay = context_overlay.cli:main

context_overlay-0.0.1.dist-info/licenses/LICENSE

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

context_overlay-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+context_overlay