dash-ai-chatbot 1.0.0__tar.gz

dash_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.

dash_ai_chatbot-1.0.0/MANIFEST.in

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

dash_ai_chatbot-1.0.0/PKG-INFO

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: dash-ai-chatbot
+Version: 1.0.0
+Summary: Adds the Asyntai AI chat assistant to a Plotly Dash app. 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/plotly-dash/
+Project-URL: Source, https://github.com/asyntai/dash-ai-chatbot
+Project-URL: Issues, https://github.com/asyntai/dash-ai-chatbot/issues
+Keywords: dash,plotly,plotly-dash,chatbot,ai,ai-chatbot,live-chat,customer-support,assistant,widget
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Dash
+Classifier: Framework :: Flask
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dash>=2.0
+Dynamic: license-file
+
+# dash-ai-chatbot
+
+Adds the [Asyntai](https://asyntai.com) AI chat assistant to a
+[Plotly Dash](https://dash.plotly.com) app. 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 Dash 2.0 or newer and Python 3.10 or newer
+- Documentation: https://asyntai.com/documentation/integrations/plotly-dash/
+
+## Install
+
+```
+pip install dash-ai-chatbot
+```
+
+Add one line after you create the app:
+
+```python
+from dash import Dash, html
+import dash_ai_chatbot
+
+app = Dash(__name__)
+app.layout = html.Div("Hello")
+
+dash_ai_chatbot.init_app(app, widget_id="asyntai_ab12cd34")
+
+if __name__ == "__main__":
+    app.run()
+```
+
+You get the 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 page of the app, including
+multi-page apps.
+
+## No code change (Dash 3 and later)
+
+On Dash 3 and later the package also works with no code change. Install it and
+set one environment variable:
+
+```
+ASYNTAI_WIDGET_ID=asyntai_ab12cd34
+```
+
+Every Dash app that runs with that variable gets the chat. Without the
+variable the package does nothing.
+
+## Keep the ID out of the code
+
+Leave out `widget_id` and the package reads `ASYNTAI_WIDGET_ID` each time the
+page is built:
+
+```python
+dash_ai_chatbot.init_app(app)
+```
+
+## Options
+
+```python
+dash_ai_chatbot.init_app(
+    app,
+    widget_id="asyntai_ab12cd34",  # or the whole snippet; empty or invalid = chat off
+    script_url=None,               # change only if Asyntai support asks you to
+)
+```
+
+`script_url` can also come from the `ASYNTAI_SCRIPT_URL` environment variable.
+Only an `https` address is accepted.
+
+## How it works
+
+Dash serves one HTML page for the whole app. The package puts a small script
+just before the closing body tag of that page. The script waits for the page to
+finish loading, then fetches the chat widget from Asyntai, so your app draws
+first and its speed is unchanged.
+
+The widget ID and the script address travel to the browser on a data
+attribute, never inside the script. The package works with a custom
+`index_string`, with a subclass that overrides `interpolate_index`, and with
+`url_base_pathname`. It never adds the widget twice.
+
+## Tests
+
+```
+pip install -e . pytest
+pytest
+```
+
+## Support
+
+hello@asyntai.com
+
+## Licence
+
+MIT. See [LICENSE](LICENSE).

dash_ai_chatbot-1.0.0/README.md

@@ -0,0 +1,99 @@
+# dash-ai-chatbot
+
+Adds the [Asyntai](https://asyntai.com) AI chat assistant to a
+[Plotly Dash](https://dash.plotly.com) app. 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 Dash 2.0 or newer and Python 3.10 or newer
+- Documentation: https://asyntai.com/documentation/integrations/plotly-dash/
+
+## Install
+
+```
+pip install dash-ai-chatbot
+```
+
+Add one line after you create the app:
+
+```python
+from dash import Dash, html
+import dash_ai_chatbot
+
+app = Dash(__name__)
+app.layout = html.Div("Hello")
+
+dash_ai_chatbot.init_app(app, widget_id="asyntai_ab12cd34")
+
+if __name__ == "__main__":
+    app.run()
+```
+
+You get the 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 page of the app, including
+multi-page apps.
+
+## No code change (Dash 3 and later)
+
+On Dash 3 and later the package also works with no code change. Install it and
+set one environment variable:
+
+```
+ASYNTAI_WIDGET_ID=asyntai_ab12cd34
+```
+
+Every Dash app that runs with that variable gets the chat. Without the
+variable the package does nothing.
+
+## Keep the ID out of the code
+
+Leave out `widget_id` and the package reads `ASYNTAI_WIDGET_ID` each time the
+page is built:
+
+```python
+dash_ai_chatbot.init_app(app)
+```
+
+## Options
+
+```python
+dash_ai_chatbot.init_app(
+    app,
+    widget_id="asyntai_ab12cd34",  # or the whole snippet; empty or invalid = chat off
+    script_url=None,               # change only if Asyntai support asks you to
+)
+```
+
+`script_url` can also come from the `ASYNTAI_SCRIPT_URL` environment variable.
+Only an `https` address is accepted.
+
+## How it works
+
+Dash serves one HTML page for the whole app. The package puts a small script
+just before the closing body tag of that page. The script waits for the page to
+finish loading, then fetches the chat widget from Asyntai, so your app draws
+first and its speed is unchanged.
+
+The widget ID and the script address travel to the browser on a data
+attribute, never inside the script. The package works with a custom
+`index_string`, with a subclass that overrides `interpolate_index`, and with
+`url_base_pathname`. It never adds the widget twice.
+
+## Tests
+
+```
+pip install -e . pytest
+pytest
+```
+
+## Support
+
+hello@asyntai.com
+
+## Licence
+
+MIT. See [LICENSE](LICENSE).

dash_ai_chatbot-1.0.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dash-ai-chatbot"
+version = "1.0.0"
+description = "Adds the Asyntai AI chat assistant to a Plotly Dash app. It answers visitor questions from your own content, in more than 80 languages."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Asyntai", email = "hello@asyntai.com" }]
+keywords = ["dash", "plotly", "plotly-dash", "chatbot", "ai", "ai-chatbot", "live-chat", "customer-support", "assistant", "widget"]
+dependencies = ["dash>=2.0"]
+
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Web Environment",
+    "Framework :: Dash",
+    "Framework :: Flask",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Internet :: WWW/HTTP :: Dynamic Content",
+]
+
+[project.urls]
+Homepage = "https://asyntai.com"
+Documentation = "https://asyntai.com/documentation/integrations/plotly-dash/"
+Source = "https://github.com/asyntai/dash-ai-chatbot"
+Issues = "https://github.com/asyntai/dash-ai-chatbot/issues"
+
+# Dash 3 and later load this module when an app starts. It does nothing
+# unless ASYNTAI_WIDGET_ID is set.
+[project.entry-points.dash_hooks]
+dash_ai_chatbot = "dash_ai_chatbot._hooks"
+
+[tool.setuptools.packages.find]
+where = ["src"]

dash_ai_chatbot-1.0.0/setup.cfg

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

dash_ai_chatbot-1.0.0/src/dash_ai_chatbot/__init__.py

@@ -0,0 +1,70 @@
+"""Asyntai AI chat assistant for Plotly Dash apps.
+
+Usage::
+
+    from dash import Dash, html
+    import dash_ai_chatbot
+
+    app = Dash(__name__)
+    app.layout = html.Div('Hello')
+    dash_ai_chatbot.init_app(app, widget_id='asyntai_ab12cd34')
+
+Or, on Dash 3 and later, set ``ASYNTAI_WIDGET_ID`` in the environment and
+change no code at all.
+"""
+from ._core import (
+    DEFAULT_SCRIPT_URL,
+    clean_script_url,
+    clean_widget_id,
+    insert_widget,
+    widget_snippet,
+)
+
+__version__ = '1.0.0'
+
+__all__ = [
+    'DEFAULT_SCRIPT_URL',
+    'clean_script_url',
+    'clean_widget_id',
+    'init_app',
+    'insert_widget',
+    'widget_snippet',
+]
+
+_FLAG = '_asyntai_widget_settings'
+
+
+def init_app(app, widget_id=None, script_url=None):
+    """Add the chat widget to every page of a Dash app.
+
+    ``widget_id`` is the ID from the Install page of the Asyntai dashboard,
+    or the whole snippet copied from there. When it is left out, the
+    ``ASYNTAI_WIDGET_ID`` environment variable is read each time the page is
+    built. ``script_url`` is only for a case where Asyntai support asks you
+    to change it.
+
+    Calling it twice on the same app only updates the values. The app is
+    returned, so the call can be chained.
+    """
+    if not hasattr(app, 'interpolate_index'):
+        raise TypeError('init_app() needs a dash.Dash app.')
+
+    settings = {'widget_id': widget_id, 'script_url': script_url}
+
+    if getattr(app, _FLAG, None) is not None:
+        getattr(app, _FLAG).update(settings)
+        return app
+
+    setattr(app, _FLAG, settings)
+    original = app.interpolate_index
+
+    def interpolate_index(**kwargs):
+        page = original(**kwargs)
+        current = getattr(app, _FLAG)
+        return insert_widget(page, current['widget_id'], current['script_url'])
+
+    # Wrapping the instance method works on Dash 2, 3 and 4, and it also
+    # works when the app sets its own index_string or overrides
+    # interpolate_index in a subclass.
+    app.interpolate_index = interpolate_index
+    return app

dash_ai_chatbot-1.0.0/src/dash_ai_chatbot/_core.py

@@ -0,0 +1,144 @@
+"""Everything the package decides about the widget lives here.
+
+Dash serves one HTML page for the whole app, built by ``Dash.interpolate_index``
+and then passed through the ``index`` hooks. The widget goes into that page
+once, just before the closing body tag, so it is on every view of the app,
+including multi-page apps built with ``dash.page_registry``.
+"""
+import html
+import os
+import re
+
+DEFAULT_SCRIPT_URL = 'https://widget.asyntai.com/static/js/chat-widget.js'
+
+#: Environment variables read when no value is passed in code.
+ENV_WIDGET_ID = 'ASYNTAI_WIDGET_ID'
+ENV_SCRIPT_URL = 'ASYNTAI_SCRIPT_URL'
+
+#: Marker that shows the widget is already on the page.
+MARKER = 'asyntai-widget-config'
+
+#: 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)
+
+BODY_CLOSE = '</body>'
+
+_LOADER = """<div class="asyntai-widget-config" data-asyntai-widget="{widget_id}" data-asyntai-src="{script_url}" style="display: none"></div>
+<script>
+    // Loads the Asyntai chat widget after the page has finished loading, so
+    // the Dash app draws first. The two values arrive on data attributes,
+    // because nothing is ever written into the script itself.
+    (function () {{
+        var config = document.querySelector('.asyntai-widget-config');
+        if (!config) {{ return; }}
+
+        var widgetId = config.getAttribute('data-asyntai-widget') || '';
+        var scriptUrl = config.getAttribute('data-asyntai-src') || '';
+        if (!widgetId || scriptUrl.indexOf('https://') !== 0) {{ return; }}
+
+        var load = function () {{
+            if (document.querySelector('script[data-asyntai-id]')) {{ return; }}
+
+            var script = document.createElement('script');
+            script.src = scriptUrl;
+            script.async = true;
+            script.setAttribute('data-asyntai-id', widgetId);
+            document.head.appendChild(script);
+        }};
+
+        if (document.readyState === 'complete') {{
+            load();
+        }} else {{
+            window.addEventListener('load', load);
+        }}
+    }}());
+</script>
+"""
+
+
+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.
+    """
+    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 the page. None or an empty 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 ''
+
+
+def widget_snippet(widget_id, script_url=None):
+    """Return the HTML that loads the widget, or an empty string.
+
+    The empty string comes back when the identifier or the address is not
+    valid, so a typo leaves the app as it was instead of breaking it.
+    """
+    clean_id = clean_widget_id(widget_id)
+    clean_url = clean_script_url(script_url)
+    if not clean_id or not clean_url:
+        return ''
+
+    return _LOADER.format(
+        widget_id=html.escape(clean_id, quote=True),
+        script_url=html.escape(clean_url, quote=True),
+    )
+
+
+def insert_widget(page, widget_id=None, script_url=None):
+    """Return the page with the widget added before the closing body tag.
+
+    Values passed in come first; missing ones are read from the environment
+    at the moment the page is built, so a deployment can change the ID
+    without a code change. The page is returned unchanged when there is no
+    valid ID, when it has no body tag, or when the widget is already on it.
+    """
+    if not isinstance(page, str) or MARKER in page:
+        return page
+
+    if widget_id is None:
+        widget_id = os.environ.get(ENV_WIDGET_ID, '')
+    if script_url is None:
+        script_url = os.environ.get(ENV_SCRIPT_URL) or None
+
+    snippet = widget_snippet(widget_id, script_url)
+    if not snippet or BODY_CLOSE not in page:
+        return page
+
+    # Split on the last closing tag, so a page that prints the tag inside an
+    # example or a code block is left alone.
+    head, _, tail = page.rpartition(BODY_CLOSE)
+    return head + snippet + BODY_CLOSE + tail

dash_ai_chatbot-1.0.0/src/dash_ai_chatbot/_hooks.py

@@ -0,0 +1,25 @@
+"""Zero-code mode for Dash 3 and later.
+
+Dash loads every module named in a ``dash_hooks`` entry point when an app
+starts. This one registers an ``index`` hook, so the widget appears on every
+Dash app on the machine once ``ASYNTAI_WIDGET_ID`` is set, with no code
+change. Without that variable the hook leaves every page as it was.
+
+Older Dash versions have no hooks; there ``init_app`` does the same job.
+"""
+from ._core import insert_widget
+
+try:
+    from dash import hooks
+except ImportError:  # Dash 2 has no hooks module.
+    hooks = None
+
+
+def _add_widget(page):
+    # Only the environment is read here. An app that called init_app() has
+    # already got the widget, and insert_widget() sees the marker and stops.
+    return insert_widget(page)
+
+
+if hooks is not None and hasattr(hooks, 'index'):
+    hooks.index()(_add_widget)

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

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: dash-ai-chatbot
+Version: 1.0.0
+Summary: Adds the Asyntai AI chat assistant to a Plotly Dash app. 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/plotly-dash/
+Project-URL: Source, https://github.com/asyntai/dash-ai-chatbot
+Project-URL: Issues, https://github.com/asyntai/dash-ai-chatbot/issues
+Keywords: dash,plotly,plotly-dash,chatbot,ai,ai-chatbot,live-chat,customer-support,assistant,widget
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Dash
+Classifier: Framework :: Flask
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dash>=2.0
+Dynamic: license-file
+
+# dash-ai-chatbot
+
+Adds the [Asyntai](https://asyntai.com) AI chat assistant to a
+[Plotly Dash](https://dash.plotly.com) app. 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 Dash 2.0 or newer and Python 3.10 or newer
+- Documentation: https://asyntai.com/documentation/integrations/plotly-dash/
+
+## Install
+
+```
+pip install dash-ai-chatbot
+```
+
+Add one line after you create the app:
+
+```python
+from dash import Dash, html
+import dash_ai_chatbot
+
+app = Dash(__name__)
+app.layout = html.Div("Hello")
+
+dash_ai_chatbot.init_app(app, widget_id="asyntai_ab12cd34")
+
+if __name__ == "__main__":
+    app.run()
+```
+
+You get the 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 page of the app, including
+multi-page apps.
+
+## No code change (Dash 3 and later)
+
+On Dash 3 and later the package also works with no code change. Install it and
+set one environment variable:
+
+```
+ASYNTAI_WIDGET_ID=asyntai_ab12cd34
+```
+
+Every Dash app that runs with that variable gets the chat. Without the
+variable the package does nothing.
+
+## Keep the ID out of the code
+
+Leave out `widget_id` and the package reads `ASYNTAI_WIDGET_ID` each time the
+page is built:
+
+```python
+dash_ai_chatbot.init_app(app)
+```
+
+## Options
+
+```python
+dash_ai_chatbot.init_app(
+    app,
+    widget_id="asyntai_ab12cd34",  # or the whole snippet; empty or invalid = chat off
+    script_url=None,               # change only if Asyntai support asks you to
+)
+```
+
+`script_url` can also come from the `ASYNTAI_SCRIPT_URL` environment variable.
+Only an `https` address is accepted.
+
+## How it works
+
+Dash serves one HTML page for the whole app. The package puts a small script
+just before the closing body tag of that page. The script waits for the page to
+finish loading, then fetches the chat widget from Asyntai, so your app draws
+first and its speed is unchanged.
+
+The widget ID and the script address travel to the browser on a data
+attribute, never inside the script. The package works with a custom
+`index_string`, with a subclass that overrides `interpolate_index`, and with
+`url_base_pathname`. It never adds the widget twice.
+
+## Tests
+
+```
+pip install -e . pytest
+pytest
+```
+
+## Support
+
+hello@asyntai.com
+
+## Licence
+
+MIT. See [LICENSE](LICENSE).

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

@@ -0,0 +1,15 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+src/dash_ai_chatbot/__init__.py
+src/dash_ai_chatbot/_core.py
+src/dash_ai_chatbot/_hooks.py
+src/dash_ai_chatbot.egg-info/PKG-INFO
+src/dash_ai_chatbot.egg-info/SOURCES.txt
+src/dash_ai_chatbot.egg-info/dependency_links.txt
+src/dash_ai_chatbot.egg-info/entry_points.txt
+src/dash_ai_chatbot.egg-info/requires.txt
+src/dash_ai_chatbot.egg-info/top_level.txt
+tests/test_core.py
+tests/test_dash_app.py

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

@@ -0,0 +1 @@
+

dash_ai_chatbot-1.0.0/src/dash_ai_chatbot.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[dash_hooks]
+dash_ai_chatbot = dash_ai_chatbot._hooks

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

@@ -0,0 +1 @@
+dash>=2.0

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

@@ -0,0 +1 @@
+dash_ai_chatbot

dash_ai_chatbot-1.0.0/tests/test_core.py

@@ -0,0 +1,119 @@
+"""The rules for the two stored values and for placing the widget."""
+import pytest
+
+from dash_ai_chatbot import (
+    DEFAULT_SCRIPT_URL,
+    clean_script_url,
+    clean_widget_id,
+    insert_widget,
+    widget_snippet,
+)
+
+PAGE = '<!DOCTYPE html><html><head></head><body><div id="react-entry-point"></div></body></html>'
+
+
+@pytest.fixture(autouse=True)
+def no_env(monkeypatch):
+    monkeypatch.delenv('ASYNTAI_WIDGET_ID', raising=False)
+    monkeypatch.delenv('ASYNTAI_SCRIPT_URL', raising=False)
+
+
+@pytest.mark.parametrize('raw, expected', [
+    ('asyntai_ab12cd34', 'asyntai_ab12cd34'),
+    ('  asyntai_ab12cd34  ', 'asyntai_ab12cd34'),
+    ('<script async src="https://widget.asyntai.com/static/js/chat-widget.js" data-asyntai-id="asyntai_ab12cd34"></script>', 'asyntai_ab12cd34'),
+    ("<script data-asyntai-id='asyntai_ab12cd34'></script>", 'asyntai_ab12cd34'),
+    ('asyntai_' + 'a' * 64, 'asyntai_' + 'a' * 64),
+])
+def test_good_ids_are_kept(raw, expected):
+    assert clean_widget_id(raw) == expected
+
+
+@pytest.mark.parametrize('raw', [
+    '', '   ', None, 123, ['asyntai_ab12cd34'],
+    'ab12cd34', 'asyntai_', 'asyntai_ab12', 'asyntai_' + 'a' * 65,
+    'asyntai_ab12cd34"><script>alert(1)</script>', 'asyntai_ab-12cd34',
+])
+def test_bad_ids_switch_the_chat_off(raw):
+    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
+    assert clean_script_url('   ') == DEFAULT_SCRIPT_URL
+
+
+def test_only_https_script_urls_are_accepted():
+    assert clean_script_url('https://cdn.example.com/w.js') == 'https://cdn.example.com/w.js'
+    for bad in ['http://cdn.example.com/w.js', 'javascript:alert(1)', '//cdn.example.com/w.js',
+                'https://a.com/"onload="x', 'https://a.com/w.js x', 42]:
+        assert clean_script_url(bad) == ''
+
+
+def test_snippet_carries_the_values_on_data_attributes():
+    snippet = widget_snippet('asyntai_ab12cd34')
+    assert 'data-asyntai-widget="asyntai_ab12cd34"' in snippet
+    assert 'data-asyntai-src="%s"' % DEFAULT_SCRIPT_URL in snippet
+    script = snippet[snippet.index('<script>'):]
+    assert 'asyntai_ab12cd34' not in script
+
+
+def test_snippet_is_empty_for_bad_values():
+    assert widget_snippet('nope') == ''
+    assert widget_snippet('asyntai_ab12cd34', 'http://x.com/w.js') == ''
+
+
+def test_snippet_escapes_the_script_address():
+    snippet = widget_snippet('asyntai_ab12cd34', 'https://cdn.example.com/w.js?a=1&b=2')
+    assert 'data-asyntai-src="https://cdn.example.com/w.js?a=1&amp;b=2"' in snippet
+
+
+def test_widget_goes_just_before_the_last_body_tag():
+    page = PAGE.replace('<body>', '<body><pre>&lt;/body&gt; </body> in a sample</pre>')
+    result = insert_widget(page, 'asyntai_ab12cd34')
+    assert result.count('class="asyntai-widget-config"') == 1
+    assert result.endswith('</script>\n</body></html>')
+    assert result.index('in a sample') < result.index('asyntai-widget-config')
+
+
+def test_page_is_unchanged_without_a_valid_id():
+    assert insert_widget(PAGE) == PAGE
+    assert insert_widget(PAGE, 'bad') == PAGE
+    assert insert_widget(PAGE, '') == PAGE
+
+
+def test_page_without_body_tag_is_unchanged():
+    page = '<div>partial</div>'
+    assert insert_widget(page, 'asyntai_ab12cd34') == page
+
+
+def test_widget_is_never_added_twice():
+    once = insert_widget(PAGE, 'asyntai_ab12cd34')
+    assert insert_widget(once, 'asyntai_zz99yy88') == once
+
+
+def test_non_string_page_is_returned_as_is():
+    assert insert_widget(None, 'asyntai_ab12cd34') is None
+
+
+def test_environment_is_used_when_no_id_is_passed(monkeypatch):
+    monkeypatch.setenv('ASYNTAI_WIDGET_ID', 'asyntai_env12345')
+    assert 'data-asyntai-widget="asyntai_env12345"' in insert_widget(PAGE)
+
+
+def test_passed_id_beats_the_environment(monkeypatch):
+    monkeypatch.setenv('ASYNTAI_WIDGET_ID', 'asyntai_env12345')
+    result = insert_widget(PAGE, 'asyntai_code1234')
+    assert 'asyntai_code1234' in result
+    assert 'asyntai_env12345' not in result
+
+
+def test_script_address_can_come_from_the_environment(monkeypatch):
+    monkeypatch.setenv('ASYNTAI_SCRIPT_URL', 'https://cdn.example.com/w.js')
+    assert 'data-asyntai-src="https://cdn.example.com/w.js"' in insert_widget(PAGE, 'asyntai_ab12cd34')
+
+
+def test_bad_script_address_in_the_environment_keeps_the_chat_off(monkeypatch):
+    monkeypatch.setenv('ASYNTAI_SCRIPT_URL', 'http://cdn.example.com/w.js')
+    assert insert_widget(PAGE, 'asyntai_ab12cd34') == PAGE

dash_ai_chatbot-1.0.0/tests/test_dash_app.py

@@ -0,0 +1,175 @@
+"""The widget on the page a real Dash app serves."""
+import os
+import shutil
+import subprocess
+import tempfile
+
+import dash
+import pytest
+from dash import Dash, html
+
+import dash_ai_chatbot
+
+WIDGET = 'class="asyntai-widget-config"'
+HAS_HOOKS = hasattr(dash, 'hooks') and hasattr(getattr(dash, 'hooks'), 'index')
+
+
+@pytest.fixture(autouse=True)
+def no_env(monkeypatch):
+    monkeypatch.delenv('ASYNTAI_WIDGET_ID', raising=False)
+    monkeypatch.delenv('ASYNTAI_SCRIPT_URL', raising=False)
+
+
+def make_app(**kwargs):
+    app = Dash(__name__, **kwargs)
+    app.layout = html.Div('Hello from Dash', id='hello')
+    return app
+
+
+def page(app, path='/'):
+    response = app.server.test_client().get(path)
+    assert response.status_code == 200
+    return response.get_data(as_text=True)
+
+
+def test_init_app_puts_the_widget_on_the_page():
+    app = make_app()
+    assert dash_ai_chatbot.init_app(app, widget_id='asyntai_ab12cd34') is app
+
+    body = page(app)
+    assert body.count(WIDGET) == 1
+    assert 'data-asyntai-widget="asyntai_ab12cd34"' in body
+    # Dash's own parts are still there, so the app still starts.
+    assert 'id="react-entry-point"' in body
+    assert body.index(WIDGET) > body.index('id="react-entry-point"')
+    assert body.rstrip().endswith('</html>')
+
+
+def test_a_pasted_snippet_works():
+    app = make_app()
+    dash_ai_chatbot.init_app(app, widget_id='<script async src="x" data-asyntai-id="asyntai_ab12cd34"></script>')
+    assert 'data-asyntai-widget="asyntai_ab12cd34"' in page(app)
+
+
+def test_a_bad_id_leaves_the_app_as_it_was():
+    # Dash 4 puts a fresh token on every page, so two loads never match
+    # byte for byte. Check that nothing of ours is on the page instead.
+    app = make_app()
+    dash_ai_chatbot.init_app(app, widget_id='not-an-id')
+    body = page(app)
+    assert 'asyntai' not in body.lower()
+    assert 'id="react-entry-point"' in body
+
+
+def test_calling_init_app_twice_only_updates_the_id():
+    app = make_app()
+    dash_ai_chatbot.init_app(app, widget_id='asyntai_first123')
+    dash_ai_chatbot.init_app(app, widget_id='asyntai_second12')
+    body = page(app)
+    assert body.count(WIDGET) == 1
+    assert 'asyntai_second12' in body
+    assert 'asyntai_first123' not in body
+
+
+def test_init_app_reads_the_environment_on_each_page_build(monkeypatch):
+    app = make_app()
+    dash_ai_chatbot.init_app(app)
+    assert WIDGET not in page(app)
+
+    monkeypatch.setenv('ASYNTAI_WIDGET_ID', 'asyntai_env12345')
+    assert 'data-asyntai-widget="asyntai_env12345"' in page(app)
+
+
+def test_init_app_rejects_something_that_is_not_an_app():
+    with pytest.raises(TypeError):
+        dash_ai_chatbot.init_app(object(), widget_id='asyntai_ab12cd34')
+
+
+def test_custom_index_string():
+    app = make_app()
+    app.index_string = """<!DOCTYPE html>
+<html>
+    <head>{%metas%}<title>Custom</title>{%favicon%}{%css%}</head>
+    <body>
+        <header>My header</header>
+        {%app_entry%}
+        <footer>{%config%}{%scripts%}{%renderer%}</footer>
+    </body>
+</html>"""
+    dash_ai_chatbot.init_app(app, widget_id='asyntai_ab12cd34')
+    body = page(app)
+    assert 'My header' in body
+    assert body.count(WIDGET) == 1
+    assert body.index('</footer>') < body.index(WIDGET)
+
+
+def test_subclass_that_overrides_interpolate_index():
+    class MyDash(Dash):
+        def interpolate_index(self, **kwargs):
+            return (
+                '<!DOCTYPE html><html><head>{metas}{title}{favicon}{css}</head>'
+                '<body><p>Subclass page</p>{app_entry}{config}{scripts}{renderer}</body></html>'
+            ).format(**kwargs)
+
+    app = MyDash(__name__)
+    app.layout = html.Div('x')
+    dash_ai_chatbot.init_app(app, widget_id='asyntai_ab12cd34')
+    body = page(app)
+    assert 'Subclass page' in body
+    assert body.count(WIDGET) == 1
+
+
+def test_url_base_pathname():
+    app = make_app(url_base_pathname='/reports/')
+    dash_ai_chatbot.init_app(app, widget_id='asyntai_ab12cd34')
+    assert WIDGET in page(app, '/reports/')
+
+
+def test_two_apps_keep_their_own_ids():
+    one, two = make_app(), make_app()
+    dash_ai_chatbot.init_app(one, widget_id='asyntai_appone12')
+    dash_ai_chatbot.init_app(two, widget_id='asyntai_apptwo12')
+    assert 'asyntai_appone12' in page(one) and 'asyntai_apptwo12' not in page(one)
+    assert 'asyntai_apptwo12' in page(two) and 'asyntai_appone12' not in page(two)
+
+
+@pytest.mark.skipif(not HAS_HOOKS, reason='this Dash version has no hooks')
+def test_no_code_mode_needs_the_environment_variable(monkeypatch):
+    app = make_app()
+    assert WIDGET not in page(app)
+
+    monkeypatch.setenv('ASYNTAI_WIDGET_ID', 'asyntai_env12345')
+    body = page(make_app())
+    assert body.count(WIDGET) == 1
+    assert 'data-asyntai-widget="asyntai_env12345"' in body
+
+
+@pytest.mark.skipif(not HAS_HOOKS, reason='this Dash version has no hooks')
+def test_init_app_and_no_code_mode_never_add_two_widgets(monkeypatch):
+    monkeypatch.setenv('ASYNTAI_WIDGET_ID', 'asyntai_env12345')
+    app = make_app()
+    dash_ai_chatbot.init_app(app, widget_id='asyntai_code1234')
+    body = page(app)
+    assert body.count(WIDGET) == 1
+    assert 'asyntai_code1234' in body
+
+
+def test_the_script_on_the_page_parses():
+    node = shutil.which('node')
+    if not node:
+        pytest.skip('node is not installed')
+
+    app = make_app()
+    dash_ai_chatbot.init_app(app, widget_id='asyntai_ab12cd34')
+    body = page(app)
+    start = body.index('<script>', body.index(WIDGET)) + len('<script>')
+    source = body[start:body.index('</script>', start)]
+
+    handle, path = tempfile.mkstemp(suffix='.js')
+    with os.fdopen(handle, 'w', encoding='utf-8') as fh:
+        fh.write(source)
+    try:
+        result = subprocess.run([node, '--check', path], capture_output=True, text=True)
+    finally:
+        os.unlink(path)
+    assert result.returncode == 0, result.stderr