coastal-dynamics 0.0.2__tar.gz

coastal_dynamics-0.0.2/LICENSE

@@ -0,0 +1,29 @@
+BSD License
+
+Copyright (c) 2022, Floris Calkoen
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+OF THE POSSIBILITY OF SUCH DAMAGE.

coastal_dynamics-0.0.2/PKG-INFO

@@ -0,0 +1,214 @@
+Metadata-Version: 2.1
+Name: coastal-dynamics
+Version: 0.0.2
+Summary: Jupyterbook for Delft Technical University Coastal Systems
+License: MIT
+Author: Floris Calkoen
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: pytest (>=7.4.0,<8.0.0)
+Description-Content-Type: text/markdown
+
+![](https://github.com/FlorisCalkoen/CoastalCodebook/blob/main/coastalcodebook/imgs/waves_angola.jpeg)
+# Coastal Systems Open Codebook
+
+
+Tutorial notebooks for Delft University of Technology Coastal Systems course. The book is
+available [online](https://floriscalkoen.github.io/CoastalCodebook/intro.html) in both
+PDF and markdown.
+
+## Usage
+
+For the tuturial sessions we will use an interactive computing environment, that is built
+on the [Jupyter]() ecosystem and mostly rely on software that is supported by numfocus. We will communicate the tutorial content
+using `git` version control and provide instructions on how to do so using the GitHub client. In the subsections
+that follow we talk you through the three configurations steps.
+
+### 1. Git
+
+If you are not familiar with using Git, please have a look this short but excellent
+[introduction](https://earth-env-data-science.github.io/lectures/environment/intro_to_git.html)
+first.
+
+1. Please refer to the [GitHub Client documentation](https://desktop.github.com/) to
+   install the GitHub client, or see [these
+   instructions](https://github.com/git-guides/install-git) to install git using the
+   command line.
+2. Clone this repository to your local
+   computer using either of the following options.
+
+   1. **GitHub client**: Browse to the
+   [webpage](https://github.com/FlorisCalkoen/CoastalCodebook), click on the green "Code"
+   button and select "Open with GitHub Desktop"; or simply paste the URL into the GitHub
+   client "clone repository" menu.
+
+   2. **Bash shell**: If you have a bash terminal available, assuming that git [is
+     configured](https://docs.github.com/en/get-started/getting-started-with-git), you
+   can simply run: ` git clone https://github.com/FlorisCalkoen/CoastalCodebook.git`.
+
+3. GitHub client does not install the underlying git software on your machine. Follow [these
+   instructions](https://learn.microsoft.com/en-us/devops/develop/git/install-and-set-up-git)
+   to install git on your machine.
+
+
+By these steps, the files that are hosted at GitHub are "pulled" to your machine. You can
+check that by opening a file explorer and going to the path where you cloned the
+directory. The files that you find there should reflect what's on the GitHub page.
+But we can't we do anything with the files yet, as we don't have the software that can
+understand the code, so we will continue with installing a package manager.
+
+### 2. Mamba package manager
+
+If you're not familiar with managing Python environments, please have a look at this
+[introduction](https://earth-env-data-science.github.io/lectures/environment/python_environments.html?highlight=conda)
+first. The bottom line is that it is good practice to manage your software environments
+to avoid dependency conflicts. For the tutorial notebooks,  we recommend to use the
+lightweight package manager `mambaforge`. The instructions to install this package
+manager can be found in [their
+documentation](https://mamba.readthedocs.io/en/latest/installation.html), in which they
+refer to the [Conda Forge GitHub](https://github.com/conda-forge/miniforge#mambaforge)
+page to download the software.
+
+#### Windows
+
+1. Download the mambaforge executable file for Windows from [Miniforge GitHub
+page](https://github.com/conda-forge/miniforge#mambaforge). On that page there are also
+binaries for Mac and Linux; and for `conda` package managers, so make sure you download
+the `mambaforge` executable file for Windows. Install the executable by clicking on it;
+you can stay with the default settings by just clicking next through the installation
+client.
+2. Now that mambaforge is installed, you can open a `Miniforge Prompt`. You can open this
+   shell by opening the start window and search for "Miniforge".
+
+**Known issues**: Some users have their firewalls configured in such way that the
+mambaforge installation is blocked. If you have trouble installing mambaforge, please make
+sure to temporarily disable your firewall.
+
+#### Unix like - Mac and Linux
+1. We recommend to install Mambaforge on Linux and Mac using a terminal. On Mac, you can
+   open a terminal by searching for "terminal" or "iterm". On Linux the hotkey to open a
+   terminal is "cntrl + shift + t". The commands to
+   install the package manager are copied from their documentation and can be run by
+   copying the commands below over to your terminal and pressing enter:
+   ```bash
+   curl -L -O "https://github.com/conda-forge/miniforge/releases/latest/download/Mambaforge-$(uname)-$(uname -m).sh"
+   bash Mambaforge-$(uname)-$(uname -m).sh
+
+   ```
+2. Accept the user agreements, and allow the installation script to edit your profile
+   file. The profile file (`~/.bashrc` on Linux or possibly `~/.zshrc` on Mac) is the
+   first script which is being executed when you open a new terminal. The installation
+   script will add a few lines to that file to make the `mamba` command available every
+   time open a new terminal.
+3. Close the terminal.
+
+### 3. Software environments
+To run the tutorial notebooks we need several packages. To avoid dependency conflicts it
+is good practice to seperate your environments; that was the reason for installing a
+package manager. Now that we have our package manager we will create the software
+environments. We will create one environment that runs the JupyterLab IDE, including
+several extensions; and another one that contains the packages that we need for the
+tutorials.
+
+1. Now that mambaforge is available on your machine, open a terminal. On Windows you
+   should open the Miniforge prompt, which you can find by searching for it in the Start
+   window. On Mac you can open a terminal by searching for "terminal" or "iterm". For
+   Linux it's "cntrl + shift + t".
+2. You can check if mamba was installed by running the following command in the terminal:
+   ```bash
+   mamba --version
+
+   ```
+   It should output something like:
+
+   ```console
+   ~ (base) mamba --version
+   mamba 1.1.0
+   conda 22.9.0
+   ```
+
+3. Now that mambaforge is installed, navigate in the terminal to the directory
+   where you cloned the GitHub CoastalCodeBook repository. You can navigate the terminal
+   using `cd`, which stands for "change directory".
+   - **Windows**: if you are on Windows and you installed the GitHub client using their default settings you can
+   simply run `cd %userprofile%\Documents\GitHub\CoastalCodeBook`.
+   - **Linux/Mac**: change to the directory where you cloned the GitHub repository. This
+     will be something like `cd ~/path/to/github/repository`.
+4. The CoastalCodeBook root directory contains an [environment.yml](environment.yml) file that describes the software
+   dependencies. This environment contains several packages and extension to build an
+   interactive Jupyter lab environment that you can use to run the tutorial notebooks.
+
+   You can create the software environment using this command:
+
+   ```bash
+   mamba env create -f environment.yml
+   ```
+
+
+### Running the tutorial notebooks
+Now that you have access to the code (cloning this Github repository), installed a
+package manager and created your environments we can start running the notebooks in
+Jupyterlab. If you are new to JupyterLab we encourage you to have a look at [this
+introduction](https://earth-env-data-science.github.io/lectures/environment/intro_to_jupyterlab.html).
+
+1. Open a terminal or Miniforge prompt.
+2. Change to the directory where you cloned the repository `cd </path/to/local/repo>`.
+   Note, on Windows you should use backslashes (see sec 2).
+3. Activate your environment by running:
+   ```bash
+   mamba activate coastal
+   ```
+4. Open Jupyterlab by running the following command:
+   ```bash
+   jupyter lab
+   ```
+   This will open a Jupyterlab client in your browser.
+5. In the JupyterLab IDE you can browse to the `notebooks` directory and open
+      one of the notebooks, for instance,
+      [01_coastal_classification.ipynb](notebooks/01_coastal_classification.ipynb).
+6. Once the notebook is open you can activate the `coastal` environment in the
+      upper-right corner; change `Python 3 (ipykernel)` to `Python [conda env:coastal]`.
+7. Now you can run the cells and do some interactive coastal analysis!
+
+## Questions
+
+If you have a question about the installation process or notebooks, feel free to open an
+issue in the [GitHub repository](https://github.com/FlorisCalkoen/CoastalCodebook). If
+that's your first time, have a look at [these
+instructions](https://docs.github.com/en/issues/tracking-your-work-with-issues/creating-an-issue).
+We choose to use the GitHub issue-tracker because your fellow students probably have
+similar problems. We will not troubleshoot the tutorial notebooks by email.
+
+### Building the book
+
+If you'd like to develop and/or build the CoastalCodeBook book, you should:
+
+1. Clone this repository
+2. Run `mamba env create -f environment-coastal.yml`
+3. Run `mamba activate coastal`
+5. Run `jupyter-book build book`
+
+A fully-rendered HTML version of the book will be built in
+`book/_build/html/`.
+
+**Known issues**: If you use `nb_conda_kernels` to expose your environments, you might run
+into kernelspec errors when building the book. Until
+https://github.com/executablebooks/jupyter-book/issues/1348 is fixed, a workaround is to
+add the environments manually to the kernselspec:
+1. Run `mamba activate coastal`
+2. Run `python -m ipykernel install --user --name conda-env-coastal-py --display-name "conda-env-coastal-py"`
+
+## Contributors
+
+We welcome and recognize all contributions. You can see a list of current contributors in
+the [contributors
+tab](https://github.com/floriscalkoen/coastalcodebook/graphs/contributors).
+
+## Credits
+
+This project is created using the excellent open source [Jupyter Book
+project](https://jupyterbook.org/) and the [executablebooks/cookiecutter-jupyter-book
+template](https://github.com/executablebooks/cookiecutter-jupyter-book).

coastal_dynamics-0.0.2/README.md

@@ -0,0 +1,200 @@
+![](https://github.com/FlorisCalkoen/CoastalCodebook/blob/main/coastalcodebook/imgs/waves_angola.jpeg)
+# Coastal Systems Open Codebook
+
+
+Tutorial notebooks for Delft University of Technology Coastal Systems course. The book is
+available [online](https://floriscalkoen.github.io/CoastalCodebook/intro.html) in both
+PDF and markdown.
+
+## Usage
+
+For the tuturial sessions we will use an interactive computing environment, that is built
+on the [Jupyter]() ecosystem and mostly rely on software that is supported by numfocus. We will communicate the tutorial content
+using `git` version control and provide instructions on how to do so using the GitHub client. In the subsections
+that follow we talk you through the three configurations steps.
+
+### 1. Git
+
+If you are not familiar with using Git, please have a look this short but excellent
+[introduction](https://earth-env-data-science.github.io/lectures/environment/intro_to_git.html)
+first.
+
+1. Please refer to the [GitHub Client documentation](https://desktop.github.com/) to
+   install the GitHub client, or see [these
+   instructions](https://github.com/git-guides/install-git) to install git using the
+   command line.
+2. Clone this repository to your local
+   computer using either of the following options.
+
+   1. **GitHub client**: Browse to the
+   [webpage](https://github.com/FlorisCalkoen/CoastalCodebook), click on the green "Code"
+   button and select "Open with GitHub Desktop"; or simply paste the URL into the GitHub
+   client "clone repository" menu.
+
+   2. **Bash shell**: If you have a bash terminal available, assuming that git [is
+     configured](https://docs.github.com/en/get-started/getting-started-with-git), you
+   can simply run: ` git clone https://github.com/FlorisCalkoen/CoastalCodebook.git`.
+
+3. GitHub client does not install the underlying git software on your machine. Follow [these
+   instructions](https://learn.microsoft.com/en-us/devops/develop/git/install-and-set-up-git)
+   to install git on your machine.
+
+
+By these steps, the files that are hosted at GitHub are "pulled" to your machine. You can
+check that by opening a file explorer and going to the path where you cloned the
+directory. The files that you find there should reflect what's on the GitHub page.
+But we can't we do anything with the files yet, as we don't have the software that can
+understand the code, so we will continue with installing a package manager.
+
+### 2. Mamba package manager
+
+If you're not familiar with managing Python environments, please have a look at this
+[introduction](https://earth-env-data-science.github.io/lectures/environment/python_environments.html?highlight=conda)
+first. The bottom line is that it is good practice to manage your software environments
+to avoid dependency conflicts. For the tutorial notebooks,  we recommend to use the
+lightweight package manager `mambaforge`. The instructions to install this package
+manager can be found in [their
+documentation](https://mamba.readthedocs.io/en/latest/installation.html), in which they
+refer to the [Conda Forge GitHub](https://github.com/conda-forge/miniforge#mambaforge)
+page to download the software.
+
+#### Windows
+
+1. Download the mambaforge executable file for Windows from [Miniforge GitHub
+page](https://github.com/conda-forge/miniforge#mambaforge). On that page there are also
+binaries for Mac and Linux; and for `conda` package managers, so make sure you download
+the `mambaforge` executable file for Windows. Install the executable by clicking on it;
+you can stay with the default settings by just clicking next through the installation
+client.
+2. Now that mambaforge is installed, you can open a `Miniforge Prompt`. You can open this
+   shell by opening the start window and search for "Miniforge".
+
+**Known issues**: Some users have their firewalls configured in such way that the
+mambaforge installation is blocked. If you have trouble installing mambaforge, please make
+sure to temporarily disable your firewall.
+
+#### Unix like - Mac and Linux
+1. We recommend to install Mambaforge on Linux and Mac using a terminal. On Mac, you can
+   open a terminal by searching for "terminal" or "iterm". On Linux the hotkey to open a
+   terminal is "cntrl + shift + t". The commands to
+   install the package manager are copied from their documentation and can be run by
+   copying the commands below over to your terminal and pressing enter:
+   ```bash
+   curl -L -O "https://github.com/conda-forge/miniforge/releases/latest/download/Mambaforge-$(uname)-$(uname -m).sh"
+   bash Mambaforge-$(uname)-$(uname -m).sh
+
+   ```
+2. Accept the user agreements, and allow the installation script to edit your profile
+   file. The profile file (`~/.bashrc` on Linux or possibly `~/.zshrc` on Mac) is the
+   first script which is being executed when you open a new terminal. The installation
+   script will add a few lines to that file to make the `mamba` command available every
+   time open a new terminal.
+3. Close the terminal.
+
+### 3. Software environments
+To run the tutorial notebooks we need several packages. To avoid dependency conflicts it
+is good practice to seperate your environments; that was the reason for installing a
+package manager. Now that we have our package manager we will create the software
+environments. We will create one environment that runs the JupyterLab IDE, including
+several extensions; and another one that contains the packages that we need for the
+tutorials.
+
+1. Now that mambaforge is available on your machine, open a terminal. On Windows you
+   should open the Miniforge prompt, which you can find by searching for it in the Start
+   window. On Mac you can open a terminal by searching for "terminal" or "iterm". For
+   Linux it's "cntrl + shift + t".
+2. You can check if mamba was installed by running the following command in the terminal:
+   ```bash
+   mamba --version
+
+   ```
+   It should output something like:
+
+   ```console
+   ~ (base) mamba --version
+   mamba 1.1.0
+   conda 22.9.0
+   ```
+
+3. Now that mambaforge is installed, navigate in the terminal to the directory
+   where you cloned the GitHub CoastalCodeBook repository. You can navigate the terminal
+   using `cd`, which stands for "change directory".
+   - **Windows**: if you are on Windows and you installed the GitHub client using their default settings you can
+   simply run `cd %userprofile%\Documents\GitHub\CoastalCodeBook`.
+   - **Linux/Mac**: change to the directory where you cloned the GitHub repository. This
+     will be something like `cd ~/path/to/github/repository`.
+4. The CoastalCodeBook root directory contains an [environment.yml](environment.yml) file that describes the software
+   dependencies. This environment contains several packages and extension to build an
+   interactive Jupyter lab environment that you can use to run the tutorial notebooks.
+
+   You can create the software environment using this command:
+
+   ```bash
+   mamba env create -f environment.yml
+   ```
+
+
+### Running the tutorial notebooks
+Now that you have access to the code (cloning this Github repository), installed a
+package manager and created your environments we can start running the notebooks in
+Jupyterlab. If you are new to JupyterLab we encourage you to have a look at [this
+introduction](https://earth-env-data-science.github.io/lectures/environment/intro_to_jupyterlab.html).
+
+1. Open a terminal or Miniforge prompt.
+2. Change to the directory where you cloned the repository `cd </path/to/local/repo>`.
+   Note, on Windows you should use backslashes (see sec 2).
+3. Activate your environment by running:
+   ```bash
+   mamba activate coastal
+   ```
+4. Open Jupyterlab by running the following command:
+   ```bash
+   jupyter lab
+   ```
+   This will open a Jupyterlab client in your browser.
+5. In the JupyterLab IDE you can browse to the `notebooks` directory and open
+      one of the notebooks, for instance,
+      [01_coastal_classification.ipynb](notebooks/01_coastal_classification.ipynb).
+6. Once the notebook is open you can activate the `coastal` environment in the
+      upper-right corner; change `Python 3 (ipykernel)` to `Python [conda env:coastal]`.
+7. Now you can run the cells and do some interactive coastal analysis!
+
+## Questions
+
+If you have a question about the installation process or notebooks, feel free to open an
+issue in the [GitHub repository](https://github.com/FlorisCalkoen/CoastalCodebook). If
+that's your first time, have a look at [these
+instructions](https://docs.github.com/en/issues/tracking-your-work-with-issues/creating-an-issue).
+We choose to use the GitHub issue-tracker because your fellow students probably have
+similar problems. We will not troubleshoot the tutorial notebooks by email.
+
+### Building the book
+
+If you'd like to develop and/or build the CoastalCodeBook book, you should:
+
+1. Clone this repository
+2. Run `mamba env create -f environment-coastal.yml`
+3. Run `mamba activate coastal`
+5. Run `jupyter-book build book`
+
+A fully-rendered HTML version of the book will be built in
+`book/_build/html/`.
+
+**Known issues**: If you use `nb_conda_kernels` to expose your environments, you might run
+into kernelspec errors when building the book. Until
+https://github.com/executablebooks/jupyter-book/issues/1348 is fixed, a workaround is to
+add the environments manually to the kernselspec:
+1. Run `mamba activate coastal`
+2. Run `python -m ipykernel install --user --name conda-env-coastal-py --display-name "conda-env-coastal-py"`
+
+## Contributors
+
+We welcome and recognize all contributions. You can see a list of current contributors in
+the [contributors
+tab](https://github.com/floriscalkoen/coastalcodebook/graphs/contributors).
+
+## Credits
+
+This project is created using the excellent open source [Jupyter Book
+project](https://jupyterbook.org/) and the [executablebooks/cookiecutter-jupyter-book
+template](https://github.com/executablebooks/cookiecutter-jupyter-book).

coastal_dynamics-0.0.2/pyproject.toml

@@ -0,0 +1,61 @@
+[tool.poetry]
+name = "coastal-dynamics"
+version = "0.0.2"
+description = "Jupyterbook for Delft Technical University Coastal Systems"
+authors = ["Floris Calkoen"]
+license = "MIT"
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+pytest = "^7.4.0"
+
+[tool.poetry.dev-dependencies]
+black = "^23.7.0"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+line-length = 88
+
+[tool.ruff]
+select = [
+  "E", "F", "W", # flake8
+  "B",           # flake8-bugbear
+  "I",           # isort
+  "ARG",         # flake8-unused-arguments
+  "C4",          # flake8-comprehensions
+  "EM",          # flake8-errmsg
+  "ICN",         # flake8-import-conventions
+  "ISC",         # flake8-implicit-str-concat
+  "PGH",         # pygrep-hooks
+  "PIE",         # flake8-pie
+  "PL",          # pylint
+  "PT",          # flake8-pytest-style
+  "PTH",         # flake8-use-pathlib
+  "RUF",         # Ruff-specific
+  "SIM",         # flake8-simplify
+  "TID251",      # flake8-tidy-imports.banned-api
+  "T20",         # flake8-print
+  "UP",          # pyupgrade
+  "YTT",         # flake8-2020
+]
+extend-ignore = [
+  "PLR",    # Design related pylint codes
+  "E501",   # Line too long
+  "PT004",  # Incorrect check, usefixtures is the correct way to do this
+  "RUF012", # Would require a lot of ClassVar's
+]
+src = ["src"]
+unfixable = [
+  "T20",  # Removes print statements
+  "F841", # Removes unused variables
+]
+exclude = []
+target-version = "py311"
+flake8-unused-arguments.ignore-variadic-names = true
+
+[tool.ruff.pydocstyle]
+convention = "google"

coastal_dynamics-0.0.2/src/coastal_dynamics/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.2"

coastal_dynamics-0.0.2/src/coastal_dynamics/geometries.py

@@ -0,0 +1,121 @@
+from typing import Any, Dict, List, Union
+
+import geopandas as gpd
+import shapely
+from pyproj import Transformer
+
+
+def build_bbox(min_lon, min_lat, max_lon, max_lat, src_crs, crs):
+    """
+    Build a latitude / longitude bounding box from the coordinates.
+    """
+    # minimum / maximum points from the dataset
+    # left, bottom, right, top = (-5802250.0, -622000.0, -5519250.0, -39000.0)
+    points = [
+        [min_lon, max_lon, max_lon, min_lon],
+        [min_lat, min_lat, max_lat, max_lat],
+    ]
+
+    transformer = Transformer.from_crs(src_crs, crs, always_xy=True)
+    lons, lats = transformer.transform(*points)
+
+    west = min(lons)
+    east = max(lons)
+    north = max(lats)
+    south = min(lats)
+    return [west, south, east, north]
+
+
+def geometry_to_bbox(geometry: Dict[str, Any]) -> List[float]:
+    """Extract the bounding box from a geojson geometry
+
+    Args:
+        geometry : GeoJSON geometry dict
+
+    Returns:
+        list: Bounding box of geojson geometry, formatted according to:
+        https://tools.ietf.org/html/rfc7946#section-5
+    """
+    coords = geometry["coordinates"]
+
+    lats: List[float] = []
+    lons: List[float] = []
+
+    def extract_coords(coords: List[Union[List[float], List[List[Any]]]]) -> None:
+        for x in coords:
+            # This handles points
+            if isinstance(x, float):
+                assert isinstance(
+                    coords[0], float
+                ), f"Type mismatch: {coords[0]} is not a float"
+                assert isinstance(
+                    coords[1], float
+                ), f"Type mismatch: {coords[1]} is not a float"
+                lats.append(coords[0])
+                lons.append(coords[1])
+                return
+            if isinstance(x[0], list):
+                extract_coords(x)  # type:ignore
+            else:
+                lat, lon = x
+                lats.append(lat)  # type:ignore
+                lons.append(lon)  # type:ignore
+
+    extract_coords(coords)
+
+    lons.sort()
+    lats.sort()
+
+    bbox = [lats[0], lons[0], lats[-1], lons[-1]]
+
+    return bbox
+
+
+def bbox_to_geometry(bbox: List[float]) -> Dict:
+    """Use shapely.geometry.shape to cast to shapeley geom"""
+    return {
+        "type": "Polygon",
+        "coordinates": [
+            [
+                [bbox[2], bbox[1]],
+                [bbox[2], bbox[3]],
+                [bbox[0], bbox[3]],
+                [bbox[0], bbox[1]],
+                [bbox[2], bbox[1]],
+            ]
+        ],
+    }
+
+
+def geo_bbox(
+    min_lon: float,
+    min_lat: float,
+    max_lon: float,
+    max_lat: float,
+    src_crs="EPSG:4326",
+    dst_crs="EPSG:4326",
+) -> gpd.GeoDataFrame:
+    """GeoDataFrame with a bounding box that can be used for various gis operations.
+    Args:
+        min_lon (float): most eastern longitude
+        min_lat (float): most northern latitude
+        max_lon (float): most wester longitude
+        max_lat (float): most soutern latitude
+        src_crs (str, optional): Valid EPSG string or number (int). Defaults to "EPSG:4326".
+        dst_crs (str, optional): Valid EPSG string or number (int). Defaults to "EPSG:4326".
+
+    Returns:
+        gpd.GeoDataFrame: GeoDataFrame with bounding box as geometry.
+    """
+
+    bbox = [min_lon, min_lat, max_lon, max_lat]
+    bbox = bbox_to_geometry(bbox)
+    bbox = shapely.geometry.shape(bbox)
+    return gpd.GeoDataFrame(geometry=[bbox], crs=src_crs).to_crs(dst_crs)
+
+
+def get_xy_range(gdf):
+    """min, max lon/lat formatted as xy range for geoviews."""
+    x_range = tuple(gdf.total_bounds[[0, 2]])
+    y_range = tuple(gdf.total_bounds[[1, 3]])
+    return x_range, y_range

coastal_dynamics-0.0.2/src/coastal_dynamics/hidden.py

@@ -0,0 +1,204 @@
+# TODO: in future use https://github.com/jupyter/nbgrader instead
+# Function for cheking the first exercise:
+def Check1(ans1, ans2, ans3, ans4, ans5):
+    c = 0
+    # Checking answer 1:
+    if ans1 == "A":
+        c = c + 1
+        print(
+            "Answer 1: \t Correct! The channel velocity is too small to keep the inlet open. Sedimentation leads to closure of the inlet."
+        )
+    if ans1 == "B":
+        print("Answer 1: \t Are you sure that point B is a stable point?")
+    if (ans1 == "C") & (ans1 == "D"):
+        print(
+            "Answer 1: \t Is it possible for a tidal inlet to naturally pass point B from location 1?"
+        )
+    if ans1 == "E":
+        print(
+            "Answer1: \t Wow! Talking about over compensation... I suggest you rethink your answer"
+        )
+
+    # Checking answer 2:
+    if ans2 == "D":
+        c = c + 1
+        print(
+            "Answer 2: \t Correct! Although we are close to point B, an unstable equilibrium, the channel velocity is large enough to increase the channel cross-section. It grows towards point C, passes it, and eventually reach point D, a stable equilibrium."
+        )
+    if ans2 == "C":
+        print(
+            "Answer 2: \t Almost! The cross-section grows towards point C, but does it stop there?"
+        )
+    if (ans2 != "D") & (ans2 != "C"):
+        print(
+            'Answer 2: \t Location 2 lies between an unstable equilibrium (point B) and stable equilbrium (point D). The unstable equilibrium "pushes" away and the stable equilibrium "attracts". It can\'t really go anywhere else but...?'
+        )
+
+    # Checking answer 3:
+    if ans3 == "D":
+        c = c + 1
+        print(
+            "Answer 3: \t Correct! The channel velocity is still too large. Through erosion the channel moves to point D."
+        )
+    if ans3 == "C":
+        print(
+            "Answer 3: \t Almost! The channel velocity is larger than the equilibrium velocity. The channel is eroding, thus moving towards?"
+        )
+    if (ans3 != "D") & (ans3 != "C"):
+        print(
+            'Answer 3: \t Location 3 lies between an unstable equilibrium (point B) and stable equilbrium (point D). The unstable equilibrium "pushes" away and the stable equilibrium "attracts". It can\'t really go anywhere else but...?'
+        )
+
+    # Checking answer 4:
+    if ans4 == "D":
+        c = c + 1
+        print(
+            "Answer 4: \t Correct! The channel velocity is too small and the cross-section too large. Sedimentation occurs and we move towards point D"
+        )
+    if (ans4 == "C") | (ans4 == "B"):
+        print("Answer 4: \t Hmmm, are you sure we can move past point D?")
+    if ans4 == "A":
+        print("Answer 4: \t Oh no! Where are you going, come back!")
+    if ans4 == "E":
+        print(
+            "Answer 4: \t A channel cross-section that is actually too large will grow even more. Are you sure about that?"
+        )
+
+    # Checking answer 5:
+    if ans5 == "D":
+        c = c + 1
+        print(
+            "Answer 5: \t Correct! The cross-section will grow until an equilibrium is found."
+        )
+    if ans5 == "E":
+        print(
+            "Answer 5: \t A channel cross-section that is actually too large will grow even more. Are you sure about that?"
+        )
+    if (ans5 != "D") & (ans5 != "E"):
+        print("Answer 5: \t Hmmm, are you sure we can move past point D?")
+    if ans5 == "A":
+        print("Answer 4: \t Oh no! Where are you going, come back!")
+
+    if c == 5:
+        print(
+            "Well done! You are a master of understanding the Escoffier curve. But what about other scenarios? Go to Part 2 and find out."
+        )
+    if c == 0:
+        print(
+            "Mmm... I think you should read the section about this topic again. If you can't figure it out, discuss with your peers or ask us for help."
+        )
+    if (c > 0) & (c < 5):
+        print(
+            "Some of your answers are incorrect. Retrhink your answers or dicuss with your peers what the correct answers should be."
+        )
+
+
+# Function for cheking the second exercise:
+def Check2(ansII_1, ansII_2, ansII_3, ansIII_1, ansIII_2, ansIII_3):
+    c = 0
+    # Checking scenario II answer 1:
+    if ansII_1 == "A":
+        c = c + 1
+        print("Answer II_1: \t Correct!")
+    if ansII_1 == "C":
+        print(
+            "Answer II_1: \t Point C does coincide with the equilibrium velocity, but is this a stable situtaion?"
+        )
+    if ansII_1 == "E":
+        print(
+            "Answer II_1: \t Are you sure? Look back at the previous exercise and reconsider what happens."
+        )
+
+    # Checking scenario II answer 2:
+    if ansII_2 == "A":
+        c = c + 1
+        print("Answer II_2: \t Correct!")
+    if ansII_1 == "C":
+        print(
+            'Answer II_2: \t Definitely possible, as long as the deviation is "to the right". As soon as a deviation is "to the left", what happens?'
+        )
+    if ansII_1 == "E":
+        print(
+            "Answer II_2: \t Are you sure? Look back at the previous exercise and reconsider what happens."
+        )
+
+    # Checking scenario II answer 3:
+    if ansII_3 == "A":
+        c = c + 1
+        print("Answer II_3: \t Correct!")
+    if ansII_1 == "C":
+        print(
+            "Answer II_3: \t The situation will approach point C, but how likely is it that no overshoot occurs?"
+        )
+    if ansII_1 == "E":
+        print(
+            "Answer II_3: \t Are you sure? Look back at the previous exercise and reconsider what happens."
+        )
+
+    # Checking scenario III answer 1:
+    if ansIII_1 == "A":
+        c = c + 1
+        print("Answer III_1: \t Correct!")
+    if ansIII_1 == "C":
+        print(
+            "Answer III_1: \t Are you sure? Look back at the previous exercise and reconsider what happens."
+        )
+    if ansIII_1 == "E":
+        print(
+            "Answer III_1: \t Are you sure? Look back at the previous exercise and reconsider what happens."
+        )
+
+    # Checking scenario III answer 2:
+    if ansIII_2 == "A":
+        c = c + 1
+        print("Answer III_2: \t Correct!")
+    if ansIII_2 == "C":
+        print(
+            "Answer III_2: \t Are you sure? Look back at the previous exercise and reconsider what happens."
+        )
+    if ansIII_2 == "E":
+        print(
+            "Answer III_2: \t Are you sure? Look back at the previous exercise and reconsider what happens."
+        )
+
+    # Checking scenario III answer 3:
+    if ansIII_3 == "A":
+        c = c + 1
+        print("Answer III_3: \t Correct!")
+    if ansIII_3 == "C":
+        print(
+            "Answer III_3: \t Are you sure? Look back at the previous exercise and reconsider what happens."
+        )
+    if ansIII_3 == "E":
+        print(
+            "Answer III_3: \t Are you sure? Look back at the previous exercise and reconsider what happens."
+        )
+
+    if c == 6:
+        print(
+            "Well done! Your understanding of the possible scenarios is very good. Now we are going to test you some more, go to the next exercise."
+        )
+    if c == 0:
+        print(
+            "Mmm... I think you should go through the theory and this notebook again."
+        )
+    if (c > 0) & (c < 6):
+        print(
+            "Some of your answers are incorrect. Retrhink your answers or dicuss with your peers what the correct answers should be."
+        )
+
+
+# Function for cheking the third exercise:
+def Check3():
+    print(
+        "Question 1: \t If the cross-section gets really large, there is a point where the estuary/basin starts to act more as a normal coastline."
+    )
+    print(
+        "Question 2: \t A cross-sectional (area) going to inifity does not really have a physical meaning."
+    )
+    print(
+        "Question 3: \t Modifying the Escoffier curve means modifying the tidal prism, see the equation in this notebook. You can change the tidal prism in many ways. A possbility is damming the estuary, as is done with the Zuiderzee (now IJsselmeer) in The Netherlands. Another option is to dredge and/or reclaim land, altering the storage capacity of the estuary. "
+    )
+    print(
+        "Question 4: \t Ofcourse! Estuaries constantly change due to changes in sediment import/export and fluvial discharges. As long as the estuary is not in a steady equilibrium, the tidal prism can vary in time, and thus the closure curve."
+    )

coastal_dynamics-0.0.2/src/coastal_dynamics/maps.py

@@ -0,0 +1,31 @@
+import ipyleaflet
+from ipyleaflet import Map, Marker, ScaleControl, basemaps
+from ipywidgets import HTML
+
+
+def plot_esri_basemap(
+    lon: float, lat: float, zoom: int, name: str
+) -> ipyleaflet.leaflet.Map:
+    """Plot IPyleaflet map with ESRI basemap tiles.
+
+    Args:
+        lon (float): Longitude in degrees.
+        lat (float): Latitude in degrees.
+        zoom (int): Zoom level following OSM slippy map tiles.
+        name (str): Name for the marker.
+
+    Returns:
+        ipyleaflet.leaflet.Map: Basemap with ESRI World Imagery.
+    """
+    m = Map(basemap=basemaps.Esri.WorldImagery, scroll_wheel_zoom=True)
+    center = (lat, lon)
+    marker = Marker(location=center)
+    m.add_layer(marker)
+    m.center = center
+    m.zoom = zoom
+    m.layout.height = "800px"
+    m.add_control(ScaleControl(position="bottomleft"))
+    title = HTML()
+    title.value = name
+    marker.popup = title
+    return m

coastal_dynamics-0.0.2/src/coastal_dynamics/questions/factory.py

@@ -0,0 +1,87 @@
+from typing import Any
+
+from coastal_dynamics.questions.multiple_choice import MultipleChoiceQuestion
+from coastal_dynamics.questions.multiple_selection import MultipleSelectionQuestion
+from coastal_dynamics.questions.numeric import NumericQuestion
+
+
+class QuestionWidgetFactory:
+    """
+    A factory class for creating question widgets based on question data.
+
+    Attributes:
+        question_data (Dict[str, Any]): Dictionary containing data for the question.
+
+    Methods:
+        create_question_widget(): Creates a question widget based on the question data.
+    """
+
+    def __init__(self, question_data: dict[str, Any]):
+        self.question_data = question_data
+
+    def create_question_widget(self):
+        """Creates a question widget based on the question data."""
+        question_type = self.question_data.get("type")
+        valid_types = ["multiple_choice", "multiple_selection", "numeric"]
+
+        if question_type not in valid_types:
+            raise ValueError(f"Unknown question type: {question_type}")
+
+        if question_type == "multiple_choice":
+            return self._create_multiple_choice_question()
+        elif question_type == "multiple_selection":
+            return self._create_multiple_selection_question()
+        elif question_type == "numeric":
+            return self._create_numeric_question()
+
+    def _create_multiple_choice_question(self):
+        return MultipleChoiceQuestion(
+            question_name=self.question_data.get("name", ""),
+            question_text=self.question_data.get("question", ""),
+            question_options=self.question_data.get("options", {}),
+            question_answer=self.question_data.get("answer", ""),
+            **self.question_data.get("kwargs", {}),
+        )
+
+    def _create_multiple_selection_question(self):
+        return MultipleSelectionQuestion(
+            question_name=self.question_data.get("name", ""),
+            question_text=self.question_data.get("question", ""),
+            question_options=self.question_data.get("options", {}),
+            question_answers=self.question_data.get("answers", []),
+            **self.question_data.get("kwargs", {}),
+        )
+
+    def _create_numeric_question(self):
+        return NumericQuestion(
+            question_name=self.question_data.get("name", ""),
+            question_text=self.question_data.get("question", ""),
+            question_answer=self.question_data.get("answer", 0),
+            **self.question_data.get("kwargs", {}),
+        )
+
+
+if __name__ == "__main__":
+
+    def example():
+        question_data = {
+            "type": "multiple_choice",
+            "name": "q1",
+            "question": (
+                "Which of the following is a common along the coast in the middle"
+                " latitudes?"
+            ),
+            "options": {
+                "a": "Salt marshes",
+                "b": "Coral reefs",
+                "c": "Tropical rainforests",
+                "d": "Mangrove swamps",
+            },
+            "answer": "a",
+            "feedback": "...",
+            "hint": "...",
+        }
+        factory = QuestionWidgetFactory(question_data)
+        return factory.create_question_widget()
+
+    widget = example()

coastal_dynamics-0.0.2/src/coastal_dynamics/questions/multiple_choice.py

@@ -0,0 +1,130 @@
+import base64
+
+import panel as pn
+
+
+class MultipleChoiceQuestion:
+    """A class to create and manage a multiple choice question widget.
+
+    This class creates a multiple choice question using Panel widgets.
+    It supports question text, multiple options, and a single correct answer.
+    The correct answer is stored in an encrypted format for basic obfuscation.
+
+    Attributes:
+        question_text (str): The text of the question.
+        options (Dict[str, str]): A dictionary of option keys and their text.
+        correct_answer (str): The encrypted correct answer key.
+        name (str): The name of the question widget.
+        question_widget (pn.widgets.StaticText): The widget for displaying the question.
+        options_widget (pn.widgets.RadioBoxGroup): The widget for displaying the options.
+        submit_button (pn.widgets.Button): The button to submit the answer.
+        feedback_widget (pn.widgets.StaticText): The widget to display feedback.
+
+    Args:
+        question_name: (str): The name for the question widget.
+        question_text: (str): The question.
+        question_options: (str): The options for the question,
+        question_answerL: (str): The answer for the question,
+    """
+
+    def __init__(
+        self,
+        question_name: str,
+        question_text: str,
+        question_options: dict[str, str],
+        question_answer: str,
+        **kwargs
+    ):
+        self.question_text: str = question_text
+        self.options: dict[str, str] = question_options
+        self.correct_answer: str = self._encode_answer(question_answer)
+        self.name: str = question_name
+        self.question_widget: pn.widgets.StaticText
+        self.options_widget: pn.widgets.RadioBoxGroup
+        self.submit_button: pn.widgets.Button
+        self.feedback_widget: pn.widgets.StaticText
+        self.options_inverse: dict[str, str] = {v: k for k, v in self.options.items()}
+        self.create_widgets()
+
+    def create_widgets(self) -> None:
+        """Create and initialize the Panel widgets for the question."""
+        self.question_widget = pn.widgets.StaticText(
+            name=self.name, value=self.question_text
+        )
+        self.options_widget = pn.widgets.RadioBoxGroup(
+            name="Options", options=list(self.options.values())
+        )
+        self.submit_button = pn.widgets.Button(name="Submit")
+        self.feedback_widget = pn.widgets.StaticText()
+        self.submit_button.on_click(self._check_answer)
+
+    def _check_answer(self, event: pn.widgets.Button) -> None:
+        """Check the selected answer against the correct answer.
+
+        Args:
+            event (pn.widgets.Button): The event triggered by the submit button.
+        """
+        selected_option = self.options_inverse[self.options_widget.value]
+        decoded_answer = self._decode_answer(self.correct_answer)
+        if selected_option == decoded_answer:
+            self.feedback_widget.value = "Correct!"
+        else:
+            self.feedback_widget.value = "Incorrect, try again."
+
+    def _encode_answer(self, plain_answer: str) -> str:
+        """Encode the answer using base64.
+
+        Args:
+            plain_answer (str): The plain text answer to encode.
+
+        Returns:
+            str: The encoded answer.
+        """
+        return base64.b64encode(plain_answer.encode()).decode()
+
+    def _decode_answer(self, encoded_answer: str) -> str:
+        """Decode the encoded answer.
+
+        Args:
+            encoded_answer (str): The encoded answer to decode.
+
+        Returns:
+            str: The decoded answer.
+        """
+        return base64.b64decode(encoded_answer.encode()).decode()
+
+    def serve(self) -> pn.Column:
+        """Serve the question as a Panel column.
+
+        Returns:
+            pn.Column: The column containing the question and widgets.
+        """
+        return pn.Column(
+            self.question_widget,
+            self.options_widget,
+            self.submit_button,
+            self.feedback_widget,
+        )
+
+
+if __name__ == "__main__":
+    question_data = {
+        "question": (
+            "Which coastal system do you typically find in tide-dominated coasts?"
+        ),
+        "options": {
+            "a": "Mudflats",
+            "b": "Open coasts",
+            "c": "Cliffed coasts",
+            "d": "Mixed sand and gravel beaches",
+        },
+        "answer": "a",  # Multiple correct answers
+    }
+
+    mcq = MultipleChoiceQuestion(
+        question_name="Q1: Coastline Features Quiz",
+        question_text=question_data["question"],
+        question_options=question_data["options"],
+        question_answer=question_data["answer"],
+    )
+    print("done")

coastal_dynamics-0.0.2/src/coastal_dynamics/questions/multiple_selection.py

@@ -0,0 +1,109 @@
+import base64
+
+import panel as pn
+
+
+class MultipleSelectionQuestion:
+    """A class to create and manage multiple selection questions using Panel widgets.
+
+    This class creates a multiple selection using Panel widgets.
+    It supports question text, multiple options, and a multiple correct answers.
+    The correct answers are stored in an encrypted format for basic obfuscation.
+
+    Attributes:
+        question_text (str): The text of the question.
+        options (Dict[str, str]): A dictionary of option keys and their text.
+        correct_answers (List[str]): A list of base64-encoded correct answer keys.
+        name (str): The name of the question widget.
+        question_widget (pn.widgets.StaticText): Panel widget for displaying the question.
+        options_widget (pn.widgets.CheckBoxGroup): Panel widget for displaying options.
+        submit_button (pn.widgets.Button): Button widget for submitting the answer.
+        feedback_widget (pn.widgets.StaticText): Widget for showing feedback.
+        options_inverse (Dict[str, str]): Inverse mapping of options for easy lookup.
+
+    Args:
+        question_name: (str): The name for the question widget.
+        question_text: (str): The question.
+        question_options: (str): The options for the question,
+        question_answers: (str): The answer for the question,
+    """
+
+    def __init__(
+        self,
+        question_name: str,
+        question_text: str,
+        question_options: dict[str, str],
+        question_answers: list[str],
+        **kwargs,
+    ):
+        self.name: str = question_name
+        self.question_text: str = question_text
+        self.options: dict[str, str] = question_options
+        self.correct_answers: list[str] = [
+            self._encode_answer(ans) for ans in question_answers
+        ]
+        self.create_widgets()
+        self.options_inverse: dict[str, str] = {v: k for k, v in self.options.items()}
+
+    def create_widgets(self) -> None:
+        """Creates the Panel widgets for the question."""
+        self.question_widget = pn.widgets.StaticText(
+            name=self.name, value=self.question_text
+        )
+        self.options_widget = pn.widgets.CheckBoxGroup(
+            name="Options", options=list(self.options.values())
+        )
+        self.submit_button = pn.widgets.Button(name="Submit")
+        self.feedback_widget = pn.widgets.StaticText()
+        self.submit_button.on_click(self._check_answers)
+
+    def _check_answers(self, event: pn.widgets.Button) -> None:
+        """Checks the selected answers against the correct ones."""
+        selected_options = [
+            self.options_inverse[opt] for opt in self.options_widget.value
+        ]
+        decoded_answers = [
+            self._decode_answer(enc_ans) for enc_ans in self.correct_answers
+        ]
+        if set(selected_options) == set(decoded_answers):
+            self.feedback_widget.value = "Correct!"
+        else:
+            self.feedback_widget.value = "Incorrect, try again."
+
+    def _encode_answer(self, plain_answer: str) -> str:
+        """Encodes the answer using base64."""
+        return base64.b64encode(plain_answer.encode()).decode()
+
+    def _decode_answer(self, encoded_answer: str) -> str:
+        """Decodes the answer from base64."""
+        return base64.b64decode(encoded_answer.encode()).decode()
+
+    def serve(self) -> pn.Column:
+        """Serves the complete question widget."""
+        return pn.Column(
+            self.question_widget,
+            self.options_widget,
+            self.submit_button,
+            self.feedback_widget,
+        )
+
+
+if __name__ == "__main__":
+    question_data = {
+        "question": "Select all features commonly found along a coastline",
+        "options": {
+            "a": "Beaches",
+            "b": "Glaciers",
+            "c": "Estuaries",
+            "d": "Mountains",
+        },
+        "answers": ["a", "c"],  # Multiple correct answers
+    }
+
+    mcq = MultipleSelectionQuestion(
+        question_name="Q1: Coastline Features Quiz",
+        question_text=question_data["question"],
+        question_options=question_data["options"],
+        question_answers=question_data["answers"],
+    )
+    print("done")

coastal_dynamics-0.0.2/src/coastal_dynamics/questions/numeric.py

@@ -0,0 +1,86 @@
+import panel as pn
+
+
+class NumericQuestion:
+    """
+    A class to create and manage a numeric answer question widget.
+
+    This class creates a numeric question using Panel widgets.
+    It supports a question text, numeric answer, and precision for the answer.
+
+    Attributes:
+        question_text (str): The text of the question.
+        correct_answer (float): The correct numeric answer.
+        precision (int): The precision of the numeric answer.
+        name (str): The name of the question widget.
+        question_widget (pn.widgets.StaticText): The widget for displaying the question.
+        answer_input (pn.widgets.FloatInput): The widget for inputting the answer.
+        submit_button (pn.widgets.Button): The button to submit the answer.
+        feedback_widget (pn.widgets.StaticText): The widget to display feedback.
+
+    Args:
+        question_data (Dict[str, any]): The data for the question, including text and answer.
+        name (str): The name for the question widget.
+        precision (int): The precision for rounding the numeric answer.
+    """
+
+    def __init__(
+        self,
+        question_name: str,
+        question_text: str,
+        question_answer: float,
+        precision: int = 0,
+        **kwargs,
+    ):
+        self.name: str = question_name
+        self.question_text: str = question_text
+        self.precision: int = precision
+        self.correct_answer: float = round(float(question_answer), self.precision)
+        self.create_widgets()
+
+    def create_widgets(self) -> None:
+        """Create and initialize the Panel widgets for the question."""
+        self.question_widget = pn.widgets.StaticText(
+            name=self.name, value=self.question_text
+        )
+        self.answer_input = pn.widgets.FloatInput(name="Your Answer")
+        self.submit_button = pn.widgets.Button(name="Submit")
+        self.feedback_widget = pn.widgets.StaticText()
+        self.submit_button.on_click(self.check_answer)
+
+    def check_answer(self, event) -> None:
+        """Check the submitted answer against the correct answer."""
+        try:
+            user_answer = round(float(self.answer_input.value), self.precision)
+            if user_answer == self.correct_answer:
+                self.feedback_widget.value = "Correct!"
+            else:
+                self.feedback_widget.value = "Incorrect, try again."
+        except ValueError:
+            self.feedback_widget.value = "Please enter a valid number."
+
+    def serve(self) -> pn.Column:
+        """Serve the question as a Panel column."""
+        return pn.Column(
+            self.question_widget,
+            self.answer_input,
+            self.submit_button,
+            self.feedback_widget,
+        )
+
+
+if __name__ == "__main__":
+    # Example Usage
+    question_data = {
+        "question": "What is the relative importance of S2 vs M2?",
+        "answer": 0.33,
+        "kwargs": {"precision": 2},
+    }
+
+    nq = NumericQuestion(
+        question_name="Q3: Simple numeric question",
+        question_text=question_data["question"],
+        question_answer=question_data["answer"],
+        **question_data["kwargs"],
+    )
+    print("done")

coastal_dynamics-0.0.2/src/coastal_dynamics/visualization.py

@@ -0,0 +1,58 @@
+import warnings
+
+import numpy as np
+import pandas as pd
+import panel as pn
+
+pn.extension()
+
+warnings.filterwarnings("ignore", category=FutureWarning, module="holoviews.core.data")
+
+
+class DynamicWavePlot(pn.viewable.Viewer):
+    """
+    A class for creating a dynamic wave plot with adjustable parameters.
+
+    This class uses Panel widgets to create an interactive visualization
+    of a sine wave, where the amplitude 'a' and wavelength 'L' can be adjusted.
+
+    Attributes:
+        amplitude_slider (pn.widgets.FloatSlider): Slider to adjust the amplitude.
+        wavelength_slider (pn.widgets.FloatSlider): Slider to adjust the wavelength.
+        plot (pn.Column): A Panel Column containing the dynamic plot.
+    """
+
+    def __init__(
+        self,
+        amplitude_range: tuple[float, float, float],
+        wavelength_range: tuple[float, float, float],
+    ):
+        """Inits DynamicWavePlot with ranges for amplitude and wavelength sliders."""
+        self.amplitude_slider = pn.widgets.FloatSlider(
+            name="Amplitude [a]",
+            start=amplitude_range[0],
+            end=amplitude_range[1],
+            step=amplitude_range[2],
+            value=amplitude_range[0],
+        )
+        self.wavelength_slider = pn.widgets.FloatSlider(
+            name="Wavelength [L]",
+            start=wavelength_range[0],
+            end=wavelength_range[1],
+            step=wavelength_range[2],
+            value=wavelength_range[0],
+        )
+        self.plot = pn.bind(
+            self.generate_wave_plot, a=self.amplitude_slider, L=self.wavelength_slider
+        )
+
+    def generate_wave_plot(self, a: float, L: float):
+        """Generates a sine wave plot based on the given amplitude and wavelength."""
+        x = np.linspace(0, 12, 100)
+        eta = a * np.sin(2 * np.pi / L * x)
+        df = pd.DataFrame({"x": x, "eta": eta})
+        return df.hvplot.line(x="x", y="eta", grid=True, width=900, height=600)
+
+    def __panel__(self) -> pn.Column:
+        """Creates a Panel layout with the sliders and the plot."""
+        return pn.Column(self.amplitude_slider, self.wavelength_slider, self.plot)