pluggle-interface-streamlit 0.1.0__tar.gz

pluggle_interface_streamlit-0.1.0/LICENSE

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

pluggle_interface_streamlit-0.1.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: pluggle-interface-streamlit
+Version: 0.1.0
+Summary: Browser-based dashboard for Pluggle — run and inspect ETL pipelines interactively, powered by Streamlit.
+Author: hsnwhte
+License: MIT
+Project-URL: Homepage, https://pluggle.org
+Project-URL: Repository, https://github.com/hsnwhte/pluggle-interface-streamlit
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3.14
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pluggle>=0.13.0
+Requires-Dist: streamlit>=1.62
+Provides-Extra: dev
+Requires-Dist: ruff>=0.16; extra == "dev"
+Dynamic: license-file
+
+# pluggle-interface-streamlit
+
+A browser-based dashboard for [Pluggle](https://pluggle.org) — run and inspect ETL
+pipelines interactively, powered by Streamlit.
+
+Pluggle is a plugin-based ETL/sync engine with a CLI and a programmatic API. This
+package adds a third way to drive it: a local web interface where you can configure a
+pipeline, run it, and manage installed transform strategies without touching the command
+line.
+
+It is a one-way consumer of Pluggle — Pluggle has no knowledge of this package and does
+not discover it at runtime. Everything goes through Pluggle's declared public interface
+(`pluggle.interfaces.api`), never through its internals.
+
+## Install
+
+```bash
+pip install pluggle-interface-streamlit
+```
+
+Pluggle is pulled in as a dependency. Python 3.14 or newer is required.
+
+For local development:
+
+```bash
+git clone https://github.com/hsnwhte/pluggle-interface-streamlit
+cd pluggle-interface-streamlit
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+```
+
+## Running
+
+```bash
+streamlit run src/pluggle_interface_streamlit/app.py
+```
+
+The app opens at `http://localhost:8501`.
+
+Run this from the project root. The working directory determines where `data/`
+is created and where the theme in `.streamlit/config.toml` is read from.
+
+## Pages
+
+**Run** — configure and execute a pipeline. Mirrors the CLI's `run` command:
+source and target type (file, db, api), addresses, table names for database endpoints,
+the transform strategy, and the output format. The target address is prefilled with a
+timestamped path under `data/outputs/` when the target is a file.
+
+**Strategies** — browse the curated
+[pluggle-strategies](https://github.com/hsnwhte/pluggle-strategies) catalog, read a
+strategy's README before installing it, install from the catalog or from a local `.py`
+file, and remove installed strategies. The built-in
+`default_v1.0` passthrough strategy cannot be removed.
+
+## Configuration
+
+All runtime data — the SQLite store, installed strategies, logs, uploads and pipeline
+outputs — is created under a `data/` folder in the directory you run the app from.
+
+Log output is fixed to `data/logs` by this package so that every runtime artifact sits
+in one place; it is not configurable.
+
+The remaining Pluggle paths can be overridden with a `.env` file in your working
+directory:
+
+```env
+PLUGGLE_STORE_ADDRESS=sqlite:///data/runtime.sqlite
+PLUGGLE_STRATEGIES_DIR=data/strategies
+```
+
+Pluggle reads these via `os.environ.get(...)` at import time, so no code changes are
+needed.
+
+SQLite is the default store and is sufficient here: this is a single-user local tool
+with none of the concurrent-write exposure that would call for PostgreSQL.
+
+### Theme
+
+Colours come from `.streamlit/config.toml` in the working directory. Streamlit exposes
+five theme variables; edit `primaryColor` to change the accent used by buttons, selected
+rows, and links.
+
+## Project layout
+
+```
+src/pluggle_interface_streamlit/
+├── app.py              # landing page
+├── settings.py         # package paths (assets, uploads, outputs)
+├── assets/             # logo and icon
+└── pages/
+    ├── 1_Run.py
+    └── 2_Strategies.py
+```
+
+`settings.py` distinguishes two roots: `PACKAGE_ROOT` for files shipped with the package
+(assets), and `RUNTIME_ROOT` (`Path.cwd()`) for anything created while running.
+Pluggle's own `settings.py` handles the `mkdir` calls for its directories on import, so
+there is no bootstrap step.
+
+## Scope
+
+This package is a generic interface — it runs whatever strategies you have installed and
+makes no assumptions about your data. It is not a hosted service; for a deployed demo of
+Pluggle, see
+[pluggle.org](https://pluggle.org).
+
+There are no automated tests. Almost nothing here is more than a Streamlit widget call
+or a thin pass through to `pluggle.interfaces.api`; the engine's own test suite covers
+the logic, and Streamlit's `AppTest` would be brittle against any widget reordering.
+Both pages are verified manually end to end.
+
+## License
+
+MIT

pluggle_interface_streamlit-0.1.0/README.md

@@ -0,0 +1,115 @@
+# pluggle-interface-streamlit
+
+A browser-based dashboard for [Pluggle](https://pluggle.org) — run and inspect ETL
+pipelines interactively, powered by Streamlit.
+
+Pluggle is a plugin-based ETL/sync engine with a CLI and a programmatic API. This
+package adds a third way to drive it: a local web interface where you can configure a
+pipeline, run it, and manage installed transform strategies without touching the command
+line.
+
+It is a one-way consumer of Pluggle — Pluggle has no knowledge of this package and does
+not discover it at runtime. Everything goes through Pluggle's declared public interface
+(`pluggle.interfaces.api`), never through its internals.
+
+## Install
+
+```bash
+pip install pluggle-interface-streamlit
+```
+
+Pluggle is pulled in as a dependency. Python 3.14 or newer is required.
+
+For local development:
+
+```bash
+git clone https://github.com/hsnwhte/pluggle-interface-streamlit
+cd pluggle-interface-streamlit
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+```
+
+## Running
+
+```bash
+streamlit run src/pluggle_interface_streamlit/app.py
+```
+
+The app opens at `http://localhost:8501`.
+
+Run this from the project root. The working directory determines where `data/`
+is created and where the theme in `.streamlit/config.toml` is read from.
+
+## Pages
+
+**Run** — configure and execute a pipeline. Mirrors the CLI's `run` command:
+source and target type (file, db, api), addresses, table names for database endpoints,
+the transform strategy, and the output format. The target address is prefilled with a
+timestamped path under `data/outputs/` when the target is a file.
+
+**Strategies** — browse the curated
+[pluggle-strategies](https://github.com/hsnwhte/pluggle-strategies) catalog, read a
+strategy's README before installing it, install from the catalog or from a local `.py`
+file, and remove installed strategies. The built-in
+`default_v1.0` passthrough strategy cannot be removed.
+
+## Configuration
+
+All runtime data — the SQLite store, installed strategies, logs, uploads and pipeline
+outputs — is created under a `data/` folder in the directory you run the app from.
+
+Log output is fixed to `data/logs` by this package so that every runtime artifact sits
+in one place; it is not configurable.
+
+The remaining Pluggle paths can be overridden with a `.env` file in your working
+directory:
+
+```env
+PLUGGLE_STORE_ADDRESS=sqlite:///data/runtime.sqlite
+PLUGGLE_STRATEGIES_DIR=data/strategies
+```
+
+Pluggle reads these via `os.environ.get(...)` at import time, so no code changes are
+needed.
+
+SQLite is the default store and is sufficient here: this is a single-user local tool
+with none of the concurrent-write exposure that would call for PostgreSQL.
+
+### Theme
+
+Colours come from `.streamlit/config.toml` in the working directory. Streamlit exposes
+five theme variables; edit `primaryColor` to change the accent used by buttons, selected
+rows, and links.
+
+## Project layout
+
+```
+src/pluggle_interface_streamlit/
+├── app.py              # landing page
+├── settings.py         # package paths (assets, uploads, outputs)
+├── assets/             # logo and icon
+└── pages/
+    ├── 1_Run.py
+    └── 2_Strategies.py
+```
+
+`settings.py` distinguishes two roots: `PACKAGE_ROOT` for files shipped with the package
+(assets), and `RUNTIME_ROOT` (`Path.cwd()`) for anything created while running.
+Pluggle's own `settings.py` handles the `mkdir` calls for its directories on import, so
+there is no bootstrap step.
+
+## Scope
+
+This package is a generic interface — it runs whatever strategies you have installed and
+makes no assumptions about your data. It is not a hosted service; for a deployed demo of
+Pluggle, see
+[pluggle.org](https://pluggle.org).
+
+There are no automated tests. Almost nothing here is more than a Streamlit widget call
+or a thin pass through to `pluggle.interfaces.api`; the engine's own test suite covers
+the logic, and Streamlit's `AppTest` would be brittle against any widget reordering.
+Both pages are verified manually end to end.
+
+## License
+
+MIT

pluggle_interface_streamlit-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+name = "pluggle-interface-streamlit"
+version = "0.1.0"
+description = "Browser-based dashboard for Pluggle — run and inspect ETL pipelines interactively, powered by Streamlit."
+readme = "README.md"
+requires-python = ">=3.14"
+license = { text = "MIT" }
+authors = [
+    { name = "hsnwhte" }
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3.14",
+    "License :: OSI Approved :: MIT License",
+]
+dependencies = [
+    "pluggle>=0.13.0",
+    "streamlit>=1.62",
+]
+
+[project.optional-dependencies]
+dev = ["ruff>=0.16"]
+
+[project.urls]
+Homepage = "https://pluggle.org"
+Repository = "https://github.com/hsnwhte/pluggle-interface-streamlit"

pluggle_interface_streamlit-0.1.0/setup.cfg

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

pluggle_interface_streamlit-0.1.0/src/pluggle_interface_streamlit/app.py

@@ -0,0 +1,23 @@
+from importlib.metadata import version as lib_version
+
+import streamlit as st
+from pluggle.interfaces.api import api
+
+from pluggle_interface_streamlit.settings import ASSETS_DIR
+
+st.set_page_config(page_title="Pluggle", page_icon=str(ASSETS_DIR / "logo.svg"))
+st.logo(str(ASSETS_DIR / "logo.svg"))
+
+st.title("Pluggle")
+
+st.markdown("""
+Interactive browser interface for the **Pluggle** ETL engine.
+
+- **Run** — execute a pipeline from source to target
+- **Strategies** — browse the catalog, install and remove transform strategies
+""")
+
+col1, col2, col3 = st.columns(3)
+col1.metric("Installed strategies", len(api.list_installed_strategies()))
+col2.metric("Available in catalog", len(api.get_repo_catalog()))
+col3.metric("Pluggle version", lib_version("pluggle"))

pluggle_interface_streamlit-0.1.0/src/pluggle_interface_streamlit/pages/1_Run.py

@@ -0,0 +1,76 @@
+from datetime import datetime
+
+import streamlit as st
+from pluggle.enums import ContentFormat, PluggleIOType
+from pluggle.exceptions import errors
+from pluggle.interfaces.api import api
+from pluggle.models.dto import InputArgs
+from pydantic import ValidationError
+
+from pluggle_interface_streamlit.settings import ASSETS_DIR, OUTPUTS_DIR
+
+st.set_page_config(page_title="Pluggle", page_icon=str(ASSETS_DIR / "logo.svg"))
+st.logo(str(ASSETS_DIR / "logo.svg"))
+
+st.title("Run Pipeline")
+
+source_type = st.radio(
+    "Source Type",
+    options=list(PluggleIOType),
+    format_func=lambda x: x.value,
+    horizontal=True,
+)
+source_address = st.text_input(
+    "Source Address", placeholder="Enter filepath or URL...", value=""
+)
+source_table = st.text_input("Source Table (database only)")
+installed = api.list_installed_strategies()
+transform_strategy_name = st.selectbox("Transform Strategy", options=installed)
+
+target_type = st.radio(
+    "Target Type",
+    options=list(PluggleIOType),
+    format_func=lambda x: x.value,
+    horizontal=True,
+)
+
+target_table = st.text_input("Target Table (database only)")
+target_format = st.selectbox(
+    "Target Format",
+    options=list(ContentFormat),
+    index=0,
+    format_func=lambda x: x.value,
+)
+output_file = str(
+    OUTPUTS_DIR
+    / f"output_{datetime.now().strftime('%Y%m%d_%H%M%S')}.{target_format.value}"
+)
+target_address = st.text_input(
+    "Target Address",
+    placeholder="Enter filepath or URL...",
+    value=output_file if target_type == PluggleIOType.FILE else "",
+)
+
+if st.button("▶ Run", type="primary"):
+    try:
+        input_args = InputArgs(
+            source_type=source_type,
+            source_address=source_address,
+            source_table=source_table,
+            transform_strategy_name=transform_strategy_name,
+            target_type=target_type,
+            target_address=target_address,
+            target_table=target_table,
+            target_format=target_format,
+        )
+    except (ValidationError, AttributeError) as e:
+        st.error(f"Invalid input: {e}")
+    else:
+        try:
+            entry_id = api.run(input_args=input_args)
+        except errors.PluggleError as e:
+            st.error(f"Pipeline failed: {e}")
+        except Exception as e:
+            st.error(f"Unexpected error: {e}")
+        else:
+            st.success(f"Success. Entry id: {entry_id}")

pluggle_interface_streamlit-0.1.0/src/pluggle_interface_streamlit/pages/2_Strategies.py

@@ -0,0 +1,137 @@
+from pathlib import Path
+
+import streamlit as st
+from pluggle.exceptions import errors
+from pluggle.interfaces.api import api
+
+from pluggle_interface_streamlit.settings import ASSETS_DIR, UPLOADS_DIR
+
+st.set_page_config(page_title="Pluggle", page_icon=str(ASSETS_DIR / "logo.svg"))
+st.logo(str(ASSETS_DIR / "logo.svg"))
+
+
+@st.dialog("README", width="large")
+def show_readme(name: str, content: str):
+    st.subheader(name)
+    st.markdown(content)
+
+
+st.title("Strategies")
+msg = st.session_state.pop("flash", None)
+if msg:
+    st.success(msg)
+
+installed = api.list_installed_strategies()
+
+catalog = api.get_repo_catalog()
+catalog_normalized = [
+    {"name": name, "status": "installed" if name in installed else "", **info}
+    for name, info in catalog.items()
+]
+
+st.subheader("Available Strategies (Repo)")
+event = st.dataframe(
+    catalog_normalized,
+    width="stretch",
+    on_select="rerun",
+    selection_mode="single-row",
+    row_height=80,
+    column_order=["name", "status", "author", "source_hint", "target_hint", "summary"],
+    column_config={
+        "name": st.column_config.TextColumn("Strategy Name", width="medium"),
+        "status": st.column_config.TextColumn("Status", width="small"),
+        "author": st.column_config.TextColumn("Author", width="small"),
+        "source_hint": st.column_config.TextColumn("Source", width="small"),
+        "target_hint": st.column_config.TextColumn("Target", width="small"),
+        "summary": st.column_config.TextColumn("Summary", width="large"),
+    },
+    hide_index=True,
+)
+
+
+col_install_from_repo, col_readme, _ = st.columns([1, 1, 3])
+
+with col_install_from_repo:
+    install_from_repo_clicked = st.button(
+        "Install from Repo", type="primary", width="stretch"
+    )
+if install_from_repo_clicked:
+    if not event.selection.rows:
+        st.warning("Select a strategy first.")
+    else:
+        selected = catalog_normalized[event.selection.rows[0]]
+        try:
+            new_name = api.install_from_repo(strategy_name=selected["name"])
+        except errors.StrategySetupError as e:
+            st.error(f"Install failed: {e}")
+        else:
+            st.session_state.flash = f"Installed: {new_name}"
+            st.rerun()
+
+with col_readme:
+    readme_clicked = st.button("Show README", width="stretch")
+if readme_clicked:
+    if not event.selection.rows:
+        st.warning("Select a strategy first.")
+    else:
+        selected = catalog_normalized[event.selection.rows[0]]
+        try:
+            readme = api.get_readme_from_repo(strategy_name=selected["name"])
+            content = readme.read_text(encoding="utf-8")
+            show_readme(selected["name"], content)
+        except errors.StrategySetupError as e:
+            st.error(f"Could not get README: {e}")
+
+
+st.divider()
+
+st.subheader("Install from File")
+
+
+if "upload_counter" not in st.session_state:
+    st.session_state.upload_counter = 0
+
+uploaded = st.file_uploader(
+    "Strategy File",
+    type=["py"],
+    key=f"strategy_upload_{st.session_state.upload_counter}",
+    accept_multiple_files=False,
+)
+col_install_from_file, _, _ = st.columns([1, 1, 3])
+with col_install_from_file:
+    install_from_file_clicked = st.button(
+        "Install from File", type="primary", width="stretch"
+    )
+
+if install_from_file_clicked:
+    if uploaded is None:
+        st.warning("Select a file first.")
+    else:
+        target = UPLOADS_DIR / uploaded.name
+        target.write_bytes(uploaded.getvalue())
+        try:
+            new_name = api.install_from_path(file_path=Path(target))
+        except errors.StrategySetupError as e:
+            st.error(f"Install failed: {e}")
+        else:
+            st.session_state.flash = f"Installed: {new_name}"
+            st.session_state.upload_counter += 1
+            st.rerun()
+
+
+st.divider()
+
+st.subheader("Installed Strategies")
+for name in installed:
+    col_name, col_action = st.columns([4, 1])
+    col_name.text(name)
+    if col_action.button(
+        "🗑 Remove", key=f"try_remove_{name}", disabled=(name == "default_v1.0")
+    ):
+        try:
+            api.uninstall_strategy(strategy_name=name)
+        except errors.StrategySetupError as e:
+            st.error(f"Uninstall failed: {e}")
+        else:
+            st.session_state.flash = f"Removed: {name}"
+            st.rerun()

pluggle_interface_streamlit-0.1.0/src/pluggle_interface_streamlit/settings.py

@@ -0,0 +1,12 @@
+from pathlib import Path
+
+RUNTIME_ROOT = Path.cwd()
+
+PACKAGE_ROOT = Path(__file__).resolve().parent
+ASSETS_DIR = PACKAGE_ROOT / "assets"
+
+OUTPUTS_DIR = RUNTIME_ROOT / "data" / "outputs"
+OUTPUTS_DIR.mkdir(parents=True, exist_ok=True)
+
+UPLOADS_DIR = RUNTIME_ROOT / "data" / "uploads"
+UPLOADS_DIR.mkdir(parents=True, exist_ok=True)

pluggle_interface_streamlit-0.1.0/src/pluggle_interface_streamlit.egg-info/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: pluggle-interface-streamlit
+Version: 0.1.0
+Summary: Browser-based dashboard for Pluggle — run and inspect ETL pipelines interactively, powered by Streamlit.
+Author: hsnwhte
+License: MIT
+Project-URL: Homepage, https://pluggle.org
+Project-URL: Repository, https://github.com/hsnwhte/pluggle-interface-streamlit
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3.14
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pluggle>=0.13.0
+Requires-Dist: streamlit>=1.62
+Provides-Extra: dev
+Requires-Dist: ruff>=0.16; extra == "dev"
+Dynamic: license-file
+
+# pluggle-interface-streamlit
+
+A browser-based dashboard for [Pluggle](https://pluggle.org) — run and inspect ETL
+pipelines interactively, powered by Streamlit.
+
+Pluggle is a plugin-based ETL/sync engine with a CLI and a programmatic API. This
+package adds a third way to drive it: a local web interface where you can configure a
+pipeline, run it, and manage installed transform strategies without touching the command
+line.
+
+It is a one-way consumer of Pluggle — Pluggle has no knowledge of this package and does
+not discover it at runtime. Everything goes through Pluggle's declared public interface
+(`pluggle.interfaces.api`), never through its internals.
+
+## Install
+
+```bash
+pip install pluggle-interface-streamlit
+```
+
+Pluggle is pulled in as a dependency. Python 3.14 or newer is required.
+
+For local development:
+
+```bash
+git clone https://github.com/hsnwhte/pluggle-interface-streamlit
+cd pluggle-interface-streamlit
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+```
+
+## Running
+
+```bash
+streamlit run src/pluggle_interface_streamlit/app.py
+```
+
+The app opens at `http://localhost:8501`.
+
+Run this from the project root. The working directory determines where `data/`
+is created and where the theme in `.streamlit/config.toml` is read from.
+
+## Pages
+
+**Run** — configure and execute a pipeline. Mirrors the CLI's `run` command:
+source and target type (file, db, api), addresses, table names for database endpoints,
+the transform strategy, and the output format. The target address is prefilled with a
+timestamped path under `data/outputs/` when the target is a file.
+
+**Strategies** — browse the curated
+[pluggle-strategies](https://github.com/hsnwhte/pluggle-strategies) catalog, read a
+strategy's README before installing it, install from the catalog or from a local `.py`
+file, and remove installed strategies. The built-in
+`default_v1.0` passthrough strategy cannot be removed.
+
+## Configuration
+
+All runtime data — the SQLite store, installed strategies, logs, uploads and pipeline
+outputs — is created under a `data/` folder in the directory you run the app from.
+
+Log output is fixed to `data/logs` by this package so that every runtime artifact sits
+in one place; it is not configurable.
+
+The remaining Pluggle paths can be overridden with a `.env` file in your working
+directory:
+
+```env
+PLUGGLE_STORE_ADDRESS=sqlite:///data/runtime.sqlite
+PLUGGLE_STRATEGIES_DIR=data/strategies
+```
+
+Pluggle reads these via `os.environ.get(...)` at import time, so no code changes are
+needed.
+
+SQLite is the default store and is sufficient here: this is a single-user local tool
+with none of the concurrent-write exposure that would call for PostgreSQL.
+
+### Theme
+
+Colours come from `.streamlit/config.toml` in the working directory. Streamlit exposes
+five theme variables; edit `primaryColor` to change the accent used by buttons, selected
+rows, and links.
+
+## Project layout
+
+```
+src/pluggle_interface_streamlit/
+├── app.py              # landing page
+├── settings.py         # package paths (assets, uploads, outputs)
+├── assets/             # logo and icon
+└── pages/
+    ├── 1_Run.py
+    └── 2_Strategies.py
+```
+
+`settings.py` distinguishes two roots: `PACKAGE_ROOT` for files shipped with the package
+(assets), and `RUNTIME_ROOT` (`Path.cwd()`) for anything created while running.
+Pluggle's own `settings.py` handles the `mkdir` calls for its directories on import, so
+there is no bootstrap step.
+
+## Scope
+
+This package is a generic interface — it runs whatever strategies you have installed and
+makes no assumptions about your data. It is not a hosted service; for a deployed demo of
+Pluggle, see
+[pluggle.org](https://pluggle.org).
+
+There are no automated tests. Almost nothing here is more than a Streamlit widget call
+or a thin pass through to `pluggle.interfaces.api`; the engine's own test suite covers
+the logic, and Streamlit's `AppTest` would be brittle against any widget reordering.
+Both pages are verified manually end to end.
+
+## License
+
+MIT

pluggle_interface_streamlit-0.1.0/src/pluggle_interface_streamlit.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/__init__.py
+src/pluggle_interface_streamlit/__init__.py
+src/pluggle_interface_streamlit/app.py
+src/pluggle_interface_streamlit/settings.py
+src/pluggle_interface_streamlit.egg-info/PKG-INFO
+src/pluggle_interface_streamlit.egg-info/SOURCES.txt
+src/pluggle_interface_streamlit.egg-info/dependency_links.txt
+src/pluggle_interface_streamlit.egg-info/requires.txt
+src/pluggle_interface_streamlit.egg-info/top_level.txt
+src/pluggle_interface_streamlit/pages/1_Run.py
+src/pluggle_interface_streamlit/pages/2_Strategies.py

pluggle_interface_streamlit-0.1.0/src/pluggle_interface_streamlit.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pluggle_interface_streamlit-0.1.0/src/pluggle_interface_streamlit.egg-info/requires.txt

@@ -0,0 +1,5 @@
+pluggle>=0.13.0
+streamlit>=1.62
+
+[dev]
+ruff>=0.16

pluggle_interface_streamlit-0.1.0/src/pluggle_interface_streamlit.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+__init__
+pluggle_interface_streamlit