aiohttp-ai-chatbot 1.0.0__tar.gz

aiohttp_ai_chatbot-1.0.0/LICENSE

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

aiohttp_ai_chatbot-1.0.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include LICENSE
+include README.md

aiohttp_ai_chatbot-1.0.0/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: aiohttp-ai-chatbot
+Version: 1.0.0
+Summary: Adds the Asyntai AI chat assistant to aiohttp sites. It answers visitor questions from your own content, in more than 80 languages.
+Author-email: Asyntai <hello@asyntai.com>
+License-Expression: MIT
+Project-URL: Homepage, https://asyntai.com
+Project-URL: Documentation, https://asyntai.com/documentation/integrations/aiohttp/
+Project-URL: Source, https://github.com/asyntai/aiohttp-ai-chatbot
+Project-URL: Issues, https://github.com/asyntai/aiohttp-ai-chatbot/issues
+Keywords: aiohttp,asyncio,middleware,chatbot,ai,ai-chatbot,live-chat,customer-support,widget
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: aiohttp
+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 :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.8
+Dynamic: license-file
+
+# aiohttp-ai-chatbot
+
+Adds the [Asyntai](https://asyntai.com) AI chat assistant to an aiohttp site.
+The assistant answers visitor questions from your own content, day and night,
+in more than 80 languages.
+
+Free and open source. Works on every Asyntai plan, including the free plan.
+
+- Requires Python 3.9 or newer and aiohttp 3.8 or newer
+- Documentation: https://asyntai.com/documentation/integrations/aiohttp/
+
+## Install
+
+```
+pip install aiohttp-ai-chatbot
+```
+
+```python
+from aiohttp import web
+from aiohttp_ai_chatbot import setup
+
+app = web.Application()
+app.router.add_get("/", index)
+setup(app, widget_id="asyntai_ab12cd34")
+
+web.run_app(app)
+```
+
+Or pass the middleware yourself:
+
+```python
+from aiohttp_ai_chatbot import asyntai_middleware
+
+app = web.Application(middlewares=[asyntai_middleware("asyntai_ab12cd34")])
+```
+
+You get the widget ID from the Install page of your
+[Asyntai dashboard](https://asyntai.com/dashboard). You can paste the whole
+snippet; the package keeps only the ID.
+
+That is all. The chat button appears on every HTML page of the site. JSON,
+files, streams, websockets and redirects pass through untouched.
+
+## Options
+
+```python
+setup(
+    app,
+    widget_id="asyntai_ab12cd34",   # without it: the ASYNTAI_WIDGET_ID environment variable
+    skip_paths=["/admin*"],         # the default
+)
+```
+
+- Leave out `widget_id` to read the `ASYNTAI_WIDGET_ID` environment variable.
+  It is read on every request, so you can change it without a code change.
+  An empty value switches the chat off.
+- `skip_paths` lists paths that never get the widget. A path that ends in `*`
+  also matches everything below it, so `/admin*` covers `/admin` and
+  `/admin/users`, but not `/administrator`.
+
+The middleware changes complete `web.Response` pages with status 200 and the
+`text/html` content type. A response that uses `enable_compression()` still
+gets the widget, because aiohttp compresses the body after the middleware.
+Files from `add_static` or `web.FileResponse` and responses that you prepare
+and stream yourself are sent as they are.
+
+## Placing the widget by hand
+
+With aiohttp-jinja2, register the helper once:
+
+```python
+import aiohttp_jinja2
+from aiohttp_ai_chatbot import asyntai_widget
+
+env = aiohttp_jinja2.setup(app, loader=...)
+env.globals["asyntai_widget"] = asyntai_widget
+```
+
+Then put it before the closing body tag:
+
+```html
+{{ asyntai_widget() }}
+</body>
+```
+
+`widget_snippet()` returns the same HTML as a plain string. The middleware
+never adds a second copy to a page that already has one.
+
+## How it loads
+
+The widget script loads after the page has finished loading, so your page
+draws first and page speed does not change.
+
+## License
+
+MIT

aiohttp_ai_chatbot-1.0.0/README.md

@@ -0,0 +1,96 @@
+# aiohttp-ai-chatbot
+
+Adds the [Asyntai](https://asyntai.com) AI chat assistant to an aiohttp site.
+The assistant answers visitor questions from your own content, day and night,
+in more than 80 languages.
+
+Free and open source. Works on every Asyntai plan, including the free plan.
+
+- Requires Python 3.9 or newer and aiohttp 3.8 or newer
+- Documentation: https://asyntai.com/documentation/integrations/aiohttp/
+
+## Install
+
+```
+pip install aiohttp-ai-chatbot
+```
+
+```python
+from aiohttp import web
+from aiohttp_ai_chatbot import setup
+
+app = web.Application()
+app.router.add_get("/", index)
+setup(app, widget_id="asyntai_ab12cd34")
+
+web.run_app(app)
+```
+
+Or pass the middleware yourself:
+
+```python
+from aiohttp_ai_chatbot import asyntai_middleware
+
+app = web.Application(middlewares=[asyntai_middleware("asyntai_ab12cd34")])
+```
+
+You get the widget ID from the Install page of your
+[Asyntai dashboard](https://asyntai.com/dashboard). You can paste the whole
+snippet; the package keeps only the ID.
+
+That is all. The chat button appears on every HTML page of the site. JSON,
+files, streams, websockets and redirects pass through untouched.
+
+## Options
+
+```python
+setup(
+    app,
+    widget_id="asyntai_ab12cd34",   # without it: the ASYNTAI_WIDGET_ID environment variable
+    skip_paths=["/admin*"],         # the default
+)
+```
+
+- Leave out `widget_id` to read the `ASYNTAI_WIDGET_ID` environment variable.
+  It is read on every request, so you can change it without a code change.
+  An empty value switches the chat off.
+- `skip_paths` lists paths that never get the widget. A path that ends in `*`
+  also matches everything below it, so `/admin*` covers `/admin` and
+  `/admin/users`, but not `/administrator`.
+
+The middleware changes complete `web.Response` pages with status 200 and the
+`text/html` content type. A response that uses `enable_compression()` still
+gets the widget, because aiohttp compresses the body after the middleware.
+Files from `add_static` or `web.FileResponse` and responses that you prepare
+and stream yourself are sent as they are.
+
+## Placing the widget by hand
+
+With aiohttp-jinja2, register the helper once:
+
+```python
+import aiohttp_jinja2
+from aiohttp_ai_chatbot import asyntai_widget
+
+env = aiohttp_jinja2.setup(app, loader=...)
+env.globals["asyntai_widget"] = asyntai_widget
+```
+
+Then put it before the closing body tag:
+
+```html
+{{ asyntai_widget() }}
+</body>
+```
+
+`widget_snippet()` returns the same HTML as a plain string. The middleware
+never adds a second copy to a page that already has one.
+
+## How it loads
+
+The widget script loads after the page has finished loading, so your page
+draws first and page speed does not change.
+
+## License
+
+MIT

aiohttp_ai_chatbot-1.0.0/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aiohttp-ai-chatbot"
+version = "1.0.0"
+description = "Adds the Asyntai AI chat assistant to aiohttp sites. It answers visitor questions from your own content, in more than 80 languages."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Asyntai", email = "hello@asyntai.com" }]
+keywords = ["aiohttp", "asyncio", "middleware", "chatbot", "ai", "ai-chatbot", "live-chat", "customer-support", "widget"]
+dependencies = ["aiohttp>=3.8"]
+
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Web Environment",
+    "Framework :: AsyncIO",
+    "Framework :: aiohttp",
+    "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 :: 3.14",
+    "Topic :: Internet :: WWW/HTTP :: Dynamic Content",
+]
+
+[project.urls]
+Homepage = "https://asyntai.com"
+Documentation = "https://asyntai.com/documentation/integrations/aiohttp/"
+Source = "https://github.com/asyntai/aiohttp-ai-chatbot"
+Issues = "https://github.com/asyntai/aiohttp-ai-chatbot/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+testpaths = ["tests"]

aiohttp_ai_chatbot-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

aiohttp_ai_chatbot-1.0.0/src/aiohttp_ai_chatbot/__init__.py

@@ -0,0 +1,6 @@
+"""Adds the Asyntai AI chat assistant to aiohttp sites."""
+from .middleware import DEFAULT_SKIP_PATHS, asyntai_middleware, setup
+from .snippet import asyntai_widget, widget_snippet
+
+__all__ = ['DEFAULT_SKIP_PATHS', 'asyntai_middleware', 'asyntai_widget', 'setup', 'widget_snippet']
+__version__ = '1.0.0'

aiohttp_ai_chatbot-1.0.0/src/aiohttp_ai_chatbot/middleware.py

@@ -0,0 +1,121 @@
+"""Puts the chat widget on every HTML page of an aiohttp site, with no template edit.
+
+The middleware only touches complete web.Response objects that carry an HTML
+page with status 200. Everything else passes through untouched: JSON, files
+from add_static or web.FileResponse, prepared streams, websockets and
+redirects.
+"""
+from aiohttp import web
+
+from .snippet import MARKER, resolve_widget_id, widget_snippet
+from .utils import clean_script_url
+
+BODY_CLOSE = b'</body>'
+
+#: Paths the widget never touches by default. A path that ends in * matches
+#: the path itself and everything below it.
+DEFAULT_SKIP_PATHS = ('/admin*',)
+
+#: The key under which setup() stores its settings on the application.
+APP_KEY = 'aiohttp_ai_chatbot'
+
+
+def path_is_skipped(path, skip_paths):
+    """Answer whether the widget must stay off on this path."""
+    for rule in skip_paths:
+        if rule.endswith('*'):
+            base = rule[:-1].rstrip('/')
+            if path == base or path.startswith(base + '/'):
+                return True
+        elif path == rule:
+            return True
+    return False
+
+
+def insert_snippet(body, snippet, charset='utf-8'):
+    """Return the page with the snippet before the last </body>, or None.
+
+    None means "leave the page as it is": the page has no closing body tag,
+    it already carries the widget, or it is not readable text.
+    """
+    if MARKER.encode() in body or b'data-asyntai-id' in body:
+        return None
+
+    if BODY_CLOSE not in body.lower():
+        return None
+
+    try:
+        html = body.decode(charset)
+        encoded_snippet = snippet.encode(charset)
+    except (UnicodeError, LookupError):
+        return None
+
+    # Split on the last closing tag, so a page that prints the tag inside an
+    # example or a code block is left alone.
+    index = html.lower().rfind('</body>')
+    if index < 0:
+        return None
+    return html[:index].encode(charset) + encoded_snippet + html[index:].encode(charset)
+
+
+def asyntai_middleware(widget_id=None, skip_paths=DEFAULT_SKIP_PATHS, script_url=None):
+    """Return an aiohttp middleware that inserts the widget before </body>.
+
+    widget_id      the ID from the Asyntai dashboard; without it, the
+                   ASYNTAI_WIDGET_ID environment variable (read on every
+                   request, so the ID can change without a code change)
+    skip_paths     paths the widget never touches
+    script_url     change only if Asyntai support asks
+
+        app = web.Application(middlewares=[asyntai_middleware("asyntai_ab12cd34")])
+    """
+    skip = tuple(skip_paths or ())
+
+    @web.middleware
+    async def asyntai_widget_middleware(request, handler):
+        response = await handler(request)
+
+        if request.method == 'HEAD' or path_is_skipped(request.path or '/', skip):
+            return response
+
+        if not resolve_widget_id(widget_id) or not clean_script_url(script_url):
+            return response
+
+        if _can_carry_widget(response):
+            snippet = widget_snippet(widget_id, script_url)
+            new_body = insert_snippet(response.body, snippet, response.charset or 'utf-8') if snippet else None
+            if new_body is not None:
+                # The body setter also sets the new Content-Length.
+                response.body = new_body
+
+        return response
+
+    return asyntai_widget_middleware
+
+
+def setup(app, widget_id=None, skip_paths=DEFAULT_SKIP_PATHS, script_url=None):
+    """Add the widget middleware to an application before it starts.
+
+        from aiohttp_ai_chatbot import setup
+        setup(app, widget_id="asyntai_ab12cd34")
+    """
+    middleware = asyntai_middleware(widget_id=widget_id, skip_paths=skip_paths, script_url=script_url)
+    app.middlewares.append(middleware)
+    return middleware
+
+
+def _can_carry_widget(response):
+    # A FileResponse or a hand-made StreamResponse is not a web.Response,
+    # and a prepared response has already left; neither can change.
+    if not isinstance(response, web.Response) or response.prepared:
+        return False
+
+    if response.status != 200 or response.headers.get('Content-Encoding'):
+        return False
+
+    if response.content_type != 'text/html':
+        return False
+
+    # A body object (a file, a stream) is sent piece by piece; only plain
+    # bytes can be read and changed here.
+    return isinstance(response.body, (bytes, bytearray))

aiohttp_ai_chatbot-1.0.0/src/aiohttp_ai_chatbot/snippet.py

@@ -0,0 +1,82 @@
+"""The HTML that loads the chat widget, for the middleware and for templates."""
+import os
+from html import escape
+
+from .utils import clean_script_url, clean_widget_id
+
+#: Text that only this package writes. The middleware looks for it, so the
+#: widget is never added twice.
+MARKER = 'asyntai-widget-config'
+
+_TEMPLATE = (
+    '<div class="' + MARKER + '" data-asyntai-widget="__WIDGET_ID__" '
+    'data-asyntai-src="__SCRIPT_URL__" style="display: none"></div>\n'
+    '<script>\n'
+    '    // Loads the Asyntai chat widget after the page has finished loading,\n'
+    '    // so the site draws first and page speed does not change. The two\n'
+    '    // values arrive on a data attribute, so nothing is ever written into\n'
+    '    // the script itself.\n'
+    '    (function () {\n'
+    "        var config = document.querySelector('." + MARKER + "');\n"
+    '        if (!config) { return; }\n'
+    '\n'
+    "        var widgetId = config.getAttribute('data-asyntai-widget') || '';\n"
+    "        var scriptUrl = config.getAttribute('data-asyntai-src') || '';\n"
+    "        if (!widgetId || scriptUrl.indexOf('https://') !== 0) { return; }\n"
+    '\n'
+    '        var load = function () {\n'
+    "            if (document.querySelector('script[data-asyntai-id]')) { return; }\n"
+    '\n'
+    "            var script = document.createElement('script');\n"
+    '            script.src = scriptUrl;\n'
+    '            script.async = true;\n'
+    "            script.setAttribute('data-asyntai-id', widgetId);\n"
+    '            document.head.appendChild(script);\n'
+    '        };\n'
+    '\n'
+    "        if (document.readyState === 'complete') {\n"
+    '            load();\n'
+    '        } else {\n'
+    "            window.addEventListener('load', load);\n"
+    '        }\n'
+    '    }());\n'
+    '</script>\n'
+)
+
+
+def resolve_widget_id(widget_id=None):
+    """The given ID, or the ASYNTAI_WIDGET_ID environment variable."""
+    if widget_id is None:
+        widget_id = os.environ.get('ASYNTAI_WIDGET_ID', '')
+    return clean_widget_id(widget_id)
+
+
+def widget_snippet(widget_id=None, script_url=None):
+    """Return the widget HTML, or an empty string when the chat must stay off.
+
+    Without a widget_id, the ASYNTAI_WIDGET_ID environment variable is used.
+    """
+    clean_id = resolve_widget_id(widget_id)
+    clean_url = clean_script_url(script_url)
+    if not clean_id or not clean_url:
+        return ''
+
+    return (_TEMPLATE
+            .replace('__WIDGET_ID__', escape(clean_id, quote=True))
+            .replace('__SCRIPT_URL__', escape(clean_url, quote=True)))
+
+
+def asyntai_widget(widget_id=None, script_url=None):
+    """Template helper: the same HTML, marked safe for Jinja2.
+
+    With aiohttp-jinja2, register it once, then write {{ asyntai_widget() }}
+    before </body>:
+
+        aiohttp_jinja2.get_env(app).globals['asyntai_widget'] = asyntai_widget
+    """
+    html = widget_snippet(widget_id, script_url)
+    try:
+        from markupsafe import Markup
+    except ImportError:  # Jinja2 is optional.
+        return html
+    return Markup(html)

aiohttp_ai_chatbot-1.0.0/src/aiohttp_ai_chatbot/utils.py

@@ -0,0 +1,57 @@
+"""Reading and checking the two values the widget needs.
+
+Every decision the package makes about a configured value lives here, so the
+tests can run it on its own.
+"""
+import re
+
+DEFAULT_SCRIPT_URL = 'https://widget.asyntai.com/static/js/chat-widget.js'
+
+#: Shape of a widget identifier from the Asyntai dashboard.
+ID_PATTERN = re.compile(r'^asyntai_[A-Za-z0-9]{6,64}$')
+
+#: The identifier inside a pasted snippet.
+SNIPPET_PATTERN = re.compile(r'data-asyntai-id\s*=\s*["\']([^"\']+)["\']')
+
+_HTTPS_PATTERN = re.compile(r'^https://[^\s"\'<>]+$', re.IGNORECASE)
+
+
+def clean_widget_id(raw):
+    """Return a usable widget identifier, or an empty string.
+
+    Accepts a bare identifier or the whole snippet from the Asyntai
+    dashboard, because people paste the snippet. An empty string means the
+    chat stays off, which is how you switch it off again.
+    """
+    if not isinstance(raw, str):
+        return ''
+
+    value = raw.strip()
+    if not value:
+        return ''
+
+    match = SNIPPET_PATTERN.search(value)
+    if match:
+        value = match.group(1).strip()
+
+    return value if ID_PATTERN.match(value) else ''
+
+
+def clean_script_url(raw):
+    """Return the script address, or an empty string when the value is bad.
+
+    Only an https address is accepted, so a bad value can never put a
+    javascript: URL on every page of the site. No value means the Asyntai
+    address.
+    """
+    if raw is None:
+        return DEFAULT_SCRIPT_URL
+
+    if not isinstance(raw, str):
+        return ''
+
+    value = raw.strip()
+    if not value:
+        return DEFAULT_SCRIPT_URL
+
+    return value if _HTTPS_PATTERN.match(value) else ''

aiohttp_ai_chatbot-1.0.0/src/aiohttp_ai_chatbot.egg-info/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: aiohttp-ai-chatbot
+Version: 1.0.0
+Summary: Adds the Asyntai AI chat assistant to aiohttp sites. It answers visitor questions from your own content, in more than 80 languages.
+Author-email: Asyntai <hello@asyntai.com>
+License-Expression: MIT
+Project-URL: Homepage, https://asyntai.com
+Project-URL: Documentation, https://asyntai.com/documentation/integrations/aiohttp/
+Project-URL: Source, https://github.com/asyntai/aiohttp-ai-chatbot
+Project-URL: Issues, https://github.com/asyntai/aiohttp-ai-chatbot/issues
+Keywords: aiohttp,asyncio,middleware,chatbot,ai,ai-chatbot,live-chat,customer-support,widget
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: aiohttp
+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 :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.8
+Dynamic: license-file
+
+# aiohttp-ai-chatbot
+
+Adds the [Asyntai](https://asyntai.com) AI chat assistant to an aiohttp site.
+The assistant answers visitor questions from your own content, day and night,
+in more than 80 languages.
+
+Free and open source. Works on every Asyntai plan, including the free plan.
+
+- Requires Python 3.9 or newer and aiohttp 3.8 or newer
+- Documentation: https://asyntai.com/documentation/integrations/aiohttp/
+
+## Install
+
+```
+pip install aiohttp-ai-chatbot
+```
+
+```python
+from aiohttp import web
+from aiohttp_ai_chatbot import setup
+
+app = web.Application()
+app.router.add_get("/", index)
+setup(app, widget_id="asyntai_ab12cd34")
+
+web.run_app(app)
+```
+
+Or pass the middleware yourself:
+
+```python
+from aiohttp_ai_chatbot import asyntai_middleware
+
+app = web.Application(middlewares=[asyntai_middleware("asyntai_ab12cd34")])
+```
+
+You get the widget ID from the Install page of your
+[Asyntai dashboard](https://asyntai.com/dashboard). You can paste the whole
+snippet; the package keeps only the ID.
+
+That is all. The chat button appears on every HTML page of the site. JSON,
+files, streams, websockets and redirects pass through untouched.
+
+## Options
+
+```python
+setup(
+    app,
+    widget_id="asyntai_ab12cd34",   # without it: the ASYNTAI_WIDGET_ID environment variable
+    skip_paths=["/admin*"],         # the default
+)
+```
+
+- Leave out `widget_id` to read the `ASYNTAI_WIDGET_ID` environment variable.
+  It is read on every request, so you can change it without a code change.
+  An empty value switches the chat off.
+- `skip_paths` lists paths that never get the widget. A path that ends in `*`
+  also matches everything below it, so `/admin*` covers `/admin` and
+  `/admin/users`, but not `/administrator`.
+
+The middleware changes complete `web.Response` pages with status 200 and the
+`text/html` content type. A response that uses `enable_compression()` still
+gets the widget, because aiohttp compresses the body after the middleware.
+Files from `add_static` or `web.FileResponse` and responses that you prepare
+and stream yourself are sent as they are.
+
+## Placing the widget by hand
+
+With aiohttp-jinja2, register the helper once:
+
+```python
+import aiohttp_jinja2
+from aiohttp_ai_chatbot import asyntai_widget
+
+env = aiohttp_jinja2.setup(app, loader=...)
+env.globals["asyntai_widget"] = asyntai_widget
+```
+
+Then put it before the closing body tag:
+
+```html
+{{ asyntai_widget() }}
+</body>
+```
+
+`widget_snippet()` returns the same HTML as a plain string. The middleware
+never adds a second copy to a page that already has one.
+
+## How it loads
+
+The widget script loads after the page has finished loading, so your page
+draws first and page speed does not change.
+
+## License
+
+MIT

aiohttp_ai_chatbot-1.0.0/src/aiohttp_ai_chatbot.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+src/aiohttp_ai_chatbot/__init__.py
+src/aiohttp_ai_chatbot/middleware.py
+src/aiohttp_ai_chatbot/snippet.py
+src/aiohttp_ai_chatbot/utils.py
+src/aiohttp_ai_chatbot.egg-info/PKG-INFO
+src/aiohttp_ai_chatbot.egg-info/SOURCES.txt
+src/aiohttp_ai_chatbot.egg-info/dependency_links.txt
+src/aiohttp_ai_chatbot.egg-info/requires.txt
+src/aiohttp_ai_chatbot.egg-info/top_level.txt
+tests/test_middleware.py
+tests/test_snippet.py
+tests/test_utils.py

aiohttp_ai_chatbot-1.0.0/src/aiohttp_ai_chatbot.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aiohttp_ai_chatbot-1.0.0/src/aiohttp_ai_chatbot.egg-info/requires.txt

@@ -0,0 +1 @@
+aiohttp>=3.8

aiohttp_ai_chatbot-1.0.0/src/aiohttp_ai_chatbot.egg-info/top_level.txt

@@ -0,0 +1 @@
+aiohttp_ai_chatbot

aiohttp_ai_chatbot-1.0.0/tests/test_middleware.py

@@ -0,0 +1,312 @@
+import json
+
+import pytest
+from aiohttp import web
+
+from aiohttp_ai_chatbot import DEFAULT_SKIP_PATHS, asyntai_middleware, setup
+from aiohttp_ai_chatbot.middleware import insert_snippet, path_is_skipped
+
+WIDGET = 'asyntai_ab12cd34'
+PAGE = '<!doctype html><html><head><title>Home</title></head><body><h1>Hello</h1></body></html>'
+# The hidden config element: exactly one per inserted widget.
+MARKER = 'class="asyntai-widget-config"'
+
+
+def html(text=PAGE, status=200, **kwargs):
+    async def handler(request):
+        return web.Response(text=text, content_type='text/html', status=status, **kwargs)
+    return handler
+
+
+def make_app(*routes, **options):
+    options.setdefault('widget_id', WIDGET)
+    app = web.Application(middlewares=[asyntai_middleware(**options)])
+    for method, path, handler in routes:
+        if method == 'GET':
+            app.router.add_get(path, handler)  # also answers HEAD
+        else:
+            app.router.add_route(method, path, handler)
+    return app
+
+
+async def get_text(client, path, method='GET'):
+    response = await client.request(method, path)
+    return response, await response.text()
+
+
+# ---------------------------------------------------------------- pages
+
+async def test_html_page_gets_widget_once_before_body_close(aiohttp_client):
+    client = await aiohttp_client(make_app(('GET', '/', html())))
+    response, text = await get_text(client, '/')
+
+    assert response.status == 200
+    assert text.count(MARKER) == 1
+    assert f'data-asyntai-widget="{WIDGET}"' in text
+    assert text.index(MARKER) < text.rindex('</body>')
+    assert text.endswith('</body></html>')
+    assert int(response.headers['Content-Length']) == len(text.encode('utf-8'))
+
+
+async def test_upper_case_body_tag_and_last_tag_used(aiohttp_client):
+    page = '<html><body><code></body></code><p>x</p></BODY></html>'
+    client = await aiohttp_client(make_app(('GET', '/', html(page))))
+    _, text = await get_text(client, '/')
+
+    assert text.count(MARKER) == 1
+    assert text.index(MARKER) > text.index('<p>x</p>')
+    assert text.endswith('</BODY></html>')
+
+
+async def test_page_without_body_close_is_untouched(aiohttp_client):
+    client = await aiohttp_client(make_app(('GET', '/', html('<p>fragment</p>'))))
+    _, text = await get_text(client, '/')
+    assert text == '<p>fragment</p>'
+
+
+async def test_page_that_already_has_widget_is_not_doubled(aiohttp_client):
+    own = PAGE.replace('</body>', '<script src="x.js" data-asyntai-id="asyntai_zz99yy88"></script></body>')
+    client = await aiohttp_client(make_app(('GET', '/', html(own))))
+    _, text = await get_text(client, '/')
+    assert text == own
+    assert MARKER not in text
+
+
+async def test_charset_is_kept(aiohttp_client):
+    page = '<html><body><p>Příliš žluťoučký kůň</p></body></html>'
+
+    async def handler(request):
+        return web.Response(body=page.encode('cp1250'), content_type='text/html', charset='cp1250')
+
+    client = await aiohttp_client(make_app(('GET', '/', handler)))
+    response = await client.get('/')
+    raw = await response.read()
+
+    assert 'charset=cp1250' in response.headers['Content-Type']
+    decoded = raw.decode('cp1250')
+    assert 'Příliš žluťoučký kůň' in decoded
+    assert decoded.count(MARKER) == 1
+    assert int(response.headers['Content-Length']) == len(raw)
+
+
+async def test_compressed_response_gets_widget_and_stays_compressed(aiohttp_client):
+    async def handler(request):
+        response = web.Response(text=PAGE * 50, content_type='text/html')
+        response.enable_compression()
+        return response
+
+    client = await aiohttp_client(make_app(('GET', '/', handler)))
+    response = await client.get('/', headers={'Accept-Encoding': 'gzip'})
+    text = await response.text()
+
+    assert response.headers.get('Content-Encoding') == 'gzip'
+    assert text.count(MARKER) == 1
+
+
+async def test_pre_compressed_body_is_untouched(aiohttp_client):
+    import gzip
+    body = gzip.compress(PAGE.encode())
+
+    async def handler(request):
+        return web.Response(body=body, content_type='text/html', headers={'Content-Encoding': 'gzip'})
+
+    client = await aiohttp_client(make_app(('GET', '/', handler)))
+    response = await client.get('/')
+    text = await response.text()  # the client unpacks the gzip body
+    assert MARKER not in text
+    assert text == PAGE
+
+
+# ---------------------------------------------------------------- left alone
+
+async def test_json_is_untouched(aiohttp_client):
+    async def handler(request):
+        return web.json_response({'body': '</body>'})
+
+    client = await aiohttp_client(make_app(('GET', '/api', handler)))
+    response = await client.get('/api')
+    assert await response.json() == {'body': '</body>'}
+
+
+async def test_plain_text_is_untouched(aiohttp_client):
+    async def handler(request):
+        return web.Response(text='</body>')
+
+    client = await aiohttp_client(make_app(('GET', '/t', handler)))
+    _, text = await get_text(client, '/t')
+    assert text == '</body>'
+
+
+async def test_error_status_is_untouched(aiohttp_client):
+    client = await aiohttp_client(make_app(('GET', '/', html(status=500))))
+    _, text = await get_text(client, '/')
+    assert text == PAGE
+
+
+async def test_raised_not_found_and_redirect_pass(aiohttp_client):
+    async def redirect(request):
+        raise web.HTTPFound('/')
+
+    client = await aiohttp_client(make_app(('GET', '/', html()), ('GET', '/old', redirect)))
+
+    response = await client.get('/missing')
+    assert response.status == 404
+    assert MARKER not in await response.text()
+
+    response = await client.get('/old', allow_redirects=False)
+    assert response.status == 302
+    assert response.headers['Location'] == '/'
+
+
+async def test_head_request_is_untouched(aiohttp_client):
+    client = await aiohttp_client(make_app(('GET', '/', html())))
+    response = await client.head('/')
+    assert response.status == 200
+    assert int(response.headers['Content-Length']) == len(PAGE.encode())
+
+
+async def test_static_html_file_is_untouched(aiohttp_client, tmp_path):
+    (tmp_path / 'page.html').write_text(PAGE, encoding='utf-8')
+    app = make_app()
+    app.router.add_static('/static', tmp_path)
+    client = await aiohttp_client(app)
+
+    _, text = await get_text(client, '/static/page.html')
+    assert text == PAGE
+
+
+async def test_prepared_stream_is_untouched(aiohttp_client):
+    async def handler(request):
+        response = web.StreamResponse(headers={'Content-Type': 'text/html'})
+        await response.prepare(request)
+        await response.write(PAGE.encode())
+        await response.write_eof()
+        return response
+
+    client = await aiohttp_client(make_app(('GET', '/stream', handler)))
+    _, text = await get_text(client, '/stream')
+    assert text == PAGE
+
+
+async def test_websocket_still_works(aiohttp_client):
+    async def handler(request):
+        ws = web.WebSocketResponse()
+        await ws.prepare(request)
+        async for message in ws:
+            await ws.send_str('echo:' + message.data)
+            await ws.close()
+        return ws
+
+    client = await aiohttp_client(make_app(('GET', '/ws', handler)))
+    ws = await client.ws_connect('/ws')
+    await ws.send_str('hi')
+    assert (await ws.receive()).data == 'echo:hi'
+    await ws.close()
+
+
+# ---------------------------------------------------------------- skip paths
+
+def test_path_rules():
+    assert path_is_skipped('/admin', DEFAULT_SKIP_PATHS)
+    assert path_is_skipped('/admin/users', DEFAULT_SKIP_PATHS)
+    assert not path_is_skipped('/administrator', DEFAULT_SKIP_PATHS)
+    assert not path_is_skipped('/', DEFAULT_SKIP_PATHS)
+    assert path_is_skipped('/login', ('/login',))
+    assert not path_is_skipped('/login/x', ('/login',))
+
+
+async def test_skip_paths(aiohttp_client):
+    client = await aiohttp_client(make_app(
+        ('GET', '/admin', html()), ('GET', '/admin/x', html()),
+        ('GET', '/administrator', html()), ('GET', '/login', html()),
+        skip_paths=['/admin*', '/login'],
+    ))
+    assert MARKER not in (await get_text(client, '/admin'))[1]
+    assert MARKER not in (await get_text(client, '/admin/x'))[1]
+    assert MARKER not in (await get_text(client, '/login'))[1]
+    assert MARKER in (await get_text(client, '/administrator'))[1]
+
+
+async def test_empty_skip_paths_puts_widget_everywhere(aiohttp_client):
+    client = await aiohttp_client(make_app(('GET', '/admin', html()), skip_paths=None))
+    assert MARKER in (await get_text(client, '/admin'))[1]
+
+
+# ---------------------------------------------------------------- settings
+
+async def test_environment_variable_is_read_per_request(aiohttp_client, monkeypatch):
+    monkeypatch.delenv('ASYNTAI_WIDGET_ID', raising=False)
+    client = await aiohttp_client(make_app(('GET', '/', html()), widget_id=None))
+
+    assert MARKER not in (await get_text(client, '/'))[1]
+
+    monkeypatch.setenv('ASYNTAI_WIDGET_ID', 'asyntai_env12345')
+    _, text = await get_text(client, '/')
+    assert 'data-asyntai-widget="asyntai_env12345"' in text
+
+    monkeypatch.setenv('ASYNTAI_WIDGET_ID', '')
+    assert MARKER not in (await get_text(client, '/'))[1]
+
+
+async def test_pasted_snippet_keeps_only_the_id(aiohttp_client):
+    pasted = '<script async src="https://widget.asyntai.com/static/js/chat-widget.js" data-asyntai-id="asyntai_pasted99"></script>'
+    client = await aiohttp_client(make_app(('GET', '/', html()), widget_id=pasted))
+    _, text = await get_text(client, '/')
+    assert 'data-asyntai-widget="asyntai_pasted99"' in text
+
+
+@pytest.mark.parametrize('bad', ['', 'nonsense', 'asyntai_<x>', 'asyntai_"onload=', 123])
+async def test_bad_widget_id_keeps_chat_off(aiohttp_client, bad):
+    client = await aiohttp_client(make_app(('GET', '/', html()), widget_id=bad))
+    _, text = await get_text(client, '/')
+    assert text == PAGE
+
+
+async def test_bad_script_url_keeps_chat_off_and_https_url_is_used(aiohttp_client):
+    client = await aiohttp_client(make_app(('GET', '/', html()), script_url='javascript:alert(1)'))
+    assert MARKER not in (await get_text(client, '/'))[1]
+
+    client = await aiohttp_client(make_app(('GET', '/', html()), script_url='https://cdn.example.com/w.js'))
+    _, text = await get_text(client, '/')
+    assert 'data-asyntai-src="https://cdn.example.com/w.js"' in text
+
+
+async def test_setup_adds_the_middleware(aiohttp_client):
+    app = web.Application()
+    app.router.add_get('/', html())
+    setup(app, widget_id=WIDGET)
+    assert len(app.middlewares) == 1
+
+    client = await aiohttp_client(app)
+    assert (await get_text(client, '/'))[1].count(MARKER) == 1
+
+
+async def test_jinja2_helper_with_aiohttp_jinja2(aiohttp_client):
+    aiohttp_jinja2 = pytest.importorskip('aiohttp_jinja2')
+    jinja2 = pytest.importorskip('jinja2')
+    from aiohttp_ai_chatbot import asyntai_widget
+
+    app = web.Application()
+    env = aiohttp_jinja2.setup(app, loader=jinja2.DictLoader({
+        'page.html': '<html><body>{{ asyntai_widget("' + WIDGET + '") }}</body></html>',
+    }))
+    env.globals['asyntai_widget'] = asyntai_widget
+    setup(app, widget_id=WIDGET)
+
+    async def handler(request):
+        return aiohttp_jinja2.render_template('page.html', request, {})
+
+    app.router.add_get('/', handler)
+    client = await aiohttp_client(app)
+    _, text = await get_text(client, '/')
+
+    # The template already carries the widget, so the middleware adds nothing.
+    assert text.count(MARKER) == 1
+    assert '&lt;' not in text
+
+
+# ---------------------------------------------------------------- helper
+
+def test_insert_snippet_bad_charset_returns_none():
+    assert insert_snippet(b'<body></body>', 'x', 'no-such-charset') is None
+    assert insert_snippet('<body>ž</body>'.encode('utf-8'), 'x', 'ascii') is None

aiohttp_ai_chatbot-1.0.0/tests/test_snippet.py

@@ -0,0 +1,51 @@
+import re
+import shutil
+import subprocess
+
+import pytest
+
+from aiohttp_ai_chatbot import asyntai_widget, widget_snippet
+
+
+def test_snippet_carries_id_and_script_url():
+    html = widget_snippet('asyntai_ab12cd34')
+    assert 'data-asyntai-widget="asyntai_ab12cd34"' in html
+    assert 'data-asyntai-src="https://widget.asyntai.com/static/js/chat-widget.js"' in html
+
+
+def test_snippet_is_empty_without_a_good_id(monkeypatch):
+    monkeypatch.delenv('ASYNTAI_WIDGET_ID', raising=False)
+    assert widget_snippet() == ''
+    assert widget_snippet('bad') == ''
+
+
+def test_snippet_reads_the_environment(monkeypatch):
+    monkeypatch.setenv('ASYNTAI_WIDGET_ID', 'asyntai_env12345')
+    assert 'asyntai_env12345' in widget_snippet()
+
+
+def test_template_helper_is_safe_markup():
+    markupsafe = pytest.importorskip('markupsafe')
+    value = asyntai_widget('asyntai_ab12cd34')
+    assert isinstance(value, markupsafe.Markup)
+    assert str(markupsafe.escape(value)) == str(value)
+
+
+def test_jinja_template_renders_the_widget():
+    jinja2 = pytest.importorskip('jinja2')
+    env = jinja2.Environment(autoescape=True)
+    env.globals['asyntai_widget'] = asyntai_widget
+    html = env.from_string('<body>{{ asyntai_widget("asyntai_ab12cd34") }}</body>').render()
+    assert '<script>' in html
+    assert 'data-asyntai-widget="asyntai_ab12cd34"' in html
+
+
+def test_script_is_valid_javascript(tmp_path):
+    node = shutil.which('node')
+    if not node:
+        pytest.skip('node is not installed')
+    script = re.search(r'<script>(.*)</script>', widget_snippet('asyntai_ab12cd34'), re.S).group(1)
+    path = tmp_path / 'widget.js'
+    path.write_text(script, encoding='utf-8')
+    result = subprocess.run([node, '--check', str(path)], capture_output=True, text=True)
+    assert result.returncode == 0, result.stderr

aiohttp_ai_chatbot-1.0.0/tests/test_utils.py

@@ -0,0 +1,30 @@
+from aiohttp_ai_chatbot.utils import DEFAULT_SCRIPT_URL, clean_script_url, clean_widget_id
+
+
+def test_bare_id_is_kept():
+    assert clean_widget_id('asyntai_ab12cd34') == 'asyntai_ab12cd34'
+
+
+def test_id_is_trimmed():
+    assert clean_widget_id('  asyntai_ab12cd34 \n') == 'asyntai_ab12cd34'
+
+
+def test_id_comes_out_of_a_pasted_snippet():
+    snippet = '<script async src="https://widget.asyntai.com/static/js/chat-widget.js" data-asyntai-id="asyntai_ab12cd34"></script>'
+    assert clean_widget_id(snippet) == 'asyntai_ab12cd34'
+
+
+def test_bad_ids_switch_the_chat_off():
+    for raw in ['', '   ', 'hello', 'asyntai_', 'asyntai_ab"><script>', 'asyntai_ab12 cd34', None, 42]:
+        assert clean_widget_id(raw) == ''
+
+
+def test_script_url_defaults_to_asyntai():
+    assert clean_script_url(None) == DEFAULT_SCRIPT_URL
+    assert clean_script_url('') == DEFAULT_SCRIPT_URL
+
+
+def test_only_https_script_urls_are_accepted():
+    assert clean_script_url('https://example.com/w.js') == 'https://example.com/w.js'
+    for raw in ['http://example.com/w.js', 'javascript:alert(1)', 'https://e.com/a b.js', 'https://e.com/"x', 42]:
+        assert clean_script_url(raw) == ''