Add everything from yfdashboard

.devcontainer/devcontainer.json

@@ -0,0 +1,49 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/docker-existing-docker-compose
+{
+	"name": "Existing Docker Compose (Extend)",
+
+	// Update the 'dockerComposeFile' list if you have more compose files or use different names.
+	// The .devcontainer/docker-compose.yml file contains any overrides you need/want to make.
+	"dockerComposeFile": [
+		"../docker-compose.yml",
+		"docker-compose.yml"
+	],
+
+	// The 'service' property is the name of the service for the container that VS Code should
+	// use. Update this value and .devcontainer/docker-compose.yml to the real service name.
+	"service": "streamlit",
+
+	// The optional 'workspaceFolder' property is the path VS Code should open by default when
+	// connected. This is typically a file mount in .devcontainer/docker-compose.yml
+	"workspaceFolder": "/app",
+	"customizations": {
+		"vscode": {
+			"extensions": [
+				"ms-python.python",
+				"ms-toolsai.jupyter"
+			]
+		}
+	}
+
+	// Features to add to the dev container. More info: https://containers.dev/features.
+	// "features": {},
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// Uncomment the next line if you want start specific services in your Docker Compose config.
+	// "runServices": [],
+
+	// Uncomment the next line if you want to keep your containers running after VS Code shuts down.
+	// "shutdownAction": "none",
+
+	// Uncomment the next line to run commands after the container is created.
+	// "postCreateCommand": "cat /etc/os-release",
+
+	// Configure tool-specific properties.
+	// "customizations": {},
+
+	// Uncomment to connect as an existing user other than the container default. More info: https://aka.ms/dev-containers-non-root.
+	// "remoteUser": "devcontainer"
+}

.devcontainer/docker-compose.yml

@@ -0,0 +1,27 @@
+version: '3.8'
+services:
+  # Update this to the name of the service you want to work with in your docker-compose.yml file
+  streamlit:
+    # Uncomment if you want to override the service's Dockerfile to one in the .devcontainer 
+    # folder. Note that the path of the Dockerfile and context is relative to the *primary* 
+    # docker-compose.yml file (the first in the devcontainer.json "dockerComposeFile"
+    # array). The sample below assumes your primary file is in the root of your project.
+    #
+    build:
+      dockerfile: ./Dockerfile
+      context: ./
+      target: development
+
+    volumes:
+      # Update this to wherever you want VS Code to mount the folder of your project
+      - .:/app:cached
+
+    # Uncomment the next four lines if you will use a ptrace-based debugger like C++, Go, and Rust.
+    # cap_add:
+    #   - SYS_PTRACE
+    # security_opt:
+    #   - seccomp:unconfined
+
+    # Overrides default command so things don't shut down after the process ends.
+    command: ["/bin/sh -c \"while sleep 1000; do :; done\""]
+ 

.gitignore

@@ -0,0 +1,166 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Streamlit
+secrets.toml
+
+.ipynb_checkpoints
+*.ipynb

Dockerfile

@@ -0,0 +1,37 @@
+FROM python:3.11-slim as base
+
+ENV APP_BASE_PATH="/app"
+ENV APP_SRC_PATH=${APP_BASE_PATH}/src
+ENV PYTHONPATH="${APP_SRC_PATH}:${PYTHONPATH}"
+WORKDIR $APP_BASE_PATH
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN pip3 install pip-tools
+COPY ./pyproject.toml .
+
+FROM base as pip-service
+
+COPY ./requirements.txt .
+RUN pip3 install -r requirements.txt
+
+FROM pip-service as service-setup
+EXPOSE 8501
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+ENTRYPOINT ["./start.sh"]
+
+FROM pip-service as service
+WORKDIR $APP_SRC_PATH
+COPY ./src .
+
+FROM service-setup as development
+WORKDIR $APP_BASE_PATH
+COPY ./dev-requirements.txt .
+RUN pip3 install -r dev-requirements.txt
+
+WORKDIR $APP_SRC_PATH

README.md

@@ -1,12 +1,55 @@
 ---
-title: Nfl Playoff Challenge Streamlit
-emoji: 😻
-colorFrom: pink
-colorTo: gray
+title: YFDash
+emoji: 🏃
+colorFrom: indigo
+colorTo: blue
 sdk: streamlit
 sdk_version: 1.29.0
-app_file: app.py
+app_file: src/Home.py
 pinned: false
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# nfl-playoff-challenge-steamlit Streamlit Application
+
+Template Repo for Streamlit Application - https://github.com/JonSolow/streamlit-template
+
+Here are some of the features of the template:
+
+- VSCode .devcontainer for local development: [Documentation](https://code.visualstudio.com/docs/devcontainers/containers)
+  - docker-compose.yml
+  - Dockerfile
+- Linting Configuration [TO-DO] (allows for clean code and quicker detection of possible bugs as one of the first steps in Shift-left testing)
+  - [Black](https://black.readthedocs.io/en/stable/index.html)
+  - [ruff](https://beta.ruff.rs/docs/)
+  - [mypy](https://mypy.readthedocs.io/en/stable/index.html)
+- Unit Tests
+  - [pytest](https://docs.pytest.org/)
+
+# Start Here to Develop
+
+1. Prerequisites
+
+- Install [Visual Studio Code](https://code.visualstudio.com/)
+- Install [Visual Studo Code Extension - Dev containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers)
+- Install [Docker](https://www.docker.com/)
+
+2. Confirm Docker is installed by executing command `docker -v`
+3. Open VSCode to a New Window and open this repository's directory
+4. You may see a notification that the Folder containers a Dev Container configuration file. If so, click on "Reopen in Container"
+
+- If you do not see this notification, press `F1` key and begin typing the following until you can see the option "Dev Containers: Rebuild and reopen in Container".
+- This action will reopen the VSCode within a Docker container suitable to develop and locally run the application.
+
+5. The dev container will start up the Streamlit application.
+
+- To access the application, navigate to http://localhost:8501
+  - The container forwards the port 8501 where the Streamlit application is hosted
+- Any changes made to the code will be reflected in the Streamlit application when you refresh.
+
+6. Now inside the VSCode dev container, to run tests, execute `./tests/run_tests.sh`
+
+- This script has an optional argument `-f` for "fix mode" which allows for configuration of black and ruff to automatically apply fixes.
+
+7. As functions are added to the application, unit tests can/should be added in `tests/unit`, with existing support utilizing the `pytest` library.

dev-requirements.txt

@@ -0,0 +1,463 @@
+#
+# This file is autogenerated by pip-compile with Python 3.11
+# by the following command:
+#
+#    pip-compile --extra=dev --output-file=dev-requirements.txt pyproject.toml
+#
+altair==5.2.0
+    # via streamlit
+annotated-types==0.6.0
+    # via pydantic
+anyio==4.1.0
+    # via
+    #   httpcore
+    #   jupyter-server
+argon2-cffi==23.1.0
+    # via jupyter-server
+argon2-cffi-bindings==21.2.0
+    # via argon2-cffi
+arrow==1.3.0
+    # via isoduration
+asttokens==2.4.1
+    # via stack-data
+async-lru==2.0.4
+    # via jupyterlab
+attrs==23.1.0
+    # via
+    #   jsonschema
+    #   referencing
+babel==2.13.1
+    # via jupyterlab-server
+beautifulsoup4==4.12.2
+    # via
+    #   nfl-playoff-challenge-steamlit (pyproject.toml)
+    #   nbconvert
+black==23.11.0
+    # via nfl-playoff-challenge-steamlit (pyproject.toml)
+bleach==6.1.0
+    # via nbconvert
+blinker==1.7.0
+    # via streamlit
+cachetools==5.3.2
+    # via streamlit
+certifi==2023.11.17
+    # via
+    #   httpcore
+    #   httpx
+    #   requests
+cffi==1.16.0
+    # via argon2-cffi-bindings
+charset-normalizer==3.3.2
+    # via requests
+click==8.1.7
+    # via
+    #   black
+    #   streamlit
+comm==0.2.0
+    # via
+    #   ipykernel
+    #   ipywidgets
+debugpy==1.8.0
+    # via ipykernel
+decorator==5.1.1
+    # via ipython
+defusedxml==0.7.1
+    # via nbconvert
+duckdb==0.9.2
+    # via nfl-playoff-challenge-steamlit (pyproject.toml)
+executing==2.0.1
+    # via stack-data
+fastjsonschema==2.19.0
+    # via nbformat
+fqdn==1.5.1
+    # via jsonschema
+gitdb==4.0.11
+    # via gitpython
+gitpython==3.1.40
+    # via streamlit
+h11==0.14.0
+    # via httpcore
+html5lib==1.1
+    # via nfl-playoff-challenge-steamlit (pyproject.toml)
+httpcore==0.17.3
+    # via httpx
+httpx==0.24.1
+    # via httpx-oauth
+httpx-oauth==0.13.0
+    # via streamlit-oauth
+idna==3.6
+    # via
+    #   anyio
+    #   httpx
+    #   jsonschema
+    #   requests
+importlib-metadata==6.9.0
+    # via streamlit
+iniconfig==2.0.0
+    # via pytest
+ipykernel==6.27.1
+    # via
+    #   jupyter
+    #   jupyter-console
+    #   jupyterlab
+    #   qtconsole
+ipython==8.18.1
+    # via
+    #   ipykernel
+    #   ipywidgets
+    #   jupyter-console
+ipywidgets==8.1.1
+    # via jupyter
+isoduration==20.11.0
+    # via jsonschema
+jedi==0.19.1
+    # via ipython
+jinja2==3.1.2
+    # via
+    #   altair
+    #   jupyter-server
+    #   jupyterlab
+    #   jupyterlab-server
+    #   nbconvert
+    #   pydeck
+json5==0.9.14
+    # via jupyterlab-server
+jsonpointer==2.4
+    # via jsonschema
+jsonschema[format-nongpl]==4.20.0
+    # via
+    #   altair
+    #   jupyter-events
+    #   jupyterlab-server
+    #   nbformat
+jsonschema-specifications==2023.11.2
+    # via jsonschema
+jupyter==1.0.0
+    # via nfl-playoff-challenge-steamlit (pyproject.toml)
+jupyter-client==8.6.0
+    # via
+    #   ipykernel
+    #   jupyter-console
+    #   jupyter-server
+    #   nbclient
+    #   qtconsole
+jupyter-console==6.6.3
+    # via jupyter
+jupyter-core==5.5.0
+    # via
+    #   ipykernel
+    #   jupyter-client
+    #   jupyter-console
+    #   jupyter-server
+    #   jupyterlab
+    #   nbclient
+    #   nbconvert
+    #   nbformat
+    #   qtconsole
+jupyter-events==0.9.0
+    # via jupyter-server
+jupyter-lsp==2.2.1
+    # via jupyterlab
+jupyter-server==2.11.1
+    # via
+    #   jupyter-lsp
+    #   jupyterlab
+    #   jupyterlab-server
+    #   notebook
+    #   notebook-shim
+jupyter-server-terminals==0.4.4
+    # via jupyter-server
+jupyterlab==4.0.9
+    # via notebook
+jupyterlab-pygments==0.3.0
+    # via nbconvert
+jupyterlab-server==2.25.2
+    # via
+    #   jupyterlab
+    #   notebook
+jupyterlab-widgets==3.0.9
+    # via ipywidgets
+lxml==4.9.3
+    # via nfl-playoff-challenge-steamlit (pyproject.toml)
+lxml-stubs==0.4.0
+    # via nfl-playoff-challenge-steamlit (pyproject.toml)
+markdown-it-py==3.0.0
+    # via rich
+markupsafe==2.1.3
+    # via
+    #   jinja2
+    #   nbconvert
+matplotlib-inline==0.1.6
+    # via
+    #   ipykernel
+    #   ipython
+mdurl==0.1.2
+    # via markdown-it-py
+mistune==3.0.2
+    # via nbconvert
+mypy==1.7.1
+    # via nfl-playoff-challenge-steamlit (pyproject.toml)
+mypy-extensions==1.0.0
+    # via
+    #   black
+    #   mypy
+nbclient==0.9.0
+    # via nbconvert
+nbconvert==7.11.0
+    # via
+    #   jupyter
+    #   jupyter-server
+nbformat==5.9.2
+    # via
+    #   jupyter-server
+    #   nbclient
+    #   nbconvert
+nest-asyncio==1.5.8
+    # via ipykernel
+notebook==7.0.6
+    # via jupyter
+notebook-shim==0.2.3
+    # via
+    #   jupyterlab
+    #   notebook
+numpy==1.26.2
+    # via
+    #   nfl-playoff-challenge-steamlit (pyproject.toml)
+    #   altair
+    #   pandas
+    #   pandas-stubs
+    #   pyarrow
+    #   pydeck
+    #   streamlit
+overrides==7.4.0
+    # via jupyter-server
+packaging==23.2
+    # via
+    #   altair
+    #   black
+    #   ipykernel
+    #   jupyter-server
+    #   jupyterlab
+    #   jupyterlab-server
+    #   nbconvert
+    #   pytest
+    #   qtconsole
+    #   qtpy
+    #   streamlit
+pandas==2.1.3
+    # via
+    #   nfl-playoff-challenge-steamlit (pyproject.toml)
+    #   altair
+    #   streamlit
+pandas-stubs==2.1.1.230928
+    # via nfl-playoff-challenge-steamlit (pyproject.toml)
+pandocfilters==1.5.0
+    # via nbconvert
+parso==0.8.3
+    # via jedi
+pathspec==0.11.2
+    # via black
+pexpect==4.9.0
+    # via ipython
+pillow==10.1.0
+    # via streamlit
+platformdirs==4.0.0
+    # via
+    #   black
+    #   jupyter-core
+pluggy==1.3.0
+    # via pytest
+prometheus-client==0.19.0
+    # via jupyter-server
+prompt-toolkit==3.0.41
+    # via
+    #   ipython
+    #   jupyter-console
+protobuf==4.25.1
+    # via streamlit
+psutil==5.9.6
+    # via ipykernel
+ptyprocess==0.7.0
+    # via
+    #   pexpect
+    #   terminado
+pure-eval==0.2.2
+    # via stack-data
+pyarrow==14.0.1
+    # via streamlit
+pycparser==2.21
+    # via cffi
+pydantic==2.5.2
+    # via nfl-playoff-challenge-steamlit (pyproject.toml)
+pydantic-core==2.14.5
+    # via pydantic
+pydeck==0.8.1b0
+    # via streamlit
+pygments==2.17.2
+    # via
+    #   ipython
+    #   jupyter-console
+    #   nbconvert
+    #   qtconsole
+    #   rich
+pytest==7.4.3
+    # via nfl-playoff-challenge-steamlit (pyproject.toml)
+python-dateutil==2.8.2
+    # via
+    #   arrow
+    #   jupyter-client
+    #   pandas
+    #   streamlit
+python-dotenv==1.0.0
+    # via streamlit-oauth
+python-json-logger==2.0.7
+    # via jupyter-events
+pytz==2023.3.post1
+    # via pandas
+pyyaml==6.0.1
+    # via jupyter-events
+pyzmq==25.1.1
+    # via
+    #   ipykernel
+    #   jupyter-client
+    #   jupyter-console
+    #   jupyter-server
+    #   qtconsole
+qtconsole==5.5.1
+    # via jupyter
+qtpy==2.4.1
+    # via qtconsole
+referencing==0.31.1
+    # via
+    #   jsonschema
+    #   jsonschema-specifications
+    #   jupyter-events
+requests==2.31.0
+    # via
+    #   jupyterlab-server
+    #   streamlit
+rfc3339-validator==0.1.4
+    # via
+    #   jsonschema
+    #   jupyter-events
+rfc3986-validator==0.1.1
+    # via
+    #   jsonschema
+    #   jupyter-events
+rich==13.7.0
+    # via streamlit
+rpds-py==0.13.2
+    # via
+    #   jsonschema
+    #   referencing
+ruff==0.1.6
+    # via nfl-playoff-challenge-steamlit (pyproject.toml)
+send2trash==1.8.2
+    # via jupyter-server
+six==1.16.0
+    # via
+    #   asttokens
+    #   bleach
+    #   html5lib
+    #   python-dateutil
+    #   rfc3339-validator
+smmap==5.0.1
+    # via gitdb
+sniffio==1.3.0
+    # via
+    #   anyio
+    #   httpcore
+    #   httpx
+soupsieve==2.5
+    # via beautifulsoup4
+stack-data==0.6.3
+    # via ipython
+streamlit==1.29.0
+    # via
+    #   nfl-playoff-challenge-steamlit (pyproject.toml)
+    #   streamlit-oauth
+streamlit-oauth==0.1.5
+    # via nfl-playoff-challenge-steamlit (pyproject.toml)
+tenacity==8.2.3
+    # via streamlit
+terminado==0.18.0
+    # via
+    #   jupyter-server
+    #   jupyter-server-terminals
+tinycss2==1.2.1
+    # via nbconvert
+toml==0.10.2
+    # via streamlit
+toolz==0.12.0
+    # via altair
+tornado==6.4
+    # via
+    #   ipykernel
+    #   jupyter-client
+    #   jupyter-server
+    #   jupyterlab
+    #   notebook
+    #   streamlit
+    #   terminado
+traitlets==5.14.0
+    # via
+    #   comm
+    #   ipykernel
+    #   ipython
+    #   ipywidgets
+    #   jupyter-client
+    #   jupyter-console
+    #   jupyter-core
+    #   jupyter-events
+    #   jupyter-server
+    #   jupyterlab
+    #   matplotlib-inline
+    #   nbclient
+    #   nbconvert
+    #   nbformat
+    #   qtconsole
+types-beautifulsoup4==4.12.0.7
+    # via nfl-playoff-challenge-steamlit (pyproject.toml)
+types-html5lib==1.1.11.15
+    # via types-beautifulsoup4
+types-python-dateutil==2.8.19.14
+    # via arrow
+types-pytz==2023.3.1.1
+    # via pandas-stubs
+types-requests==2.31.0.10
+    # via nfl-playoff-challenge-steamlit (pyproject.toml)
+typing-extensions==4.8.0
+    # via
+    #   mypy
+    #   pydantic
+    #   pydantic-core
+    #   streamlit
+tzdata==2023.3
+    # via pandas
+tzlocal==5.2
+    # via streamlit
+uri-template==1.3.0
+    # via jsonschema
+urllib3==2.1.0
+    # via
+    #   requests
+    #   types-requests
+validators==0.22.0
+    # via streamlit
+watchdog==3.0.0
+    # via streamlit
+wcwidth==0.2.12
+    # via prompt-toolkit
+webcolors==1.13
+    # via jsonschema
+webencodings==0.5.1
+    # via
+    #   bleach
+    #   html5lib
+    #   tinycss2
+websocket-client==1.6.4
+    # via jupyter-server
+widgetsnbextension==4.0.9
+    # via ipywidgets
+zipp==3.17.0
+    # via importlib-metadata

docker-compose.yml

@@ -0,0 +1,11 @@
+services:
+  streamlit:
+    build:
+      dockerfile: ./Dockerfile
+      context: ./
+      target: service
+    ports:
+      - '8501:8501'
+    environment:
+      - USER_ID=1000
+      - GROUP_ID=1000

pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools"]
+
+[project]
+requires-python = ">=3.9"
+version = "1"
+name = "nfl-playoff-challenge-steamlit"
+dependencies = [
+    "streamlit",
+    "beautifulsoup4",
+    "duckdb",
+    "html5lib",
+    "lxml",
+    "numpy",
+    "pandas",
+    "pydantic",
+    "streamlit-oauth",
+    ]
+
+[project.optional-dependencies]
+dev = [
+    "black",
+    "jupyter",
+    "lxml-stubs",
+    "mypy",
+    "pytest",
+    "pandas-stubs",
+    "ruff",
+    "types-beautifulsoup4",
+    "types-requests",
+    ]
+
+[tool.black]
+line-length = 120
+target-version = ["py311"]
+
+[tool.ruff]
+line-length = 120
+src = ["src"]
+
+[tool.mypy]
+python_version = "3.11"
+
+[[tool.mypy.overrides]]
+module = [
+    'streamlit_oauth'
+]
+ignore_missing_imports = true

regenerate_requirements.sh

@@ -0,0 +1,19 @@
+
+#!/bin/bash
+
+set -ex
+
+ADDITIONAL_ARGS=$@
+
+pip-compile \
+    -o requirements.txt \
+    $ADDITIONAL_ARGS \
+    pyproject.toml
+    
+pip-compile \
+    --extra=dev \
+    -o dev-requirements.txt \
+    $ADDITIONAL_ARGS \
+    pyproject.toml
+
+python update_streamlit_version.py

requirements.txt

@@ -0,0 +1,167 @@
+#
+# This file is autogenerated by pip-compile with Python 3.11
+# by the following command:
+#
+#    pip-compile --output-file=requirements.txt pyproject.toml
+#
+altair==5.2.0
+    # via streamlit
+annotated-types==0.6.0
+    # via pydantic
+anyio==4.1.0
+    # via httpcore
+attrs==23.1.0
+    # via
+    #   jsonschema
+    #   referencing
+beautifulsoup4==4.12.2
+    # via nfl-playoff-challenge-steamlit (pyproject.toml)
+blinker==1.7.0
+    # via streamlit
+cachetools==5.3.2
+    # via streamlit
+certifi==2023.11.17
+    # via
+    #   httpcore
+    #   httpx
+    #   requests
+charset-normalizer==3.3.2
+    # via requests
+click==8.1.7
+    # via streamlit
+duckdb==0.9.2
+    # via nfl-playoff-challenge-steamlit (pyproject.toml)
+gitdb==4.0.11
+    # via gitpython
+gitpython==3.1.40
+    # via streamlit
+h11==0.14.0
+    # via httpcore
+html5lib==1.1
+    # via nfl-playoff-challenge-steamlit (pyproject.toml)
+httpcore==0.17.3
+    # via httpx
+httpx==0.24.1
+    # via httpx-oauth
+httpx-oauth==0.13.0
+    # via streamlit-oauth
+idna==3.6
+    # via
+    #   anyio
+    #   httpx
+    #   requests
+importlib-metadata==6.9.0
+    # via streamlit
+jinja2==3.1.2
+    # via
+    #   altair
+    #   pydeck
+jsonschema==4.20.0
+    # via altair
+jsonschema-specifications==2023.11.2
+    # via jsonschema
+lxml==4.9.3
+    # via nfl-playoff-challenge-steamlit (pyproject.toml)
+markdown-it-py==3.0.0
+    # via rich
+markupsafe==2.1.3
+    # via jinja2
+mdurl==0.1.2
+    # via markdown-it-py
+numpy==1.26.2
+    # via
+    #   nfl-playoff-challenge-steamlit (pyproject.toml)
+    #   altair
+    #   pandas
+    #   pyarrow
+    #   pydeck
+    #   streamlit
+packaging==23.2
+    # via
+    #   altair
+    #   streamlit
+pandas==2.1.3
+    # via
+    #   nfl-playoff-challenge-steamlit (pyproject.toml)
+    #   altair
+    #   streamlit
+pillow==10.1.0
+    # via streamlit
+protobuf==4.25.1
+    # via streamlit
+pyarrow==14.0.1
+    # via streamlit
+pydantic==2.5.2
+    # via nfl-playoff-challenge-steamlit (pyproject.toml)
+pydantic-core==2.14.5
+    # via pydantic
+pydeck==0.8.1b0
+    # via streamlit
+pygments==2.17.2
+    # via rich
+python-dateutil==2.8.2
+    # via
+    #   pandas
+    #   streamlit
+python-dotenv==1.0.0
+    # via streamlit-oauth
+pytz==2023.3.post1
+    # via pandas
+referencing==0.31.1
+    # via
+    #   jsonschema
+    #   jsonschema-specifications
+requests==2.31.0
+    # via streamlit
+rich==13.7.0
+    # via streamlit
+rpds-py==0.13.2
+    # via
+    #   jsonschema
+    #   referencing
+six==1.16.0
+    # via
+    #   html5lib
+    #   python-dateutil
+smmap==5.0.1
+    # via gitdb
+sniffio==1.3.0
+    # via
+    #   anyio
+    #   httpcore
+    #   httpx
+soupsieve==2.5
+    # via beautifulsoup4
+streamlit==1.29.0
+    # via
+    #   nfl-playoff-challenge-steamlit (pyproject.toml)
+    #   streamlit-oauth
+streamlit-oauth==0.1.5
+    # via nfl-playoff-challenge-steamlit (pyproject.toml)
+tenacity==8.2.3
+    # via streamlit
+toml==0.10.2
+    # via streamlit
+toolz==0.12.0
+    # via altair
+tornado==6.4
+    # via streamlit
+typing-extensions==4.8.0
+    # via
+    #   pydantic
+    #   pydantic-core
+    #   streamlit
+tzdata==2023.3
+    # via pandas
+tzlocal==5.2
+    # via streamlit
+urllib3==2.1.0
+    # via requests
+validators==0.22.0
+    # via streamlit
+watchdog==3.0.0
+    # via streamlit
+webencodings==0.5.1
+    # via html5lib
+zipp==3.17.0
+    # via importlib-metadata

src/.streamlit/config.toml

@@ -0,0 +1,2 @@
+[theme]
+base="dark"

src/Home.py

@@ -0,0 +1,27 @@
+import streamlit as st
+
+from config import DEFAULT_ICON, LEAGUE_NAME
+from login_component import get_authorization_button
+from page_selector import remove_seasonal_pages
+
+
+def get_app():
+    keeper_title = f"{LEAGUE_NAME}"
+    st.set_page_config(page_title=keeper_title, page_icon=DEFAULT_ICON)
+    get_authorization_button()
+    st.markdown(
+        f"""
+    Welcome {LEAGUE_NAME}!
+    
+    Navigate between pages using the left sidebar.  
+    
+    If the sidebar is not visible, click the **>** in the upper left corner to open.
+                
+                """
+    )
+
+    remove_seasonal_pages()
+
+
+if __name__ == "__main__":
+    get_app()

src/config.py

@@ -0,0 +1,3 @@
+LEAGUE_NAME = "LOFG"
+DEFAULT_ICON = "🏉"
+LEAGUE_NUMBER_TEAMS = 12

src/domain/conferences.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+from typing import List
+
+
+@dataclass
+class NFLConference:
+    name: str
+    short_name: str
+
+    def __post_init__(self):
+        ALL_CONFERENCES.append(self)
+
+
+ALL_CONFERENCES: List[NFLConference] = []
+
+NFC = NFLConference(name="National Football Conference", short_name="NFC")
+AFC = NFLConference(name="American Football Conference", short_name="AFC")

src/domain/divisions.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass
+from typing import List
+from domain import conferences
+
+
+@dataclass
+class NFLDivision:
+    name: str
+    conference: conferences.NFLConference
+
+    def __post_init__(self):
+        ALL_DIVISIONS.append(self)
+
+
+ALL_DIVISIONS: List[NFLDivision] = []
+
+NFCWest = NFLDivision(name="NFC West", conference=conferences.NFC)
+NFCNorth = NFLDivision(name="NFC North", conference=conferences.NFC)
+NFCSouth = NFLDivision(name="NFC South", conference=conferences.NFC)
+NFCEast = NFLDivision(name="NFC East", conference=conferences.NFC)
+AFCWest = NFLDivision(name="AFC West", conference=conferences.AFC)
+AFCNorth = NFLDivision(name="AFC North", conference=conferences.AFC)
+AFCSouth = NFLDivision(name="AFC South", conference=conferences.AFC)
+AFCEast = NFLDivision(name="AFC East", conference=conferences.AFC)

src/domain/teams.py

@@ -0,0 +1,286 @@
+from dataclasses import dataclass
+from urllib.parse import urljoin
+from typing import List
+from domain.conferences import NFLConference
+from domain import divisions
+
+
+@dataclass
+class NFLTeam:
+    team_name: str
+    team_short_name: str
+    city: str
+    division: divisions.NFLDivision
+    footballguys_short_name: str = ""
+    url: str = ""
+    injury_report_suffix: str = "/team/injury-report/"
+
+    def __post_init__(self):
+        self.footballguys_short_name = (
+            self.team_short_name if self.footballguys_short_name == "" else self.footballguys_short_name
+        )
+        self.conference: NFLConference = self.division.conference
+        self.injury_report_url = urljoin(self.url, self.injury_report_suffix)
+        self.team_full_name = " ".join([self.city, self.team_name])
+
+        ALL_TEAMS.append(self)
+
+
+ALL_TEAMS: List[NFLTeam] = []
+
+
+arizona_cardinals = NFLTeam(
+    team_name="Cardinals",
+    team_short_name="ARI",
+    city="Arizona",
+    division=divisions.NFCWest,
+    url="https://www.azcardinals.com/",
+)
+
+atlanta_falcons = NFLTeam(
+    team_name="Falcons",
+    team_short_name="ATL",
+    city="Atlanta",
+    division=divisions.NFCSouth,
+    url="https://www.atlantafalcons.com/",
+)
+
+baltimore_ravens = NFLTeam(
+    team_name="Ravens",
+    team_short_name="BAL",
+    city="Baltimore",
+    division=divisions.AFCNorth,
+    url="https://www.baltimoreravens.com/",
+)
+
+buffalo_bills = NFLTeam(
+    team_name="Bills",
+    team_short_name="BUF",
+    city="Buffalo",
+    division=divisions.AFCEast,
+    url="https://www.buffalobills.com/",
+)
+
+carolina_panthers = NFLTeam(
+    team_name="Panthers",
+    team_short_name="CAR",
+    city="Carolina",
+    division=divisions.NFCSouth,
+    url="https://www.panthers.com/",
+)
+
+chicago_bears = NFLTeam(
+    team_name="Bears",
+    team_short_name="CHI",
+    city="Chicago",
+    division=divisions.NFCNorth,
+    url="https://www.chicagobears.com/",
+)
+
+cincinnati_bengals = NFLTeam(
+    team_name="Bengals",
+    team_short_name="CIN",
+    city="Cincinnati",
+    division=divisions.AFCNorth,
+    url="https://www.bengals.com/",
+)
+
+cleveland_browns = NFLTeam(
+    team_name="Browns",
+    team_short_name="CLE",
+    city="Cleveland",
+    division=divisions.AFCNorth,
+    url="https://www.clevelandbrowns.com/",
+)
+
+dallas_cowboys = NFLTeam(
+    team_name="Cowboys",
+    team_short_name="DAL",
+    city="Dallas",
+    division=divisions.NFCEast,
+    url="https://www.dallascowboys.com/",
+)
+
+denver_broncos = NFLTeam(
+    team_name="Broncos",
+    team_short_name="DEN",
+    city="Denver",
+    division=divisions.AFCWest,
+    url="https://www.denverbroncos.com/",
+)
+
+detroit_lions = NFLTeam(
+    team_name="Lions",
+    team_short_name="DET",
+    city="Detroit",
+    division=divisions.NFCNorth,
+    url="https://www.detroitlions.com/",
+)
+
+green_bay_packers = NFLTeam(
+    team_name="Packers",
+    team_short_name="GB",
+    city="Green Bay",
+    division=divisions.NFCNorth,
+    url="https://www.packers.com/",
+)
+
+houston_texans = NFLTeam(
+    team_name="Texans",
+    team_short_name="HOU",
+    city="Houston",
+    division=divisions.AFCSouth,
+    url="https://www.houstontexans.com/",
+)
+
+indianapolis_colts = NFLTeam(
+    city="Indianapolis",
+    team_name="Colts",
+    team_short_name="IND",
+    division=divisions.AFCSouth,
+    url="https://www.colts.com/",
+)
+
+jacksonville_jaguars = NFLTeam(
+    city="Jacksonville",
+    team_name="Jaguars",
+    team_short_name="JAX",
+    division=divisions.AFCSouth,
+    url="https://www.jaguars.com/",
+)
+
+kansas_city_chiefs = NFLTeam(
+    city="Kansas City",
+    team_name="Chiefs",
+    team_short_name="KC",
+    division=divisions.AFCWest,
+    url="https://www.chiefs.com/",
+)
+
+las_vegas_raiders = NFLTeam(
+    city="Las Vegas",
+    team_name="Raiders",
+    team_short_name="LV",
+    division=divisions.AFCWest,
+    url="https://www.raiders.com/",
+)
+
+los_angeles_chargers = NFLTeam(
+    city="Los Angeles",
+    team_name="Chargers",
+    team_short_name="LAC",
+    division=divisions.AFCWest,
+    url="https://www.chargers.com/",
+)
+
+los_angeles_rams = NFLTeam(
+    city="Los Angeles",
+    team_name="Rams",
+    team_short_name="LAR",
+    division=divisions.NFCWest,
+    url="https://www.therams.com/",
+)
+
+miami_dolphins = NFLTeam(
+    city="Miami",
+    team_name="Dolphins",
+    team_short_name="MIA",
+    division=divisions.AFCEast,
+    url="https://www.miamidolphins.com/",
+)
+
+minnesota_vikings = NFLTeam(
+    city="Minnesota",
+    team_name="Vikings",
+    team_short_name="MIN",
+    division=divisions.NFCNorth,
+    url="https://www.vikings.com/",
+)
+
+new_england_patriots = NFLTeam(
+    city="New England",
+    team_name="Patriots",
+    team_short_name="NE",
+    division=divisions.AFCEast,
+    url="https://www.patriots.com/",
+)
+
+new_orleans_saints = NFLTeam(
+    city="New Orleans",
+    team_name="Saints",
+    team_short_name="NO",
+    division=divisions.NFCSouth,
+    url="https://www.neworleanssaints.com/",
+)
+
+new_york_giants = NFLTeam(
+    city="New York",
+    team_name="Giants",
+    team_short_name="NYG",
+    division=divisions.NFCEast,
+    url="https://www.giants.com/",
+)
+
+new_york_jets = NFLTeam(
+    city="New York",
+    team_name="Jets",
+    team_short_name="NYJ",
+    division=divisions.AFCEast,
+    url="https://www.newyorkjets.com/",
+)
+
+philadelphia_eagles = NFLTeam(
+    city="Philadelphia",
+    team_name="Eagles",
+    team_short_name="PHI",
+    division=divisions.NFCEast,
+    url="https://www.philadelphiaeagles.com/",
+)
+
+pittsburgh_steelers = NFLTeam(
+    city="Pittsburgh",
+    team_name="Steelers",
+    team_short_name="PIT",
+    division=divisions.AFCNorth,
+    url="https://www.steelers.com/",
+)
+
+san_francisco_49ers = NFLTeam(
+    city="San Francisco",
+    team_name="49ers",
+    team_short_name="SF",
+    division=divisions.NFCWest,
+    url="https://www.49ers.com/",
+)
+
+seattle_seahawks = NFLTeam(
+    city="Seattle",
+    team_name="Seahawks",
+    team_short_name="SEA",
+    division=divisions.NFCWest,
+    url="https://www.seahawks.com/",
+)
+
+tampa_bay_buccaneers = NFLTeam(
+    city="Tampa Bay",
+    team_name="Buccaneers",
+    team_short_name="TB",
+    division=divisions.NFCSouth,
+    url="https://www.buccaneers.com/",
+)
+
+tennessee_titans = NFLTeam(
+    city="Tennessee",
+    team_name="Titans",
+    team_short_name="TEN",
+    division=divisions.AFCSouth,
+    url="https://www.tennesseetitans.com/",
+)
+
+washington_football_team = NFLTeam(
+    city="Washington",
+    team_name="Commanders",
+    team_short_name="WAS",
+    division=divisions.NFCEast,
+    url="https://www.commanders.com/",
+)

src/login_component.py

@@ -0,0 +1,53 @@
+import streamlit as st
+
+from streamlit_oauth import OAuth2Component
+import os
+
+# # Load environment variables from .env file
+# from dotenv import load_dotenv
+# load_dotenv()
+
+# Set environment variables
+AUTHORIZE_URL = os.environ.get("AUTHORIZE_URL")
+TOKEN_URL = os.environ.get("TOKEN_URL")
+REFRESH_TOKEN_URL = os.environ.get("REFRESH_TOKEN_URL")
+REVOKE_TOKEN_URL = os.environ.get("REVOKE_TOKEN_URL")
+CLIENT_ID = os.environ.get("CLIENT_ID")
+CLIENT_SECRET = os.environ.get("CLIENT_SECRET")
+REDIRECT_URI = os.environ.get("REDIRECT_URI")
+SCOPE = os.environ.get("SCOPE")
+
+ENABLE_LOGIN = os.environ.get("ENABLE_LOGIN", False)
+
+# Create OAuth2Component instance
+oauth2 = OAuth2Component(CLIENT_ID, CLIENT_SECRET, AUTHORIZE_URL, TOKEN_URL, REFRESH_TOKEN_URL, REVOKE_TOKEN_URL)
+
+
+def is_token_in_session() -> bool:
+    return "token" in st.session_state
+
+
+def get_authorization_button():
+    if not ENABLE_LOGIN:
+        return
+    # Check if token exists in session state
+    if not is_token_in_session():
+        # If not, show authorize button
+        result = oauth2.authorize_button("Login", REDIRECT_URI, SCOPE)
+        if result and "token" in result:
+            # If authorization successful, save token in session state
+            st.session_state.token = result.get("token")
+            st.rerun()
+    else:
+        # # If token exists in session state, allow logout
+        st.session_state["token"]
+        if st.button("Logout"):
+            del st.session_state.token
+            st.rerun()
+        # # If token exists in session state, show the token
+        # token = st.session_state["token"]
+        # if st.button("Refresh Token"):
+        #     # If refresh token button is clicked, refresh the token
+        #     token = oauth2.refresh_token(token)
+        #     st.session_state.token = token
+        #     st.rerun()

src/maximum_roster_strategy/data_loader.py

@@ -0,0 +1,19 @@
+import os
+import pandas as pd
+
+
+MRS_SHEET_ID = os.environ.get("MRS_SHEET_ID")
+
+
+def get_google_sheet_data() -> pd.DataFrame:
+    return get_sheet_data(0)
+
+
+def get_sheet_data(sheet_id: int = 0):
+    sheet_url = f"https://docs.google.com/spreadsheet/ccc?key={MRS_SHEET_ID}&output=csv&gid={sheet_id}"
+    df = pd.read_csv(sheet_url)
+    return df
+
+
+def get_timeslot_labels() -> pd.DataFrame:
+    return get_sheet_data(1875906423)

src/page_selector.py

@@ -0,0 +1,40 @@
+from streamlit.source_util import _on_pages_changed, get_pages
+
+# Adapted from https://discuss.streamlit.io/t/how-to-hide-all-pages-before-login/32508
+# Note this code is intended to remove pages at app load time, not based on login
+
+SEASON_MODE = "season"
+OFFSEASON_MODE = "offseason"
+
+CURRENT_MODE = SEASON_MODE
+
+MAIN_PAGE_FILE = "Home.py"
+
+MODE_PAGE_EXCLUSION_MAP = {
+    SEASON_MODE: [
+        "Keepers",
+        "ECR",
+        "League_Simulation",
+        "Keeper_Rules",
+        "Maximum_Roster_Strategy",
+    ],
+    OFFSEASON_MODE: [
+        "Practice_Reports",
+        "League_Simulation",
+        "Maximum_Roster_Strategy",
+    ],
+}
+
+
+def remove_seasonal_pages():
+    all_pages = get_pages(MAIN_PAGE_FILE)
+    pages_to_remove = MODE_PAGE_EXCLUSION_MAP[CURRENT_MODE]
+
+    page_keys_to_remove = []
+    for k, v in all_pages.items():
+        if v["page_name"] in pages_to_remove:
+            page_keys_to_remove.append(k)
+    for k_remove in page_keys_to_remove:
+        del all_pages[k_remove]
+
+    _on_pages_changed.send()

src/pages/10_Player_News.py

@@ -0,0 +1,53 @@
+import datetime
+import streamlit as st
+
+from config import DEFAULT_ICON
+from shared_page import common_page_config
+
+from queries.nbcsports.player_news import get_player_news_window_hours
+
+
+@st.cache_data(ttl=60 * 60 * 24)
+def load_data():
+    data = get_player_news_window_hours(24)
+    teams_list = sorted(filter(None, data.Team.unique()))
+    position_list = data.Position.unique()
+    data_load_time_str = datetime.datetime.utcnow().strftime("%m/%d/%Y %I:%M %p")
+    return data, teams_list, position_list, data_load_time_str
+
+
+def get_page():
+    page_title = "Player News - Last 24 Hours"
+    st.set_page_config(page_title=page_title, page_icon=DEFAULT_ICON, layout="wide")
+    common_page_config()
+    st.title(page_title)
+    if st.button("Refresh Data"):
+        st.cache_data.clear()
+    data, teams_list, position_list, data_load_time_str = load_data()
+    st.write(f"Data loaded as of: {data_load_time_str} UTC")
+
+    teams_selected = st.multiselect("Team:", teams_list, placeholder="Select a team to filter") or teams_list
+
+    with st.container():
+        filtered_data = data[(data.Team.isin(teams_selected))]
+        st.dataframe(
+            filtered_data,
+            hide_index=True,
+            height=35 * (len(filtered_data) + 1) + 12,
+            use_container_width=True,
+            column_order=[
+                "Date/Time",
+                "Name",
+                "Headline",
+                "Team",
+                "Position",
+            ],
+            column_config={
+                "Date/Time": st.column_config.DatetimeColumn(format="MM-DD HH:mm"),
+                "Team": st.column_config.TextColumn(width="small"),
+            },
+        )
+
+
+if __name__ == "__main__":
+    get_page()

src/pages/11_Next_Gen_Stats.py

@@ -0,0 +1,70 @@
+import streamlit as st
+
+from config import DEFAULT_ICON
+from shared_page import common_page_config
+
+from streamlit_filter import get_multiselect_for_df_column
+from queries.nflverse.github_data import get_nextgen_stats, get_current_tables, SEASON
+
+
+hide_columns = [
+    "season",
+    "season_type",
+    "player_gsis_id",
+    "player_first_name",
+    "player_last_name",
+    "player_jersey_number",
+    "player_short_name",
+]
+
+
+def get_page():
+    page_title = f"Next Gen Stats - {SEASON}"
+    st.set_page_config(page_title=page_title, page_icon=DEFAULT_ICON, layout="wide")
+    common_page_config()
+    st.title(page_title)
+
+    stat_category = st.selectbox("Stat Category", ["Passing", "Rushing", "Receiving"])
+    ngs_table_name = f"nextgen_stats_ngs_{stat_category.lower()}"
+    current_tables_list = get_current_tables()
+
+    if ngs_table_name not in current_tables_list:
+        st.write("Data not loaded.")
+        st.write("Check loaded data [here](./Load_Data)")
+        return
+    data = get_nextgen_stats(SEASON, stat_category)
+
+    season_or_week = st.selectbox("Season or Weekly Stats", ["Season", "Week"])
+    if season_or_week == "Season":
+        data = data[data["week"] == 0]
+        data.drop(columns=["week"], inplace=True)
+    else:
+        data = data[data["week"] > 0]
+        week_selection = st.slider(
+            "Filter Week Range:",
+            min_value=data["week"].min(),
+            max_value=data["week"].max(),
+            value=(data["week"].min(), data["week"].max()),
+            step=1,
+        )
+        data = data[data["week"].between(*week_selection)]
+
+    data.drop(columns=hide_columns, inplace=True)
+    positions_selected = get_multiselect_for_df_column(data, "player_position")
+    teams_selected = get_multiselect_for_df_column(data, "team_abbr")
+
+    data = data[(data["player_position"].isin(positions_selected) & data["team_abbr"].isin(teams_selected))]
+
+    with st.container():
+        filtered_data = data
+        st.dataframe(
+            filtered_data,
+            hide_index=True,
+            # height=35 * (len(filtered_data) + 1) + 12,
+            use_container_width=False,
+            column_config={},
+        )
+
+
+if __name__ == "__main__":
+    get_page()

src/pages/1_Keepers.py

@@ -0,0 +1,178 @@
+import os
+import numpy as np
+import pandas as pd
+import streamlit as st
+
+from config import DEFAULT_ICON, LEAGUE_NAME, LEAGUE_NUMBER_TEAMS
+from shared_page import common_page_config
+from streamlit_filter import filter_dataframe
+
+
+KEEPER_DATA_URL = "../../tests/mocks/2023_keepers.csv"
+HEADSHOT_DATA_URL = "../../tests/mocks/2023_player_headshots.csv"
+
+
+def load_player_ids() -> pd.DataFrame:
+    df = pd.read_csv(r"https://raw.githubusercontent.com/dynastyprocess/data/master/files/db_playerids.csv")
+    df["merge_id"] = df["yahoo_id"].combine_first(df["stats_id"])
+    return df
+
+
+def load_adp() -> pd.DataFrame:
+    df = pd.read_csv(r"https://raw.githubusercontent.com/dynastyprocess/data/master/files/db_fpecr_latest.csv")
+    df = df.loc[
+        df.fp_page == "/nfl/rankings/ppr-superflex-cheatsheets.php",
+        [
+            "yahoo_id",
+            "ecr",
+            "sd",
+        ],
+    ]
+    return df
+
+
+def convert_ecr_to_round_val(ecr_float: float, round_offset: float = 1.0, pick_offset: float = -1.0) -> float:
+    # As a float, store pick 1 of round 1 as 1.0
+    return round_offset + (ecr_float + pick_offset) / LEAGUE_NUMBER_TEAMS
+
+
+def add_opinionated_keeper_value(df: pd.DataFrame):
+    # Manual Hack for overranking of backup QBs
+    df.loc[
+        df["name"].isin(
+            [
+                "Teddy Bridgewater",
+                "Davis Mills",
+                "Andy Dalton",
+                "Tyler Huntley",
+                "Mike White",
+                "Gardner Minshew",
+                "Colt McCoy",
+                "Sam Darnold",
+                "Carson Wentz",
+                "Trey Lance",
+                "Taylor Heinicke",
+            ]
+        ),
+        ["ecr"],
+    ] = np.nan
+
+    df["ecr"] = df["ecr"].apply(convert_ecr_to_round_val)
+    # Convert sd without offset to show as pure pick diff
+    df["sd"] = df["sd"].apply(lambda x: convert_ecr_to_round_val(x, 0, 0))
+    # assumes midround keeper
+    # fill -99 for players that are not ranked in ecr
+    df["value_keeper"] = (df["keeper_cost"] + 0.5 - df["ecr"]).fillna(-99)
+
+
+@st.cache_data(ttl=60 * 60 * 24)
+def load_data():
+    data = pd.read_csv(os.path.join(os.path.dirname(__file__), KEEPER_DATA_URL), index_col=0)
+    # Hack to get position, replace with better position from yahoo api in future
+    data["position"] = data["eligible_positions"].apply(lambda x: eval(x)[0])
+    data.columns = data.columns.str.lower()
+    teams_list = sorted(list(data["team_name"].unique()))
+
+    # Merge player ids
+    df_player_ids = load_player_ids()
+    data = data.merge(df_player_ids, how="left", left_on="player_id", right_on="merge_id", suffixes=("", "_ids"))
+
+    # Merge ADP
+    df_adp = load_adp()
+    data = data.merge(df_adp, how="left", left_on="player_id", right_on="yahoo_id", suffixes=("", "_adp"))
+    add_opinionated_keeper_value(data)
+    return data, teams_list
+
+
+def filtered_keeper_dataframe(data: pd.DataFrame, teams_list: list[str]):
+    teams_selected = st.multiselect("Team:", teams_list, placeholder="Select a user team to filter")
+    teams_filter = data["team_name"].isin(teams_selected) if teams_selected else data["team_name"].isin(teams_list)
+
+    eligible_options = [True, False]
+    is_eligible_selected = st.multiselect(
+        "Keeper Eligible:", eligible_options, placeholder="Select True to filter eligible only"
+    )
+    eligible_filter = (
+        data["eligible"].isin(is_eligible_selected) if is_eligible_selected else data["eligible"].isin(eligible_options)
+    )
+    is_advanced = st.checkbox("Show Advanced View")
+
+    id_cols = [
+        "team_name",
+        "headshot_url",
+        "name",
+    ]
+
+    id_cols_advanced = [
+        "team",
+        "position",
+    ]
+
+    cost_cols = [
+        "keeper_cost",
+        "eligible",
+    ]
+
+    cost_cols_advanced = [
+        "years_eligible",
+    ]
+
+    adp_cols: list[str] = []
+
+    adp_cols_advanced = [
+        "ecr",
+        "value_keeper",
+    ]
+
+    if is_advanced:
+        show_columns = id_cols + id_cols_advanced + cost_cols + cost_cols_advanced + adp_cols + adp_cols_advanced
+    else:
+        show_columns = id_cols + cost_cols + adp_cols
+
+    data_with_filters_applied = data.loc[teams_filter & eligible_filter, show_columns]
+
+    filtered_data = filter_dataframe(data_with_filters_applied)
+    st.dataframe(
+        filtered_data,
+        hide_index=True,
+        height=35 * (len(filtered_data) + 1) + 12,
+        use_container_width=True,
+        column_config={
+            "team_name": st.column_config.TextColumn(label="League Team", help="Name of fantasy League team."),
+            "headshot_url": st.column_config.ImageColumn(label="", help="Player image"),
+            "name": st.column_config.TextColumn(label="Name", help="Player's name"),
+            "team": st.column_config.TextColumn(label="NFL Team"),
+            "position": st.column_config.TextColumn(label="Position", help="Player's position"),
+            "keeper_cost": st.column_config.NumberColumn(
+                label="Keeper Cost", help="Draft Round Cost to keep player.  See Rules for details."
+            ),
+            "eligible": st.column_config.CheckboxColumn(label="Eligible", help="Is player eligible to be keeper?"),
+            "years_eligible": st.column_config.NumberColumn(
+                label="Years Eligible",
+                help="Number of further consecutive seasons player can be kept (subject to maximum of 2)",
+            ),
+            "ecr": st.column_config.NumberColumn(
+                label="ECR",
+                help="Player's average draft round.pick Expert Consensus Rank (ECR) for PPR - Superflex League",
+            ),
+            "value_keeper": st.column_config.NumberColumn(
+                label="Value Keeper",
+                help="Approx. number of draft rounds of keeper value vs ECR PPR - Superflex League",
+            ),
+        },
+    )
+
+
+def get_keeper_app():
+    keeper_title = f"{LEAGUE_NAME} Keeper Options"
+    st.set_page_config(page_title=keeper_title, page_icon=DEFAULT_ICON, layout="wide")
+    common_page_config()
+    st.title(keeper_title)
+    data, teams_list = load_data()
+
+    with st.container():
+        filtered_keeper_dataframe(data, teams_list)
+
+
+if __name__ == "__main__":
+    get_keeper_app()

src/pages/3_ECR.py

@@ -0,0 +1,88 @@
+import os
+import pandas as pd
+import streamlit as st
+
+from config import DEFAULT_ICON
+from shared_page import common_page_config
+from streamlit_filter import filter_dataframe
+
+
+KEEPER_DATA_URL = "../../tests/mocks/2023_keepers.csv"
+HEADSHOT_DATA_URL = "../../tests/mocks/2023_player_headshots.csv"
+
+
+def load_adp() -> pd.DataFrame:
+    df = pd.read_csv(r"https://raw.githubusercontent.com/dynastyprocess/data/master/files/db_fpecr_latest.csv")
+    df["ranking_type"] = df["fp_page"].apply(lambda x: os.path.split(x)[-1].replace(".php", ""))
+    return df
+
+
+@st.cache_data(ttl=60 * 60 * 24)
+def load_data():
+    # Merge ADP
+    data = load_adp()
+    ranking_type_list = sorted(list(data.ranking_type.unique()))
+    return data, ranking_type_list
+
+
+def filtered_ecr_dataframe(data: pd.DataFrame, ranking_type_list: list[str]):
+    default_ix = ranking_type_list.index("ppr-superflex-cheatsheets")
+    ranking_type_selected = st.selectbox("ECR Format:", ranking_type_list, index=default_ix)
+    ranking_type_filter = data["ranking_type"] == ranking_type_selected
+
+    is_advanced = st.checkbox("Show Advanced View")
+
+    id_cols = [
+        # "player_square_image_url",
+        "player",
+        "pos",
+        "team",
+    ]
+
+    id_cols_advanced = [
+        "bye",
+        "player_owned_yahoo",
+    ]
+
+    adp_cols: list[str] = [
+        "ecr",
+    ]
+
+    adp_cols_advanced = ["sd", "best", "worst"]
+
+    if is_advanced:
+        show_columns = id_cols + id_cols_advanced + adp_cols + adp_cols_advanced
+    else:
+        show_columns = id_cols + adp_cols
+
+    data_filtered_by_ranking_type = data.loc[ranking_type_filter]
+    latest_scrape_date = data_filtered_by_ranking_type.scrape_date.max()
+    st.write(f"Scraped data as of: {latest_scrape_date}")
+
+    filtered_data = filter_dataframe(data.loc[ranking_type_filter, show_columns])
+    st.dataframe(
+        filtered_data,
+        hide_index=True,
+        height=35 * (len(filtered_data) + 1) + 12,
+        use_container_width=True,
+        column_config={
+            # "player_square_image_url": st.column_config.ImageColumn(label="", help="Player image"),
+        },
+    )
+
+    st.write("Source: https://github.com/dynastyprocess/data")
+
+
+def get_keeper_app():
+    keeper_title = "Expert Consensus Rankings"
+    st.set_page_config(page_title=keeper_title, page_icon=DEFAULT_ICON, layout="wide")
+    common_page_config()
+    st.title(keeper_title)
+    data, ecr_type_list = load_data()
+
+    with st.container():
+        filtered_ecr_dataframe(data, ecr_type_list)
+
+
+if __name__ == "__main__":
+    get_keeper_app()

src/pages/4_Practice_Reports.py

@@ -0,0 +1,66 @@
+import datetime
+import streamlit as st
+
+from config import DEFAULT_ICON
+from shared_page import common_page_config
+
+from queries.nfl_teams.practice_reports import scrape_all_team_injury_report, CURRENT_SEASON, CURRENT_WEEK
+from streamlit_filter import filter_dataframe
+
+
+@st.cache_data(ttl=60 * 60 * 1)
+def load_data():
+    data = scrape_all_team_injury_report()
+    teams_list = list(data.Team.unique())
+    position_list = list(data.Position.unique())
+    status_list = list(data.game_status.unique())
+    last_practice_day_list = list(data["Last Practice Day"].unique())
+    data_load_time_str = datetime.datetime.utcnow().strftime("%m/%d/%Y %I:%M %p")
+    return data, teams_list, position_list, status_list, last_practice_day_list, data_load_time_str
+
+
+def get_page():
+    page_title = f"Team Practice Reports - {CURRENT_SEASON} Week {CURRENT_WEEK}"
+    st.set_page_config(page_title=page_title, page_icon=DEFAULT_ICON, layout="wide")
+    common_page_config()
+    st.title(page_title)
+    if st.button("Refresh Data"):
+        st.cache_data.clear()
+    data, teams_list, position_list, status_list, last_practice_day_list, data_load_time_str = load_data()
+    st.write(f"Data loaded as of: {data_load_time_str} UTC")
+    teams_selected = st.multiselect("Team:", teams_list, placeholder="Select a team to filter") or teams_list
+    positions_selected = (
+        st.multiselect("Position:", position_list, placeholder="Select a position to filter") or position_list
+    )
+    status_selected = (
+        st.multiselect("Game Status:", status_list, placeholder="Select a game status to filter") or status_list
+    )
+    last_practice_day_selected = (
+        st.multiselect(
+            "Last Practice Day:", last_practice_day_list, placeholder="Select a day of last team practice to filter"
+        )
+        or last_practice_day_list
+    )
+
+    with st.container():
+        filtered_data = filter_dataframe(
+            data[
+                (
+                    data.Team.isin(teams_selected)
+                    & data.Position.isin(positions_selected)
+                    & data.game_status.isin(status_selected)
+                    & data["Last Practice Day"].isin(last_practice_day_selected)
+                )
+            ]
+        )
+        st.dataframe(
+            filtered_data,
+            hide_index=True,
+            height=35 * (len(filtered_data) + 1) + 12,
+            use_container_width=False,
+            column_config={},
+        )
+
+
+if __name__ == "__main__":
+    get_page()

src/pages/50_League_Simulation.py

@@ -0,0 +1,26 @@
+import streamlit as st
+
+from config import DEFAULT_ICON
+from shared_page import common_page_config
+
+from login_component import is_token_in_session
+
+
+def get_page():
+    page_title = "Yahoo FF League Simulation"
+    st.set_page_config(page_title=page_title, page_icon=DEFAULT_ICON, layout="wide")
+    common_page_config()
+    st.title(page_title)
+
+    if not is_token_in_session():
+        st.write(
+            "You must authorize the application to access your account in order to use this feature."
+            " Please click Login button above."
+        )
+
+    else:
+        st.write("Logged in.  Feature to go here")
+
+
+if __name__ == "__main__":
+    get_page()

src/pages/5_Targets.py

@@ -0,0 +1,56 @@
+import datetime
+import numpy as np
+import streamlit as st
+
+from config import DEFAULT_ICON
+from shared_page import common_page_config
+
+from queries.footballguys.constants import YEAR
+from queries.footballguys.refresh import request_stat
+from streamlit_filter import filter_dataframe
+
+
+@st.cache_data(ttl=60 * 60 * 24)
+def load_data():
+    stat_name = "targets"
+    data = request_stat(stat_name)
+    data_load_time_str = datetime.datetime.utcnow().strftime("%m/%d/%Y %I:%M %p")
+    return data, data_load_time_str
+
+
+def get_page():
+    page_title = f"Player Targets - {YEAR}"
+    st.set_page_config(page_title=page_title, page_icon=DEFAULT_ICON, layout="wide")
+    common_page_config()
+    st.title(page_title)
+    if st.button("Refresh Data"):
+        st.cache_data.clear()
+    data, data_load_time_str = load_data()
+    st.write(f"Data loaded as of: {data_load_time_str} UTC")
+
+    selected_subtotals = st.selectbox("Show:", ["Player Totals", "Position Totals"], index=0)
+    if selected_subtotals == "Player Totals":
+        data = data[~data.name.str.contains(" Totals")]
+    elif selected_subtotals == "Position Totals":
+        data = data[data.name.str.contains(" Totals")]
+
+    value_types = st.selectbox("Counts / Percent:", ["Counts", "Percent"], index=0)
+    if value_types == "Percent":
+        numerical_data = data.select_dtypes(include=np.number)
+        numerical_cols = numerical_data.columns
+        df_percent_values = numerical_data / data.groupby("TEAM").transform(sum).select_dtypes(include=np.number)
+        data.loc[:, numerical_cols] = df_percent_values
+
+    with st.container():
+        filtered_data = filter_dataframe(data)
+        st.dataframe(
+            filtered_data,
+            hide_index=True,
+            height=35 * (len(filtered_data) + 1) + 12,
+            use_container_width=False,
+            column_config={},
+        )
+
+
+if __name__ == "__main__":
+    get_page()

src/pages/6_Redzone_Opportunities.py

@@ -0,0 +1,56 @@
+import datetime
+import numpy as np
+import streamlit as st
+
+from config import DEFAULT_ICON
+from shared_page import common_page_config
+
+from queries.footballguys.constants import YEAR
+from queries.footballguys.refresh import request_stat
+from streamlit_filter import filter_dataframe
+
+
+@st.cache_data(ttl=60 * 60 * 24)
+def load_data():
+    stat_name = "redzone"
+    data = request_stat(stat_name)
+    data_load_time_str = datetime.datetime.utcnow().strftime("%m/%d/%Y %I:%M %p")
+    return data, data_load_time_str
+
+
+def get_page():
+    page_title = f"Player Redzone Opportunities - {YEAR}"
+    st.set_page_config(page_title=page_title, page_icon=DEFAULT_ICON, layout="wide")
+    common_page_config()
+    st.title(page_title)
+    if st.button("Refresh Data"):
+        st.cache_data.clear()
+    data, data_load_time_str = load_data()
+    st.write(f"Data loaded as of: {data_load_time_str} UTC")
+
+    selected_subtotals = st.selectbox("Show:", ["Player Totals", "Position Totals"], index=0)
+    if selected_subtotals == "Player Totals":
+        data = data[~data.name.str.contains(" Totals")]
+    elif selected_subtotals == "Position Totals":
+        data = data[data.name.str.contains(" Totals")]
+
+    value_types = st.selectbox("Counts / Percent:", ["Counts", "Percent"], index=0)
+    if value_types == "Percent":
+        numerical_data = data.select_dtypes(include=np.number)
+        numerical_cols = numerical_data.columns
+        df_percent_values = numerical_data / data.groupby("TEAM").transform(sum).select_dtypes(include=np.number)
+        data.loc[:, numerical_cols] = df_percent_values
+
+    with st.container():
+        filtered_data = filter_dataframe(data)
+        st.dataframe(
+            filtered_data,
+            hide_index=True,
+            height=35 * (len(filtered_data) + 1) + 12,
+            use_container_width=False,
+            column_config={},
+        )
+
+
+if __name__ == "__main__":
+    get_page()

src/pages/7_Snap_Counts.py

@@ -0,0 +1,69 @@
+import datetime
+import streamlit as st
+
+from config import DEFAULT_ICON
+from shared_page import common_page_config
+
+from queries.footballguys.constants import YEAR
+from queries.nflverse.github_data import get_snap_counts, get_current_tables, SEASON
+
+
+def load_data():
+    data = get_snap_counts(YEAR)
+    data = data[data.fantasy_position]
+    teams_list = sorted(data.team.unique())
+    position_list = data.position.unique()
+    weeks_list = sorted(data.week.unique())
+    data_load_time_str = datetime.datetime.utcnow().strftime("%m/%d/%Y %I:%M %p")
+    return data, teams_list, position_list, weeks_list, data_load_time_str
+
+
+def get_page():
+    page_title = f"Snap Counts and Percentages - {YEAR}"
+    st.set_page_config(page_title=page_title, page_icon=DEFAULT_ICON, layout="wide")
+    common_page_config()
+    st.title(page_title)
+    if f"snap_counts_snap_counts_{SEASON}" not in get_current_tables():
+        st.write("Data not loaded.")
+        st.write("Check loaded data [here](./Load_Data)")
+        return
+    data, teams_list, position_list, weeks_list, data_load_time_str = load_data()
+    st.write(f"Data loaded as of: {data_load_time_str} UTC")
+    teams_selected = st.multiselect("Team:", teams_list, placeholder="Select a team to filter") or teams_list
+    positions_selected = (
+        st.multiselect("Position:", position_list, placeholder="Select a position to filter") or position_list
+    )
+    weeks_selected = st.multiselect("Week:", weeks_list, placeholder="Select a week to filter") or weeks_list
+
+    with st.container():
+        filtered_data = data[
+            (data.team.isin(teams_selected) & data.position.isin(positions_selected) & data.week.isin(weeks_selected))
+        ]
+        st.dataframe(
+            filtered_data,
+            hide_index=True,
+            # height=35 * (len(filtered_data) + 1) + 12,
+            use_container_width=False,
+            column_order=[
+                "season",
+                "game_type",
+                "week",
+                "player",
+                "position",
+                "team",
+                "opponent",
+                "offense_snaps",
+                "offense_pct",
+                "defense_snaps",
+                "defense_pct",
+                "st_snaps",
+                "st_pct",
+            ],
+            column_config={
+                "season": st.column_config.TextColumn(help="Year of NFL Season"),
+            },
+        )
+
+
+if __name__ == "__main__":
+    get_page()

src/pages/80_Maximum_Roster_Strategy.py

@@ -0,0 +1,165 @@
+import pandas as pd
+import streamlit as st
+import streamlit.components.v1 as components
+
+
+from config import DEFAULT_ICON
+from shared_page import common_page_config, get_local_style
+from maximum_roster_strategy import data_loader
+
+
+MINIMUM_WEEK = 6
+MAXIMUM_WEEK = 7
+
+MIN_TIER = 1
+MAX_TIER = 4
+
+POSITION_OPTIONS = ["RB", "WR", "TE", "QB"]
+
+POSITION_ABBR_FULL_NAME_MAP = {
+    "RB": "Running Backs",
+    "WR": "Wide Receivers",
+    "TE": "Tight Ends",
+    "QB": "Quarterbacks (Superflex / 2QB Leagues Only)",
+}
+
+
+@st.cache_data(ttl=5 * 60)
+def load_data():
+    return data_loader.get_google_sheet_data(), data_loader.get_timeslot_labels()
+
+
+def get_player_grid_div(player_series: pd.Series) -> str:
+    player_notes = player_series["Hold Condition"]
+    if (outcome := player_series["Outcome"]) == "Drop":
+        player_class = "drop-player"
+    elif outcome == "Light Hold":
+        player_class = "light-hold-player"
+    elif outcome == "Hold":
+        player_class = "hold-player"
+    else:
+        player_class = "undetermined-player"
+
+    if isinstance(player_weekly_note := player_series["Article Notes"], str):
+        player_notes += "<br><br>" + player_weekly_note
+    return f"""
+<details class="mrs-grid-player content">
+  <summary class="{player_class}">
+    {player_series["Formatted"]}
+  </summary>
+  <p>
+    {player_notes}
+  </p>
+</details>
+"""
+
+
+def get_time_slot_div(time_slot_list: list[str]) -> str:
+    code_str = ""
+    for time_slot_idx, time_slot in enumerate(time_slot_list):
+        code_str += f"""<div class="timeslot{time_slot_idx + 1} timeslot">{time_slot}</div>\n"""
+    return code_str
+
+
+def get_tier_div(tier_str: str | int, tier_num: str | int) -> str:
+    return f"""<div class="tier{tier_num} tier">Tier {tier_str}</div>"""
+
+
+def get_player_container(df_players: pd.DataFrame, slot_number: int | str) -> str:
+    if len(df_players) == 0:
+        player_code_str = "<br>"
+    else:
+        player_code_str = "\n".join(df_players.apply(get_player_grid_div, axis=1).tolist())
+    return f"""<div class="playerslot{slot_number} playerslot">{player_code_str}</div>"""
+
+
+def get_position_breakdown(df: pd.DataFrame, position_abbr: str, position_full_str: str, time_slots: list[str]):
+    with st.container():
+        st.header(position_full_str)
+        df_pos = df[df["Position"] == position_abbr]
+
+        grid_code_str = ""
+        grid_code_str += get_time_slot_div(time_slots)
+
+        tier_list = list(range(MIN_TIER, MAX_TIER + 1))
+        slot_number = 0
+        for tier_idx, tier in enumerate(tier_list):
+            grid_code_str += get_tier_div(tier, tier_idx + 1)
+            for time_slot in time_slots:
+                df_tier_slot = df_pos[(df_pos["TimeSlotName"] == time_slot) & (df_pos["Tier"] == tier)]
+                slot_number += 1
+                grid_code_str += get_player_container(df_tier_slot, slot_number)
+
+        components.html(
+            f"""
+{get_local_style()}
+<div class="grid-container-{len(time_slots)}">
+    {grid_code_str}
+</div>
+<br>
+<div class="grid-legend">Colors Legend: 
+    <div class="drop-player">Drop Player</div> |
+    <div class="light-hold-player">Light Hold Player</div> |
+    <div class="hold-player">Strong Hold Player</div>
+</div>
+""",
+            height=1000,
+            scrolling=True,
+        )
+
+
+def get_page():
+    page_title = "Maximum Roster Strategy"
+    st.set_page_config(page_title=page_title, page_icon=DEFAULT_ICON, layout="wide")
+    common_page_config()
+    st.title(page_title)
+
+    with st.expander(label="Instructions"):
+        st.write(
+            """
+To get started with MRS: https://solowfantasyfootball.wordpress.com/2023/09/07/maximum-roster-strategy-explained/
+
+Players are organized by game time slot, position, and tier.
+                 
+Pick up a player during their game's time slot for potential upside if particular circumstances are met.
+
+After the game, players will be colored by outcome: Drop (Red), Light Hold (Yellow), or Strong Hold (Green)."""
+        )
+    col_select, week_select = st.columns(2, gap="small")
+    url_params = st.experimental_get_query_params()
+    initial_position_index = 0
+    if url_position := url_params.get("position"):
+        selected_position = url_position[0]
+        if selected_position in POSITION_OPTIONS:
+            initial_position_index = POSITION_OPTIONS.index(selected_position)
+
+    week_options = list(range(MAXIMUM_WEEK, MINIMUM_WEEK - 1, -1))
+    initial_week_index = 0
+    if url_week := url_params.get("week"):
+        try:
+            selected_week = int(url_week[0])
+        except Exception:
+            st.warning("Week parameter must be integer value", icon="⚠️")
+            selected_week = MAXIMUM_WEEK
+        if selected_week in week_options:
+            initial_week_index = week_options.index(selected_week)
+
+    with col_select:
+        position = st.selectbox(label="Position", options=POSITION_OPTIONS, index=initial_position_index)
+    with week_select:
+        week = st.selectbox(label="Week", options=week_options, index=initial_week_index)
+    url_params.update({"position": position, "week": week})
+    st.experimental_set_query_params(**url_params)
+    if st.experimental_get_query_params().get("refresh"):
+        st.cache_data.clear()
+    df_mrs, all_time_slots_df = load_data()
+    df_mrs = df_mrs[df_mrs["Week"] == week]
+    current_week_timeslots = (
+        all_time_slots_df[all_time_slots_df["Week"] == week].sort_values("WeekTimeSlotIndex").TimeSlotName.tolist()
+    )
+
+    get_position_breakdown(df_mrs, position, POSITION_ABBR_FULL_NAME_MAP[position], current_week_timeslots)
+
+
+if __name__ == "__main__":
+    get_page()

src/pages/8_FTN_Charting.py

@@ -0,0 +1,40 @@
+import datetime
+import streamlit as st
+
+from config import DEFAULT_ICON
+from shared_page import common_page_config
+
+from queries.footballguys.constants import YEAR
+from queries.nflverse.github_data import get_ftn_charting, get_current_tables, SEASON
+
+
+def load_data():
+    data = get_ftn_charting(YEAR)
+    data_load_time_str = datetime.datetime.utcnow().strftime("%m/%d/%Y %I:%M %p")
+    return data, data_load_time_str
+
+
+def get_page():
+    page_title = f"FTN Charting - {YEAR}"
+    st.set_page_config(page_title=page_title, page_icon=DEFAULT_ICON, layout="wide")
+    common_page_config()
+    st.title(page_title)
+    if f"ftn_charting_ftn_charting_{SEASON}" not in get_current_tables():
+        st.write("Data not loaded.")
+        st.write("Check loaded data [here](./Load_Data)")
+        return
+    data, data_load_time_str = load_data()
+    st.write(f"Data loaded as of: {data_load_time_str} UTC")
+
+    with st.container():
+        filtered_data = data
+        st.dataframe(
+            filtered_data,
+            hide_index=True,
+            # height=35 * (len(filtered_data) + 1) + 12,
+            use_container_width=False,
+        )
+
+
+if __name__ == "__main__":
+    get_page()

src/pages/98_Load_Data.py

@@ -0,0 +1,35 @@
+import duckdb
+import streamlit as st
+
+from config import DEFAULT_ICON
+from shared_page import common_page_config
+
+from queries.nflverse.github_data import load_assets, get_current_tables
+
+
+def get_page():
+    page_title = "Data Loader"
+    st.set_page_config(page_title=page_title, page_icon=DEFAULT_ICON, layout="wide")
+    common_page_config()
+    st.title(page_title)
+
+    current_tables_list = get_current_tables()
+
+    if st.button("Refresh Data"):
+        load_assets()
+        st.rerun()
+
+    if selected_table := st.selectbox("Describe a table:", current_tables_list, index=0):
+        describe_df = duckdb.sql(f"DESCRIBE {selected_table}").df()
+        st.dataframe(
+            describe_df,
+            hide_index=True,
+            use_container_width=True,
+        )
+
+        if st.checkbox("Explore data"):
+            st.dataframe(duckdb.sql(f"SELECT * FROM {selected_table} LIMIT 50").df())
+
+
+if __name__ == "__main__":
+    get_page()

src/pages/99_Keeper_Rules.py

@@ -0,0 +1,37 @@
+import streamlit as st
+
+from config import DEFAULT_ICON, LEAGUE_NAME
+from shared_page import common_page_config
+
+
+page_title = f"{LEAGUE_NAME} Keeper Rules"
+st.set_page_config(page_title=page_title, page_icon=DEFAULT_ICON)
+common_page_config()
+st.title(page_title)
+st.markdown(
+    """
+***Note: First LOFG keeper season was 2019***
+            
+1. Teams can keep up to 3 players from the prior season.
+    - Note: changed from 2 to 3 beginning with 2022 season
+2. Players are kept at the expense of a draft pick.
+    - The round of that draft pick will depend on when the player was drafted in the prior season.
+3. Players drafted in the 1st round of the prior season will not be eligible to keep.
+4. Players drafted in rounds 2 and after can be kept at the expense of one higher round
+    - Ex: player drafted in round 2 can be kept for your 1st round pick.
+5. Players who were not drafted and were picked up during the season can be kept for 10th round picks (FA Keeper cost)
+    - Changed beginning 2022 from 9th round
+6. Post-Draft Acquired Keeper cost Minimum - 
+    - Players drafted by other teams have a keeper cost of minimum of round player drafted and FA Keeper Cost. 
+    - This rewards people who drafted the players, versus those who picked them up off waivers.
+7. If you select 2 players with the same keeper cost, one of the players would count as one round higher.
+    - Ex: Two players both have keeper cost of 10th round.
+      - One of those players would instead be counted as your 9th round pick if both are kept.
+8. Players can not be kept for more than 2 consecutive seasons
+    - Ex: player drafted in 2019 in 6th round, 2020 for 5th round, and 2021 for 4th round - can't be kept in 2022
+    - Exception to the above rule is that players originally drafted in 2nd round can only be kept for one season.
+9. Players traded in a season are not subject to the FA Keeper cost minimum cost
+In other words, keeper rights transfer with the trade
+
+            """
+)

src/pages/9_Team_Formations.py

@@ -0,0 +1,83 @@
+import datetime
+import pandas as pd
+import streamlit as st
+
+from config import DEFAULT_ICON
+from shared_page import common_page_config
+
+from queries.footballguys.constants import YEAR
+from queries.nflverse.github_data import get_pbp_participation, get_current_tables, SEASON
+
+
+def load_data():
+    data = get_pbp_participation(YEAR)
+    teams_list = sorted(filter(None, data.possession_team.unique()))
+    # position_list = data.position.unique()
+    # weeks_list = sorted(data.week.unique())
+    data_load_time_str = datetime.datetime.utcnow().strftime("%m/%d/%Y %I:%M %p")
+    return data, teams_list, data_load_time_str
+
+
+def get_page():
+    page_title = f"Team Formations - {YEAR}"
+    st.set_page_config(page_title=page_title, page_icon=DEFAULT_ICON, layout="wide")
+    common_page_config()
+    st.title(page_title)
+    if f"ftn_charting_ftn_charting_{SEASON}" not in get_current_tables():
+        st.write("Data not loaded.")
+        st.write("Check loaded data [here](./Load_Data)")
+        return
+    data, teams_list, data_load_time_str = load_data()
+    st.write(f"Data loaded as of: {data_load_time_str} UTC")
+    default_groups = [
+        "down",
+        "play_type",
+        "offense_personnel",
+    ]
+    group_options = [
+        "week",
+        "down",
+        "qtr",
+        "ydstogo",
+        "play_type",
+        "pass_length",
+        "pass_location",
+        "possession_team",
+        "offense_formation",
+        "offense_personnel",
+        "number_of_pass_rushers",
+        "defenders_in_box",
+        "defense_personnel",
+    ]
+    group_by_selected = st.multiselect("Group by:", group_options) or default_groups
+    team_selected = st.selectbox("Team:", teams_list)
+    week_selection = st.slider(
+        "Filter Week Range:",
+        min_value=data["week"].min(),
+        max_value=data["week"].max(),
+        value=(data["week"].min(), data["week"].max()),
+        step=1,
+    )
+
+    with st.container():
+        filtered_data = data[
+            (data.possession_team == team_selected)
+            & (data.play_type.isin(["pass", "run"]))
+            & (data["week"].between(*week_selection))
+        ]
+
+        st.dataframe(
+            pd.pivot_table(
+                filtered_data,
+                values="count_col",
+                index=group_by_selected,
+                columns="week",
+                aggfunc={"count_col": "sum"},
+                # margins=True,
+            ),
+            use_container_width=False,
+        )
+
+
+if __name__ == "__main__":
+    get_page()

src/queries/footballguys/constants.py

@@ -0,0 +1,34 @@
+from typing import List, Mapping
+
+# constants relevant to parsing from footballguys
+
+SNAP_PAGE_POSITON_ORDER: List[str] = [
+    "QB",
+    "RB",
+    "WR",
+    "TE",
+    "DT",
+    "DE",
+    "ILB",
+    "OLB",
+    "CB",
+    "S",
+]
+
+POSITIONS_TO_OFFENSE_DEFENSE: Mapping[str, str] = {
+    "QB": "OFF",
+    "RB": "OFF",
+    "WR": "OFF",
+    "TE": "OFF",
+    "DT": "DEF",
+    "DE": "DEF",
+    "ILB": "DEF",
+    "OLB": "DEF",
+    "S": "DEF",
+    "CB": "DEF",
+}
+
+
+BASE_URL = "https://www.footballguys.com/stats"
+
+YEAR = 2023

src/queries/footballguys/helpers.py

@@ -0,0 +1,130 @@
+from io import StringIO
+import lxml.html
+import pandas as pd
+import requests
+from typing import List
+from queries.footballguys import constants as fbgc
+
+
+def url_to_pandas(url) -> List[pd.DataFrame]:
+    page = requests.get(url)
+    table = pd.read_html(StringIO(page.text.replace("<br>", "-")))
+    return table
+
+
+def create_html_table_from_header_body(header_html_str: str, body_html_str: str):
+    return f"""
+<table>
+{header_html_str}
+{body_html_str}
+</table>
+"""
+
+
+def extract_snaps_to_pandas(url: str):
+    root = lxml.html.document_fromstring(requests.get(url).text)
+    table_element_list = root.xpath("""//*[@id="stats_snapcounts_data"]/div/table""")
+    assert isinstance(table_element_list, list)
+    table_element = table_element_list[0]
+    assert isinstance(table_element, lxml.html.HtmlElement)
+    table_child_list = table_element.getchildren()
+    assert len(table_child_list) % 2 == 0  # check is even
+    half_len = int(len(table_child_list) / 2)
+    df_list = []
+    for i in range(half_len):
+        table_html = create_html_table_from_header_body(
+            lxml.html.tostring(table_child_list[2 * i]), lxml.html.tostring(table_child_list[2 * i + 1])
+        ).replace("\\n", "")
+        df = pd.read_html(table_html)[0]
+        # First column contains name and is initially labeled as each position, example "Quarterback"
+        # Insert column at front called POS and fill with current first column label
+        position_name = df.columns[0]
+        df.insert(0, "POS", position_name)
+        df.rename(columns={position_name: "name"}, inplace=True)
+        df_list.append(df)
+    return df_list
+
+
+def add_snap_off_def_column(team_snap_df: pd.DataFrame):
+    off_def = team_snap_df["POS"].apply(lambda x: fbgc.POSITIONS_TO_OFFENSE_DEFENSE[x])
+    team_snap_df.insert(0, "OFF/DEF", off_def)
+
+
+def add_snap_position_column(
+    team_snap_df_list: List[pd.DataFrame],
+    position_name_array: List[str] = fbgc.SNAP_PAGE_POSITON_ORDER,
+):
+    # blank player names between positions, so we can use cumsum
+    # 8/22/23 - We are currently failing here because snap counts are incorrectly not split by position atm
+    assert len(team_snap_df_list) == len(position_name_array)
+    for pos_idx, pos_df in enumerate(team_snap_df_list):
+        pos_df.insert(0, "POS", position_name_array[pos_idx])
+
+
+def set_multilevel_columns(df):
+    new_cols = [tuple(x.split("-")) if "-" in x else (x, x) for x in df.columns]
+    df.columns = pd.MultiIndex.from_tuples(new_cols)
+
+
+def parse_snaps(team_short_name: str, base_url: str = fbgc.BASE_URL, year: int = fbgc.YEAR) -> pd.DataFrame:
+    print(f"Attempting to parse snaps for {team_short_name}")
+    team_snap_df_list = parse_team_page(team_short_name, base_url, "snap-counts", year)
+    team_snap_df = pd.concat(team_snap_df_list)
+    # add_snap_off_def_column(team_snap_df)
+    split_snap_count_percents(team_snap_df)
+    team_snap_df.dropna(subset=["name"], inplace=True)
+    # set_multilevel_columns(team_snap_df)
+    return team_snap_df
+
+
+def add_targets_position(team_df: pd.DataFrame):
+    # fill blanks up by reversing index, fill down, and re-reversing
+    positions = team_df.name.apply(lambda x: x.replace(" Totals", "") if " Totals" in x else None)[::-1].ffill()[::-1]
+    team_df.insert(0, "POS", positions)
+
+
+def parse_targets(team_short_name: str, base_url: str = fbgc.BASE_URL, year: int = fbgc.YEAR) -> pd.DataFrame:
+    # snaps are index 2
+    print(f"Attempting to parse targets for {team_short_name}")
+    team_df = parse_team_page(team_short_name, base_url, "targets", year)[0]
+    add_targets_position(team_df)
+    return team_df[team_df.name.notna()]
+
+
+def parse_redzone(team_short_name: str, base_url: str = fbgc.BASE_URL, year: int = fbgc.YEAR) -> pd.DataFrame:
+    # snaps are index 3
+    print(f"Attempting to parse redzone for {team_short_name}")
+    team_df = parse_team_page(team_short_name, base_url, "redzone", year)[0]
+    add_targets_position(team_df)
+    return team_df[team_df.name.notna()]
+
+
+def split_snap_count_percents(team_snap_df: pd.DataFrame):
+    for week in range(1, 18):
+        if f"Wk {week}" not in team_snap_df.columns:
+            continue
+        # if values are all NaN column will be dtype float 64 and should skip
+        if team_snap_df[f"Wk {week}"].dtype == float:
+            team_snap_df[f"{week}-count"] = 0
+            team_snap_df[f"{week}-%"] = 0.0
+        else:
+            week_split = team_snap_df[f"Wk {week}"].astype(str).str.split("-")
+            week_count = week_split.apply(lambda x: 0 if len(x) == 1 or x[0] == "" else int(x[0]))
+            week_pct = week_split.apply(lambda x: 0.0 if len(x) == 1 else float(x[1].strip("%")) / 100.0)
+            team_snap_df[f"{week}-count"] = week_count
+            team_snap_df[f"{week}-%"] = week_pct
+        team_snap_df.drop(columns=f"Wk {week}", inplace=True)
+
+
+def parse_team_page(
+    team_short_name: str,
+    base_url: str,
+    stat_name: str,
+    year: int,
+) -> List[pd.DataFrame]:
+    url = f"{base_url}/{stat_name}/teams?team={team_short_name}&year={year}"
+    if stat_name == "snap-counts":
+        all_tables = extract_snaps_to_pandas(url)
+    else:
+        all_tables = url_to_pandas(url)
+    return all_tables

src/queries/footballguys/refresh.py

@@ -0,0 +1,46 @@
+from domain.teams import NFLTeam, ALL_TEAMS
+from queries.footballguys.helpers import parse_snaps, parse_targets, parse_redzone
+from typing import List, Callable, Optional
+import pandas as pd
+
+
+def add_team_name_columns(team_df: pd.DataFrame, team_short_name: str, team_name: str):
+    team_df.insert(0, "TEAM", team_short_name)
+    team_df.insert(1, "TEAM_NAME", team_name)
+
+
+def apply_intended_column_sorting(df: pd.DataFrame, first_columns: List[str]) -> pd.DataFrame:
+    first_columns_in_df = [col for col in first_columns if col in df.columns]
+    remaining_columns = [col for col in df.columns if col not in first_columns_in_df]
+    return df[first_columns_in_df + remaining_columns]
+
+
+def get_all_teams_stat_type(
+    all_teams_list: List[NFLTeam],
+    parsing_function: Callable,
+    store_key: str,
+    intended_first_columns: Optional[List[str]] = None,
+):
+    team_df_list = []
+    for team in all_teams_list:
+        team_df = parsing_function(team.footballguys_short_name)
+        add_team_name_columns(team_df, team.team_short_name, team.team_name)
+        team_df_list.append(team_df)
+    df = pd.concat(team_df_list)
+    if intended_first_columns:
+        df = apply_intended_column_sorting(df, intended_first_columns)
+    print(f"footballguy {store_key} loaded")
+    return df
+
+
+def request_stat(stat_name: str) -> pd.DataFrame:
+    intended_col_sort = None
+    if stat_name == "targets":
+        parse_fxn = parse_targets
+        intended_col_sort = ["TEAM", "TEAM_NAME", "POS", "name", "total"]
+    elif stat_name == "snap-counts":
+        parse_fxn = parse_snaps
+    elif stat_name == "redzone":
+        parse_fxn = parse_redzone
+        intended_col_sort = ["TEAM", "TEAM_NAME", "POS", "name", "total"]
+    return get_all_teams_stat_type(ALL_TEAMS, parse_fxn, stat_name, intended_col_sort)

src/queries/nbcsports/player_news.py

@@ -0,0 +1,52 @@
+from bs4 import BeautifulSoup
+import datetime
+import pandas as pd
+import requests
+from typing import Mapping
+
+NEWS_URL = "https://www.nbcsports.com/fantasy/football/player-news"
+
+
+def find_soup_text_with_default(soup, element: str, find_search_map: Mapping[str, str]):
+    find_result = soup.find(element, find_search_map)
+    if not find_result:
+        return ""
+    return find_result.text.strip()
+
+
+def parse_player_div(player_div):
+    return {
+        "Date/Time": player_div.find("div", {"class": "PlayerNewsPost-date"}).get("data-date"),
+        "Name": find_soup_text_with_default(player_div, "div", {"class": "PlayerNewsPost-name"}),
+        "Team": find_soup_text_with_default(player_div, "span", {"class": "PlayerNewsPost-team-abbr"}).upper(),
+        "Position": find_soup_text_with_default(player_div, "span", {"class": "PlayerNewsPost-position"}).title(),
+        "Headline": find_soup_text_with_default(player_div, "div", {"class": "PlayerNewsPost-headline"}),
+        "Analysis": find_soup_text_with_default(player_div, "div", {"class": "PlayerNewsPost-analysis"}),
+    }
+
+
+def get_nfl_player_news(page_number: int = 1) -> pd.DataFrame:
+    url = f"{NEWS_URL}?p={page_number}"
+    request_page = requests.get(url)
+    soup = BeautifulSoup(request_page.content)
+    player_div_list = soup.find_all("div", {"class": "PlayerNewsPost"})
+    if not player_div_list:
+        return pd.DataFrame()
+    parsed_player_list = [parse_player_div(d) for d in player_div_list]
+    df = pd.DataFrame(parsed_player_list)
+    df["Date/Time"] = pd.to_datetime(df["Date/Time"])
+    return df
+
+
+def get_player_news_window_hours(hours: int = 1):
+    end_date = datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(hours=hours)
+    page = 1
+    max_pages = 20
+    date_reached = False
+    df_list = []
+    while page < max_pages and not date_reached:
+        last_news = get_nfl_player_news(page)
+        df_list.append(last_news)
+        date_reached = min(last_news["Date/Time"]) < end_date
+        page += 1
+    return pd.concat(df_list)

src/queries/nfl_teams/practice_reports.py

@@ -0,0 +1,123 @@
+from bs4 import BeautifulSoup
+import datetime
+from multiprocessing import Pool
+import numpy as np
+import pandas as pd
+from pydantic import BaseModel, Field
+import requests
+from typing import Optional
+from urllib.parse import urljoin
+
+from domain.teams import ALL_TEAMS, NFLTeam
+
+
+MULTIPROCESSING_ENABLED = False
+
+PRACTICE_WEEK = {
+    "Mon": 0,
+    "Tue": 1,
+    "Wed": 2,
+    "Thu": 3,
+    "Fri": 4,
+    "Sat": 5,
+    "Sun": 6,
+    "Monday": 0,
+    "Tuesday": 1,
+    "Wednesday": 2,
+    "Thursday": 3,
+    "Friday": 4,
+    "Saturday": 5,
+    "Sunday": 6,
+}
+
+
+DAY_OF_WEEK_STRING_MAPPING = {
+    "Monday": "Mon",
+    "Tuesday": "Tue",
+    "Wednesday": "Wed",
+    "Thursday": "Thu",
+    "Friday": "Fri",
+    "Saturday": "Sat",
+    "Sunday": "Sun",
+}
+
+
+WEEK_1_BEGIN_DATE = datetime.datetime(2023, 9, 4)
+CURRENT_DATE = datetime.datetime.now()
+CURRENT_WEEK = max(1, int(1 + (CURRENT_DATE - WEEK_1_BEGIN_DATE).days / 7))
+CURRENT_SEASON = 2023
+
+
+class PracticeReportRawRow(BaseModel):
+    Team: str
+    Player: str
+    Position: str
+    Injury: str
+    Sun: Optional[str] = None
+    Mon: Optional[str] = None
+    Tue: Optional[str] = None
+    Wed: Optional[str] = None
+    Thu: Optional[str] = None
+    Fri: Optional[str] = None
+    Sat: Optional[str] = None
+    game_status: str = Field(alias="Game Status")
+
+    @classmethod
+    def replace_nan(self, value) -> str:
+        if isinstance(value, float):
+            if np.isnan(value):
+                return ""
+        return value
+
+    @classmethod
+    def from_raw(cls, input_dict) -> "PracticeReportRawRow":
+        return cls(**{DAY_OF_WEEK_STRING_MAPPING.get(k, k): cls.replace_nan(v) for k, v in input_dict.items()})
+
+
+def get_injury_report_dataframe(team: NFLTeam):
+    injury_report_url = urljoin(team.injury_report_url, f"week/REG-{CURRENT_WEEK}")
+    report_request = requests.get(injury_report_url)
+    report_soup = BeautifulSoup(report_request.content)
+    team_names_spans = report_soup.find_all("span", {"class": "nfl-o-injury-report__club-name"})
+    assert team_names_spans
+    team_names_str = [x.get_text() for x in team_names_spans]
+    assert team_names_str[0] == team.team_full_name
+    tables = report_soup.find_all("table")
+    df_report = pd.read_html(str(tables))[0]
+    return df_report
+
+
+def scrape_team_injury_report(team: NFLTeam) -> pd.DataFrame:
+    print(f"Scraping Injury Report for: {team.team_full_name}")
+    try:
+        team_report = get_injury_report_dataframe(team)
+    except Exception:
+        print(f"Failed to scrape practice report for: {team.team_full_name}")
+        return pd.DataFrame()
+    validated_row_list = []
+    for df_row_dict in team_report.to_dict("records"):
+        row_to_add = df_row_dict
+        row_to_add["Team"] = team.team_full_name
+        validated_row_list.append(PracticeReportRawRow.from_raw(row_to_add))
+    validated_df = pd.DataFrame([x.dict() for x in validated_row_list])
+    # drop all na columns
+    validated_df.dropna(axis=1, how="all", inplace=True)
+    # replace day of week with practice day from 1-3
+    day_idx = 1
+    last_practice_day = None
+    for col in validated_df.columns:
+        if col in PRACTICE_WEEK:
+            validated_df.rename(columns={col: str(day_idx)}, inplace=True)
+            day_idx += 1
+            last_practice_day = col
+    validated_df["Last Practice Day"] = last_practice_day
+    return validated_df
+
+
+def scrape_all_team_injury_report() -> pd.DataFrame:
+    if MULTIPROCESSING_ENABLED:
+        with Pool() as pool:
+            team_df_list = pool.map(scrape_team_injury_report, ALL_TEAMS)
+    else:
+        team_df_list = [scrape_team_injury_report(team) for team in ALL_TEAMS]
+    return pd.concat(team_df_list)

src/queries/nflverse/github_data.py

@@ -0,0 +1,123 @@
+import duckdb
+import pandas as pd
+import os
+from typing import Callable
+
+
+duckdb.default_connection.execute("SET GLOBAL pandas_analyze_sample=100000")
+
+BASE_URL = "https://github.com/nflverse/nflverse-data/releases/download/"
+
+
+FANTASY_POSITIONS = [
+    "QB",
+    "RB",
+    "WR",
+    "TE",
+    "FB",
+    "K",
+]
+
+
+def get_snap_counts(season_int: int) -> pd.DataFrame:
+    df = duckdb.sql(f"SELECT * from snap_counts_snap_counts_{season_int}").df()
+    df["fantasy_position"] = df["position"].isin(FANTASY_POSITIONS)
+    return df
+
+
+def get_play_by_play(season_int: int) -> pd.DataFrame:
+    df = duckdb.sql(f"SELECT * from pbp_play_by_play_{season_int}").df()
+    return df
+
+
+def get_player_stats(season_int: int) -> pd.DataFrame:
+    df = duckdb.sql("SELECT * from player_stats_player_stats").df()
+    return df
+
+
+def get_ftn_charting(season_int: int) -> pd.DataFrame:
+    df = duckdb.sql(f"SELECT * from ftn_charting_ftn_charting_{season_int}").df()
+    return df
+
+
+def get_pbp_participation(season_int: int) -> pd.DataFrame:
+    df = duckdb.sql(
+        f"""
+                    SELECT 
+                        a.*
+                        , b.*
+                        , 1 as count_col
+                    from pbp_participation_pbp_participation_{season_int} a
+                    left join pbp_play_by_play_{season_int} b
+                    on a.play_id = b.play_id
+                    and a.nflverse_game_id = b.game_id
+                    where b.week is not null
+"""
+    ).df()
+    return df
+
+
+def get_nextgen_stats(season_int: int, stat_category: str) -> pd.DataFrame:
+    df = duckdb.sql(f"SELECT * from nextgen_stats_ngs_{stat_category} where season = {season_int}").df()
+    return df
+
+
+SEASON = "2023"
+
+NFLVERSE_ASSETS = [
+    ("ftn_charting", f"ftn_charting_{SEASON}.parquet"),
+    ("espn_data", "qbr_season_level.parquet"),
+    ("espn_data", "qbr_week_level.parquet"),
+    ("players", "players.parquet"),
+    ("pbp_participation", f"pbp_participation_{SEASON}.parquet"),
+    ("snap_counts", f"snap_counts_{SEASON}.parquet"),
+    ("player_stats", f"player_stats_{SEASON}.parquet"),
+    ("player_stats", f"player_stats_def_{SEASON}.parquet"),
+    ("player_stats", f"player_stats_kicking_{SEASON}.parquet"),
+    ("pfr_advstats", "advstats_season_def.parquet"),
+    ("pfr_advstats", "advstats_season_pass.parquet"),
+    ("pfr_advstats", "advstats_season_rec.parquet"),
+    ("pfr_advstats", "advstats_season_rush.parquet"),
+    ("pfr_advstats", f"advstats_week_def_{SEASON}.parquet"),
+    ("pfr_advstats", f"advstats_week_pass_{SEASON}.parquet"),
+    ("pfr_advstats", f"advstats_week_rec_{SEASON}.parquet"),
+    ("pfr_advstats", f"advstats_week_rush_{SEASON}.parquet"),
+    ("pbp", f"play_by_play_{SEASON}.parquet"),
+    ("nextgen_stats", "ngs_passing.parquet"),
+    ("nextgen_stats", "ngs_receiving.parquet"),
+    ("nextgen_stats", "ngs_rushing.parquet"),
+]
+
+
+class NflVerseDataAsset:
+    def __init__(
+        self,
+        release_tag: str,
+        asset_name: str,
+        dataframe_mutation_fxn: Callable[[pd.DataFrame], pd.DataFrame] = lambda x: x,
+    ):
+        self.release_tag = release_tag
+        self.asset_name = asset_name
+        self.dataframe_mutation_fxn = dataframe_mutation_fxn
+        self.table_name = f"{release_tag}_{asset_name.rsplit('.', 1)[0]}"
+
+    def load_parquet_asset_to_df(self) -> pd.DataFrame:
+        location = os.path.join(BASE_URL, self.release_tag, self.asset_name)
+        df = pd.read_parquet(location)
+        return df
+
+    def register_asset_to_duckdb(self) -> None:
+        df = self.load_parquet_asset_to_df()
+        df = self.dataframe_mutation_fxn(df)
+        duckdb.register(self.table_name, df)
+
+
+def load_assets():
+    for tag, asset in NFLVERSE_ASSETS:
+        asset = NflVerseDataAsset(tag, asset)
+        asset.register_asset_to_duckdb()
+
+
+def get_current_tables() -> list[str]:
+    current_tables_df = duckdb.sql("SHOW TABLES").df()
+    return current_tables_df["name"].tolist()

src/shared_page.py

@@ -0,0 +1,22 @@
+import os
+import streamlit as st
+
+from page_selector import remove_seasonal_pages
+from login_component import get_authorization_button
+
+
+def get_local_style():
+    code_str = ""
+    with open(os.path.join(os.path.dirname(__file__), "style.css")) as f:
+        code_str = "<style>{}</style>".format(f.read())
+    return code_str
+
+
+def local_css():
+    return st.markdown(get_local_style(), unsafe_allow_html=True)
+
+
+def common_page_config():
+    local_css()
+    get_authorization_button()
+    remove_seasonal_pages()

src/start.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+streamlit run Home.py --server.port=8501 --server.address=0.0.0.0

src/streamlit_filter.py

@@ -0,0 +1,102 @@
+# https://blog.streamlit.io/auto-generate-a-dataframe-filtering-ui-in-streamlit-with-filter_dataframe/
+
+from pandas.api.types import (
+    is_categorical_dtype,
+    is_datetime64_any_dtype,
+    is_numeric_dtype,
+    is_object_dtype,
+)
+import pandas as pd
+import streamlit as st
+
+
+def filter_dataframe(df: pd.DataFrame, force_on: bool = False, force_on_columns: list[str] = []) -> pd.DataFrame:
+    """
+    Adds a UI on top of a dataframe to let viewers filter columns
+
+    Args:
+        df (pd.DataFrame): Original dataframe
+
+    Returns:
+        pd.DataFrame: Filtered dataframe
+    """
+    if force_on:
+        modify = True
+    else:
+        modify = st.checkbox("Add more filters")
+
+    if not modify:
+        return df
+
+    df = df.copy()
+
+    # Try to convert datetimes into a standard format (datetime, no timezone)
+    for col in df.columns:
+        if is_object_dtype(df[col]):
+            try:
+                df[col] = pd.to_datetime(df[col])
+            except Exception:
+                pass
+
+        if is_datetime64_any_dtype(df[col]):
+            df[col] = df[col].dt.tz_localize(None)
+
+    modification_container = st.container()
+
+    with modification_container:
+        to_filter_columns = st.multiselect("Filter dataframe on", df.columns) + force_on_columns
+        for column in to_filter_columns:
+            left, right = st.columns((1, 20))
+            # Treat columns with < 17 unique values as categorical
+            if is_categorical_dtype(df[column]) or df[column].nunique() < 50:
+                user_cat_input = right.multiselect(
+                    f"Values for {column}",
+                    df[column].unique(),
+                    default=list(df[column].unique()),
+                )
+                df = df[df[column].isin(user_cat_input)]
+            elif is_numeric_dtype(df[column]):
+                _min = float(df[column].min())
+                _max = float(df[column].max())
+                step = (_max - _min) / 100
+                user_num_input = right.slider(
+                    f"Values for {column}",
+                    min_value=_min,
+                    max_value=_max,
+                    value=(_min, _max),
+                    step=step,
+                )
+                df = df[df[column].between(*user_num_input)]
+            elif is_datetime64_any_dtype(df[column]):
+                user_date_input = right.date_input(
+                    f"Values for {column}",
+                    value=(
+                        df[column].min(),
+                        df[column].max(),
+                    ),
+                )
+                if isinstance(user_date_input, tuple):
+                    if len(user_date_input) == 2:
+                        user_date_input_dt = tuple(map(pd.to_datetime, user_date_input))
+                        start_date, end_date = user_date_input_dt
+                        df = df.loc[df[column].between(start_date, end_date)]
+            else:
+                user_text_input = right.text_input(
+                    f"Substring or regex in {column}",
+                )
+                if user_text_input:
+                    df = df[df[column].astype(str).str.contains(user_text_input)]
+
+    return df
+
+
+def get_multiselect_for_df_column(df: pd.DataFrame, column_name: str) -> list:
+    options_list = sorted(df[column_name].unique().tolist())
+    if len(options_list) > 1:
+        selected = (
+            st.multiselect(column_name.title(), options_list, placeholder=f"Select a {column_name} to filter")
+            or options_list
+        )
+    else:
+        selected = options_list
+    return selected

src/style.css

@@ -0,0 +1,150 @@
+.mrs-grid-player {
+  font-size: x-small;
+  margin-bottom: 5px;
+  padding-left: 4px;
+  padding-right: 4px;
+}
+
+.tier {
+  text-align: center;
+}
+
+.timeslot {
+  text-align: center;
+}
+
+.tier1 {
+  border: 2px solid blue;
+}
+.tier2 {
+  border: 2px solid gold;
+}
+
+.tier3 {
+  border: 2px solid silver;
+}
+
+.tier4 {
+  border: 2px solid brown;
+}
+
+.drop-player {
+  color: red;
+}
+
+.light-hold-player {
+  color: yellow;
+}
+
+.hold-player {
+  color: rgba(68, 235, 62, 0.774);
+}
+
+.playerslot {
+  border-left: 1px solid white;
+  border-right: 1px solid white;
+}
+
+.grid-legend {
+  color: white;
+  border: 1px solid white;
+  display: flex;
+  gap: 5px;
+  justify-content: center;
+  font-size: x-small;
+}
+
+.grid-container-6 {
+  display: grid;
+  grid-template-columns: repeat(6, 1fr);
+  grid-template-rows: repeat(9, auto);
+  grid-column-gap: 0px;
+  grid-row-gap: 10px;
+  color: white;
+  
+  .timeslot1 { grid-area: 1 / 1 / 2 / 2; }
+  .timeslot2 { grid-area: 1 / 2 / 2 / 3; }
+  .timeslot3 { grid-area: 1 / 3 / 2 / 4; }
+  .timeslot4 { grid-area: 1 / 4 / 2 / 5; }
+  .timeslot5 { grid-area: 1 / 5 / 2 / 6; }
+  .timeslot6 { grid-area: 1 / 6 / 2 / 7; }
+  .tier1 { grid-area: 2 / 1 / 3 / 7; }
+  .playerslot1 { grid-area: 3 / 1 / 4 / 2; }
+  .playerslot2 { grid-area: 3 / 2 / 4 / 3; }
+  .playerslot3 { grid-area: 3 / 3 / 4 / 4; }
+  .playerslot4 { grid-area: 3 / 4 / 4 / 5; }
+  .playerslot5 { grid-area: 3 / 5 / 4 / 6; }
+  .playerslot6 { grid-area: 3 / 6 / 4 / 7; }
+  .tier2 { grid-area: 4 / 1 / 5 / 7; }
+  .playerslot7 { grid-area: 5 / 1 / 6 / 2; }
+  .playerslot8 { grid-area: 5 / 2 / 6 / 3; }
+  .playerslot9 { grid-area: 5 / 3 / 6 / 4; }
+  .playerslot10 { grid-area: 5 / 4 / 6 / 5; }
+  .playerslot11 { grid-area: 5 / 5 / 6 / 6; }
+  .playerslot12 { grid-area: 5 / 6 / 6 / 7; }
+  .tier3 { grid-area: 6 / 1 / 7 / 7; }
+  .playerslot13 { grid-area: 7 / 1 / 8 / 2; }
+  .playerslot14 { grid-area: 7 / 2 / 8 / 3; }
+  .playerslot15 { grid-area: 7 / 3 / 8 / 4; }
+  .playerslot16 { grid-area: 7 / 4 / 8 / 5; }
+  .playerslot17 { grid-area: 7 / 5 / 8 / 6; }
+  .playerslot18 { grid-area: 7 / 6 / 8 / 7; }
+  .tier4 { grid-area: 8 / 1 / 9 / 7; }
+  .playerslot19 { grid-area: 9 / 1 / 10 / 2; }
+  .playerslot20 { grid-area: 9 / 2 / 10 / 3; }
+  .playerslot21 { grid-area: 9 / 3 / 10 / 4; }
+  .playerslot22 { grid-area: 9 / 4 / 10 / 5; }
+  .playerslot23 { grid-area: 9 / 5 / 10 / 6; }
+  .playerslot24 { grid-area: 9 / 6 / 10 / 7; }
+
+}
+
+.grid-container-7 {
+  display: grid;
+  grid-template-columns: repeat(7, 1fr);
+  grid-template-rows: repeat(9, auto);
+  grid-column-gap: 0px;
+  grid-row-gap: 10px;
+  color: white;
+  
+  .timeslot1 { grid-area: 1 / 1 / 2 / 2; }
+  .timeslot2 { grid-area: 1 / 2 / 2 / 3; }
+  .timeslot3 { grid-area: 1 / 3 / 2 / 4; }
+  .timeslot4 { grid-area: 1 / 4 / 2 / 5; }
+  .timeslot5 { grid-area: 1 / 5 / 2 / 6; }
+  .timeslot6 { grid-area: 1 / 6 / 2 / 7; }
+  .timeslot7 { grid-area: 1 / 7 / 2 / 8; }
+  .tier1 { grid-area: 2 / 1 / 3 / 8; }
+  .playerslot1 { grid-area: 3 / 1 / 4 / 2; }
+  .playerslot2 { grid-area: 3 / 2 / 4 / 3; }
+  .playerslot3 { grid-area: 3 / 3 / 4 / 4; }
+  .playerslot4 { grid-area: 3 / 4 / 4 / 5; }
+  .playerslot5 { grid-area: 3 / 5 / 4 / 6; }
+  .playerslot6 { grid-area: 3 / 6 / 4 / 7; }
+  .playerslot7 { grid-area: 3 / 7 / 4 / 8; }
+  .tier2 { grid-area: 4 / 1 / 5 / 8; }
+  .playerslot8 { grid-area: 5 / 1 / 6 / 2; }
+  .playerslot9 { grid-area: 5 / 2 / 6 / 3; }
+  .playerslot10 { grid-area: 5 / 3 / 6 / 4; }
+  .playerslot11 { grid-area: 5 / 4 / 6 / 5; }
+  .playerslot12 { grid-area: 5 / 5 / 6 / 6; }
+  .playerslot13 { grid-area: 5 / 6 / 6 / 7; }
+  .playerslot14 { grid-area: 5 / 7 / 6 / 8; }
+  .tier3 { grid-area: 6 / 1 / 7 / 8; }
+  .playerslot15 { grid-area: 7 / 1 / 8 / 2; }
+  .playerslot16 { grid-area: 7 / 2 / 8 / 3; }
+  .playerslot17 { grid-area: 7 / 3 / 8 / 4; }
+  .playerslot18 { grid-area: 7 / 4 / 8 / 5; }
+  .playerslot19 { grid-area: 7 / 5 / 8 / 6; }
+  .playerslot20 { grid-area: 7 / 6 / 8 / 7; }
+  .playerslot21 { grid-area: 7 / 7 / 8 / 8; }
+  .tier4 { grid-area: 8 / 1 / 9 / 8; }
+  .playerslot22 { grid-area: 9 / 1 / 10 / 2; }
+  .playerslot23 { grid-area: 9 / 2 / 10 / 3; }
+  .playerslot24 { grid-area: 9 / 3 / 10 / 4; }
+  .playerslot25 { grid-area: 9 / 4 / 10 / 5; }
+  .playerslot26 { grid-area: 9 / 5 / 10 / 6; }
+  .playerslot27 { grid-area: 9 / 6 / 10 / 7; }
+  .playerslot28 { grid-area: 9 / 7 / 10 / 8; }
+
+}

tests/contract/test_nbcsports_player_news.py

@@ -0,0 +1,13 @@
+import pytest
+
+from queries.nbcsports import player_news
+
+
+@pytest.mark.parametrize("page_number", [(1), (2)])
+def test_get_nfl_player_news(page_number: int):
+    _ = player_news.get_nfl_player_news(page_number)
+
+
+@pytest.mark.parametrize("hours", [(1), (10)])
+def test_get_player_news_window_hours(hours: int):
+    _ = player_news.get_player_news_window_hours(hours)