├── .github
└── workflows
│ └── streambook.yml
├── .gitignore
├── LICENSE
├── README.md
├── example.gif
├── example.notebook.ipynb
├── example.py
├── example.streambook.py
├── notebook.png
├── output.gif
├── requirements.dev.txt
├── requirements.example.txt
├── requirements.txt
├── setup.py
├── streambook.png
├── streambook
├── __init__.py
├── __main__.py
├── cli.py
├── gen.py
└── lib.py
└── tests
├── example.streambook.main.tmp
├── example.streambook.tmp
└── test_generate.py
/.github/workflows/streambook.yml:
--------------------------------------------------------------------------------
1 | on: [push, pull_request]
2 | jobs:
3 | build:
4 | runs-on: ${{ matrix.os }}
5 | strategy:
6 | matrix:
7 | os: [macos-latest, ubuntu-latest]
8 | python-version: [3.6, 3.8]
9 |
10 | steps:
11 | - uses: actions/checkout@v2
12 | - name: Set up Python ${{ matrix.python-version }}
13 | uses: actions/setup-python@v2
14 | with:
15 | python-version: ${{ matrix.python-version }}
16 | - name: Install package dependencies
17 | run: |
18 | python -m pip install --upgrade pip
19 | if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
20 | if [ -f requirements.dev.txt ]; then pip install -r requirements.dev.txt; fi
21 | - name: Test package install
22 | run: pip install .
23 | - name: Lint with flake8
24 | run: |
25 | # stop the build if there are Python syntax errors or undefined names
26 | flake8 --ignore "N801, E203, E266, E501, W503, F812, E741, N803, N802, N806" streambook/ tests/
27 | - name: Test with pytest
28 | run: |
29 | pytest tests/
30 | - name: Run command line
31 | run: |
32 | if [ -f requirements.dev.txt ]; then pip install -r requirements.example.txt; fi
33 | streambook export example.py
34 | cmp example.streambook.py tests/example.streambook.tmp
35 | python example.streambook.py
36 | python example.notebook.py
37 |
38 |
39 |
40 |
41 |
42 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # Byte-compiled / optimized / DLL files
2 | __pycache__/
3 | *.py[cod]
4 | *$py.class
5 |
6 | # C extensions
7 | *.so
8 |
9 | # Distribution / packaging
10 | .Python
11 | build/
12 | develop-eggs/
13 | dist/
14 | downloads/
15 | eggs/
16 | .eggs/
17 | lib/
18 | lib64/
19 | parts/
20 | sdist/
21 | var/
22 | wheels/
23 | pip-wheel-metadata/
24 | share/python-wheels/
25 | *.egg-info/
26 | .installed.cfg
27 | *.egg
28 | MANIFEST
29 |
30 | # PyInstaller
31 | # Usually these files are written by a python script from a template
32 | # before PyInstaller builds the exe, so as to inject date/other infos into it.
33 | *.manifest
34 | *.spec
35 |
36 | # Installer logs
37 | pip-log.txt
38 | pip-delete-this-directory.txt
39 |
40 | # Unit test / coverage reports
41 | htmlcov/
42 | .tox/
43 | .nox/
44 | .coverage
45 | .coverage.*
46 | .cache
47 | nosetests.xml
48 | coverage.xml
49 | *.cover
50 | *.py,cover
51 | .hypothesis/
52 | .pytest_cache/
53 |
54 | # Translations
55 | *.mo
56 | *.pot
57 |
58 | # Django stuff:
59 | *.log
60 | local_settings.py
61 | db.sqlite3
62 | db.sqlite3-journal
63 |
64 | # Flask stuff:
65 | instance/
66 | .webassets-cache
67 |
68 | # Scrapy stuff:
69 | .scrapy
70 |
71 | # Sphinx documentation
72 | docs/_build/
73 |
74 | # PyBuilder
75 | target/
76 |
77 | # Jupyter Notebook
78 | .ipynb_checkpoints
79 |
80 | # IPython
81 | profile_default/
82 | ipython_config.py
83 |
84 | # pyenv
85 | .python-version
86 |
87 | # pipenv
88 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
89 | # However, in case of collaboration, if having platform-specific dependencies or dependencies
90 | # having no cross-platform support, pipenv may install dependencies that don't work, or not
91 | # install all needed dependencies.
92 | #Pipfile.lock
93 |
94 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow
95 | __pypackages__/
96 |
97 | # Celery stuff
98 | celerybeat-schedule
99 | celerybeat.pid
100 |
101 | # SageMath parsed files
102 | *.sage.py
103 |
104 | # Environments
105 | .env
106 | .venv
107 | env/
108 | venv/
109 | ENV/
110 | env.bak/
111 | venv.bak/
112 |
113 | # Spyder project settings
114 | .spyderproject
115 | .spyproject
116 |
117 | # Rope project settings
118 | .ropeproject
119 |
120 | # mkdocs documentation
121 | /site
122 |
123 | # mypy
124 | .mypy_cache/
125 | .dmypy.json
126 | dmypy.json
127 |
128 | # Pyre type checker
129 | .pyre/
130 | # Pycharm
131 | .idea/
132 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2021 Sasha Rush
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Streambook
2 |
3 | Python notebooks without compromises.
4 |
5 | 
6 |
7 | * Write your code in any editor (emacs, vi, vscode)
8 | * Use standard tools (git, black, lint, pytest)
9 | * Export to standard Jupyter format for collaboration
10 |
11 | ## Quick start
12 |
13 | Install:
14 |
15 | ```bash
16 | pip install streambook
17 | ```
18 |
19 | Run streambook on a Python file. For the example notebook included:
20 |
21 | ```bash
22 | pip install matplotlib
23 | streambook run example.py
24 | ```
25 |
26 | The output should look like this [streambook](https://share.streamlit.io/srush/streambook-example/main/example.streambook.py).
27 |
28 | Editing your file `example.py` should automatically update the viewer.
29 |
30 | When you are done and ready to export to a notebook run:
31 |
32 | ```bash
33 | streambook convert example.py
34 | ```
35 |
36 | This produces a standard [notebook](https://nbviewer.jupyter.org/github/srush/streambook/blob/main/example.notebook.ipynb).
37 |
38 |
39 | ## How does this work?
40 |
41 | Streambook is a simple library (< 50 lines!) that hooks together Streamlit + Jupytext + Watchdog.
42 |
43 | * [Streamlit](https://docs.streamlit.io/) - Live updating webview with an advanced caching system
44 | * [Jupytext](https://jupytext.readthedocs.io/) - Bidirectional bridge between plaintext and jupyter format
45 | * [Watchdog](https://github.com/gorakhargosh/watchdog) - File watching in python
46 |
47 |
48 | ## Is this fast enough?
49 |
50 | 
51 |
52 |
53 | A "benefit" of using notebooks is being able to keep data cached in memory,
54 | at the cost of often forgetting how it was created and in what order.
55 |
56 | Streambook instead reruns your notebook from the top whenever the file is changed.
57 | Typically this is pretty fast for writing demos or quick notebooks.
58 |
59 |
60 | However this can be very slow for long running ML applications, particularly for users used to standard notebooks.
61 | In order to circumvent this issue there are two tricks.
62 |
63 | 1) You can divide your notebook us into sections. This allows you to edit individual parts of the notebook.
64 |
65 | ```
66 | streambook run --section "Main" example.py
67 | ```
68 |
69 | 2) You can write functions and add caching.
70 |
71 | Streamlit's caching API to makes it pretty easy in most use case. See
72 | https://docs.streamlit.io/en/stable/caching.html for docs.
73 |
74 | An example is given in the [notebook](https://nbviewer.jupyter.org/github/srush/streambook/blob/main/example.notebook.ipynb).
75 |
--------------------------------------------------------------------------------
/example.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/srush/streambook/120311b7e87e525557719cfe2a943d24a1c59e2a/example.gif
--------------------------------------------------------------------------------
/example.notebook.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "id": "ed186238",
6 | "metadata": {},
7 | "source": [
8 | "# Streambook example"
9 | ]
10 | },
11 | {
12 | "cell_type": "markdown",
13 | "id": "83e965bb",
14 | "metadata": {},
15 | "source": [
16 | "Streambook is a setup for writing live-updating notebooks\n",
17 | "in any editor that you might want to use (emacs, vi, notepad)."
18 | ]
19 | },
20 | {
21 | "cell_type": "code",
22 | "execution_count": null,
23 | "id": "14a4e11c",
24 | "metadata": {},
25 | "outputs": [],
26 | "source": []
27 | },
28 | {
29 | "cell_type": "code",
30 | "execution_count": 1,
31 | "id": "7c768749",
32 | "metadata": {
33 | "execution": {
34 | "iopub.execute_input": "2021-04-12T04:33:45.186839Z",
35 | "iopub.status.busy": "2021-04-12T04:33:45.185793Z",
36 | "iopub.status.idle": "2021-04-12T04:33:45.503548Z",
37 | "shell.execute_reply": "2021-04-12T04:33:45.502548Z"
38 | }
39 | },
40 | "outputs": [],
41 | "source": [
42 | "import numpy as np\n",
43 | "import pandas as pd\n",
44 | "import matplotlib.pyplot as plt\n",
45 | "import time"
46 | ]
47 | },
48 | {
49 | "cell_type": "markdown",
50 | "id": "4702566f",
51 | "metadata": {},
52 | "source": [
53 | "## Main Code"
54 | ]
55 | },
56 | {
57 | "cell_type": "markdown",
58 | "id": "0690ed8d",
59 | "metadata": {},
60 | "source": [
61 | "Notebook cells are separated by spaces. Comment cells are rendered\n",
62 | "as markdown.\n",
63 | "\n",
64 | "See https://jupytext.readthedocs.io/en/latest/formats.html#the-light-format"
65 | ]
66 | },
67 | {
68 | "cell_type": "code",
69 | "execution_count": 2,
70 | "id": "c3781d0e",
71 | "metadata": {
72 | "execution": {
73 | "iopub.execute_input": "2021-04-12T04:33:45.510026Z",
74 | "iopub.status.busy": "2021-04-12T04:33:45.509117Z",
75 | "iopub.status.idle": "2021-04-12T04:33:45.512247Z",
76 | "shell.execute_reply": "2021-04-12T04:33:45.511341Z"
77 | },
78 | "lines_to_next_cell": 2
79 | },
80 | "outputs": [],
81 | "source": [
82 | "x = np.array([10, 20, 30])"
83 | ]
84 | },
85 | {
86 | "cell_type": "markdown",
87 | "id": "91c619fd",
88 | "metadata": {},
89 | "source": [
90 | "Cells that end with an explicit variables are printed. \n",
91 | "\n",
92 | "See https://docs.streamlit.io/en/stable/api.html#magic-commands"
93 | ]
94 | },
95 | {
96 | "cell_type": "code",
97 | "execution_count": 3,
98 | "id": "e74a6cb8",
99 | "metadata": {
100 | "execution": {
101 | "iopub.execute_input": "2021-04-12T04:33:45.521111Z",
102 | "iopub.status.busy": "2021-04-12T04:33:45.520375Z",
103 | "iopub.status.idle": "2021-04-12T04:33:45.524249Z",
104 | "shell.execute_reply": "2021-04-12T04:33:45.525030Z"
105 | },
106 | "lines_to_next_cell": 2
107 | },
108 | "outputs": [
109 | {
110 | "data": {
111 | "text/plain": [
112 | "array([10, 20, 30])"
113 | ]
114 | },
115 | "execution_count": 1,
116 | "metadata": {},
117 | "output_type": "execute_result"
118 | }
119 | ],
120 | "source": [
121 | "x"
122 | ]
123 | },
124 | {
125 | "cell_type": "markdown",
126 | "id": "0dc21cde",
127 | "metadata": {},
128 | "source": [
129 | "Dictionaries are pretty-printed using streamlit and can be collapsed"
130 | ]
131 | },
132 | {
133 | "cell_type": "code",
134 | "execution_count": 4,
135 | "id": "f29c44e3",
136 | "metadata": {
137 | "execution": {
138 | "iopub.execute_input": "2021-04-12T04:33:45.531718Z",
139 | "iopub.status.busy": "2021-04-12T04:33:45.530819Z",
140 | "iopub.status.idle": "2021-04-12T04:33:45.533983Z",
141 | "shell.execute_reply": "2021-04-12T04:33:45.533200Z"
142 | },
143 | "lines_to_next_cell": 2
144 | },
145 | "outputs": [],
146 | "source": [
147 | "data = [dict(key1 = i, key2=f\"{i}\", key3=100 -i) for i in range(100)] "
148 | ]
149 | },
150 | {
151 | "cell_type": "markdown",
152 | "id": "e0b361f9",
153 | "metadata": {
154 | "lines_to_next_cell": 2
155 | },
156 | "source": [
157 | "Pandas dataframe also show up in tables. "
158 | ]
159 | },
160 | {
161 | "cell_type": "code",
162 | "execution_count": 5,
163 | "id": "11e558cd",
164 | "metadata": {
165 | "execution": {
166 | "iopub.execute_input": "2021-04-12T04:33:45.545351Z",
167 | "iopub.status.busy": "2021-04-12T04:33:45.544409Z",
168 | "iopub.status.idle": "2021-04-12T04:33:45.558847Z",
169 | "shell.execute_reply": "2021-04-12T04:33:45.558072Z"
170 | },
171 | "lines_to_next_cell": 2
172 | },
173 | "outputs": [
174 | {
175 | "data": {
176 | "text/html": [
177 | "\n",
178 | "\n",
191 | "
\n",
192 | " \n",
193 | " \n",
194 | " | \n",
195 | " key1 | \n",
196 | " key2 | \n",
197 | " key3 | \n",
198 | "
\n",
199 | " \n",
200 | " \n",
201 | " \n",
202 | " | 0 | \n",
203 | " 0 | \n",
204 | " 0 | \n",
205 | " 100 | \n",
206 | "
\n",
207 | " \n",
208 | " | 1 | \n",
209 | " 1 | \n",
210 | " 1 | \n",
211 | " 99 | \n",
212 | "
\n",
213 | " \n",
214 | " | 2 | \n",
215 | " 2 | \n",
216 | " 2 | \n",
217 | " 98 | \n",
218 | "
\n",
219 | " \n",
220 | " | 3 | \n",
221 | " 3 | \n",
222 | " 3 | \n",
223 | " 97 | \n",
224 | "
\n",
225 | " \n",
226 | " | 4 | \n",
227 | " 4 | \n",
228 | " 4 | \n",
229 | " 96 | \n",
230 | "
\n",
231 | " \n",
232 | " | ... | \n",
233 | " ... | \n",
234 | " ... | \n",
235 | " ... | \n",
236 | "
\n",
237 | " \n",
238 | " | 95 | \n",
239 | " 95 | \n",
240 | " 95 | \n",
241 | " 5 | \n",
242 | "
\n",
243 | " \n",
244 | " | 96 | \n",
245 | " 96 | \n",
246 | " 96 | \n",
247 | " 4 | \n",
248 | "
\n",
249 | " \n",
250 | " | 97 | \n",
251 | " 97 | \n",
252 | " 97 | \n",
253 | " 3 | \n",
254 | "
\n",
255 | " \n",
256 | " | 98 | \n",
257 | " 98 | \n",
258 | " 98 | \n",
259 | " 2 | \n",
260 | "
\n",
261 | " \n",
262 | " | 99 | \n",
263 | " 99 | \n",
264 | " 99 | \n",
265 | " 1 | \n",
266 | "
\n",
267 | " \n",
268 | "
\n",
269 | "
100 rows × 3 columns
\n",
270 | "
![](\"example.gif\")
"
643 | ],
644 | "text/plain": [
645 | ""
646 | ]
647 | },
648 | "execution_count": 1,
649 | "metadata": {},
650 | "output_type": "execute_result"
651 | }
652 | ],
653 | "source": [
654 | "# Jupyter command\n",
655 | "from IPython.display import HTML\n",
656 | "HTML('')\n",
657 | "# Streamlit command"
658 | ]
659 | }
660 | ],
661 | "metadata": {
662 | "jupytext": {
663 | "cell_metadata_filter": "-all"
664 | },
665 | "kernelspec": {
666 | "display_name": "myenv",
667 | "language": "python",
668 | "name": "myenv"
669 | },
670 | "language_info": {
671 | "codemirror_mode": {
672 | "name": "ipython",
673 | "version": 3
674 | },
675 | "file_extension": ".py",
676 | "mimetype": "text/x-python",
677 | "name": "python",
678 | "nbconvert_exporter": "python",
679 | "pygments_lexer": "ipython3",
680 | "version": "3.8.5"
681 | }
682 | },
683 | "nbformat": 4,
684 | "nbformat_minor": 5
685 | }
686 |
--------------------------------------------------------------------------------
/example.py:
--------------------------------------------------------------------------------
1 | # # Streambook example
2 |
3 | # Streambook is a setup for writing live-updating notebooks
4 | # in any editor that you might want to use (emacs, vi, notepad).
5 |
6 |
7 |
8 | import numpy as np
9 | import pandas as pd
10 | import matplotlib.pyplot as plt
11 | import time
12 |
13 | # ## Main Code
14 |
15 | # Notebook cells are separated by spaces. Comment cells are rendered
16 | # as markdown.
17 | #
18 | # See https://jupytext.readthedocs.io/en/latest/formats.html#the-light-format
19 |
20 | x = np.array([10, 20, 30])
21 |
22 |
23 | # Cells that end with an explicit variables are printed.
24 | #
25 | # See https://docs.streamlit.io/en/stable/api.html#magic-commands
26 |
27 | x
28 |
29 |
30 | # Dictionaries are pretty-printed using streamlit and can be collapsed
31 |
32 | data = [dict(key1 = i, key2=f"{i}", key3=100 -i) for i in range(100)]
33 |
34 |
35 | # Pandas dataframe also show up in tables.
36 |
37 |
38 | df = pd.DataFrame(data)
39 | df
40 |
41 |
42 |
43 | df.plot()
44 | __st.pyplot()
45 |
46 |
47 | x = "hello"
48 | # Printing
49 | print("Printing", x)
50 | print("Printing2", x)
51 | "Output", x
52 |
53 |
54 | # ## Advanced Features
55 |
56 |
57 | # By default, the notebook is rerun on save to ensure
58 | # consistency.
59 |
60 | def simple_function(x):
61 | return x + 10
62 | y = simple_function(10)
63 | y
64 |
65 |
66 | # Slower functions such as functions are loading data
67 | # can be cached during development.
68 |
69 | @__st.cache()
70 | def slow_function():
71 | for i in range(10):
72 | time.sleep(0.1)
73 | return None
74 | slow_function()
75 |
76 |
77 | # This uses streamlit caching behind the scenes. It will
78 | # run if the arguments or the body of the function change.
79 |
80 | # See https://docs.streamlit.io/en/stable/caching.html
81 |
82 |
83 | # ## Longer example
84 |
85 | def lorenz(x, y, z, s=10, r=28, b=2.667):
86 | """
87 | Given:
88 | x, y, z: a point of interest in three dimensional space
89 | s, r, b: parameters defining the lorenz attractor
90 | Returns:
91 | x_dot, y_dot, z_dot: values of the lorenz attractor's partial
92 | derivatives at the point x, y, z
93 | """
94 | x_dot = s*(y - x)
95 | y_dot = r*x - y - x*z
96 | z_dot = x*y - b*z
97 | return x_dot, y_dot, z_dot
98 |
99 |
100 | dt = 0.01
101 | num_steps = 20000
102 |
103 | def calc_curve(dt, num_steps):
104 | # Need one more for the initial values
105 | xs = np.empty(num_steps + 1)
106 | ys = np.empty(num_steps + 1)
107 | zs = np.empty(num_steps + 1)
108 |
109 | # Set initial values
110 | xs[0], ys[0], zs[0] = (0., 1., 1.05)
111 |
112 | # Step through "time", calculating the partial derivatives at the
113 | # current point and using them to estimate the next point
114 | for i in range(num_steps):
115 | x_dot, y_dot, z_dot = lorenz(xs[i], ys[i], zs[i])
116 | xs[i + 1] = xs[i] + (x_dot * dt)
117 | ys[i + 1] = ys[i] + (y_dot * dt)
118 | zs[i + 1] = zs[i] + (z_dot * dt)
119 | return xs, ys, zs
120 | xs, ys, zs = calc_curve(dt, num_steps)
121 |
122 | # Plot file
123 | fig = plt.figure(figsize=(12, 4))
124 | ax = fig.add_subplot(projection='3d')
125 | ax.plot(xs, ys, zs, lw=0.5)
126 | ax.set_xlabel("X Axis")
127 | ax.set_ylabel("Y Axis")
128 | ax.set_zlabel("Z Axis")
129 | ax.set_title("Lorenz Attractor")
130 | fig
131 |
132 |
133 | # ## Exporting to Jupyter
134 |
135 | # The whole notebook can also be exported as a
136 | # Jupyter notebook.
137 |
138 | # The command is:
139 | #
140 | # `streambook convert example.py`
141 |
142 | # Some commands are slightly different in streamlit that jupyter.
143 | # You can include both and all `__st` lines will be stripped out.
144 |
145 | # Jupyter command
146 | from IPython.display import HTML
147 | HTML('
')
148 | # Streamlit command
149 | __st.image("example.gif")
150 |
151 |
--------------------------------------------------------------------------------
/example.streambook.py:
--------------------------------------------------------------------------------
1 |
2 | import streamlit as __st
3 | import streambook
4 | __toc = streambook.TOCSidebar()
5 | __toc._add(streambook.H1('Streambook example'))
6 | __toc._add(streambook.H2('Main Code'))
7 | __toc._add(streambook.H2('Advanced Features'))
8 | __toc._add(streambook.H2('Longer example'))
9 | __toc._add(streambook.H2('Exporting to Jupyter'))
10 |
11 | __toc.generate()
12 | __st.markdown(r"""
13 | # Streambook example""", unsafe_allow_html=True)
14 | __st.markdown(r"""Streambook is a setup for writing live-updating notebooks
15 | in any editor that you might want to use (emacs, vi, notepad).""", unsafe_allow_html=True)
16 | with __st.echo(), streambook.st_stdout('info'):
17 | import numpy as np
18 | import pandas as pd
19 | import matplotlib.pyplot as plt
20 | import time
21 | __st.markdown(r"""
22 | ## Main Code""", unsafe_allow_html=True)
23 | __st.markdown(r"""Notebook cells are separated by spaces. Comment cells are rendered
24 | as markdown.
25 |
26 | See https://jupytext.readthedocs.io/en/latest/formats.html#the-light-format""", unsafe_allow_html=True)
27 | with __st.echo(), streambook.st_stdout('info'):
28 | x = np.array([10, 20, 30])
29 | __st.markdown(r"""Cells that end with an explicit variables are printed.
30 |
31 | See https://docs.streamlit.io/en/stable/api.html#magic-commands""", unsafe_allow_html=True)
32 | with __st.echo(), streambook.st_stdout('info'):
33 | x
34 | __st.markdown(r"""Dictionaries are pretty-printed using streamlit and can be collapsed""", unsafe_allow_html=True)
35 | with __st.echo(), streambook.st_stdout('info'):
36 | data = [dict(key1 = i, key2=f"{i}", key3=100 -i) for i in range(100)]
37 | __st.markdown(r"""Pandas dataframe also show up in tables. """, unsafe_allow_html=True)
38 | with __st.echo(), streambook.st_stdout('info'):
39 | df = pd.DataFrame(data)
40 | df
41 | with __st.echo(), streambook.st_stdout('info'):
42 | df.plot()
43 | __st.pyplot()
44 | with __st.echo(), streambook.st_stdout('info'):
45 | x = "hello"
46 | # Printing
47 | print("Printing", x)
48 | print("Printing2", x)
49 | "Output", x
50 | __st.markdown(r"""
51 | ## Advanced Features""", unsafe_allow_html=True)
52 | __st.markdown(r"""By default, the notebook is rerun on save to ensure
53 | consistency.""", unsafe_allow_html=True)
54 | with __st.echo(), streambook.st_stdout('info'):
55 | def simple_function(x):
56 | return x + 10
57 | y = simple_function(10)
58 | y
59 | __st.markdown(r"""Slower functions such as functions are loading data
60 | can be cached during development.""", unsafe_allow_html=True)
61 | with __st.echo(), streambook.st_stdout('info'):
62 | @__st.cache()
63 | def slow_function():
64 | for i in range(10):
65 | time.sleep(0.1)
66 | return None
67 | slow_function()
68 | __st.markdown(r"""This uses streamlit caching behind the scenes. It will
69 | run if the arguments or the body of the function change.""", unsafe_allow_html=True)
70 | __st.markdown(r"""See https://docs.streamlit.io/en/stable/caching.html""", unsafe_allow_html=True)
71 | __st.markdown(r"""
72 | ## Longer example""", unsafe_allow_html=True)
73 | with __st.echo(), streambook.st_stdout('info'):
74 | def lorenz(x, y, z, s=10, r=28, b=2.667):
75 | """
76 | Given:
77 | x, y, z: a point of interest in three dimensional space
78 | s, r, b: parameters defining the lorenz attractor
79 | Returns:
80 | x_dot, y_dot, z_dot: values of the lorenz attractor's partial
81 | derivatives at the point x, y, z
82 | """
83 | x_dot = s*(y - x)
84 | y_dot = r*x - y - x*z
85 | z_dot = x*y - b*z
86 | return x_dot, y_dot, z_dot
87 | with __st.echo(), streambook.st_stdout('info'):
88 | dt = 0.01
89 | num_steps = 20000
90 | with __st.echo(), streambook.st_stdout('info'):
91 | def calc_curve(dt, num_steps):
92 | # Need one more for the initial values
93 | xs = np.empty(num_steps + 1)
94 | ys = np.empty(num_steps + 1)
95 | zs = np.empty(num_steps + 1)
96 |
97 | # Set initial values
98 | xs[0], ys[0], zs[0] = (0., 1., 1.05)
99 |
100 | # Step through "time", calculating the partial derivatives at the
101 | # current point and using them to estimate the next point
102 | for i in range(num_steps):
103 | x_dot, y_dot, z_dot = lorenz(xs[i], ys[i], zs[i])
104 | xs[i + 1] = xs[i] + (x_dot * dt)
105 | ys[i + 1] = ys[i] + (y_dot * dt)
106 | zs[i + 1] = zs[i] + (z_dot * dt)
107 | return xs, ys, zs
108 | xs, ys, zs = calc_curve(dt, num_steps)
109 | with __st.echo(), streambook.st_stdout('info'):
110 | # Plot file
111 | fig = plt.figure(figsize=(12, 4))
112 | ax = fig.add_subplot(projection='3d')
113 | ax.plot(xs, ys, zs, lw=0.5)
114 | ax.set_xlabel("X Axis")
115 | ax.set_ylabel("Y Axis")
116 | ax.set_zlabel("Z Axis")
117 | ax.set_title("Lorenz Attractor")
118 | fig
119 | __st.markdown(r"""
120 | ## Exporting to Jupyter""", unsafe_allow_html=True)
121 | __st.markdown(r"""The whole notebook can also be exported as a
122 | Jupyter notebook.""", unsafe_allow_html=True)
123 | __st.markdown(r"""The command is:
124 |
125 | `streambook convert example.py`""", unsafe_allow_html=True)
126 | __st.markdown(r"""Some commands are slightly different in streamlit that jupyter.
127 | You can include both and all `__st` lines will be stripped out.""", unsafe_allow_html=True)
128 | with __st.echo(), streambook.st_stdout('info'):
129 | # Jupyter command
130 | from IPython.display import HTML
131 | HTML('')
132 | # Streamlit command
133 | __st.image("example.gif")
134 |
135 |
--------------------------------------------------------------------------------
/notebook.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/srush/streambook/120311b7e87e525557719cfe2a943d24a1c59e2a/notebook.png
--------------------------------------------------------------------------------
/output.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/srush/streambook/120311b7e87e525557719cfe2a943d24a1c59e2a/output.gif
--------------------------------------------------------------------------------
/requirements.dev.txt:
--------------------------------------------------------------------------------
1 | pytest == 6.0.1
2 | flake8==3.8.3
3 | pep8-naming==0.11.1
4 |
--------------------------------------------------------------------------------
/requirements.example.txt:
--------------------------------------------------------------------------------
1 | pandas
2 | matplotlib
3 | jupyter
4 |
--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | streamlit==1.3
2 | jupytext
3 | watchdog
4 | in_place
5 | mistune==0.8.4
6 |
--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
1 | from setuptools import setup
2 |
3 | with open("README.md", "r", encoding="utf-8") as fh:
4 | long_description = fh.read()
5 |
6 | setup(
7 | name="streambook",
8 | author="Alexander Rush",
9 | author_email="arush@cornell.edu",
10 | version="0.3",
11 | packages=["streambook"],
12 | long_description=long_description,
13 | long_description_content_type="text/markdown",
14 | package_data={"streambook": []},
15 | setup_requires=["pytest-runner"],
16 | install_requires=["streamlit", "jupytext", "watchdog", "in_place", "mistune", "typer"],
17 | tests_require=["pytest"],
18 | python_requires=">=3.6",
19 | entry_points={
20 | "console_scripts": [
21 | "streambook = streambook.cli:app",
22 | ],
23 | },
24 | )
25 |
--------------------------------------------------------------------------------
/streambook.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/srush/streambook/120311b7e87e525557719cfe2a943d24a1c59e2a/streambook.png
--------------------------------------------------------------------------------
/streambook/__init__.py:
--------------------------------------------------------------------------------
1 | from .lib import * # noqa: F401,F403
2 | from .gen import * # noqa: F401,F403
3 |
--------------------------------------------------------------------------------
/streambook/__main__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/srush/streambook/120311b7e87e525557719cfe2a943d24a1c59e2a/streambook/__main__.py
--------------------------------------------------------------------------------
/streambook/cli.py:
--------------------------------------------------------------------------------
1 | import subprocess
2 | import time
3 | from pathlib import Path
4 | import os
5 |
6 | import in_place
7 | import typer
8 | from watchdog.events import FileSystemEventHandler
9 | from watchdog.observers import Observer
10 |
11 | from streambook.gen import Generator
12 |
13 | app = typer.Typer()
14 |
15 |
16 | class MyHandler(FileSystemEventHandler):
17 | def __init__(
18 | self,
19 | abs_path: str,
20 | stream_file: str,
21 | notebook_file: str,
22 | jupytext_command: str,
23 | generator: Generator,
24 | quiet: bool,
25 | ):
26 | self.abs_path = abs_path
27 | self.stream_file = stream_file
28 | self.notebook_file = notebook_file
29 | self.jupytext_command = jupytext_command
30 | self.generator = generator
31 | self.quiet = quiet
32 | super().__init__()
33 |
34 | def on_modified(self, event):
35 | if event is None or event.src_path == self.abs_path:
36 | if not self.quiet:
37 | print(f"Regenerating from {self.abs_path}...")
38 | with in_place.InPlace(self.stream_file) as out:
39 | self.generator.generate(self.abs_path, out)
40 | with open(self.notebook_file, "w") as out:
41 | for line in open(self.abs_path, "r"):
42 | if "__st" not in line:
43 | out.write(line)
44 | if self.jupytext_command is not None:
45 | os.system(self.jupytext_command)
46 |
47 |
48 | def file_paths(file: Path):
49 | abs_path = file.resolve()
50 | directory = str(abs_path.parent)
51 | abs_path = str(abs_path)
52 |
53 | ipynb_file = abs_path[:-3] + ".ipynb"
54 | stream_file = abs_path[:-3] + ".streambook.py"
55 | notebook_file = abs_path[:-3] + ".notebook.py"
56 | return abs_path, directory, stream_file, notebook_file, ipynb_file
57 |
58 |
59 | def main(
60 | file: Path,
61 | watch: bool,
62 | streamlit: bool,
63 | quiet: bool,
64 | jupyter: bool = False,
65 | port: int = None,
66 | sections: str = None,
67 | ):
68 | abs_path, directory, stream_file, notebook_file, ipynb_file = file_paths(file)
69 | jupytext_command = (
70 | f"jupytext --to notebook --execute {notebook_file} -o {ipynb_file}"
71 | )
72 | event_handler = MyHandler(
73 | abs_path=abs_path,
74 | stream_file=stream_file,
75 | notebook_file=notebook_file,
76 | jupytext_command=jupytext_command if jupyter else None,
77 | generator=Generator(sections),
78 | quiet=quiet,
79 | )
80 | observer = Observer()
81 | open(stream_file, "w").close()
82 |
83 | view_command = ["streamlit", "run", "--server.runOnSave", "true"]
84 | if port is not None:
85 | view_command += ["--server.port", str(port)]
86 | view_command += [stream_file]
87 |
88 | if not quiet:
89 | if watch:
90 | print("Streambook Daemon\n")
91 | print("Watching directory for changes:")
92 | print(f"\n {directory}")
93 | print()
94 |
95 | print("View Command")
96 | print(" ".join(view_command))
97 | print()
98 | if jupyter:
99 | print("Jupyter Daemon\n")
100 | print(jupytext_command)
101 |
102 | event_handler.on_modified(None)
103 |
104 | if watch:
105 | observer.schedule(event_handler, path=directory, recursive=False)
106 | observer.start()
107 |
108 | if streamlit:
109 | print()
110 | print("Starting Streamlit")
111 | subprocess.run(
112 | view_command, capture_output=True,
113 | )
114 |
115 | try:
116 | while True:
117 | time.sleep(1)
118 | except KeyboardInterrupt:
119 | observer.stop()
120 | observer.join()
121 |
122 |
123 | @app.command()
124 | def convert(file: Path = typer.Argument(..., help="file to convert")):
125 | abs_path, directory, stream_file, notebook_file, ipynb_file = file_paths(file)
126 | command = f"jupytext --to notebook --execute {notebook_file} -o {ipynb_file} "
127 | os.system(command)
128 |
129 |
130 | @app.command()
131 | def run(
132 | file: Path = typer.Argument(..., help="file to run"),
133 | streamlit: bool = typer.Option(True, help="Lauches streamlit"),
134 | jupyter: bool = typer.Option(False, help="Compiles ipynb file"),
135 | quiet: bool = typer.Option(False, help="Don't print anything"),
136 | port: int = typer.Option(None, help="Port to launch streamlit on."),
137 | sections: str = typer.Option(None, help="Regex to filter sections."),
138 | ):
139 | """
140 | Starts the watcher and streamlit services.
141 | """
142 | main(
143 | file,
144 | watch=True,
145 | streamlit=streamlit,
146 | jupyter=jupyter,
147 | quiet=quiet,
148 | port=port,
149 | sections=sections,
150 | )
151 |
152 |
153 | @app.command()
154 | def export(
155 | file: Path = typer.Argument(..., help="file to run"),
156 | quiet: bool = typer.Option(False, help="Don't print anything"),
157 | ):
158 | """
159 | Only creates the '*.streambook.py' file.
160 | """
161 | main(file, watch=False, streamlit=False, quiet=quiet)
162 |
163 |
164 | if __name__ == "__main__":
165 | app()
166 |
--------------------------------------------------------------------------------
/streambook/gen.py:
--------------------------------------------------------------------------------
1 | import jupytext
2 | import textwrap
3 | import mistune
4 | import re
5 | import io
6 |
7 |
8 | class Collect(mistune.Renderer):
9 | def __init__(self):
10 | super().__init__()
11 | self.headers = []
12 |
13 | def header(self, text, level, raw=None):
14 | self.headers.append((text, level - 1))
15 | return ""
16 |
17 |
18 | class Generate:
19 | def __init__(self, out_stream, section_filter=None):
20 | self.out_stream = out_stream
21 | self.all_markdown = ""
22 | self.headers = []
23 | self.current_section = [None, None, None]
24 | self.section_filter = section_filter
25 |
26 | def gen(self, output):
27 | print(output, file=self.out_stream)
28 |
29 | def markdown(self, source):
30 | # Collect all the markdown headers
31 | c = Collect()
32 |
33 | markdown = mistune.Markdown(renderer=c)
34 | markdown(source)
35 | self.headers += c.headers
36 | head = ""
37 | for text, _ in c.headers:
38 | head += f" "
39 | for text, level in c.headers:
40 | self.current_section[level] = text
41 | self.all_markdown += source + "\n"
42 | if self.section_filter is not None and self.current_section[1] is not None:
43 | if not re.search(self.section_filter, self.current_section[1]):
44 | return
45 | if head:
46 | self.gen(
47 | '__st.markdown(r"""%s\n%s""", unsafe_allow_html=True)' % (head, source)
48 | )
49 | else:
50 | self.gen('__st.markdown(r"""%s""", unsafe_allow_html=True)' % (source))
51 |
52 | def code(self, source):
53 | if self.section_filter is not None and self.current_section[1] is not None:
54 | if not re.search(self.section_filter, self.current_section[1]):
55 | return
56 | wrapper = textwrap.TextWrapper(
57 | initial_indent=" ", subsequent_indent=" ", width=5000
58 | )
59 | if not source.strip():
60 | return
61 | self.gen("with __st.echo(), streambook.st_stdout('info'):")
62 | for line in source.splitlines():
63 | self.gen(wrapper.fill(line))
64 |
65 |
66 | header = """
67 | import streamlit as __st
68 | import streambook
69 | __toc = streambook.TOCSidebar()"""
70 |
71 | footer = """
72 | __toc.generate()"""
73 |
74 |
75 | class Generator:
76 | def __init__(self, section_filter=None):
77 | self.section_filter = section_filter
78 |
79 | def generate(self, in_file, out_stream):
80 | out = io.StringIO()
81 | gen = Generate(out, section_filter=self.section_filter)
82 |
83 | print(header, file=out_stream)
84 |
85 | for i, cell in enumerate(jupytext.read(in_file)["cells"]):
86 | if cell["cell_type"] == "markdown":
87 | gen.markdown(cell["source"])
88 | else:
89 | gen.code(cell["source"])
90 | levels = ["streambook.H1", "streambook.H2", "streambook.H3"]
91 | print(
92 | "\n".join(
93 | [
94 | "__toc._add(" + levels[level] + "('" + text + "'))"
95 | for text, level in gen.headers
96 | ]
97 | ),
98 | file=out_stream,
99 | )
100 | print(footer, file=out_stream)
101 | print(out.getvalue(), file=out_stream)
102 |
103 |
104 | if __name__ == "__main__":
105 | import argparse
106 | import os
107 | import sys
108 |
109 | parser = argparse.ArgumentParser(description="Stream book options.")
110 | parser.add_argument("file", help="file to run", type=os.path.abspath)
111 | args = parser.parse_args()
112 | Generator().generate(args.file, sys.stdout)
113 |
--------------------------------------------------------------------------------
/streambook/lib.py:
--------------------------------------------------------------------------------
1 | import streamlit as st
2 | from contextlib import contextmanager
3 | from io import StringIO
4 | from streamlit.report_thread import REPORT_CONTEXT_ATTR_NAME
5 | from threading import current_thread
6 | import sys
7 |
8 | st.set_option("deprecation.showPyplotGlobalUse", False)
9 |
10 |
11 | @contextmanager
12 | def st_redirect(src, dst):
13 | placeholder = st.empty()
14 | output_func = getattr(placeholder, dst)
15 |
16 | with StringIO() as buffer:
17 | old_write = src.write
18 |
19 | def new_write(b):
20 | if getattr(current_thread(), REPORT_CONTEXT_ATTR_NAME, None):
21 | buffer.write(b.replace("\n", "\n\n"))
22 | output_func(buffer.getvalue())
23 | else:
24 | old_write(b)
25 |
26 | try:
27 | src.write = new_write
28 | yield
29 | finally:
30 | src.write = old_write
31 |
32 |
33 | @contextmanager
34 | def st_stdout(dst):
35 | with st_redirect(sys.stdout, dst):
36 | yield
37 |
38 |
39 | @contextmanager
40 | def st_stderr(dst):
41 | with st_redirect(sys.stderr, dst):
42 | yield
43 |
44 |
45 | class Header:
46 | tag: str = ""
47 |
48 | def __init__(self, text: str):
49 | self.text = text
50 |
51 | @property
52 | def id(self):
53 | """Create an identifcator from text."""
54 | return "-".join(self.text.split()).lower()
55 |
56 | @property
57 | def anchor(self):
58 | """Provide html text for anchored header. Example:
59 | Abc Def
60 | """
61 | return f"<{self.tag} id='{self.id}'>{self.text}"
62 |
63 | def toc_item(self) -> str:
64 | """Make markdown item for TOC listing. Example:
65 | ' - Abc'
66 | """
67 | return f"{self.spaces}- {self.text}"
68 |
69 | @property
70 | def spaces(self):
71 | return dict(h1="", h2=" " * 2, h3=" " * 4).get(self.tag)
72 |
73 |
74 | class H1(Header):
75 | tag = "h1"
76 |
77 |
78 | class H2(Header):
79 | tag = "h2"
80 |
81 |
82 | class H3(Header):
83 | tag = "h3"
84 |
85 |
86 | class TOC:
87 | """
88 | Original code, used with modifications:
89 | https://discuss.streamlit.io/t/table-of-contents-widget/3470/8?u=epogrebnyak
90 | """
91 |
92 | def __init__(self):
93 | self._headers = []
94 | self._placeholder = st.empty()
95 |
96 | def title(self, text):
97 | self._add(H1(text))
98 |
99 | def header(self, text):
100 | self._add(H2(text))
101 |
102 | def subheader(self, text):
103 | self._add(H3(text))
104 |
105 | def generate(self):
106 | text = "\n".join([h.toc_item() for h in self._headers])
107 | self._placeholder.markdown(text, unsafe_allow_html=True)
108 |
109 | def _add(self, header):
110 | self._headers.append(header)
111 |
112 |
113 | class TOCSidebar(TOC):
114 | def __init__(self):
115 | self._headers = []
116 | self._placeholder = st.sidebar.empty()
117 |
--------------------------------------------------------------------------------
/tests/example.streambook.main.tmp:
--------------------------------------------------------------------------------
1 |
2 | import streamlit as __st
3 | import streambook
4 | __toc = streambook.TOCSidebar()
5 | __toc._add(streambook.H1('Streambook example'))
6 | __toc._add(streambook.H2('Main Code'))
7 | __toc._add(streambook.H2('Advanced Features'))
8 | __toc._add(streambook.H2('Longer example'))
9 | __toc._add(streambook.H2('Exporting to Jupyter'))
10 |
11 | __toc.generate()
12 | __st.markdown(r"""
13 | # Streambook example""", unsafe_allow_html=True)
14 | __st.markdown(r"""Streambook is a setup for writing live-updating notebooks
15 | in any editor that you might want to use (emacs, vi, notepad).""", unsafe_allow_html=True)
16 | with __st.echo(), streambook.st_stdout('info'):
17 | import numpy as np
18 | import pandas as pd
19 | import matplotlib.pyplot as plt
20 | import time
21 | __st.markdown(r"""
22 | ## Main Code""", unsafe_allow_html=True)
23 | __st.markdown(r"""Notebook cells are separated by spaces. Comment cells are rendered
24 | as markdown.
25 |
26 | See https://jupytext.readthedocs.io/en/latest/formats.html#the-light-format""", unsafe_allow_html=True)
27 | with __st.echo(), streambook.st_stdout('info'):
28 | x = np.array([10, 20, 30])
29 | __st.markdown(r"""Cells that end with an explicit variables are printed.
30 |
31 | See https://docs.streamlit.io/en/stable/api.html#magic-commands""", unsafe_allow_html=True)
32 | with __st.echo(), streambook.st_stdout('info'):
33 | x
34 | __st.markdown(r"""Dictionaries are pretty-printed using streamlit and can be collapsed""", unsafe_allow_html=True)
35 | with __st.echo(), streambook.st_stdout('info'):
36 | data = [dict(key1 = i, key2=f"{i}", key3=100 -i) for i in range(100)]
37 | __st.markdown(r"""Pandas dataframe also show up in tables. """, unsafe_allow_html=True)
38 | with __st.echo(), streambook.st_stdout('info'):
39 | df = pd.DataFrame(data)
40 | df
41 | with __st.echo(), streambook.st_stdout('info'):
42 | df.plot()
43 | __st.pyplot()
44 | with __st.echo(), streambook.st_stdout('info'):
45 | x = "hello"
46 | # Printing
47 | print("Printing", x)
48 | print("Printing2", x)
49 | "Output", x
50 |
51 |
--------------------------------------------------------------------------------
/tests/example.streambook.tmp:
--------------------------------------------------------------------------------
1 |
2 | import streamlit as __st
3 | import streambook
4 | __toc = streambook.TOCSidebar()
5 | __toc._add(streambook.H1('Streambook example'))
6 | __toc._add(streambook.H2('Main Code'))
7 | __toc._add(streambook.H2('Advanced Features'))
8 | __toc._add(streambook.H2('Longer example'))
9 | __toc._add(streambook.H2('Exporting to Jupyter'))
10 |
11 | __toc.generate()
12 | __st.markdown(r"""
13 | # Streambook example""", unsafe_allow_html=True)
14 | __st.markdown(r"""Streambook is a setup for writing live-updating notebooks
15 | in any editor that you might want to use (emacs, vi, notepad).""", unsafe_allow_html=True)
16 | with __st.echo(), streambook.st_stdout('info'):
17 | import numpy as np
18 | import pandas as pd
19 | import matplotlib.pyplot as plt
20 | import time
21 | __st.markdown(r"""
22 | ## Main Code""", unsafe_allow_html=True)
23 | __st.markdown(r"""Notebook cells are separated by spaces. Comment cells are rendered
24 | as markdown.
25 |
26 | See https://jupytext.readthedocs.io/en/latest/formats.html#the-light-format""", unsafe_allow_html=True)
27 | with __st.echo(), streambook.st_stdout('info'):
28 | x = np.array([10, 20, 30])
29 | __st.markdown(r"""Cells that end with an explicit variables are printed.
30 |
31 | See https://docs.streamlit.io/en/stable/api.html#magic-commands""", unsafe_allow_html=True)
32 | with __st.echo(), streambook.st_stdout('info'):
33 | x
34 | __st.markdown(r"""Dictionaries are pretty-printed using streamlit and can be collapsed""", unsafe_allow_html=True)
35 | with __st.echo(), streambook.st_stdout('info'):
36 | data = [dict(key1 = i, key2=f"{i}", key3=100 -i) for i in range(100)]
37 | __st.markdown(r"""Pandas dataframe also show up in tables. """, unsafe_allow_html=True)
38 | with __st.echo(), streambook.st_stdout('info'):
39 | df = pd.DataFrame(data)
40 | df
41 | with __st.echo(), streambook.st_stdout('info'):
42 | df.plot()
43 | __st.pyplot()
44 | with __st.echo(), streambook.st_stdout('info'):
45 | x = "hello"
46 | # Printing
47 | print("Printing", x)
48 | print("Printing2", x)
49 | "Output", x
50 | __st.markdown(r"""
51 | ## Advanced Features""", unsafe_allow_html=True)
52 | __st.markdown(r"""By default, the notebook is rerun on save to ensure
53 | consistency.""", unsafe_allow_html=True)
54 | with __st.echo(), streambook.st_stdout('info'):
55 | def simple_function(x):
56 | return x + 10
57 | y = simple_function(10)
58 | y
59 | __st.markdown(r"""Slower functions such as functions are loading data
60 | can be cached during development.""", unsafe_allow_html=True)
61 | with __st.echo(), streambook.st_stdout('info'):
62 | @__st.cache()
63 | def slow_function():
64 | for i in range(10):
65 | time.sleep(0.1)
66 | return None
67 | slow_function()
68 | __st.markdown(r"""This uses streamlit caching behind the scenes. It will
69 | run if the arguments or the body of the function change.""", unsafe_allow_html=True)
70 | __st.markdown(r"""See https://docs.streamlit.io/en/stable/caching.html""", unsafe_allow_html=True)
71 | __st.markdown(r"""
72 | ## Longer example""", unsafe_allow_html=True)
73 | with __st.echo(), streambook.st_stdout('info'):
74 | def lorenz(x, y, z, s=10, r=28, b=2.667):
75 | """
76 | Given:
77 | x, y, z: a point of interest in three dimensional space
78 | s, r, b: parameters defining the lorenz attractor
79 | Returns:
80 | x_dot, y_dot, z_dot: values of the lorenz attractor's partial
81 | derivatives at the point x, y, z
82 | """
83 | x_dot = s*(y - x)
84 | y_dot = r*x - y - x*z
85 | z_dot = x*y - b*z
86 | return x_dot, y_dot, z_dot
87 | with __st.echo(), streambook.st_stdout('info'):
88 | dt = 0.01
89 | num_steps = 20000
90 | with __st.echo(), streambook.st_stdout('info'):
91 | def calc_curve(dt, num_steps):
92 | # Need one more for the initial values
93 | xs = np.empty(num_steps + 1)
94 | ys = np.empty(num_steps + 1)
95 | zs = np.empty(num_steps + 1)
96 |
97 | # Set initial values
98 | xs[0], ys[0], zs[0] = (0., 1., 1.05)
99 |
100 | # Step through "time", calculating the partial derivatives at the
101 | # current point and using them to estimate the next point
102 | for i in range(num_steps):
103 | x_dot, y_dot, z_dot = lorenz(xs[i], ys[i], zs[i])
104 | xs[i + 1] = xs[i] + (x_dot * dt)
105 | ys[i + 1] = ys[i] + (y_dot * dt)
106 | zs[i + 1] = zs[i] + (z_dot * dt)
107 | return xs, ys, zs
108 | xs, ys, zs = calc_curve(dt, num_steps)
109 | with __st.echo(), streambook.st_stdout('info'):
110 | # Plot file
111 | fig = plt.figure(figsize=(12, 4))
112 | ax = fig.add_subplot(projection='3d')
113 | ax.plot(xs, ys, zs, lw=0.5)
114 | ax.set_xlabel("X Axis")
115 | ax.set_ylabel("Y Axis")
116 | ax.set_zlabel("Z Axis")
117 | ax.set_title("Lorenz Attractor")
118 | fig
119 | __st.markdown(r"""
120 | ## Exporting to Jupyter""", unsafe_allow_html=True)
121 | __st.markdown(r"""The whole notebook can also be exported as a
122 | Jupyter notebook.""", unsafe_allow_html=True)
123 | __st.markdown(r"""The command is:
124 |
125 | `streambook convert example.py`""", unsafe_allow_html=True)
126 | __st.markdown(r"""Some commands are slightly different in streamlit that jupyter.
127 | You can include both and all `__st` lines will be stripped out.""", unsafe_allow_html=True)
128 | with __st.echo(), streambook.st_stdout('info'):
129 | # Jupyter command
130 | from IPython.display import HTML
131 | HTML('')
132 | # Streamlit command
133 | __st.image("example.gif")
134 |
135 |
--------------------------------------------------------------------------------
/tests/test_generate.py:
--------------------------------------------------------------------------------
1 | import streambook
2 | from io import StringIO
3 |
4 |
5 | def test_markdown():
6 | output = StringIO()
7 | gen = streambook.Generate(output)
8 | gen.markdown("test")
9 | assert output.getvalue() == '__st.markdown(r"""test""", unsafe_allow_html=True)\n'
10 |
11 |
12 | def test_gen():
13 | output = StringIO()
14 | gen = streambook.Generate(output)
15 | gen.code("x = 10\ny = 20\ny")
16 | print(output.getvalue())
17 | assert (
18 | output.getvalue()
19 | == """with __st.echo(), streambook.st_stdout('info'):
20 | x = 10
21 | y = 20
22 | y
23 | """
24 | )
25 |
26 |
27 | def test_example():
28 | output = StringIO()
29 | streambook.Generator().generate("example.py", output)
30 | generated_output = output.getvalue()
31 | expected_output = open("tests/example.streambook.tmp", "r").read()
32 | assert generated_output == expected_output
33 |
34 |
35 | def test_example_main():
36 | output = StringIO()
37 | streambook.Generator(section_filter="Main").generate("example.py", output)
38 | generated_output = output.getvalue()
39 | expected_output = open("tests/example.streambook.main.tmp", "r").read()
40 | assert generated_output == expected_output
41 |
--------------------------------------------------------------------------------