As part of the python port for the dsci 100 R notebooks, we'll need to move all nbgrader tests to the python kernel.

• install and do the tutorial at https://nbgrader.readthedocs.io/en/stable/
• review current asyncio, e.g. https://realpython.com/async-io-python/
• review new nbclient notebook execution api: https://github.com/jupyter/nbclient/blob/master/nbclient/tests/test_client.py
• get up to speed with the changes made at https://github.com/UBC-DSCI/nbgrader/tree/generate_tests_stringeq
  - see https://github.com/eoas-ubc/eoas_tlef/blob/master/docs/nbgrader.md
• Rewrite _execute_code_snippet to use code from the new nbclient.NotebookClient
• Also finish off the related limit_testcell_height
• help prepare pull request to upstream

• install r-exams
• clone the github mirror and try importing this quiz to canvas using exams2canva
• use jupytext to convert between a jupyer notebook and a r-exams Rmd file
• write a blog post about this workflow
• use rpy2 to call exams2canvas from python

Adapt https://github.com/CFMTech/jupytext_papermill_post to produce muliple versions of the same quiz

repository: https://github.com/eoas-ubc/quiz_mill

• fork https://github.com/CFMTech/jupytext_papermill_post and run the example notebook
• make a new notebook that solves two equations in two unknowns, where the equation coefficients are replacable parameters
  (see https://stackabuse.com/solving-systems-of-linear-equations-with-pythons-numpy/)
• adapt the new notebook to the layer radiative flux problem where the unknowns are radiative fluxes being emitted by the layers
• read about how to use setup.py to install command line tools: https://godatadriven.com/blog/a-practical-guide-to-using-setup-py/
• read about how to use click to document command line tools: https://click.palletsprojects.com/en/8.0.x/
• use filter-notebook to add and remove notebook cells
• add metadata to produce "precision answer" quiz (item 5) following https://github.com/phaustin/eoas-wl/blob/main/md2canvas/examples/demo_quiz/demo.md
• write a bash script to produce 10 student and 10 instructor notebooks
• move the bash script to python ala generate_notebooks.py (pha)
• push the 10 student notebooks to canvas using https://github.com/phaustin/eoas-wl
• push an instructer-commented student file back to the student submission using https://canvasapi.readthedocs.io/en/stable/submission-ref.html?highlight=assignment#canvasapi.submission.Submission.upload_comment

pangeo github actions

Working repo: https://github.com/phaustin/pangeo-docker-images/tree/eoas_base

Pull request: pangeo-data/pangeo-docker-images#126

• Working example on eoas05
• Document design choices, reference urls in writeup for #47

Create a cookie-cutter/ansible playbook that will bring up a jupyterbook hub from a git repo with a webserver

working in
https://github.com/phaustin/jupyterhub_basics/tree/master/examples/simple

• review these trio references

• fork https://github.com/eoas-ubc/trio_chrome.git and follow install instructions

• add chromium install command borrowed from pypeteer

rendered: https://cerodell.github.io/eosc510/build/html/index.html
github: https://github.com/cerodell/eosc510

• install docker desktop
• run voila notebooks with https://hub.docker.com/r/jupyterhub/jupyterhub/
• package with https://github.com/jupyter/repo2docker
• Deploy on jupyterhub using cdsdashboard
• deploy on AWS and test
• help Charles and Joe Capriotti install and test https://github.com/geoscixyz/gpgLabs

• dns for EOAS01, 03,04,05 in UDC
• nginx/letsencrypt/github oauth for eoas05
• EOAS06, 07, 08 in M235

• build working example using eoas05 and eoas04
• discuss design, reference urls for various packages used etc. in markdown doc

• figure out a workflow that would allow us to upload and download jupyterbooks to an eoas server, and create archived juputerbooks from git repos

• write an ansible playbook to spin up a jupyterhub from an archived jupyterbook

eoas-ubc/docker_by_example#2

Looks like you can borrow docker files from
https://github.com/ideonate/cdsdashboards

working now: https://github.com/slemonide/simple_jupyterhub

• voila server installed
• figure out authorization
• [x ] figure out how to update git repo for dashboards modification;
• figure out how to write notebooks in myst and ipynb (add a jupytext.toml file to notebook repo)

Looks like cookie-cutter might would allow us to parameterize our setup for #47-- simpler than ansible?

https://cookiecutter.readthedocs.io/en/1.7.2/advanced/suppressing_prompts.html#advanced-example-defaults-extra-context

• fork https://github.com/UBC-DSCI/introduction-to-datascience
• on a new branch, convert Rmd to md:myst markdown using https://jupytext.readthedocs.io/en/latest/formats.html
• build a https://github.com/executablebooks/jupyter-book with the md:myst files
• begin to convert R examples to python

I'm working on a project that utilizes a makefile to build a jupyterbook. On windows, this results in the codec error, which led me to install runjb to my conda environment.

However, attempting to run runmyst.sh and runjb.sh on gitbash results in a command not found error.

I am unsure if I am missing something obvious or if runjb is not configured to work on gitbash on windows.

• convert docx to notebooks
• convert pptx to notebooks
• convert latex to notebooks
• write a matlab test suite calling matlab --batch from python

• clone paged_trio
• install and run the nbconvert printit template
• clone the two themes that are used by pyman (sphinx_rtd_theme) and quantecon-example (pydata-sphinx-theme)
• build these two examples with local imports of the sphinx themes to see how the jinja2 templates are used to create the html
• write our own sphinx theme that uses the header information from the printit template instead, so that we add pagedjs headers and pagebreaks to the two manuals
• commit the new theme (called paged_html?) into its own github repository so it's pip installable.
• modify the single notebook example at https://github.com/phaustin/MyST-NB/tree/utf_issue/docs/examples/utf_bug so it uses the theme -- i.e. change this line to "paged_html" and change the environment.yml file to install the new theme in the pip section.
• Substitute the quiz2 notebook for the appdx1 notebook
• post readme and invite collaborators: executablebooks/MyST-NB#201

help?

document how to get started

• write workflow overview
  - tools to support our workflow (jupytext, liveserver, watchdog, etc.) https://github.com/eoas-ubc/jb_tools
• write jupytext intro
• write git intro for faculty
  - (tracking the github intro on #30 )
• write markdown editing intro
• write docx pandoc intro
• write pptx to notebook intro
• record some 15 second camtasia screencasts

Look at this working example to see how they handle page refresh with hover:

https://github.com/phaustin/dash-sample-apps
https://dash.gallery/dash-covid-xray/

https://eoss-image-processing.github.io/2020/12/16/ct-app.html

https://github.com/jamiebyer/ocgy-dataviewer

• Make a minimal reprodicible example of ocgy-dataviewer non-refersh
• Make a minimal reproducible examle of dash-covid-xray refresh
• either rewrite dataviewer to match xray behavior or vice versa

• Demo a working jupyterhub on eoas05
• Add documentation to #47 to provide design rationale/urls for packages

Figure out how to run executable books in a standalone docker container that requires some kind of authentification, following the example at: https://brian-rose.github.io/ClimateLaboratoryBook/courseware/models-budgets-fun.html for UAlbany

I think we need to intialize 3 containers -- a volume with the book html files, a container running a simple web server pointed at index.html, and a volume running a jupyterhub on port that can be referenced in the book.

Examples:

1. initializing docker compose volumes
2. running apache
3. docker compose for jupyterhub with oauth: https://opendreamkit.org/2018/10/17/jupyterhub-docker/
   and https://github.com/defeo/jupyterhub-docker

rendered book without jupyterhub links: https://phaustin.github.io/Problem-Solving-with-Python-37-Edition/
git repo with book files: https://github.com/phaustin/Problem-Solving-with-Python-37-Edition

Goal: produce the E211 equivalent of https://ubc-dsci.github.io/introduction-to-datascience/

• adapt quantecon text for earth science
• merge notebooks from pyman
• figure out a versioning mechanism to produce different user versions (beginner, intermediate, ...)
• figure out metadata to attach to notebooks (subject, prereqs, courses used in, etc.)

Resources available with open licenses:

http://greenteapress.com/thinkpython/html/index.html
https://hplgit.github.io/scipro-primer/slides/index.html
https://geo-python.github.io/site/course-info/course-info.html
https://jakevdp.github.io/WhirlwindTourOfPython/
https://github.com/jakevdp/PythonDataScienceHandbook
https://github.com/wesm/pydata-book
https://github.com/pangeo-data/education-material

• set up https://github.com/eoas-ubc/eoas-ubc.github.io
• publish to https://eoas-ubc.github.io
• begin announcements/progress reports

• Install voila and run the tutorials
• create a prototype dashboard with a layout similar to modtran, driven by data supplied from a pandas dataframe.
• replace the dataframe with an interactive call to the modtran binary
• move the dashboard to a departmental server or AWS kubernetes cluster.

Something like: https://github.com/eoas-ubc/eoas_tlef/blob/master/docs/Git_workflow.md -- but with specific cases, dos and don'ts, etc.

Some questions to consider:

1. Why we don't recommend that you use the default git pull
2. If we don't recommend you use it, why is it the default?
3. What should you do instead?
4. What problems does that avoid?

In addition to the all-in-one - https://github.com/slemonide/simple_jupyterhub I would like to have separate branches that add features incrementally -- something like:

1. letsencrypt branch that just uses https://github.com/nginx-proxy/docker-letsencrypt-nginx-proxy-companion to provide https for a single hub, with github oauth (e.g. using hub2.eoastest.xyz, which is currently pointing to jupyterhub-2.eoas.ubc.ca)
2. a backup branch that adds restc to 1)
3. a monitoring branch that adds monitoring to 1)
   etc.

then we document the separate branches as separate chapters in a jupyterbook.

• get libradtran
• parse modtran output with modout.py
• containerize voila-eoas as a driver/plotter for the modtran executable
• replicate David Archer's web app as a voila dashboard
• two boxes: 1) planck functiontransmission 2) toa - planck functiontransmission
• integration button for total water vapor: np.sum(wvdens)*np.diff(z) = integral wrt z
• libradtran -- some simple templates
• librdatran output parser: https://isofit.readthedocs.io/en/latest/isofit.radiative_transfer.libradtran.html

Now working in https://github.com/bkchang-97/e340quizzes

• Use read api token from a .env file that's not checked in to git

• dump file listing to yaml for easy editing

• read edited file list and delete listed files from sandbox

• parameterize questions using https://pypi.org/project/papermill-jupytext/

• create pdf files for the student and solution notebooks